Intravision/reactos
1
0
Fork 0
mirror of https://github.com/reactos/reactos.git synced 2024-12-28 10:04:49 +00:00
Code Issues Projects Releases Packages Wiki Activity

Need to remove existing files before doing vendor import

Browse source 
svn path=/trunk/; revision=12641
This commit is contained in:
Gé van Geldorp 2004-12-31 16:44:51 +00:00
parent 5a0eafb788
commit 0cfb700271
47 changed files with 0 additions and 20466 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

9
reactos/lib/winmm/Makefile
View file

@ -1,9 +0,0 @@
# $Id: Makefile,v 1.12 2004/02/25 20:00:41 sedwards Exp $
PATH_TO_TOP = ../..
TARGET_TYPE = winedll
include $(PATH_TO_TOP)/rules.mak
include $(TOOLS_PATH)/helper.mk

34
reactos/lib/winmm/Makefile.in
View file

@ -1,34 +0,0 @@
EXTRADEFS = -D_WINMM_
TOPSRCDIR = @top_srcdir@
TOPOBJDIR = ../..
SRCDIR = @srcdir@
VPATH = @srcdir@
MODULE = winmm.dll
IMPORTS = user32 advapi32 kernel32 ntdll
C_SRCS = \
driver.c \
joystick.c \
lolvldrv.c \
mci.c \
mmio.c \
playsound.c \
time.c \
winmm.c
C_SRCS16 = \
message16.c \
mmsystem.c \
sound16.c
SPEC_SRCS16 = \
mmsystem.spec \
sound.spec
RC_SRCS = winmm_res.rc
SUBDIRS = tests
@MAKE_DLL_RULES@
### Dependencies:

21
reactos/lib/winmm/Makefile.ros-template
View file

@ -1,21 +0,0 @@
# $Id: Makefile.ros-template,v 1.4 2004/12/03 23:37:43 blight Exp $
TARGET_NAME = winmm
TARGET_OBJECTS = @C_SRCS@
TARGET_CFLAGS = @EXTRADEFS@ -D__REACTOS__
TARGET_SDKLIBS = @IMPORTS@ wine.a wine_uuid.a ntdll.a
TARGET_BASE = $(TARGET_BASE_LIB_WINMM)
TARGET_RC_SRCS = @RC_SRCS@
TARGET_RC_BINSRC = @RC_BINSRC@
TARGET_RC_BINARIES = @RC_BINARIES@
default: all
DEP_OBJECTS = $(TARGET_OBJECTS)
include $(TOOLS_PATH)/depend.mk

567
reactos/lib/winmm/driver.c
View file

@ -1,567 +0,0 @@
/* -*- tab-width: 8; c-basic-offset: 4 -*- */
/*
* WINE Drivers functions
*
* Copyright 1994 Martin Ayotte
* Copyright 1998 Marcus Meissner
* Copyright 1999 Eric Pouech
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*/
#include <string.h>
#include <stdarg.h>
#include "windef.h"
#include "winbase.h"
#include "wingdi.h"
#include "winuser.h"
#include "winnls.h"
#include "winreg.h"
#include "mmddk.h"
#include "winemm.h"
#include "wine/debug.h"
WINE_DEFAULT_DEBUG_CHANNEL(driver);
#define HKLM_BASE "Software\\Microsoft\\Windows NT\\CurrentVersion"
static LPWINE_DRIVER lpDrvItemList /* = NULL */;
WINE_MMTHREAD* (*pFnGetMMThread16)(UINT16 h) /* = NULL */;
LPWINE_DRIVER (*pFnOpenDriver16)(LPCSTR,LPCSTR,LPARAM) /* = NULL */;
LRESULT (*pFnCloseDriver16)(UINT16,LPARAM,LPARAM) /* = NULL */;
LRESULT (*pFnSendMessage16)(UINT16,UINT,LPARAM,LPARAM) /* = NULL */;
/**************************************************************************
* DRIVER_GetNumberOfModuleRefs [internal]
*
* Returns the number of open drivers which share the same module.
*/
static unsigned DRIVER_GetNumberOfModuleRefs(HMODULE hModule, WINE_DRIVER** found)
{
LPWINE_DRIVER lpDrv;
unsigned count = 0;
if (found) *found = NULL;
for (lpDrv = lpDrvItemList; lpDrv; lpDrv = lpDrv->lpNextItem)
{
if (!(lpDrv->dwFlags & WINE_GDF_16BIT) && lpDrv->d.d32.hModule == hModule)
{
if (found && !*found) *found = lpDrv;
count++;
}
}
return count;
}
/**************************************************************************
* DRIVER_FindFromHDrvr [internal]
*
* From a hDrvr being 32 bits, returns the WINE internal structure.
*/
LPWINE_DRIVER DRIVER_FindFromHDrvr(HDRVR hDrvr)
{
LPWINE_DRIVER d = (LPWINE_DRIVER)hDrvr;
if (hDrvr && HeapValidate(GetProcessHeap(), 0, d) && d->dwMagic == WINE_DI_MAGIC) {
return d;
}
return NULL;
}
/**************************************************************************
* DRIVER_SendMessage [internal]
*/
static LRESULT inline DRIVER_SendMessage(LPWINE_DRIVER lpDrv, UINT msg,
LPARAM lParam1, LPARAM lParam2)
{
LRESULT ret = 0;
if (lpDrv->dwFlags & WINE_GDF_16BIT) {
/* no need to check mmsystem presence: the driver must have been opened as a 16 bit one,
*/
if (pFnSendMessage16)
ret = pFnSendMessage16(lpDrv->d.d16.hDriver16, msg, lParam1, lParam2);
} else {
TRACE("Before call32 proc=%p drvrID=%08lx hDrv=%p wMsg=%04x p1=%08lx p2=%08lx\n",
lpDrv->d.d32.lpDrvProc, lpDrv->d.d32.dwDriverID, (HDRVR)lpDrv, msg, lParam1, lParam2);
ret = lpDrv->d.d32.lpDrvProc(lpDrv->d.d32.dwDriverID, (HDRVR)lpDrv, msg, lParam1, lParam2);
TRACE("After call32 proc=%p drvrID=%08lx hDrv=%p wMsg=%04x p1=%08lx p2=%08lx => %08lx\n",
lpDrv->d.d32.lpDrvProc, lpDrv->d.d32.dwDriverID, (HDRVR)lpDrv, msg, lParam1, lParam2, ret);
}
return ret;
}
/**************************************************************************
* SendDriverMessage [WINMM.@]
* DrvSendMessage [WINMM.@]
*/
LRESULT WINAPI SendDriverMessage(HDRVR hDriver, UINT msg, LPARAM lParam1,
LPARAM lParam2)
{
LPWINE_DRIVER lpDrv;
LRESULT retval = 0;
TRACE("(%p, %04X, %08lX, %08lX)\n", hDriver, msg, lParam1, lParam2);
if ((lpDrv = DRIVER_FindFromHDrvr(hDriver)) != NULL) {
retval = DRIVER_SendMessage(lpDrv, msg, lParam1, lParam2);
} else {
WARN("Bad driver handle %p\n", hDriver);
}
TRACE("retval = %ld\n", retval);
return retval;
}
/**************************************************************************
* DRIVER_RemoveFromList [internal]
*
* Generates all the logic to handle driver closure / deletion
* Removes a driver struct to the list of open drivers.
*/
static BOOL DRIVER_RemoveFromList(LPWINE_DRIVER lpDrv)
{
if (!(lpDrv->dwFlags & WINE_GDF_16BIT)) {
/* last of this driver in list ? */
if (DRIVER_GetNumberOfModuleRefs(lpDrv->d.d32.hModule, NULL) == 1) {
DRIVER_SendMessage(lpDrv, DRV_DISABLE, 0L, 0L);
DRIVER_SendMessage(lpDrv, DRV_FREE, 0L, 0L);
}
}
if (lpDrv->lpPrevItem)
lpDrv->lpPrevItem->lpNextItem = lpDrv->lpNextItem;
else
lpDrvItemList = lpDrv->lpNextItem;
if (lpDrv->lpNextItem)
lpDrv->lpNextItem->lpPrevItem = lpDrv->lpPrevItem;
/* trash magic number */
lpDrv->dwMagic ^= 0xa5a5a5a5;
return TRUE;
}
/**************************************************************************
* DRIVER_AddToList [internal]
*
* Adds a driver struct to the list of open drivers.
* Generates all the logic to handle driver creation / open.
*/
static BOOL DRIVER_AddToList(LPWINE_DRIVER lpNewDrv, LPARAM lParam1, LPARAM lParam2)
{
lpNewDrv->dwMagic = WINE_DI_MAGIC;
/* First driver to be loaded for this module, need to load correctly the module */
if (!(lpNewDrv->dwFlags & WINE_GDF_16BIT)) {
/* first of this driver in list ? */
if (DRIVER_GetNumberOfModuleRefs(lpNewDrv->d.d32.hModule, NULL) == 0) {
if (DRIVER_SendMessage(lpNewDrv, DRV_LOAD, 0L, 0L) != DRV_SUCCESS) {
TRACE("DRV_LOAD failed on driver 0x%08lx\n", (DWORD)lpNewDrv);
return FALSE;
}
/* returned value is not checked */
DRIVER_SendMessage(lpNewDrv, DRV_ENABLE, 0L, 0L);
}
}
lpNewDrv->lpNextItem = NULL;
if (lpDrvItemList == NULL) {
lpDrvItemList = lpNewDrv;
lpNewDrv->lpPrevItem = NULL;
} else {
LPWINE_DRIVER lpDrv = lpDrvItemList; /* find end of list */
while (lpDrv->lpNextItem != NULL)
lpDrv = lpDrv->lpNextItem;
lpDrv->lpNextItem = lpNewDrv;
lpNewDrv->lpPrevItem = lpDrv;
}
if (!(lpNewDrv->dwFlags & WINE_GDF_16BIT)) {
/* Now just open a new instance of a driver on this module */
lpNewDrv->d.d32.dwDriverID = DRIVER_SendMessage(lpNewDrv, DRV_OPEN, lParam1, lParam2);
if (lpNewDrv->d.d32.dwDriverID == 0) {
TRACE("DRV_OPEN failed on driver 0x%08lx\n", (DWORD)lpNewDrv);
DRIVER_RemoveFromList(lpNewDrv);
return FALSE;
}
}
return TRUE;
}
/**************************************************************************
* DRIVER_GetLibName [internal]
*
*/
BOOL DRIVER_GetLibName(LPCSTR keyName, LPCSTR sectName, LPSTR buf, int sz)
{
HKEY hKey, hSecKey;
DWORD bufLen, lRet;
lRet = RegOpenKeyExA(HKEY_LOCAL_MACHINE, HKLM_BASE, 0, KEY_QUERY_VALUE, &hKey);
if (lRet == ERROR_SUCCESS) {
lRet = RegOpenKeyExA(hKey, sectName, 0, KEY_QUERY_VALUE, &hSecKey);
if (lRet == ERROR_SUCCESS) {
lRet = RegQueryValueExA(hSecKey, keyName, 0, 0, buf, &bufLen);
RegCloseKey( hSecKey );
}
RegCloseKey( hKey );
}
if (lRet == ERROR_SUCCESS) return TRUE;
/* default to system.ini if we can't find it in the registry,
* to support native installations where system.ini is still used */
return GetPrivateProfileStringA(sectName, keyName, "", buf, sz, "SYSTEM.INI");
}
/**************************************************************************
* DRIVER_TryOpenDriver32 [internal]
*
* Tries to load a 32 bit driver whose DLL's (module) name is fn
*/
LPWINE_DRIVER DRIVER_TryOpenDriver32(LPCSTR fn, LPARAM lParam2)
{
LPWINE_DRIVER lpDrv = NULL;
HMODULE hModule = 0;
LPSTR ptr;
LPCSTR cause = 0;
TRACE("(%s, %08lX);\n", debugstr_a(fn), lParam2);
if ((ptr = strchr(fn, ' ')) != NULL) {
*ptr++ = '\0';
while (*ptr == ' ') ptr++;
if (*ptr == '\0') ptr = NULL;
}
lpDrv = HeapAlloc(GetProcessHeap(), 0, sizeof(WINE_DRIVER));
if (lpDrv == NULL) {cause = "OOM"; goto exit;}
if ((hModule = LoadLibraryA(fn)) == 0) {cause = "Not a 32 bit lib"; goto exit;}
lpDrv->d.d32.lpDrvProc = (DRIVERPROC)GetProcAddress(hModule, "DriverProc");
if (lpDrv->d.d32.lpDrvProc == NULL) {cause = "no DriverProc"; goto exit;}
lpDrv->dwFlags = 0;
lpDrv->d.d32.hModule = hModule;
lpDrv->d.d32.dwDriverID = 0;
/* Win32 installable drivers must support a two phase opening scheme:
* + first open with NULL as lParam2 (session instance),
* + then do a second open with the real non null lParam2)
*/
if (DRIVER_GetNumberOfModuleRefs(lpDrv->d.d32.hModule, NULL) == 0 && lParam2)
{
LPWINE_DRIVER ret;
if (!DRIVER_AddToList(lpDrv, (LPARAM)ptr, 0L))
{
cause = "load0 failed";
goto exit;
}
ret = DRIVER_TryOpenDriver32(fn, lParam2);
if (!ret)
{
CloseDriver((HDRVR)lpDrv, 0L, 0L);
cause = "load1 failed";
goto exit;
}
return ret;
}
if (!DRIVER_AddToList(lpDrv, (LPARAM)ptr, lParam2))
{cause = "load failed"; goto exit;}
TRACE("=> %p\n", lpDrv);
return lpDrv;
exit:
FreeLibrary(hModule);
HeapFree(GetProcessHeap(), 0, lpDrv);
TRACE("Unable to load 32 bit module %s: %s\n", debugstr_a(fn), cause);
return NULL;
}
/**************************************************************************
* OpenDriverA [WINMM.@]
* DrvOpenA [WINMM.@]
* (0,1,DRV_LOAD ,0 ,0)
* (0,1,DRV_ENABLE,0 ,0)
* (0,1,DRV_OPEN ,buf[256],0)
*/
HDRVR WINAPI OpenDriverA(LPCSTR lpDriverName, LPCSTR lpSectionName, LPARAM lParam2)
{
LPWINE_DRIVER lpDrv = NULL;
char libName[128];
LPCSTR lsn = lpSectionName;
TRACE("(%s, %s, 0x%08lx);\n", debugstr_a(lpDriverName), debugstr_a(lpSectionName), lParam2);
if (lsn == NULL) {
lstrcpynA(libName, lpDriverName, sizeof(libName));
if ((lpDrv = DRIVER_TryOpenDriver32(libName, lParam2)))
goto the_end;
lsn = "Drivers32";
}
if (DRIVER_GetLibName(lpDriverName, lsn, libName, sizeof(libName)) &&
(lpDrv = DRIVER_TryOpenDriver32(libName, lParam2)))
goto the_end;
/* now we will try a 16 bit driver (and add all the glue to make it work... which
* is located in our mmsystem implementation)
* so ensure, we can load our mmsystem, otherwise just fail
*/
WINMM_CheckForMMSystem();
if (pFnOpenDriver16 &&
(lpDrv = pFnOpenDriver16(lpDriverName, lpSectionName, lParam2)))
{
if (DRIVER_AddToList(lpDrv, 0, lParam2)) goto the_end;
HeapFree(GetProcessHeap(), 0, lpDrv);
}
TRACE("Failed to open driver %s from system.ini file, section %s\n", debugstr_a(lpDriverName), debugstr_a(lpSectionName));
return 0;
the_end:
if (lpDrv) TRACE("=> %08lx\n", (DWORD)lpDrv);
return (HDRVR)lpDrv;
}
/**************************************************************************
* OpenDriver [WINMM.@]
* DrvOpen [WINMM.@]
*/
HDRVR WINAPI OpenDriverW(LPCWSTR lpDriverName, LPCWSTR lpSectionName, LPARAM lParam)
{
INT len;
LPSTR dn = NULL;
LPSTR sn = NULL;
HDRVR ret;
if (lpDriverName)
{
len = WideCharToMultiByte( CP_ACP, 0, lpDriverName, -1, NULL, 0, NULL, NULL );
dn = HeapAlloc( GetProcessHeap(), 0, len );
if (!dn) return 0;
WideCharToMultiByte( CP_ACP, 0, lpDriverName, -1, dn, len, NULL, NULL );
}
if (lpSectionName)
{
len = WideCharToMultiByte( CP_ACP, 0, lpSectionName, -1, NULL, 0, NULL, NULL );
sn = HeapAlloc( GetProcessHeap(), 0, len );
if (!sn) return 0;
WideCharToMultiByte( CP_ACP, 0, lpSectionName, -1, sn, len, NULL, NULL );
}
ret = OpenDriverA(dn, sn, lParam);
if (dn) HeapFree(GetProcessHeap(), 0, dn);
if (sn) HeapFree(GetProcessHeap(), 0, sn);
return ret;
}
/**************************************************************************
* CloseDriver [WINMM.@]
* DrvClose [WINMM.@]
*/
LRESULT WINAPI CloseDriver(HDRVR hDrvr, LPARAM lParam1, LPARAM lParam2)
{
LPWINE_DRIVER lpDrv;
TRACE("(%p, %08lX, %08lX);\n", hDrvr, lParam1, lParam2);
if ((lpDrv = DRIVER_FindFromHDrvr(hDrvr)) != NULL)
{
if (lpDrv->dwFlags & WINE_GDF_16BIT)
{
if (pFnCloseDriver16)
pFnCloseDriver16(lpDrv->d.d16.hDriver16, lParam1, lParam2);
}
else
{
DRIVER_SendMessage(lpDrv, DRV_CLOSE, lParam1, lParam2);
lpDrv->d.d32.dwDriverID = 0;
}
if (DRIVER_RemoveFromList(lpDrv)) {
if (!(lpDrv->dwFlags & WINE_GDF_16BIT))
{
LPWINE_DRIVER lpDrv0;
/* if driver has an opened session instance, we have to close it too */
if (DRIVER_GetNumberOfModuleRefs(lpDrv->d.d32.hModule, &lpDrv0) == 1)
{
DRIVER_SendMessage(lpDrv0, DRV_CLOSE, 0L, 0L);
lpDrv0->d.d32.dwDriverID = 0;
DRIVER_RemoveFromList(lpDrv0);
FreeLibrary(lpDrv0->d.d32.hModule);
HeapFree(GetProcessHeap(), 0, lpDrv0);
}
FreeLibrary(lpDrv->d.d32.hModule);
}
HeapFree(GetProcessHeap(), 0, lpDrv);
return TRUE;
}
}
WARN("Failed to close driver\n");
return FALSE;
}
/**************************************************************************
* GetDriverFlags [WINMM.@]
* [in] hDrvr handle to the driver
*
* Returns:
* 0x00000000 if hDrvr is an invalid handle
* 0x80000000 if hDrvr is a valid 32 bit driver
* 0x90000000 if hDrvr is a valid 16 bit driver
*
* native WINMM doesn't return those flags
* 0x80000000 for a valid 32 bit driver and that's it
* (I may have mixed up the two flags :-(
*/
DWORD WINAPI GetDriverFlags(HDRVR hDrvr)
{
LPWINE_DRIVER lpDrv;
DWORD ret = 0;
TRACE("(%p)\n", hDrvr);
if ((lpDrv = DRIVER_FindFromHDrvr(hDrvr)) != NULL) {
ret = WINE_GDF_EXIST | lpDrv->dwFlags;
}
return ret;
}
/**************************************************************************
* GetDriverModuleHandle [WINMM.@]
* DrvGetModuleHandle [WINMM.@]
*/
HMODULE WINAPI GetDriverModuleHandle(HDRVR hDrvr)
{
LPWINE_DRIVER lpDrv;
HMODULE hModule = 0;
TRACE("(%p);\n", hDrvr);
if ((lpDrv = DRIVER_FindFromHDrvr(hDrvr)) != NULL) {
if (!(lpDrv->dwFlags & WINE_GDF_16BIT))
hModule = lpDrv->d.d32.hModule;
}
TRACE("=> %p\n", hModule);
return hModule;
}
/**************************************************************************
* DefDriverProc [WINMM.@]
* DrvDefDriverProc [WINMM.@]
*/
LRESULT WINAPI DefDriverProc(DWORD_PTR dwDriverIdentifier, HDRVR hDrv,
UINT Msg, LPARAM lParam1, LPARAM lParam2)
{
switch (Msg) {
case DRV_LOAD:
case DRV_FREE:
case DRV_ENABLE:
case DRV_DISABLE:
return 1;
case DRV_INSTALL:
case DRV_REMOVE:
return DRV_SUCCESS;
default:
return 0;
}
}
/**************************************************************************
* DriverCallback [WINMM.@]
*/
BOOL WINAPI DriverCallback(DWORD dwCallBack, UINT uFlags, HDRVR hDev,
UINT wMsg, DWORD dwUser, DWORD dwParam1,
DWORD dwParam2)
{
TRACE("(%08lX, %04X, %p, %04X, %08lX, %08lX, %08lX); !\n",
dwCallBack, uFlags, hDev, wMsg, dwUser, dwParam1, dwParam2);
switch (uFlags & DCB_TYPEMASK) {
case DCB_NULL:
TRACE("Null !\n");
if (dwCallBack)
WARN("uFlags=%04X has null DCB value, but dwCallBack=%08lX is not null !\n", uFlags, dwCallBack);
break;
case DCB_WINDOW:
TRACE("Window(%04lX) handle=%p!\n", dwCallBack, hDev);
PostMessageA((HWND)dwCallBack, wMsg, (WPARAM)hDev, dwParam1);
break;
case DCB_TASK: /* aka DCB_THREAD */
TRACE("Task(%04lx) !\n", dwCallBack);
PostThreadMessageA(dwCallBack, wMsg, (WPARAM)hDev, dwParam1);
break;
case DCB_FUNCTION:
TRACE("Function (32 bit) !\n");
((LPDRVCALLBACK)dwCallBack)(hDev, wMsg, dwUser, dwParam1, dwParam2);
break;
case DCB_EVENT:
TRACE("Event(%08lx) !\n", dwCallBack);
SetEvent((HANDLE)dwCallBack);
break;
case 6: /* I would dub it DCB_MMTHREADSIGNAL */
/* this is an undocumented DCB_ value used for mmThreads
* loword of dwCallBack contains the handle of the lpMMThd block
* which dwSignalCount has to be incremented
*/
if (pFnGetMMThread16)
{
WINE_MMTHREAD* lpMMThd = pFnGetMMThread16(LOWORD(dwCallBack));
TRACE("mmThread (%04x, %p) !\n", LOWORD(dwCallBack), lpMMThd);
/* same as mmThreadSignal16 */
InterlockedIncrement(&lpMMThd->dwSignalCount);
SetEvent(lpMMThd->hEvent);
/* some other stuff on lpMMThd->hVxD */
}
break;
#if 0
case 4:
/* this is an undocumented DCB_ value for... I don't know */
break;
#endif
default:
WARN("Unknown callback type %d\n", uFlags & DCB_TYPEMASK);
return FALSE;
}
TRACE("Done\n");
return TRUE;
}
/******************************************************************
* DRIVER_UnloadAll
*
*
*/
void DRIVER_UnloadAll(void)
{
LPWINE_DRIVER lpDrv;
LPWINE_DRIVER lpNextDrv = NULL;
unsigned count = 0;
for (lpDrv = lpDrvItemList; lpDrv != NULL; lpDrv = lpNextDrv)
{
lpNextDrv = lpDrv->lpNextItem;
CloseDriver((HDRVR)lpDrv, 0, 0);
count++;
}
TRACE("Unloaded %u drivers\n", count);
}

309
reactos/lib/winmm/joystick.c
View file

@ -1,309 +0,0 @@
/* -*- tab-width: 8; c-basic-offset: 4 -*- */
/*
* joystick functions
*
* Copyright 1997 Andreas Mohr
* 2000 Wolfgang Schwotzer
* Eric Pouech
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*/
#include "config.h"
#ifdef HAVE_UNISTD_H
# include <unistd.h>
#endif
#include <stdarg.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <fcntl.h>
#ifdef HAVE_SYS_IOCTL_H
#include <sys/ioctl.h>
#endif
#include "windef.h"
#include "winbase.h"
#include "mmsystem.h"
#include "wingdi.h"
#include "winuser.h"
#include "winnls.h"
#include "winemm.h"
#include "mmddk.h"
#include "wine/debug.h"
WINE_DEFAULT_DEBUG_CHANNEL(winmm);
#define MAXJOYSTICK (JOYSTICKID2 + 1)
#define JOY_PERIOD_MIN (10) /* min Capture time period */
#define JOY_PERIOD_MAX (1000) /* max Capture time period */
typedef struct tagWINE_JOYSTICK {
JOYINFO ji;
HWND hCapture;
UINT wTimer;
DWORD threshold;
BOOL bChanged;
HDRVR hDriver;
} WINE_JOYSTICK;
static WINE_JOYSTICK JOY_Sticks[MAXJOYSTICK];
/**************************************************************************
* JOY_LoadDriver [internal]
*/
static BOOL JOY_LoadDriver(DWORD dwJoyID)
{
if (dwJoyID >= MAXJOYSTICK)
return FALSE;
if (JOY_Sticks[dwJoyID].hDriver)
return TRUE;
JOY_Sticks[dwJoyID].hDriver = OpenDriverA("joystick.drv", 0, dwJoyID);
return (JOY_Sticks[dwJoyID].hDriver != 0);
}
/**************************************************************************
* JOY_Timer [internal]
*/
static void CALLBACK JOY_Timer(HWND hWnd, UINT wMsg, UINT wTimer, DWORD dwTime)
{
int i;
WINE_JOYSTICK* joy;
JOYINFO ji;
LONG pos;
unsigned buttonChange;
for (i = 0; i < MAXJOYSTICK; i++) {
joy = &JOY_Sticks[i];
if (joy->hCapture != hWnd) continue;
joyGetPos(i, &ji);
pos = MAKELONG(ji.wXpos, ji.wYpos);
if (!joy->bChanged ||
abs(joy->ji.wXpos - ji.wXpos) > joy->threshold ||
abs(joy->ji.wYpos - ji.wYpos) > joy->threshold) {
SendMessageA(joy->hCapture, MM_JOY1MOVE + i, ji.wButtons, pos);
joy->ji.wXpos = ji.wXpos;
joy->ji.wYpos = ji.wYpos;
}
if (!joy->bChanged ||
abs(joy->ji.wZpos - ji.wZpos) > joy->threshold) {
SendMessageA(joy->hCapture, MM_JOY1ZMOVE + i, ji.wButtons, pos);
joy->ji.wZpos = ji.wZpos;
}
if ((buttonChange = joy->ji.wButtons ^ ji.wButtons) != 0) {
if (ji.wButtons & buttonChange)
SendMessageA(joy->hCapture, MM_JOY1BUTTONDOWN + i,
(buttonChange << 8) | (ji.wButtons & buttonChange), pos);
if (joy->ji.wButtons & buttonChange)
SendMessageA(joy->hCapture, MM_JOY1BUTTONUP + i,
(buttonChange << 8) | (joy->ji.wButtons & buttonChange), pos);
joy->ji.wButtons = ji.wButtons;
}
}
}
/**************************************************************************
* joyGetNumDevs [WINMM.@]
*/
UINT WINAPI joyGetNumDevs(void)
{
UINT ret = 0;
int i;
for (i = 0; i < MAXJOYSTICK; i++) {
if (JOY_LoadDriver(i)) {
ret += SendDriverMessage(JOY_Sticks[i].hDriver, JDD_GETNUMDEVS, 0L, 0L);
}
}
return ret;
}
/**************************************************************************
* joyGetDevCapsA [WINMM.@]
*/
MMRESULT WINAPI joyGetDevCapsA(UINT_PTR wID, LPJOYCAPSA lpCaps, UINT wSize)
{
if (wID >= MAXJOYSTICK) return JOYERR_PARMS;
if (!JOY_LoadDriver(wID)) return MMSYSERR_NODRIVER;
lpCaps->wPeriodMin = JOY_PERIOD_MIN; /* FIXME */
lpCaps->wPeriodMax = JOY_PERIOD_MAX; /* FIXME (same as MS Joystick Driver) */
return SendDriverMessage(JOY_Sticks[wID].hDriver, JDD_GETDEVCAPS, (DWORD)lpCaps, wSize);
}
/**************************************************************************
* joyGetDevCapsW [WINMM.@]
*/
MMRESULT WINAPI joyGetDevCapsW(UINT_PTR wID, LPJOYCAPSW lpCaps, UINT wSize)
{
JOYCAPSA jca;
MMRESULT ret = joyGetDevCapsA(wID, &jca, sizeof(jca));
if (ret != JOYERR_NOERROR) return ret;
lpCaps->wMid = jca.wMid;
lpCaps->wPid = jca.wPid;
MultiByteToWideChar( CP_ACP, 0, jca.szPname, -1, lpCaps->szPname,
sizeof(lpCaps->szPname)/sizeof(WCHAR) );
lpCaps->wXmin = jca.wXmin;
lpCaps->wXmax = jca.wXmax;
lpCaps->wYmin = jca.wYmin;
lpCaps->wYmax = jca.wYmax;
lpCaps->wZmin = jca.wZmin;
lpCaps->wZmax = jca.wZmax;
lpCaps->wNumButtons = jca.wNumButtons;
lpCaps->wPeriodMin = jca.wPeriodMin;
lpCaps->wPeriodMax = jca.wPeriodMax;
if (wSize >= sizeof(JOYCAPSW)) { /* Win95 extensions ? */
lpCaps->wRmin = jca.wRmin;
lpCaps->wRmax = jca.wRmax;
lpCaps->wUmin = jca.wUmin;
lpCaps->wUmax = jca.wUmax;
lpCaps->wVmin = jca.wVmin;
lpCaps->wVmax = jca.wVmax;
lpCaps->wCaps = jca.wCaps;
lpCaps->wMaxAxes = jca.wMaxAxes;
lpCaps->wNumAxes = jca.wNumAxes;
lpCaps->wMaxButtons = jca.wMaxButtons;
MultiByteToWideChar( CP_ACP, 0, jca.szRegKey, -1, lpCaps->szRegKey,
sizeof(lpCaps->szRegKey)/sizeof(WCHAR) );
MultiByteToWideChar( CP_ACP, 0, jca.szOEMVxD, -1, lpCaps->szOEMVxD,
sizeof(lpCaps->szOEMVxD)/sizeof(WCHAR) );
}
return ret;
}
/**************************************************************************
* joyGetPosEx [WINMM.@]
*/
MMRESULT WINAPI joyGetPosEx(UINT wID, LPJOYINFOEX lpInfo)
{
TRACE("(%d, %p);\n", wID, lpInfo);
if (wID >= MAXJOYSTICK) return JOYERR_PARMS;
if (!JOY_LoadDriver(wID)) return MMSYSERR_NODRIVER;
lpInfo->dwXpos = 0;
lpInfo->dwYpos = 0;
lpInfo->dwZpos = 0;
lpInfo->dwRpos = 0;
lpInfo->dwUpos = 0;
lpInfo->dwVpos = 0;
lpInfo->dwButtons = 0;
lpInfo->dwButtonNumber = 0;
lpInfo->dwPOV = 0;
lpInfo->dwReserved1 = 0;
lpInfo->dwReserved2 = 0;
return SendDriverMessage(JOY_Sticks[wID].hDriver, JDD_GETPOSEX, (DWORD)lpInfo, 0L);
}
/**************************************************************************
* joyGetPos [WINMM.@]
*/
MMRESULT WINAPI joyGetPos(UINT wID, LPJOYINFO lpInfo)
{
TRACE("(%d, %p);\n", wID, lpInfo);
if (wID >= MAXJOYSTICK) return JOYERR_PARMS;
if (!JOY_LoadDriver(wID)) return MMSYSERR_NODRIVER;
lpInfo->wXpos = 0;
lpInfo->wYpos = 0;
lpInfo->wZpos = 0;
lpInfo->wButtons = 0;
return SendDriverMessage(JOY_Sticks[wID].hDriver, JDD_GETPOS, (DWORD)lpInfo, 0L);
}
/**************************************************************************
* joyGetThreshold [WINMM.@]
*/
MMRESULT WINAPI joyGetThreshold(UINT wID, LPUINT lpThreshold)
{
TRACE("(%04X, %p);\n", wID, lpThreshold);
if (wID >= MAXJOYSTICK) return JOYERR_PARMS;
*lpThreshold = JOY_Sticks[wID].threshold;
return JOYERR_NOERROR;
}
/**************************************************************************
* joyReleaseCapture [WINMM.@]
*/
MMRESULT WINAPI joyReleaseCapture(UINT wID)
{
TRACE("(%04X);\n", wID);
if (wID >= MAXJOYSTICK) return JOYERR_PARMS;
if (!JOY_LoadDriver(wID)) return MMSYSERR_NODRIVER;
if (!JOY_Sticks[wID].hCapture) return JOYERR_NOCANDO;
KillTimer(JOY_Sticks[wID].hCapture, JOY_Sticks[wID].wTimer);
JOY_Sticks[wID].hCapture = 0;
JOY_Sticks[wID].wTimer = 0;
return JOYERR_NOERROR;
}
/**************************************************************************
* joySetCapture [WINMM.@]
*/
MMRESULT WINAPI joySetCapture(HWND hWnd, UINT wID, UINT wPeriod, BOOL bChanged)
{
TRACE("(%p, %04X, %d, %d);\n", hWnd, wID, wPeriod, bChanged);
if (wID >= MAXJOYSTICK || hWnd == 0) return JOYERR_PARMS;
if (wPeriod<JOY_PERIOD_MIN || wPeriod>JOY_PERIOD_MAX) return JOYERR_PARMS;
if (!JOY_LoadDriver(wID)) return MMSYSERR_NODRIVER;
if (JOY_Sticks[wID].hCapture || !IsWindow(hWnd))
return JOYERR_NOCANDO; /* FIXME: what should be returned ? */
if (joyGetPos(wID, &JOY_Sticks[wID].ji) != JOYERR_NOERROR)
return JOYERR_UNPLUGGED;
if ((JOY_Sticks[wID].wTimer = SetTimer(hWnd, 0, wPeriod, JOY_Timer)) == 0)
return JOYERR_NOCANDO;
JOY_Sticks[wID].hCapture = hWnd;
JOY_Sticks[wID].bChanged = bChanged;
return JOYERR_NOERROR;
}
/**************************************************************************
* joySetThreshold [WINMM.@]
*/
MMRESULT WINAPI joySetThreshold(UINT wID, UINT wThreshold)
{
TRACE("(%04X, %d);\n", wID, wThreshold);
if (wID >= MAXJOYSTICK) return MMSYSERR_INVALPARAM;
JOY_Sticks[wID].threshold = wThreshold;
return JOYERR_NOERROR;
}

857
reactos/lib/winmm/lolvldrv.c
View file

@ -1,857 +0,0 @@
/* -*- tab-width: 8; c-basic-offset: 4 -*- */
/*
* MMSYTEM low level drivers handling functions
*
* Copyright 1999 Eric Pouech
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*/
#include <string.h>
#include <stdarg.h>
#include <stdio.h>
#include <assert.h>
#include "windef.h"
#include "winbase.h"
#include "winreg.h"
#include "winver.h"
#include "winemm.h"
#include "wine/debug.h"
WINE_DEFAULT_DEBUG_CHANNEL(winmm);
LRESULT (*pFnCallMMDrvFunc16)(DWORD,WORD,WORD,LONG,LONG,LONG) /* = NULL */;
unsigned (*pFnLoadMMDrvFunc16)(LPCSTR,LPWINE_DRIVER, LPWINE_MM_DRIVER) /* = NULL */;
/* each known type of driver has an instance of this structure */
typedef struct tagWINE_LLTYPE {
/* those attributes depend on the specification of the type */
LPCSTR typestr; /* name (for debugging) */
BOOL bSupportMapper; /* if type is allowed to support mapper */
MMDRV_MAPFUNC Map16To32A; /* those are function pointers to handle */
MMDRV_UNMAPFUNC UnMap16To32A; /* the parameter conversion (16 vs 32 bit) */
MMDRV_MAPFUNC Map32ATo16; /* when hi-func (in mmsystem or winmm) and */
MMDRV_UNMAPFUNC UnMap32ATo16; /* low-func (in .drv) do not match */
LPDRVCALLBACK Callback; /* handles callback for a specified type */
/* those attributes reflect the loaded/current situation for the type */
UINT wMaxId; /* number of loaded devices (sum across all loaded drivers */
LPWINE_MLD lpMlds; /* "static" mlds to access the part though device IDs */
int nMapper; /* index to mapper */
} WINE_LLTYPE;
static int MMDrvsHi /* = 0 */;
static WINE_MM_DRIVER MMDrvs[8];
static LPWINE_MLD MM_MLDrvs[40];
#define MAX_MM_MLDRVS (sizeof(MM_MLDrvs) / sizeof(MM_MLDrvs[0]))
#define A(_x,_y) {#_y, _x, NULL, NULL, NULL, NULL, NULL, 0, NULL, -1}
/* Note: the indices of this array must match the definitions
* of the MMDRV_???? manifest constants
*/
static WINE_LLTYPE llTypes[MMDRV_MAX] = {
A(TRUE, Aux),
A(FALSE, Mixer),
A(TRUE, MidiIn),
A(TRUE, MidiOut),
A(TRUE, WaveIn),
A(TRUE, WaveOut),
};
#undef A
/******************************************************************
* MMDRV_InstallMap
*
*
*/
void MMDRV_InstallMap(unsigned int drv,
MMDRV_MAPFUNC mp1632, MMDRV_UNMAPFUNC um1632,
MMDRV_MAPFUNC mp3216, MMDRV_UNMAPFUNC um3216,
LPDRVCALLBACK cb)
{
assert(drv < MMDRV_MAX);
llTypes[drv].Map16To32A = mp1632;
llTypes[drv].UnMap16To32A = um1632;
llTypes[drv].Map32ATo16 = mp3216;
llTypes[drv].UnMap32ATo16 = um3216;
llTypes[drv].Callback = cb;
}
/******************************************************************
* MMDRV_Is32
*
*/
BOOL MMDRV_Is32(unsigned int idx)
{
TRACE("(%d)\n", idx);
return MMDrvs[idx].bIs32;
}
/**************************************************************************
* MMDRV_GetDescription32 [internal]
*/
static BOOL MMDRV_GetDescription32(const char* fname, char* buf, int buflen)
{
OFSTRUCT ofs;
DWORD h;
LPVOID ptr = 0;
LPVOID val;
DWORD dw;
BOOL ret = FALSE;
UINT u;
FARPROC pGetFileVersionInfoSizeA;
FARPROC pGetFileVersionInfoA;
FARPROC pVerQueryValueA;
HMODULE hmodule = 0;
TRACE("(%p, %p, %d)\n", fname, buf, buflen);
#define E(_x) do {TRACE _x;goto theEnd;} while(0)
if (OpenFile(fname, &ofs, OF_EXIST)==HFILE_ERROR) E(("Can't find file %s\n", fname));
if (!(hmodule = LoadLibraryA( "version.dll" ))) goto theEnd;
if (!(pGetFileVersionInfoSizeA = GetProcAddress( hmodule, "GetFileVersionInfoSizeA" )))
goto theEnd;
if (!(pGetFileVersionInfoA = GetProcAddress( hmodule, "GetFileVersionInfoA" )))
goto theEnd;
if (!(pVerQueryValueA = GetProcAddress( hmodule, "VerQueryValueA" )))
goto theEnd;
if (!(dw = pGetFileVersionInfoSizeA(ofs.szPathName, &h))) E(("Can't get FVIS\n"));
if (!(ptr = HeapAlloc(GetProcessHeap(), 0, dw))) E(("OOM\n"));
if (!pGetFileVersionInfoA(ofs.szPathName, h, dw, ptr)) E(("Can't get FVI\n"));
#define A(_x) if (pVerQueryValueA(ptr, "\\StringFileInfo\\040904B0\\" #_x, &val, &u)) \
TRACE(#_x " => %s\n", (LPSTR)val); else TRACE(#_x " @\n")
A(CompanyName);
A(FileDescription);
A(FileVersion);
A(InternalName);
A(LegalCopyright);
A(OriginalFilename);
A(ProductName);
A(ProductVersion);
A(Comments);
A(LegalTrademarks);
A(PrivateBuild);
A(SpecialBuild);
#undef A
if (!pVerQueryValueA(ptr, "\\StringFileInfo\\040904B0\\ProductName", &val, &u)) E(("Can't get product name\n"));
lstrcpynA(buf, val, buflen);
#undef E
ret = TRUE;
theEnd:
HeapFree(GetProcessHeap(), 0, ptr);
if (hmodule) FreeLibrary( hmodule );
return ret;
}
/**************************************************************************
* MMDRV_GetNum [internal]
*/
UINT MMDRV_GetNum(UINT type)
{
TRACE("(%04x)\n", type);
assert(type < MMDRV_MAX);
return llTypes[type].wMaxId;
}
/**************************************************************************
* MMDRV_Message [internal]
*/
DWORD MMDRV_Message(LPWINE_MLD mld, UINT wMsg, DWORD_PTR dwParam1,
DWORD_PTR dwParam2, BOOL bFrom32)
{
LPWINE_MM_DRIVER lpDrv;
DWORD ret;
WINE_MM_DRIVER_PART* part;
WINE_LLTYPE* llType = &llTypes[mld->type];
WINMM_MapType map;
int devID;
TRACE("(%s %u %u 0x%08lx 0x%08lx 0x%08lx %c)\n",
llTypes[mld->type].typestr, mld->uDeviceID, wMsg,
mld->dwDriverInstance, dwParam1, dwParam2, bFrom32?'Y':'N');
if (mld->uDeviceID == (UINT16)-1) {
if (!llType->bSupportMapper) {
WARN("uDev=-1 requested on non-mappable ll type %s\n",
llTypes[mld->type].typestr);
return MMSYSERR_BADDEVICEID;
}
devID = -1;
} else {
if (mld->uDeviceID >= llType->wMaxId) {
WARN("uDev(%u) requested >= max (%d)\n", mld->uDeviceID, llType->wMaxId);
return MMSYSERR_BADDEVICEID;
}
devID = mld->uDeviceID;
}
lpDrv = &MMDrvs[mld->mmdIndex];
part = &lpDrv->parts[mld->type];
#if 0
/* some sanity checks */
if (!(part->nIDMin <= devID))
ERR("!(part->nIDMin(%d) <= devID(%d))\n", part->nIDMin, devID);
if (!(devID < part->nIDMax))
ERR("!(devID(%d) < part->nIDMax(%d))\n", devID, part->nIDMax);
#endif
if (lpDrv->bIs32) {
assert(part->u.fnMessage32);
if (bFrom32) {
TRACE("Calling message(dev=%u msg=%u usr=0x%08lx p1=0x%08lx p2=0x%08lx)\n",
mld->uDeviceID, wMsg, mld->dwDriverInstance, dwParam1, dwParam2);
ret = part->u.fnMessage32(mld->uDeviceID, wMsg, mld->dwDriverInstance, dwParam1, dwParam2);
TRACE("=> %s\n", WINMM_ErrorToString(ret));
} else {
map = llType->Map16To32A(wMsg, &mld->dwDriverInstance, &dwParam1, &dwParam2);
switch (map) {
case WINMM_MAP_NOMEM:
ret = MMSYSERR_NOMEM;
break;
case WINMM_MAP_MSGERROR:
FIXME("NIY: no conversion yet 16->32 (%u)\n", wMsg);
ret = MMSYSERR_ERROR;
break;
case WINMM_MAP_OK:
case WINMM_MAP_OKMEM:
TRACE("Calling message(dev=%u msg=%u usr=0x%08lx p1=0x%08lx p2=0x%08lx)\n",
mld->uDeviceID, wMsg, mld->dwDriverInstance, dwParam1, dwParam2);
ret = part->u.fnMessage32(mld->uDeviceID, wMsg, mld->dwDriverInstance,
dwParam1, dwParam2);
TRACE("=> %s\n", WINMM_ErrorToString(ret));
if (map == WINMM_MAP_OKMEM)
llType->UnMap16To32A(wMsg, &mld->dwDriverInstance, &dwParam1, &dwParam2, ret);
break;
default:
FIXME("NIY\n");
ret = MMSYSERR_NOTSUPPORTED;
break;
}
}
} else {
assert(part->u.fnMessage16 && pFnCallMMDrvFunc16);
if (bFrom32) {
map = llType->Map32ATo16(wMsg, &mld->dwDriverInstance, &dwParam1, &dwParam2);
switch (map) {
case WINMM_MAP_NOMEM:
ret = MMSYSERR_NOMEM;
break;
case WINMM_MAP_MSGERROR:
FIXME("NIY: no conversion yet 32->16 (%u)\n", wMsg);
ret = MMSYSERR_ERROR;
break;
case WINMM_MAP_OK:
case WINMM_MAP_OKMEM:
TRACE("Calling message(dev=%u msg=%u usr=0x%08lx p1=0x%08lx p2=0x%08lx)\n",
mld->uDeviceID, wMsg, mld->dwDriverInstance, dwParam1, dwParam2);
ret = pFnCallMMDrvFunc16((DWORD)part->u.fnMessage16,
mld->uDeviceID, wMsg, mld->dwDriverInstance,
dwParam1, dwParam2);
TRACE("=> %s\n", WINMM_ErrorToString(ret));
if (map == WINMM_MAP_OKMEM)
llType->UnMap32ATo16(wMsg, &mld->dwDriverInstance, &dwParam1, &dwParam2, ret);
break;
default:
FIXME("NIY\n");
ret = MMSYSERR_NOTSUPPORTED;
break;
}
} else {
TRACE("Calling message(dev=%u msg=%u usr=0x%08lx p1=0x%08lx p2=0x%08lx)\n",
mld->uDeviceID, wMsg, mld->dwDriverInstance, dwParam1, dwParam2);
ret = pFnCallMMDrvFunc16((DWORD)part->u.fnMessage16,
mld->uDeviceID, wMsg, mld->dwDriverInstance,
dwParam1, dwParam2);
TRACE("=> %s\n", WINMM_ErrorToString(ret));
}
}
return ret;
}
/**************************************************************************
* MMDRV_Alloc [internal]
*/
LPWINE_MLD MMDRV_Alloc(UINT size, UINT type, LPHANDLE hndl, DWORD* dwFlags,
DWORD* dwCallback, DWORD* dwInstance, BOOL bFrom32)
{
LPWINE_MLD mld;
UINT i;
TRACE("(%d, %04x, %p, %p, %p, %p, %c)\n",
size, type, hndl, dwFlags, dwCallback, dwInstance, bFrom32?'Y':'N');
mld = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, size);
if (!mld) return NULL;
/* find an empty slot in MM_MLDrvs table */
for (i = 0; i < MAX_MM_MLDRVS; i++) if (!MM_MLDrvs[i]) break;
if (i == MAX_MM_MLDRVS) {
/* the MM_MLDrvs table could be made growable in the future if needed */
ERR("Too many open drivers\n");
return NULL;
}
MM_MLDrvs[i] = mld;
*hndl = (HANDLE)(i | 0x8000);
mld->type = type;
if ((UINT)*hndl < MMDRV_GetNum(type) || HIWORD(*hndl) != 0) {
/* FIXME: those conditions must be fulfilled so that:
* - we can distinguish between device IDs and handles
* - we can use handles as 16 or 32 bit entities
*/
ERR("Shouldn't happen. Bad allocation scheme\n");
}
mld->bFrom32 = bFrom32;
mld->dwFlags = HIWORD(*dwFlags);
mld->dwCallback = *dwCallback;
mld->dwClientInstance = *dwInstance;
if (llTypes[type].Callback)
{
*dwFlags = LOWORD(*dwFlags) | CALLBACK_FUNCTION;
*dwCallback = (DWORD)llTypes[type].Callback;
*dwInstance = (DWORD)mld; /* FIXME: wouldn't some 16 bit drivers only use the loword ? */
}
return mld;
}
/**************************************************************************
* MMDRV_Free [internal]
*/
void MMDRV_Free(HANDLE hndl, LPWINE_MLD mld)
{
TRACE("(%p, %p)\n", hndl, mld);
if ((UINT)hndl & 0x8000) {
unsigned idx = (UINT)hndl & ~0x8000;
if (idx < sizeof(MM_MLDrvs) / sizeof(MM_MLDrvs[0])) {
MM_MLDrvs[idx] = NULL;
HeapFree(GetProcessHeap(), 0, mld);
return;
}
}
ERR("Bad Handle %p at %p (not freed)\n", hndl, mld);
}
/**************************************************************************
* MMDRV_Open [internal]
*/
DWORD MMDRV_Open(LPWINE_MLD mld, UINT wMsg, DWORD dwParam1, DWORD dwFlags)
{
DWORD dwRet = MMSYSERR_BADDEVICEID;
DWORD dwInstance;
WINE_LLTYPE* llType = &llTypes[mld->type];
TRACE("(%p, %04x, 0x%08lx, 0x%08lx)\n", mld, wMsg, dwParam1, dwFlags);
mld->dwDriverInstance = (DWORD)&dwInstance;
if (mld->uDeviceID == (UINT)-1 || mld->uDeviceID == (UINT16)-1) {
TRACE("MAPPER mode requested !\n");
/* check if mapper is supported by type */
if (llType->bSupportMapper) {
if (llType->nMapper == -1) {
/* no driver for mapper has been loaded, try a dumb implementation */
TRACE("No mapper loaded, doing it by hand\n");
for (mld->uDeviceID = 0; mld->uDeviceID < llType->wMaxId; mld->uDeviceID++) {
if ((dwRet = MMDRV_Open(mld, wMsg, dwParam1, dwFlags)) == MMSYSERR_NOERROR) {
/* to share this function epilog */
dwInstance = mld->dwDriverInstance;
break;
}
}
} else {
mld->uDeviceID = (UINT16)-1;
mld->mmdIndex = llType->lpMlds[-1].mmdIndex;
TRACE("Setting mmdIndex to %u\n", mld->mmdIndex);
dwRet = MMDRV_Message(mld, wMsg, dwParam1, dwFlags, TRUE);
}
}
} else {
if (mld->uDeviceID < llType->wMaxId) {
mld->mmdIndex = llType->lpMlds[mld->uDeviceID].mmdIndex;
TRACE("Setting mmdIndex to %u\n", mld->mmdIndex);
dwRet = MMDRV_Message(mld, wMsg, dwParam1, dwFlags, TRUE);
}
}
if (dwRet == MMSYSERR_NOERROR)
mld->dwDriverInstance = dwInstance;
return dwRet;
}
/**************************************************************************
* MMDRV_Close [internal]
*/
DWORD MMDRV_Close(LPWINE_MLD mld, UINT wMsg)
{
TRACE("(%p, %04x)\n", mld, wMsg);
return MMDRV_Message(mld, wMsg, 0L, 0L, TRUE);
}
/**************************************************************************
* MMDRV_GetByID [internal]
*/
LPWINE_MLD MMDRV_GetByID(UINT uDevID, UINT type)
{
TRACE("(%04x, %04x)\n", uDevID, type);
if (uDevID < llTypes[type].wMaxId)
return &llTypes[type].lpMlds[uDevID];
if ((uDevID == (UINT16)-1 || uDevID == (UINT)-1) && llTypes[type].nMapper != -1)
return &llTypes[type].lpMlds[-1];
return NULL;
}
/**************************************************************************
* MMDRV_Get [internal]
*/
LPWINE_MLD MMDRV_Get(HANDLE _hndl, UINT type, BOOL bCanBeID)
{
LPWINE_MLD mld = NULL;
UINT hndl = (UINT)_hndl;
TRACE("(%p, %04x, %c)\n", _hndl, type, bCanBeID ? 'Y' : 'N');
assert(type < MMDRV_MAX);
if (hndl >= llTypes[type].wMaxId &&
hndl != (UINT16)-1 && hndl != (UINT)-1) {
if (hndl & 0x8000) {
hndl = hndl & ~0x8000;
if (hndl < sizeof(MM_MLDrvs) / sizeof(MM_MLDrvs[0])) {
mld = MM_MLDrvs[hndl];
if (!mld || !HeapValidate(GetProcessHeap(), 0, mld) || mld->type != type)
mld = NULL;
}
hndl = hndl | 0x8000;
}
}
if (mld == NULL && bCanBeID) {
mld = MMDRV_GetByID(hndl, type);
}
return mld;
}
/**************************************************************************
* MMDRV_GetRelated [internal]
*/
LPWINE_MLD MMDRV_GetRelated(HANDLE hndl, UINT srcType,
BOOL bSrcCanBeID, UINT dstType)
{
LPWINE_MLD mld;
TRACE("(%p, %04x, %c, %04x)\n",
hndl, srcType, bSrcCanBeID ? 'Y' : 'N', dstType);
if ((mld = MMDRV_Get(hndl, srcType, bSrcCanBeID)) != NULL) {
WINE_MM_DRIVER_PART* part = &MMDrvs[mld->mmdIndex].parts[dstType];
if (part->nIDMin < part->nIDMax)
return MMDRV_GetByID(part->nIDMin, dstType);
}
return NULL;
}
/**************************************************************************
* MMDRV_PhysicalFeatures [internal]
*/
UINT MMDRV_PhysicalFeatures(LPWINE_MLD mld, UINT uMsg, DWORD dwParam1,
DWORD dwParam2)
{
WINE_MM_DRIVER* lpDrv = &MMDrvs[mld->mmdIndex];
TRACE("(%p, %04x, %08lx, %08lx)\n", mld, uMsg, dwParam1, dwParam2);
/* all those function calls are undocumented */
switch (uMsg) {
case DRV_QUERYDRVENTRY:
lstrcpynA((LPSTR)dwParam1, lpDrv->drvname, LOWORD(dwParam2));
break;
case DRV_QUERYDEVNODE:
*(LPDWORD)dwParam1 = 0L; /* should be DevNode */
break;
case DRV_QUERYNAME:
WARN("NIY QueryName\n");
break;
case DRV_QUERYDRIVERIDS:
WARN("NIY call VxD\n");
/* should call VxD MMDEVLDR with (DevNode, dwParam1 and dwParam2) as pmts
* dwParam1 is buffer and dwParam2 is sizeof(buffer)
* I don't know where the result is stored though
*/
break;
case DRV_QUERYMAPPABLE:
return (lpDrv->bIsMapper) ? 2 : 0;
case DRVM_MAPPER_PREFERRED_GET:
/* FIXME: get from registry someday */
*((LPDWORD)dwParam1) = -1; /* No preferred device */
break;
case DRV_QUERYDEVICEINTERFACE:
case DRV_QUERYDEVICEINTERFACESIZE:
return MMDRV_Message(mld, uMsg, dwParam1, dwParam2, TRUE);
case DRV_QUERYDSOUNDIFACE: /* Wine-specific: Retrieve DirectSound interface */
case DRV_QUERYDSOUNDDESC: /* Wine-specific: Retrieve DirectSound driver description*/
return MMDRV_Message(mld, uMsg, dwParam1, dwParam2, TRUE);
default:
WARN("Unknown call %04x\n", uMsg);
return MMSYSERR_INVALPARAM;
}
return 0L;
}
/**************************************************************************
* MMDRV_InitPerType [internal]
*/
static BOOL MMDRV_InitPerType(LPWINE_MM_DRIVER lpDrv, UINT type, UINT wMsg)
{
WINE_MM_DRIVER_PART* part = &lpDrv->parts[type];
DWORD ret;
UINT count = 0;
int i, k;
TRACE("(%p, %04x, %04x)\n", lpDrv, type, wMsg);
part->nIDMin = part->nIDMax = 0;
/* for DRVM_INIT and DRVM_ENABLE, dwParam2 should be PnP node */
/* the DRVM_ENABLE is only required when the PnP node is non zero */
if (lpDrv->bIs32 && part->u.fnMessage32) {
ret = part->u.fnMessage32(0, DRVM_INIT, 0L, 0L, 0L);
TRACE("DRVM_INIT => %s\n", WINMM_ErrorToString(ret));
#if 0
ret = part->u.fnMessage32(0, DRVM_ENABLE, 0L, 0L, 0L);
TRACE("DRVM_ENABLE => %08lx\n", ret);
#endif
count = part->u.fnMessage32(0, wMsg, 0L, 0L, 0L);
} else if (!lpDrv->bIs32 && part->u.fnMessage16 && pFnCallMMDrvFunc16) {
ret = pFnCallMMDrvFunc16((DWORD)part->u.fnMessage16,
0, DRVM_INIT, 0L, 0L, 0L);
TRACE("DRVM_INIT => %s\n", WINMM_ErrorToString(ret));
#if 0
ret = pFnCallMMDrvFunc16((DWORD)part->u.fnMessage16,
0, DRVM_ENABLE, 0L, 0L, 0L);
TRACE("DRVM_ENABLE => %08lx\n", ret);
#endif
count = pFnCallMMDrvFunc16((DWORD)part->u.fnMessage16,
0, wMsg, 0L, 0L, 0L);
} else {
return FALSE;
}
TRACE("Got %u dev for (%s:%s)\n", count, lpDrv->drvname, llTypes[type].typestr);
if (HIWORD(count))
return FALSE;
/* got some drivers */
if (lpDrv->bIsMapper) {
/* it seems native mappers return 0 devices :-( */
if (llTypes[type].nMapper != -1)
ERR("Two mappers for type %s (%d, %s)\n",
llTypes[type].typestr, llTypes[type].nMapper, lpDrv->drvname);
if (count > 1)
ERR("Strange: mapper with %d > 1 devices\n", count);
llTypes[type].nMapper = MMDrvsHi;
} else {
if (count == 0)
return FALSE;
part->nIDMin = llTypes[type].wMaxId;
llTypes[type].wMaxId += count;
part->nIDMax = llTypes[type].wMaxId;
}
TRACE("Setting min=%d max=%d (ttop=%d) for (%s:%s)\n",
part->nIDMin, part->nIDMax, llTypes[type].wMaxId,
lpDrv->drvname, llTypes[type].typestr);
/* realloc translation table */
if (llTypes[type].lpMlds)
llTypes[type].lpMlds = (LPWINE_MLD)
HeapReAlloc(GetProcessHeap(), 0, llTypes[type].lpMlds - 1,
sizeof(WINE_MLD) * (llTypes[type].wMaxId + 1)) + 1;
else
llTypes[type].lpMlds = (LPWINE_MLD)
HeapAlloc(GetProcessHeap(), 0,
sizeof(WINE_MLD) * (llTypes[type].wMaxId + 1)) + 1;
/* re-build the translation table */
if (llTypes[type].nMapper != -1) {
TRACE("%s:Trans[%d] -> %s\n", llTypes[type].typestr, -1, MMDrvs[llTypes[type].nMapper].drvname);
llTypes[type].lpMlds[-1].uDeviceID = (UINT16)-1;
llTypes[type].lpMlds[-1].type = type;
llTypes[type].lpMlds[-1].mmdIndex = llTypes[type].nMapper;
llTypes[type].lpMlds[-1].dwDriverInstance = 0;
}
for (i = k = 0; i <= MMDrvsHi; i++) {
while (MMDrvs[i].parts[type].nIDMin <= k && k < MMDrvs[i].parts[type].nIDMax) {
TRACE("%s:Trans[%d] -> %s\n", llTypes[type].typestr, k, MMDrvs[i].drvname);
llTypes[type].lpMlds[k].uDeviceID = k;
llTypes[type].lpMlds[k].type = type;
llTypes[type].lpMlds[k].mmdIndex = i;
llTypes[type].lpMlds[k].dwDriverInstance = 0;
k++;
}
}
return TRUE;
}
/**************************************************************************
* MMDRV_Install [internal]
*/
static BOOL MMDRV_Install(LPCSTR drvRegName, LPCSTR drvFileName, BOOL bIsMapper)
{
int i, count = 0;
LPWINE_MM_DRIVER lpDrv = &MMDrvs[MMDrvsHi];
LPWINE_DRIVER d;
TRACE("('%s', '%s', mapper=%c);\n", drvRegName, drvFileName, bIsMapper ? 'Y' : 'N');
for (i = 0; i < MMDrvsHi; i++) {
if (!strcmp(drvRegName, MMDrvs[i].drvname)) return FALSE;
}
/* Be sure that size of MMDrvs matches the max number of loadable
* drivers !!
* If not just increase size of MMDrvs
*/
assert(MMDrvsHi <= sizeof(MMDrvs)/sizeof(MMDrvs[0]));
memset(lpDrv, 0, sizeof(*lpDrv));
if (!(lpDrv->hDriver = OpenDriverA(drvFileName, 0, 0))) {
WARN("Couldn't open driver '%s'\n", drvFileName);
return FALSE;
}
d = DRIVER_FindFromHDrvr(lpDrv->hDriver);
lpDrv->bIs32 = (d->dwFlags & WINE_GDF_16BIT) ? FALSE : TRUE;
/* Then look for xxxMessage functions */
#define AA(_h,_w,_x,_y,_z) \
func = (WINEMM_msgFunc##_y) _z ((_h), #_x); \
if (func != NULL) \
{ lpDrv->parts[_w].u.fnMessage##_y = func; count++; \
TRACE("Got %d bit func '%s'\n", _y, #_x); }
if (lpDrv->bIs32) {
WINEMM_msgFunc32 func;
char buffer[128];
if (d->d.d32.hModule) {
#define A(_x,_y) AA(d->d.d32.hModule,_x,_y,32,GetProcAddress)
A(MMDRV_AUX, auxMessage);
A(MMDRV_MIXER, mxdMessage);
A(MMDRV_MIDIIN, midMessage);
A(MMDRV_MIDIOUT, modMessage);
A(MMDRV_WAVEIN, widMessage);
A(MMDRV_WAVEOUT, wodMessage);
#undef A
}
if (TRACE_ON(winmm)) {
if (MMDRV_GetDescription32(drvFileName, buffer, sizeof(buffer)))
TRACE("%s => %s\n", drvFileName, buffer);
else
TRACE("%s => No description\n", drvFileName);
}
} else if (WINMM_CheckForMMSystem() && pFnLoadMMDrvFunc16) {
count += pFnLoadMMDrvFunc16(drvFileName, d, lpDrv);
}
#undef AA
if (!count) {
CloseDriver(lpDrv->hDriver, 0, 0);
WARN("No message functions found\n");
return FALSE;
}
/* FIXME: being a mapper or not should be known by another way */
/* it's known for NE drvs (the description is of the form '*mapper: *'
* I don't have any clue for PE drvs
*/
lpDrv->bIsMapper = bIsMapper;
lpDrv->drvname = strcpy(HeapAlloc(GetProcessHeap(), 0, strlen(drvRegName) + 1), drvRegName);
/* Finish init and get the count of the devices */
i = 0;
if (MMDRV_InitPerType(lpDrv, MMDRV_AUX, AUXDM_GETNUMDEVS)) i = 1;
if (MMDRV_InitPerType(lpDrv, MMDRV_MIXER, MXDM_GETNUMDEVS)) i = 1;
if (MMDRV_InitPerType(lpDrv, MMDRV_MIDIIN, MIDM_GETNUMDEVS)) i = 1;
if (MMDRV_InitPerType(lpDrv, MMDRV_MIDIOUT, MODM_GETNUMDEVS)) i = 1;
if (MMDRV_InitPerType(lpDrv, MMDRV_WAVEIN, WIDM_GETNUMDEVS)) i = 1;
if (MMDRV_InitPerType(lpDrv, MMDRV_WAVEOUT, WODM_GETNUMDEVS)) i = 1;
/* if all those func calls return FALSE, then the driver must be unloaded */
if (!i) {
CloseDriver(lpDrv->hDriver, 0, 0);
HeapFree(GetProcessHeap(), 0, lpDrv->drvname);
WARN("Driver initialization failed\n");
return FALSE;
}
MMDrvsHi++;
return TRUE;
}
/**************************************************************************
* MMDRV_InitFromRegistry [internal]
*/
static BOOL MMDRV_InitFromRegistry(void)
{
HKEY hKey;
char buffer[256];
char* p1;
char* p2;
DWORD type, size;
BOOL ret = FALSE;
TRACE("()\n");
if (RegCreateKeyA(HKEY_LOCAL_MACHINE, "Software\\Wine\\Wine\\Config\\WinMM", &hKey)) {
TRACE("Cannot open WinMM config key\n");
return FALSE;
}
size = sizeof(buffer);
if (!RegQueryValueExA(hKey, "Drivers", 0, &type, (LPVOID)buffer, &size)) {
p1 = buffer;
while (p1) {
p2 = strchr(p1, ';');
if (p2) *p2++ = '\0';
ret |= MMDRV_Install(p1, p1, FALSE);
p1 = p2;
}
}
/* finish with mappers */
size = sizeof(buffer);
if (!RegQueryValueExA(hKey, "WaveMapper", 0, &type, (LPVOID)buffer, &size))
ret |= MMDRV_Install("wavemapper", buffer, TRUE);
size = sizeof(buffer);
if (!RegQueryValueExA(hKey, "MidiMapper", 0, &type, (LPVOID)buffer, &size))
ret |= MMDRV_Install("midimapper", buffer, TRUE);
RegCloseKey(hKey);
return ret;
}
/**************************************************************************
* MMDRV_InitHardcoded [internal]
*/
static BOOL MMDRV_InitHardcoded(void)
{
TRACE("()\n");
/* first load hardware drivers */
#ifndef __REACTOS__
MMDRV_Install("wineoss.drv", "wineoss.drv", FALSE);
#endif /* __REACTOS__ */
#ifdef __REACTOS__
// AG: TESTING:
MMDRV_Install("mmdrv.dll", "mmdrv.dll", FALSE);
#endif
/* finish with mappers */
MMDRV_Install("wavemapper", "msacm32.dll", TRUE);
MMDRV_Install("midimapper", "midimap.dll", TRUE);
return TRUE;
}
/**************************************************************************
* MMDRV_Init [internal]
*/
BOOL MMDRV_Init(void)
{
TRACE("()\n");
/* FIXME: MMDRV_InitFromRegistry shall be MMDRV_Init in a near future */
return MMDRV_InitFromRegistry() || MMDRV_InitHardcoded();
}
/******************************************************************
* ExitPerType
*
*
*/
static BOOL MMDRV_ExitPerType(LPWINE_MM_DRIVER lpDrv, UINT type)
{
WINE_MM_DRIVER_PART* part = &lpDrv->parts[type];
DWORD ret;
TRACE("(%p, %04x)\n", lpDrv, type);
if (lpDrv->bIs32 && part->u.fnMessage32) {
#if 0
ret = part->u.fnMessage32(0, DRVM_DISABLE, 0L, 0L, 0L);
TRACE("DRVM_DISABLE => %08lx\n", ret);
#endif
ret = part->u.fnMessage32(0, DRVM_EXIT, 0L, 0L, 0L);
TRACE("DRVM_EXIT => %s\n", WINMM_ErrorToString(ret));
} else if (!lpDrv->bIs32 && part->u.fnMessage16 && pFnCallMMDrvFunc16) {
#if 0
ret = pFnCallMMDrvFunc16((DWORD)part->u.fnMessage16,
0, DRVM_DISABLE, 0L, 0L, 0L);
TRACE("DRVM_DISABLE => %08lx\n", ret);
#endif
ret = pFnCallMMDrvFunc16((DWORD)part->u.fnMessage16,
0, DRVM_EXIT, 0L, 0L, 0L);
TRACE("DRVM_EXIT => %s\n", WINMM_ErrorToString(ret));
} else {
return FALSE;
}
return TRUE;
}
/******************************************************************
* Exit
*
*
*/
void MMDRV_Exit(void)
{
int i;
TRACE("()\n");
for (i = 0; i < sizeof(MM_MLDrvs) / sizeof(MM_MLDrvs[0]); i++)
{
if (MM_MLDrvs[i] != NULL)
{
FIXME("Closing while ll-driver open\n");
#if 0
/* FIXME: should generate a message depending on type */
MMDRV_Free((HANDLE)(i | 0x8000), MM_MLDrvs[i]);
#endif
}
}
/* unload driver, in reverse order of loading */
for (i = sizeof(MMDrvs) / sizeof(MMDrvs[0]) - 1; i >= 0; i--)
{
MMDRV_ExitPerType(&MMDrvs[i], MMDRV_AUX);
MMDRV_ExitPerType(&MMDrvs[i], MMDRV_MIXER);
MMDRV_ExitPerType(&MMDrvs[i], MMDRV_MIDIIN);
MMDRV_ExitPerType(&MMDrvs[i], MMDRV_MIDIOUT);
MMDRV_ExitPerType(&MMDrvs[i], MMDRV_WAVEIN);
MMDRV_ExitPerType(&MMDrvs[i], MMDRV_WAVEOUT);
CloseDriver(MMDrvs[i].hDriver, 0, 0);
}
}

1743
reactos/lib/winmm/mci.c
View file

File diff suppressed because it is too large Load diff

2795
reactos/lib/winmm/message16.c
View file

File diff suppressed because it is too large Load diff

13
reactos/lib/winmm/midimap/Makefile.in
View file

@ -1,13 +0,0 @@
TOPSRCDIR = @top_srcdir@
TOPOBJDIR = ../../..
SRCDIR = @srcdir@
VPATH = @srcdir@
MODULE = midimap.drv
IMPORTS = winmm user32 advapi32 kernel32
C_SRCS = \
midimap.c
@MAKE_DLL_RULES@
### Dependencies:

23
reactos/lib/winmm/midimap/Makefile.ros-template
View file

@ -1,23 +0,0 @@
# $Id: Makefile.ros-template,v 1.4 2004/12/03 23:37:43 blight Exp $
TARGET_NAME = midimap
TARGET_OBJECTS = @C_SRCS@
TARGET_CFLAGS = @EXTRADEFS@ -D__REACTOS__
TARGET_SDKLIBS = @IMPORTS@ winmm.a wine.a wine_uuid.a ntdll.a
TARGET_BASE = $(TARGET_LIB_BASE_MIDIMAP)
TARGET_RC_SRCS = @RC_SRCS@
TARGET_RC_BINSRC = @RC_BINSRC@
TARGET_RC_BINARIES = @RC_BINARIES@
TARGET_EXTENSION = .dll
default: all
DEP_OBJECTS = $(TARGET_OBJECTS)
include $(TOOLS_PATH)/depend.mk

9
reactos/lib/winmm/midimap/makefile
View file

@ -1,9 +0,0 @@
# $Id: makefile,v 1.1 2004/03/10 15:22:44 silverblade Exp $
PATH_TO_TOP = ../../..
TARGET_TYPE = winedll
include $(PATH_TO_TOP)/rules.mak
include $(TOOLS_PATH)/helper.mk

555
reactos/lib/winmm/midimap/midimap.c
View file

@ -1,555 +0,0 @@
/* -*- tab-width: 8; c-basic-offset: 4 -*- */
/*
* Wine MIDI mapper driver
*
* Copyright 1999, 2000, 2001 Eric Pouech
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*
* TODO:
* notification has to be implemented
* IDF file loading
*/
#include <stdarg.h>
#include <string.h>
#include <stdlib.h>
#include "windef.h"
#include "winbase.h"
#include "wingdi.h"
#include "winuser.h"
#include "mmddk.h"
#include "winreg.h"
#include "wine/debug.h"
/*
* Here's how Windows stores the midiOut mapping information.
*
* Full form (in HKU) is:
*
* [Software\\Microsoft\\Windows\\CurrentVersion\\Multimedia\\MIDIMap] 988836060
* "AutoScheme"=dword:00000000
* "ConfigureCount"=dword:00000004
* "CurrentInstrument"="Wine OSS midi"
* "CurrentScheme"="epp"
* "DriverList"=""
* "UseScheme"=dword:00000000
*
* AutoScheme: ?
* CurrentInstrument: name of midiOut device to use when UseScheme is 0. Wine uses an extension
* of the form #n to link to n'th midiOut device of the system
* CurrentScheme: when UseScheme is non null, it's the scheme to use (see below)
* DriverList: ?
* UseScheme: trigger for simple/complex mapping
*
* A scheme is defined (in HKLM) as:
*
* [System\\CurrentControlSet\\Control\\MediaProperties\\PrivateProperties\\Midi\\Schemes\\<nameScheme>]
* <nameScheme>: one key for each defined scheme (system wide)
* under each one of these <nameScheme> keys, there's:
* [...\\<nameScheme>\\<idxDevice>]
* "Channels"="<bitMask>"
* (the default value of this key also refers to the name of the device).
*
* this defines, for each midiOut device (identified by its index in <idxDevice>), which
* channels have to be mapped onto it. The <bitMask> defines the channels (from 0 to 15)
* will be mapped (mapping occurs for channel <ch> if bit <ch> is set in <bitMask>
*
* Further mapping information can also be defined in:
* [System\\CurrentControlSet\\Control\\MediaProperties\\PrivateProperties\\Midi\\Ports\\<nameDevice>\\Instruments\\<idx>]
* "Definition"="<.idf file>"
* "FriendlyName"="#for .idx file#"
* "Port"="<idxPort>"
*
* This last part isn't implemented (.idf file support).
*/
WINE_DEFAULT_DEBUG_CHANNEL(msacm);
typedef struct tagMIDIOUTPORT
{
char name[MAXPNAMELEN];
int loaded;
HMIDIOUT hMidi;
unsigned short uDevID;
LPBYTE lpbPatch;
unsigned int aChn[16];
} MIDIOUTPORT;
typedef struct tagMIDIMAPDATA
{
struct tagMIDIMAPDATA* self;
MIDIOUTPORT* ChannelMap[16];
} MIDIMAPDATA;
static MIDIOUTPORT* midiOutPorts;
static unsigned numMidiOutPorts;
static BOOL MIDIMAP_IsBadData(MIDIMAPDATA* mm)
{
if (!IsBadReadPtr(mm, sizeof(MIDIMAPDATA)) && mm->self == mm)
return FALSE;
TRACE("Bad midimap data (%p)\n", mm);
return TRUE;
}
static BOOL MIDIMAP_FindPort(const char* name, unsigned* dev)
{
for (*dev = 0; *dev < numMidiOutPorts; (*dev)++)
{
TRACE("%s\n", midiOutPorts[*dev].name);
if (strcmp(midiOutPorts[*dev].name, name) == 0)
return TRUE;
}
/* try the form #nnn */
if (*name == '#' && isdigit(name[1]))
{
*dev = atoi(name + 1);
if (*dev < numMidiOutPorts)
return TRUE;
}
return FALSE;
}
static BOOL MIDIMAP_LoadSettingsDefault(MIDIMAPDATA* mom, const char* port)
{
unsigned i, dev = 0;
if (port != NULL && !MIDIMAP_FindPort(port, &dev))
{
ERR("Registry glitch: couldn't find midi out (%s)\n", port);
dev = 0;
}
/* this is necessary when no midi out ports are present */
if (dev >= numMidiOutPorts)
return FALSE;
/* sets default */
for (i = 0; i < 16; i++) mom->ChannelMap[i] = &midiOutPorts[dev];
return TRUE;
}
static BOOL MIDIMAP_LoadSettingsScheme(MIDIMAPDATA* mom, const char* scheme)
{
HKEY hSchemesKey, hKey, hPortKey;
unsigned i, idx, dev;
char buffer[256], port[256];
DWORD type, size, mask;
for (i = 0; i < 16; i++) mom->ChannelMap[i] = NULL;
if (RegOpenKeyA(HKEY_LOCAL_MACHINE,
"System\\CurrentControlSet\\Control\\MediaProperties\\PrivateProperties\\Midi\\Schemes",
&hSchemesKey))
{
return FALSE;
}
if (RegOpenKeyA(hSchemesKey, scheme, &hKey))
{
RegCloseKey(hSchemesKey);
return FALSE;
}
for (idx = 0; !RegEnumKeyA(hKey, idx, buffer, sizeof(buffer)); idx++)
{
if (RegOpenKeyA(hKey, buffer, &hPortKey)) continue;
size = sizeof(port);
if (RegQueryValueExA(hPortKey, NULL, 0, &type, port, &size)) continue;
if (!MIDIMAP_FindPort(port, &dev)) continue;
size = sizeof(mask);
if (RegQueryValueExA(hPortKey, "Channels", 0, &type, (void*)&mask, &size))
continue;
for (i = 0; i < 16; i++)
{
if (mask & (1 << i))
{
if (mom->ChannelMap[i])
ERR("Quirks in registry, channel %u is mapped twice\n", i);
mom->ChannelMap[i] = &midiOutPorts[dev];
}
}
}
RegCloseKey(hSchemesKey);
RegCloseKey(hKey);
return TRUE;
}
static BOOL MIDIMAP_LoadSettings(MIDIMAPDATA* mom)
{
HKEY hKey;
BOOL ret;
if (RegOpenKeyA(HKEY_CURRENT_USER,
"Software\\Microsoft\\Windows\\CurrentVersion\\Multimedia\\MIDIMap", &hKey))
{
ret = MIDIMAP_LoadSettingsDefault(mom, NULL);
}
else
{
DWORD type, size, out;
char buffer[256];
ret = 2;
size = sizeof(out);
if (!RegQueryValueExA(hKey, "UseScheme", 0, &type, (void*)&out, &size) && out)
{
size = sizeof(buffer);
if (!RegQueryValueExA(hKey, "CurrentScheme", 0, &type, buffer, &size))
{
if (!(ret = MIDIMAP_LoadSettingsScheme(mom, buffer)))
ret = MIDIMAP_LoadSettingsDefault(mom, NULL);
}
else
{
ERR("Wrong registry: UseScheme is active, but no CurrentScheme found\n");
}
}
if (ret == 2)
{
size = sizeof(buffer);
if (!RegQueryValueExA(hKey, "CurrentInstrument", 0, &type, buffer, &size) && *buffer)
{
ret = MIDIMAP_LoadSettingsDefault(mom, buffer);
}
else
{
ret = MIDIMAP_LoadSettingsDefault(mom, NULL);
}
}
}
RegCloseKey(hKey);
if (ret && TRACE_ON(msacm))
{
unsigned i;
for (i = 0; i < 16; i++)
{
TRACE("chnMap[%2d] => %d\n",
i, mom->ChannelMap[i] ? mom->ChannelMap[i]->uDevID : -1);
}
}
return ret;
}
static DWORD modOpen(LPDWORD lpdwUser, LPMIDIOPENDESC lpDesc, DWORD dwFlags)
{
MIDIMAPDATA* mom = HeapAlloc(GetProcessHeap(), 0, sizeof(MIDIMAPDATA));
TRACE("(%p %p %08lx)\n", lpdwUser, lpDesc, dwFlags);
if (!mom) return MMSYSERR_NOMEM;
if (MIDIMAP_LoadSettings(mom))
{
*lpdwUser = (DWORD)mom;
mom->self = mom;
return MMSYSERR_NOERROR;
}
HeapFree(GetProcessHeap(), 0, mom);
return MIDIERR_INVALIDSETUP;
}
static DWORD modClose(MIDIMAPDATA* mom)
{
UINT i;
DWORD ret = MMSYSERR_NOERROR;
if (MIDIMAP_IsBadData(mom)) return MMSYSERR_ERROR;
for (i = 0; i < 16; i++)
{
DWORD t;
if (mom->ChannelMap[i] && mom->ChannelMap[i]->loaded > 0)
{
t = midiOutClose(mom->ChannelMap[i]->hMidi);
if (t == MMSYSERR_NOERROR)
{
mom->ChannelMap[i]->loaded = 0;
mom->ChannelMap[i]->hMidi = 0;
}
else if (ret == MMSYSERR_NOERROR)
ret = t;
}
}
if (ret == MMSYSERR_NOERROR)
HeapFree(GetProcessHeap(), 0, mom);
return ret;
}
static DWORD modLongData(MIDIMAPDATA* mom, LPMIDIHDR lpMidiHdr, DWORD dwParam2)
{
WORD chn;
DWORD ret = MMSYSERR_NOERROR;
MIDIHDR mh;
if (MIDIMAP_IsBadData(mom))
return MMSYSERR_ERROR;
mh = *lpMidiHdr;
for (chn = 0; chn < 16; chn++)
{
if (mom->ChannelMap[chn] && mom->ChannelMap[chn]->loaded > 0)
{
mh.dwFlags = 0;
midiOutPrepareHeader(mom->ChannelMap[chn]->hMidi, &mh, sizeof(mh));
ret = midiOutLongMsg(mom->ChannelMap[chn]->hMidi, &mh, sizeof(mh));
midiOutUnprepareHeader(mom->ChannelMap[chn]->hMidi, &mh, sizeof(mh));
if (ret != MMSYSERR_NOERROR) break;
}
}
return ret;
}
static DWORD modData(MIDIMAPDATA* mom, DWORD dwParam)
{
BYTE lb = LOBYTE(LOWORD(dwParam));
WORD chn = lb & 0x0F;
DWORD ret = MMSYSERR_NOERROR;
if (MIDIMAP_IsBadData(mom))
return MMSYSERR_ERROR;
if (!mom->ChannelMap[chn]) return MMSYSERR_NOERROR;
switch (lb & 0xF0)
{
case 0x80:
case 0x90:
case 0xA0:
case 0xB0:
case 0xC0:
case 0xD0:
case 0xE0:
if (mom->ChannelMap[chn]->loaded == 0)
{
if (midiOutOpen(&mom->ChannelMap[chn]->hMidi, mom->ChannelMap[chn]->uDevID,
0L, 0L, CALLBACK_NULL) == MMSYSERR_NOERROR)
mom->ChannelMap[chn]->loaded = 1;
else
mom->ChannelMap[chn]->loaded = -1;
/* FIXME: should load here the IDF midi data... and allow channel and
* patch mappings
*/
}
if (mom->ChannelMap[chn]->loaded > 0)
{
/* change channel */
dwParam &= ~0x0F;
dwParam |= mom->ChannelMap[chn]->aChn[chn];
if ((LOBYTE(LOWORD(dwParam)) & 0xF0) == 0xC0 /* program change */ &&
mom->ChannelMap[chn]->lpbPatch)
{
BYTE patch = HIBYTE(LOWORD(dwParam));
/* change patch */
dwParam &= ~0x0000FF00;
dwParam |= mom->ChannelMap[chn]->lpbPatch[patch];
}
ret = midiOutShortMsg(mom->ChannelMap[chn]->hMidi, dwParam);
}
break;
case 0xF0:
for (chn = 0; chn < 16; chn++)
{
if (mom->ChannelMap[chn]->loaded > 0)
ret = midiOutShortMsg(mom->ChannelMap[chn]->hMidi, dwParam);
}
break;
default:
FIXME("ooch %lu\n", dwParam);
}
return ret;
}
static DWORD modPrepare(MIDIMAPDATA* mom, LPMIDIHDR lpMidiHdr, DWORD dwParam2)
{
if (MIDIMAP_IsBadData(mom)) return MMSYSERR_ERROR;
if (lpMidiHdr->dwFlags & (MHDR_ISSTRM|MHDR_PREPARED))
return MMSYSERR_INVALPARAM;
lpMidiHdr->dwFlags |= MHDR_PREPARED;
return MMSYSERR_NOERROR;
}
static DWORD modUnprepare(MIDIMAPDATA* mom, LPMIDIHDR lpMidiHdr, DWORD dwParam2)
{
if (MIDIMAP_IsBadData(mom)) return MMSYSERR_ERROR;
if ((lpMidiHdr->dwFlags & MHDR_ISSTRM) || !(lpMidiHdr->dwFlags & MHDR_PREPARED))
return MMSYSERR_INVALPARAM;
lpMidiHdr->dwFlags &= ~MHDR_PREPARED;
return MMSYSERR_NOERROR;
}
static DWORD modGetDevCaps(UINT wDevID, MIDIMAPDATA* mom, LPMIDIOUTCAPSA lpMidiCaps, DWORD size)
{
lpMidiCaps->wMid = 0x00FF;
lpMidiCaps->wPid = 0x0001;
lpMidiCaps->vDriverVersion = 0x0100;
strcpy(lpMidiCaps->szPname, "Wine midi out mapper");
lpMidiCaps->wTechnology = MOD_MAPPER;
lpMidiCaps->wVoices = 0;
lpMidiCaps->wNotes = 0;
lpMidiCaps->wChannelMask = 0xFFFF;
lpMidiCaps->dwSupport = 0L;
return MMSYSERR_NOERROR;
}
static DWORD modReset(MIDIMAPDATA* mom)
{
WORD chn;
DWORD ret = MMSYSERR_NOERROR;
if (MIDIMAP_IsBadData(mom))
return MMSYSERR_ERROR;
for (chn = 0; chn < 16; chn++)
{
if (mom->ChannelMap[chn] && mom->ChannelMap[chn]->loaded > 0)
{
ret = midiOutReset(mom->ChannelMap[chn]->hMidi);
if (ret != MMSYSERR_NOERROR) break;
}
}
return ret;
}
/**************************************************************************
* modMessage (MIDIMAP.@)
*/
DWORD WINAPI MIDIMAP_modMessage(UINT wDevID, UINT wMsg, DWORD dwUser,
DWORD dwParam1, DWORD dwParam2)
{
TRACE("(%u, %04X, %08lX, %08lX, %08lX);\n",
wDevID, wMsg, dwUser, dwParam1, dwParam2);
switch (wMsg)
{
case DRVM_INIT:
case DRVM_EXIT:
case DRVM_ENABLE:
case DRVM_DISABLE:
/* FIXME: Pretend this is supported */
return 0;
case MODM_OPEN: return modOpen ((LPDWORD)dwUser, (LPMIDIOPENDESC)dwParam1,dwParam2);
case MODM_CLOSE: return modClose ((MIDIMAPDATA*)dwUser);
case MODM_DATA: return modData ((MIDIMAPDATA*)dwUser, dwParam1);
case MODM_LONGDATA: return modLongData ((MIDIMAPDATA*)dwUser, (LPMIDIHDR)dwParam1, dwParam2);
case MODM_PREPARE: return modPrepare ((MIDIMAPDATA*)dwUser, (LPMIDIHDR)dwParam1, dwParam2);
case MODM_UNPREPARE: return modUnprepare ((MIDIMAPDATA*)dwUser, (LPMIDIHDR)dwParam1, dwParam2);
case MODM_RESET: return modReset ((MIDIMAPDATA*)dwUser);
case MODM_GETDEVCAPS: return modGetDevCaps (wDevID, (MIDIMAPDATA*)dwUser, (LPMIDIOUTCAPSA)dwParam1,dwParam2);
case MODM_GETNUMDEVS: return 1;
case MODM_GETVOLUME: return MMSYSERR_NOTSUPPORTED;
case MODM_SETVOLUME: return MMSYSERR_NOTSUPPORTED;
default:
FIXME("unknown message %d!\n", wMsg);
}
return MMSYSERR_NOTSUPPORTED;
}
/*======================================================================*
* Driver part *
*======================================================================*/
/**************************************************************************
* MIDIMAP_drvOpen [internal]
*/
static DWORD MIDIMAP_drvOpen(LPSTR str)
{
MIDIOUTCAPSA moc;
unsigned dev, i;
if (midiOutPorts)
return 0;
numMidiOutPorts = midiOutGetNumDevs();
midiOutPorts = HeapAlloc(GetProcessHeap(), 0,
numMidiOutPorts * sizeof(MIDIOUTPORT));
for (dev = 0; dev < numMidiOutPorts; dev++)
{
if (midiOutGetDevCapsA(dev, &moc, sizeof(moc)) == 0L)
{
strcpy(midiOutPorts[dev].name, moc.szPname);
midiOutPorts[dev].loaded = 0;
midiOutPorts[dev].hMidi = 0;
midiOutPorts[dev].uDevID = dev;
midiOutPorts[dev].lpbPatch = NULL;
for (i = 0; i < 16; i++)
midiOutPorts[dev].aChn[i] = i;
}
else
{
midiOutPorts[dev].loaded = -1;
}
}
return 1;
}
/**************************************************************************
* MIDIMAP_drvClose [internal]
*/
static DWORD MIDIMAP_drvClose(DWORD dwDevID)
{
if (midiOutPorts)
{
HeapFree(GetProcessHeap(), 0, midiOutPorts);
midiOutPorts = NULL;
return 1;
}
return 0;
}
/**************************************************************************
* DriverProc (MIDIMAP.@)
*/
LONG CALLBACK MIDIMAP_DriverProc(DWORD dwDevID, HDRVR hDriv, DWORD wMsg,
DWORD dwParam1, DWORD dwParam2)
{
/* EPP TRACE("(%08lX, %04X, %08lX, %08lX, %08lX)\n", */
/* EPP dwDevID, hDriv, wMsg, dwParam1, dwParam2); */
switch (wMsg)
{
case DRV_LOAD: return 1;
case DRV_FREE: return 1;
case DRV_OPEN: return MIDIMAP_drvOpen((LPSTR)dwParam1);
case DRV_CLOSE: return MIDIMAP_drvClose(dwDevID);
case DRV_ENABLE: return 1;
case DRV_DISABLE: return 1;
case DRV_QUERYCONFIGURE: return 1;
case DRV_CONFIGURE: MessageBoxA(0, "MIDIMAP MultiMedia Driver !", "OSS Driver", MB_OK); return 1;
case DRV_INSTALL: return DRVCNF_RESTART;
case DRV_REMOVE: return DRVCNF_RESTART;
default:
return DefDriverProc(dwDevID, hDriv, wMsg, dwParam1, dwParam2);
}
}

7
reactos/lib/winmm/midimap/midimap.rc
View file

@ -1,7 +0,0 @@
/* $Id: midimap.rc,v 1.2 2004/10/16 20:27:39 gvg Exp $ */
#define REACTOS_VERSION_DLL
#define REACTOS_STR_FILE_DESCRIPTION "ReactOS/WINE MIDI Mapper\0"
#define REACTOS_STR_INTERNAL_NAME "midimap\0"
#define REACTOS_STR_ORIGINAL_FILENAME "midimap.drv\0"
#include <reactos/version.rc>

2
reactos/lib/winmm/midimap/midimap.spec
View file

@ -1,2 +0,0 @@
@ stdcall DriverProc(long long long long long) MIDIMAP_DriverProc
@ stdcall modMessage(long long long long long) MIDIMAP_modMessage

0
reactos/lib/winmm/midimap/winehq2ros.patch
View file

1389
reactos/lib/winmm/mmio.c
View file

File diff suppressed because it is too large Load diff

3174
reactos/lib/winmm/mmsystem.c
View file

File diff suppressed because it is too large Load diff

176
reactos/lib/winmm/mmsystem.spec
View file

@ -1,176 +0,0 @@
#1 pascal MMSYSTEM_WEP(word word word ptr) MMSYSTEM_WEP
2 pascal sndPlaySound(ptr word) sndPlaySound16
3 pascal PlaySound(ptr word long) PlaySound16
5 pascal mmsystemGetVersion() mmsystemGetVersion16
6 pascal DriverProc(long word word long long) DriverProc16
8 pascal WMMMidiRunOnce() WMMMidiRunOnce16
30 pascal -ret16 OutputDebugStr(str) OutputDebugStr16
31 pascal DriverCallback(long word word word long long long) DriverCallback16
32 pascal StackEnter() StackEnter16
33 pascal StackLeave() StackLeave16
34 stub MMDRVINSTALL
101 pascal joyGetNumDevs() joyGetNumDevs16
102 pascal joyGetDevCaps(word ptr word) joyGetDevCaps16
103 pascal joyGetPos(word ptr) joyGetPos16
104 pascal joyGetThreshold(word ptr) joyGetThreshold16
105 pascal joyReleaseCapture(word) joyReleaseCapture16
106 pascal joySetCapture(word word word word) joySetCapture16
107 pascal joySetThreshold(word word) joySetThreshold16
109 pascal joySetCalibration(word) joySetCalibration16
110 pascal joyGetPosEx(word ptr) joyGetPosEx16
111 stub JOYCONFIGCHANGED
201 pascal midiOutGetNumDevs() midiOutGetNumDevs16
202 pascal midiOutGetDevCaps(word ptr word) midiOutGetDevCaps16
203 pascal midiOutGetErrorText(word ptr word) midiOutGetErrorText16
204 pascal midiOutOpen(ptr word long long long) midiOutOpen16
205 pascal midiOutClose(word) midiOutClose16
206 pascal midiOutPrepareHeader(word segptr word) midiOutPrepareHeader16
207 pascal midiOutUnprepareHeader(word segptr word) midiOutUnprepareHeader16
208 pascal midiOutShortMsg(word long) midiOutShortMsg16
209 pascal midiOutLongMsg(word segptr word) midiOutLongMsg16
210 pascal midiOutReset(word) midiOutReset16
211 pascal midiOutGetVolume(word ptr) midiOutGetVolume16
212 pascal midiOutSetVolume(word long) midiOutSetVolume16
213 pascal midiOutCachePatches(word word ptr word) midiOutCachePatches16
214 pascal midiOutCacheDrumPatches(word word ptr word) midiOutCacheDrumPatches16
215 pascal midiOutGetID(word ptr) midiOutGetID16
216 pascal midiOutMessage(word word long long) midiOutMessage16
250 pascal midiStreamProperty(word ptr long) midiStreamProperty16
251 pascal midiStreamOpen(ptr ptr long long long long) midiStreamOpen16
252 pascal midiStreamClose(word) midiStreamClose16
253 pascal midiStreamPosition(word ptr word) midiStreamPosition16
254 pascal midiStreamOut(word ptr word) midiStreamOut16
255 pascal midiStreamPause(word) midiStreamPause16
256 pascal midiStreamRestart(word) midiStreamRestart16
257 pascal midiStreamStop(word) midiStreamStop16
301 pascal midiInGetNumDevs() midiInGetNumDevs16
302 pascal midiInGetDevCaps(word ptr word) midiInGetDevCaps16
303 pascal midiInGetErrorText(word ptr word) midiInGetErrorText16
304 pascal midiInOpen(ptr word long long long) midiInOpen16
305 pascal midiInClose(word) midiInClose16
306 pascal midiInPrepareHeader(word segptr word) midiInPrepareHeader16
307 pascal midiInUnprepareHeader(word segptr word) midiInUnprepareHeader16
308 pascal midiInAddBuffer(word segptr word) midiInAddBuffer16
309 pascal midiInStart(word) midiInStart16
310 pascal midiInStop(word) midiInStop16
311 pascal midiInReset(word) midiInReset16
312 pascal midiInGetID(word ptr) midiInGetID16
313 pascal midiInMessage(word word long long) midiInMessage16
350 pascal auxGetNumDevs() auxGetNumDevs16
351 pascal auxGetDevCaps(word ptr word) auxGetDevCaps16
352 pascal auxGetVolume(word ptr) auxGetVolume16
353 pascal auxSetVolume(word long) auxSetVolume16
354 pascal auxOutMessage(word word long long) auxOutMessage16
401 pascal waveOutGetNumDevs() waveOutGetNumDevs16
402 pascal waveOutGetDevCaps(word ptr word) waveOutGetDevCaps16
403 pascal waveOutGetErrorText(word ptr word) waveOutGetErrorText16
404 pascal waveOutOpen(ptr word ptr long long long) waveOutOpen16
405 pascal waveOutClose(word) waveOutClose16
406 pascal waveOutPrepareHeader(word segptr word) waveOutPrepareHeader16
407 pascal waveOutUnprepareHeader(word segptr word) waveOutUnprepareHeader16
408 pascal waveOutWrite(word segptr word) waveOutWrite16
409 pascal waveOutPause(word) waveOutPause16
410 pascal waveOutRestart(word) waveOutRestart16
411 pascal waveOutReset(word) waveOutReset16
412 pascal waveOutGetPosition(word ptr word) waveOutGetPosition16
413 pascal waveOutGetPitch(word ptr) waveOutGetPitch16
414 pascal waveOutSetPitch(word long) waveOutSetPitch16
415 pascal waveOutGetVolume(word ptr) waveOutGetVolume16
416 pascal waveOutSetVolume(word long) waveOutSetVolume16
417 pascal waveOutGetPlaybackRate(word ptr) waveOutGetPlaybackRate16
418 pascal waveOutSetPlaybackRate(word long) waveOutSetPlaybackRate16
419 pascal waveOutBreakLoop(word) waveOutBreakLoop16
420 pascal waveOutGetID(word ptr) waveOutGetID16
421 pascal waveOutMessage(word word long long) waveOutMessage16
501 pascal waveInGetNumDevs() waveInGetNumDevs16
502 pascal waveInGetDevCaps(word ptr word) waveInGetDevCaps16
503 pascal waveInGetErrorText(word ptr word) waveInGetErrorText16
504 pascal waveInOpen(ptr word ptr long long long) waveInOpen16
505 pascal waveInClose(word) waveInClose16
506 pascal waveInPrepareHeader(word segptr word) waveInPrepareHeader16
507 pascal waveInUnprepareHeader(word segptr word) waveInUnprepareHeader16
508 pascal waveInAddBuffer(word segptr word) waveInAddBuffer16
509 pascal waveInStart(word) waveInStart16
510 pascal waveInStop(word) waveInStop16
511 pascal waveInReset(word) waveInReset16
512 pascal waveInGetPosition(word ptr word) waveInGetPosition16
513 pascal waveInGetID(word ptr) waveInGetID16
514 pascal waveInMessage(word word long long) waveInMessage16
601 pascal timeGetSystemTime(ptr word) timeGetSystemTime16
602 pascal timeSetEvent(word word segptr long word) timeSetEvent16
603 pascal timeKillEvent(word) timeKillEvent16
604 pascal timeGetDevCaps(ptr word) timeGetDevCaps16
605 pascal timeBeginPeriod(word) timeBeginPeriod16
606 pascal timeEndPeriod(word) timeEndPeriod16
607 pascal timeGetTime() timeGetTime
701 pascal mciSendCommand(word word long long) mciSendCommand16
702 pascal mciSendString(str ptr word word) mciSendString16
703 pascal mciGetDeviceID(ptr) mciGetDeviceID16
705 pascal mciLoadCommandResource(word str word) mciLoadCommandResource16
706 pascal mciGetErrorString(long ptr word) mciGetErrorString16
707 pascal mciSetDriverData(word long) mciSetDriverData16
708 pascal mciGetDriverData(word) mciGetDriverData16
710 pascal mciDriverYield(word) mciDriverYield16
711 pascal mciDriverNotify(word word word) mciDriverNotify16
712 pascal mciExecute(ptr) mciExecute
713 pascal mciFreeCommandResource(word) mciFreeCommandResource16
714 pascal mciSetYieldProc(word ptr long) mciSetYieldProc16
715 pascal mciGetDeviceIDFromElementID(long ptr) mciGetDeviceIDFromElementID16
716 pascal mciGetYieldProc(word ptr) mciGetYieldProc16
717 pascal mciGetCreatorTask(word) mciGetCreatorTask16
800 pascal mixerGetNumDevs() mixerGetNumDevs16
801 pascal mixerGetDevCaps(word ptr word) mixerGetDevCaps16
802 pascal mixerOpen(ptr word long long long) mixerOpen16
803 pascal mixerClose(word) mixerClose16
804 pascal mixerMessage(word word long long) mixerMessage16
805 pascal mixerGetLineInfo(word ptr long) mixerGetLineInfo16
806 pascal mixerGetID(word ptr long) mixerGetID16
807 pascal mixerGetLineControls(word ptr long) mixerGetLineControls16
808 pascal mixerGetControlDetails(word ptr long) mixerGetControlDetails16
809 pascal mixerSetControlDetails(word ptr long) mixerSetControlDetails16
900 pascal mmTaskCreate(long ptr long) mmTaskCreate16
902 pascal mmTaskBlock(word) mmTaskBlock16
903 pascal mmTaskSignal(word) mmTaskSignal16
904 pascal -ret16 mmGetCurrentTask() mmGetCurrentTask16
905 pascal mmTaskYield() mmTaskYield16
1100 pascal DrvOpen(str str long) DrvOpen16
1101 pascal DrvClose(word long long) DrvClose16
1102 pascal DrvSendMessage(word word long long) DrvSendMessage16
1103 pascal DrvGetModuleHandle(word) DrvGetModuleHandle16
1104 pascal DrvDefDriverProc(long word word long long) DrvDefDriverProc16
1120 pascal mmThreadCreate(segptr ptr long long) mmThreadCreate16
1121 pascal mmThreadSignal(word) mmThreadSignal16
1122 pascal mmThreadBlock(word) mmThreadBlock16
1123 pascal mmThreadIsCurrent(word) mmThreadIsCurrent16
1124 pascal mmThreadIsValid(word) mmThreadIsValid16
1125 pascal mmThreadGetTask(word) mmThreadGetTask16
1150 pascal mmShowMMCPLPropertySheet(word str str str) mmShowMMCPLPropertySheet16
1210 pascal mmioOpen(str ptr long) mmioOpen16
1211 pascal mmioClose(word word) mmioClose16
1212 pascal mmioRead(word ptr long) mmioRead16
1213 pascal mmioWrite(word ptr long) mmioWrite16
1214 pascal mmioSeek(word long word) mmioSeek16
1215 pascal mmioGetInfo(word ptr word) mmioGetInfo16
1216 pascal mmioSetInfo(word ptr word) mmioSetInfo16
1217 pascal mmioSetBuffer(word segptr long word) mmioSetBuffer16
1218 pascal mmioFlush(word word) mmioFlush16
1219 pascal mmioAdvance(word ptr word) mmioAdvance16
1220 pascal mmioStringToFOURCC(str word) mmioStringToFOURCC16
1221 pascal mmioInstallIOProc(long ptr long) mmioInstallIOProc16
1222 pascal mmioSendMessage(word word long long) mmioSendMessage16
1223 pascal mmioDescend(word ptr ptr word) mmioDescend16
1224 pascal mmioAscend(word ptr word) mmioAscend16
1225 pascal mmioCreateChunk(word ptr word) mmioCreateChunk16
1226 pascal mmioRename(ptr ptr ptr long) mmioRename16
#2000 stub WINMMF_THUNKDATA16
#2001 stub RING3_DEVLOADER
#2002 stub WINMMTILEBUFFER
#2003 stub WINMMUNTILEBUFFER
#2005 stub MCIGETTHUNKTABLE
#2006 stub WINMMSL_THUNKDATA16
2046 pascal DllEntryPoint(long word word word long word) MMSYSTEM_LibMain
# these are Wine only exported functions. Is there another way to do it ?
2047 pascal __wine_mmThreadEntryPoint(long) WINE_mmThreadEntryPoint

525
reactos/lib/winmm/playsound.c
View file

@ -1,525 +0,0 @@
/* -*- tab-width: 8; c-basic-offset: 4 -*- */
/*
* MMSYTEM functions
*
* Copyright 1993 Martin Ayotte
* 1998-2002 Eric Pouech
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*/
#include <stdarg.h>
#include <string.h>
#include "windef.h"
#include "winbase.h"
#include "mmsystem.h"
#include "wingdi.h"
#include "winuser.h"
#include "winreg.h"
#include "winemm.h"
#include "winternl.h"
#include "wine/debug.h"
WINE_DEFAULT_DEBUG_CHANNEL(winmm);
static HMMIO get_mmioFromFile(LPCWSTR lpszName)
{
HMMIO ret;
WCHAR buf[256];
LPWSTR dummy;
ret = mmioOpenW((LPWSTR)lpszName, NULL,
MMIO_ALLOCBUF | MMIO_READ | MMIO_DENYWRITE);
if (ret != 0) return ret;
if (SearchPathW(NULL, lpszName, NULL, sizeof(buf)/sizeof(buf[0]), buf, &dummy))
{
return mmioOpenW(buf, NULL,
MMIO_ALLOCBUF | MMIO_READ | MMIO_DENYWRITE);
}
return 0;
}
static HMMIO get_mmioFromProfile(UINT uFlags, LPCWSTR lpszName)
{
WCHAR str[128];
LPWSTR ptr;
HMMIO hmmio;
HKEY hRegSnd, hRegApp, hScheme, hSnd;
DWORD err, type, count;
static const WCHAR wszSounds[] = {'S','o','u','n','d','s',0};
static const WCHAR wszDefault[] = {'D','e','f','a','u','l','t',0};
static const WCHAR wszKey[] = {'A','p','p','E','v','e','n','t','s','\\',
'S','c','h','e','m','e','s','\\',
'A','p','p','s',0};
static const WCHAR wszDotDefault[] = {'.','D','e','f','a','u','l','t',0};
static const WCHAR wszDotCurrent[] = {'.','C','u','r','r','e','n','t',0};
static const WCHAR wszNull[] = {0};
TRACE("searching in SystemSound list for %s\n", debugstr_w(lpszName));
GetProfileStringW(wszSounds, lpszName, wszNull, str, sizeof(str)/sizeof(str[0]));
if (lstrlenW(str) == 0)
{
if (uFlags & SND_NODEFAULT) goto next;
GetProfileStringW(wszSounds, wszDefault, wszNull, str, sizeof(str)/sizeof(str[0]));
if (lstrlenW(str) == 0) goto next;
}
for (ptr = str; *ptr && *ptr != ','; ptr++);
if (*ptr) *ptr = 0;
hmmio = mmioOpenW(str, NULL, MMIO_ALLOCBUF | MMIO_READ | MMIO_DENYWRITE);
if (hmmio != 0) return hmmio;
next:
/* we look up the registry under
* HKCU\AppEvents\Schemes\Apps\.Default
* HKCU\AppEvents\Schemes\Apps\<AppName>
*/
if (RegOpenKeyW(HKEY_CURRENT_USER, wszKey, &hRegSnd) != 0) goto none;
if (uFlags & SND_APPLICATION)
{
DWORD len;
err = 1; /* error */
len = GetModuleFileNameW(0, str, sizeof(str)/sizeof(str[0]));
if (len > 0 && len < sizeof(str)/sizeof(str[0]))
{
for (ptr = str + lstrlenW(str) - 1; ptr >= str; ptr--)
{
if (*ptr == '.') *ptr = 0;
if (*ptr == '\\')
{
err = RegOpenKeyW(hRegSnd, ptr+1, &hRegApp);
break;
}
}
}
}
else
{
err = RegOpenKeyW(hRegSnd, wszDotDefault, &hRegApp);
}
RegCloseKey(hRegSnd);
if (err != 0) goto none;
err = RegOpenKeyW(hRegApp, lpszName, &hScheme);
RegCloseKey(hRegApp);
if (err != 0) goto none;
/* what's the difference between .Current and .Default ? */
err = RegOpenKeyW(hScheme, wszDotDefault, &hSnd);
if (err != 0)
{
err = RegOpenKeyW(hScheme, wszDotCurrent, &hSnd);
RegCloseKey(hScheme);
if (err != 0)
goto none;
}
count = sizeof(str)/sizeof(str[0]);
err = RegQueryValueExW(hSnd, NULL, 0, &type, (LPBYTE)str, &count);
RegCloseKey(hSnd);
if (err != 0 || !*str) goto none;
hmmio = mmioOpenW(str, NULL, MMIO_ALLOCBUF | MMIO_READ | MMIO_DENYWRITE);
if (hmmio) return hmmio;
none:
WARN("can't find SystemSound='%s' !\n", debugstr_w(lpszName));
return 0;
}
struct playsound_data
{
HANDLE hEvent;
DWORD dwEventCount;
};
static void CALLBACK PlaySound_Callback(HWAVEOUT hwo, UINT uMsg,
DWORD dwInstance,
DWORD dwParam1, DWORD dwParam2)
{
struct playsound_data* s = (struct playsound_data*)dwInstance;
switch (uMsg) {
case WOM_OPEN:
case WOM_CLOSE:
break;
case WOM_DONE:
InterlockedIncrement(&s->dwEventCount);
TRACE("Returning waveHdr=%lx\n", dwParam1);
SetEvent(s->hEvent);
break;
default:
ERR("Unknown uMsg=%d\n", uMsg);
}
}
static void PlaySound_WaitDone(struct playsound_data* s)
{
for (;;) {
ResetEvent(s->hEvent);
if (InterlockedDecrement(&s->dwEventCount) >= 0) break;
InterlockedIncrement(&s->dwEventCount);
WaitForSingleObject(s->hEvent, INFINITE);
}
}
static BOOL PlaySound_IsString(DWORD fdwSound, const void* psz)
{
/* SND_RESOURCE is 0x40004 while
* SND_MEMORY is 0x00004
*/
switch (fdwSound & (SND_RESOURCE|SND_ALIAS|SND_FILENAME))
{
case SND_RESOURCE: return HIWORD(psz) != 0; /* by name or by ID ? */
case SND_MEMORY: return FALSE;
case SND_ALIAS: /* what about ALIAS_ID ??? */
case SND_FILENAME:
case 0: return TRUE;
default: FIXME("WTF\n"); return FALSE;
}
}
static void PlaySound_Free(WINE_PLAYSOUND* wps)
{
WINE_PLAYSOUND** p;
EnterCriticalSection(&WINMM_IData->cs);
for (p = &WINMM_IData->lpPlaySound; *p && *p != wps; p = &((*p)->lpNext));
if (*p) *p = (*p)->lpNext;
if (WINMM_IData->lpPlaySound == NULL) SetEvent(WINMM_IData->psLastEvent);
LeaveCriticalSection(&WINMM_IData->cs);
if (wps->bAlloc) HeapFree(GetProcessHeap(), 0, (void*)wps->pszSound);
if (wps->hThread) CloseHandle(wps->hThread);
HeapFree(GetProcessHeap(), 0, wps);
}
static WINE_PLAYSOUND* PlaySound_Alloc(const void* pszSound, HMODULE hmod,
DWORD fdwSound, BOOL bUnicode)
{
WINE_PLAYSOUND* wps;
wps = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*wps));
if (!wps) return NULL;
wps->hMod = hmod;
wps->fdwSound = fdwSound;
if (PlaySound_IsString(fdwSound, pszSound))
{
if (bUnicode)
{
if (fdwSound & SND_ASYNC)
{
wps->pszSound = HeapAlloc(GetProcessHeap(), 0,
(lstrlenW(pszSound)+1) * sizeof(WCHAR));
if (!wps->pszSound) goto oom_error;
lstrcpyW((LPWSTR)wps->pszSound, pszSound);
wps->bAlloc = TRUE;
}
else
wps->pszSound = pszSound;
}
else
{
UNICODE_STRING usBuffer;
RtlCreateUnicodeStringFromAsciiz(&usBuffer, pszSound);
wps->pszSound = usBuffer.Buffer;
if (!wps->pszSound) goto oom_error;
wps->bAlloc = TRUE;
}
}
else
wps->pszSound = pszSound;
return wps;
oom_error:
PlaySound_Free(wps);
return NULL;
}
static DWORD WINAPI proc_PlaySound(LPVOID arg)
{
WINE_PLAYSOUND* wps = (WINE_PLAYSOUND*)arg;
BOOL bRet = FALSE;
HMMIO hmmio = 0;
MMCKINFO ckMainRIFF;
MMCKINFO mmckInfo;
LPWAVEFORMATEX lpWaveFormat = NULL;
HWAVEOUT hWave = 0;
LPWAVEHDR waveHdr = NULL;
INT count, bufsize, left, index;
struct playsound_data s;
void* data;
s.hEvent = 0;
TRACE("SoundName='%s' !\n", debugstr_w(wps->pszSound));
/* if resource, grab it */
if ((wps->fdwSound & SND_RESOURCE) == SND_RESOURCE) {
static const WCHAR wszWave[] = {'W','A','V','E',0};
HRSRC hRes;
HGLOBAL hGlob;
if ((hRes = FindResourceW(wps->hMod, wps->pszSound, wszWave)) == 0 ||
(hGlob = LoadResource(wps->hMod, hRes)) == 0)
goto errCleanUp;
if ((data = LockResource(hGlob)) == NULL) {
FreeResource(hGlob);
goto errCleanUp;
}
FreeResource(hGlob);
} else
data = (void*)wps->pszSound;
/* construct an MMIO stream (either in memory, or from a file */
if (wps->fdwSound & SND_MEMORY)
{ /* NOTE: SND_RESOURCE has the SND_MEMORY bit set */
MMIOINFO mminfo;
memset(&mminfo, 0, sizeof(mminfo));
mminfo.fccIOProc = FOURCC_MEM;
mminfo.pchBuffer = (LPSTR)data;
mminfo.cchBuffer = -1; /* FIXME: when a resource, could grab real size */
TRACE("Memory sound %p\n", data);
hmmio = mmioOpenW(NULL, &mminfo, MMIO_READ);
}
else if (wps->fdwSound & SND_ALIAS)
{
hmmio = get_mmioFromProfile(wps->fdwSound, wps->pszSound);
}
else if (wps->fdwSound & SND_FILENAME)
{
hmmio = get_mmioFromFile(wps->pszSound);
}
else
{
if ((hmmio = get_mmioFromProfile(wps->fdwSound | SND_NODEFAULT, wps->pszSound)) == 0)
{
if ((hmmio = get_mmioFromFile(wps->pszSound)) == 0)
{
hmmio = get_mmioFromProfile(wps->fdwSound, wps->pszSound);
}
}
}
if (hmmio == 0) goto errCleanUp;
if (mmioDescend(hmmio, &ckMainRIFF, NULL, 0))
goto errCleanUp;
TRACE("ParentChunk ckid=%.4s fccType=%.4s cksize=%08lX \n",
(LPSTR)&ckMainRIFF.ckid, (LPSTR)&ckMainRIFF.fccType, ckMainRIFF.cksize);
if ((ckMainRIFF.ckid != FOURCC_RIFF) ||
(ckMainRIFF.fccType != mmioFOURCC('W', 'A', 'V', 'E')))
goto errCleanUp;
mmckInfo.ckid = mmioFOURCC('f', 'm', 't', ' ');
if (mmioDescend(hmmio, &mmckInfo, &ckMainRIFF, MMIO_FINDCHUNK))
goto errCleanUp;
TRACE("Chunk Found ckid=%.4s fccType=%.4s cksize=%08lX \n",
(LPSTR)&mmckInfo.ckid, (LPSTR)&mmckInfo.fccType, mmckInfo.cksize);
lpWaveFormat = HeapAlloc(GetProcessHeap(), 0, mmckInfo.cksize);
if (mmioRead(hmmio, (HPSTR)lpWaveFormat, mmckInfo.cksize) < sizeof(WAVEFORMAT))
goto errCleanUp;
TRACE("wFormatTag=%04X !\n", lpWaveFormat->wFormatTag);
TRACE("nChannels=%d \n", lpWaveFormat->nChannels);
TRACE("nSamplesPerSec=%ld\n", lpWaveFormat->nSamplesPerSec);
TRACE("nAvgBytesPerSec=%ld\n", lpWaveFormat->nAvgBytesPerSec);
TRACE("nBlockAlign=%d \n", lpWaveFormat->nBlockAlign);
TRACE("wBitsPerSample=%u !\n", lpWaveFormat->wBitsPerSample);
/* move to end of 'fmt ' chunk */
mmioAscend(hmmio, &mmckInfo, 0);
mmckInfo.ckid = mmioFOURCC('d', 'a', 't', 'a');
if (mmioDescend(hmmio, &mmckInfo, &ckMainRIFF, MMIO_FINDCHUNK))
goto errCleanUp;
TRACE("Chunk Found ckid=%.4s fccType=%.4s cksize=%08lX\n",
(LPSTR)&mmckInfo.ckid, (LPSTR)&mmckInfo.fccType, mmckInfo.cksize);
s.hEvent = CreateEventA(NULL, FALSE, FALSE, NULL);
if (waveOutOpen(&hWave, WAVE_MAPPER, lpWaveFormat, (DWORD)PlaySound_Callback,
(DWORD)&s, CALLBACK_FUNCTION) != MMSYSERR_NOERROR)
goto errCleanUp;
/* make it so that 3 buffers per second are needed */
bufsize = (((lpWaveFormat->nAvgBytesPerSec / 3) - 1) / lpWaveFormat->nBlockAlign + 1) *
lpWaveFormat->nBlockAlign;
waveHdr = HeapAlloc(GetProcessHeap(), 0, 2 * sizeof(WAVEHDR) + 2 * bufsize);
waveHdr[0].lpData = (char*)waveHdr + 2 * sizeof(WAVEHDR);
waveHdr[1].lpData = (char*)waveHdr + 2 * sizeof(WAVEHDR) + bufsize;
waveHdr[0].dwUser = waveHdr[1].dwUser = 0L;
waveHdr[0].dwLoops = waveHdr[1].dwLoops = 0L;
waveHdr[0].dwFlags = waveHdr[1].dwFlags = 0L;
waveHdr[0].dwBufferLength = waveHdr[1].dwBufferLength = bufsize;
if (waveOutPrepareHeader(hWave, &waveHdr[0], sizeof(WAVEHDR)) ||
waveOutPrepareHeader(hWave, &waveHdr[1], sizeof(WAVEHDR))) {
goto errCleanUp;
}
s.dwEventCount = 1L; /* for first buffer */
do {
index = 0;
left = mmckInfo.cksize;
mmioSeek(hmmio, mmckInfo.dwDataOffset, SEEK_SET);
while (left)
{
if (WaitForSingleObject(WINMM_IData->psStopEvent, 0) == WAIT_OBJECT_0)
{
wps->bLoop = FALSE;
break;
}
count = mmioRead(hmmio, waveHdr[index].lpData, min(bufsize, left));
if (count < 1) break;
left -= count;
waveHdr[index].dwBufferLength = count;
waveHdr[index].dwFlags &= ~WHDR_DONE;
if (waveOutWrite(hWave, &waveHdr[index], sizeof(WAVEHDR)) == MMSYSERR_NOERROR) {
index ^= 1;
PlaySound_WaitDone(&s);
}
else FIXME("Couldn't play header\n");
}
bRet = TRUE;
} while (wps->bLoop);
PlaySound_WaitDone(&s); /* for last buffer */
waveOutReset(hWave);
waveOutUnprepareHeader(hWave, &waveHdr[0], sizeof(WAVEHDR));
waveOutUnprepareHeader(hWave, &waveHdr[1], sizeof(WAVEHDR));
errCleanUp:
TRACE("Done playing='%s' => %s!\n", debugstr_w(wps->pszSound), bRet ? "ok" : "ko");
CloseHandle(s.hEvent);
if (waveHdr) HeapFree(GetProcessHeap(), 0, waveHdr);
if (lpWaveFormat) HeapFree(GetProcessHeap(), 0, lpWaveFormat);
if (hWave) while (waveOutClose(hWave) == WAVERR_STILLPLAYING) Sleep(100);
if (hmmio) mmioClose(hmmio, 0);
PlaySound_Free(wps);
return bRet;
}
static BOOL MULTIMEDIA_PlaySound(const void* pszSound, HMODULE hmod, DWORD fdwSound, BOOL bUnicode)
{
WINE_PLAYSOUND* wps = NULL;
TRACE("pszSound='%p' hmod=%p fdwSound=%08lX\n",
pszSound, hmod, fdwSound);
/* FIXME? I see no difference between SND_NOWAIT and SND_NOSTOP !
* there could be one if several sounds can be played at once...
*/
if ((fdwSound & (SND_NOWAIT | SND_NOSTOP)) && WINMM_IData->lpPlaySound != NULL)
return FALSE;
/* alloc internal structure, if we need to play something */
if (pszSound && !(fdwSound & SND_PURGE))
{
if (!(wps = PlaySound_Alloc(pszSound, hmod, fdwSound, bUnicode)))
return FALSE;
}
EnterCriticalSection(&WINMM_IData->cs);
/* since several threads can enter PlaySound in parallel, we're not
* sure, at this point, that another thread didn't start a new playsound
*/
while (WINMM_IData->lpPlaySound != NULL)
{
ResetEvent(WINMM_IData->psLastEvent);
/* FIXME: doc says we have to stop all instances of pszSound if it's non
* NULL... as of today, we stop all playing instances */
SetEvent(WINMM_IData->psStopEvent);
LeaveCriticalSection(&WINMM_IData->cs);
WaitForSingleObject(WINMM_IData->psLastEvent, INFINITE);
EnterCriticalSection(&WINMM_IData->cs);
ResetEvent(WINMM_IData->psStopEvent);
}
if (wps) wps->lpNext = WINMM_IData->lpPlaySound;
WINMM_IData->lpPlaySound = wps;
LeaveCriticalSection(&WINMM_IData->cs);
if (!pszSound || (fdwSound & SND_PURGE)) return TRUE;
if (fdwSound & SND_ASYNC)
{
DWORD id;
HANDLE handle;
wps->bLoop = (fdwSound & SND_LOOP) ? TRUE : FALSE;
if ((handle = CreateThread(NULL, 0, proc_PlaySound, wps, 0, &id)) != 0) {
wps->hThread = handle;
return TRUE;
}
}
else return proc_PlaySound(wps);
/* error cases */
PlaySound_Free(wps);
return FALSE;
}
/**************************************************************************
* PlaySoundA [WINMM.@]
*/
BOOL WINAPI PlaySoundA(LPCSTR pszSoundA, HMODULE hmod, DWORD fdwSound)
{
return MULTIMEDIA_PlaySound(pszSoundA, hmod, fdwSound, FALSE);
}
/**************************************************************************
* PlaySoundW [WINMM.@]
*/
BOOL WINAPI PlaySoundW(LPCWSTR pszSoundW, HMODULE hmod, DWORD fdwSound)
{
return MULTIMEDIA_PlaySound(pszSoundW, hmod, fdwSound, TRUE);
}
/**************************************************************************
* sndPlaySoundA [WINMM.@]
*/
BOOL WINAPI sndPlaySoundA(LPCSTR pszSoundA, UINT uFlags)
{
uFlags &= SND_ASYNC|SND_LOOP|SND_MEMORY|SND_NODEFAULT|SND_NOSTOP|SND_SYNC;
return MULTIMEDIA_PlaySound(pszSoundA, 0, uFlags, FALSE);
}
/**************************************************************************
* sndPlaySoundW [WINMM.@]
*/
BOOL WINAPI sndPlaySoundW(LPCWSTR pszSound, UINT uFlags)
{
uFlags &= SND_ASYNC|SND_LOOP|SND_MEMORY|SND_NODEFAULT|SND_NOSTOP|SND_SYNC;
return MULTIMEDIA_PlaySound(pszSound, 0, uFlags, TRUE);
}
/**************************************************************************
* mmsystemGetVersion [WINMM.@]
*/
UINT WINAPI mmsystemGetVersion(void)
{
TRACE("3.10 (Win95?)\n");
return 0x030a;
}

18
reactos/lib/winmm/sound.spec
View file

@ -1,18 +0,0 @@
1 pascal -ret16 OpenSound() OpenSound16
2 pascal -ret16 CloseSound() CloseSound16
3 pascal -ret16 SetVoiceQueueSize(word word) SetVoiceQueueSize16
4 pascal -ret16 SetVoiceNote(word word word word) SetVoiceNote16
5 pascal -ret16 SetVoiceAccent(word word word word word) SetVoiceAccent16
6 pascal -ret16 SetVoiceEnvelope(word word word) SetVoiceEnvelope16
7 pascal -ret16 SetSoundNoise(word word) SetSoundNoise16
8 pascal -ret16 SetVoiceSound(word long word) SetVoiceSound16
9 pascal -ret16 StartSound() StartSound16
10 pascal -ret16 StopSound() StopSound16
11 pascal -ret16 WaitSoundState(word) WaitSoundState16
12 pascal -ret16 SyncAllVoices() SyncAllVoices16
13 pascal -ret16 CountVoiceNotes(word) CountVoiceNotes16
14 pascal GetThresholdEvent() GetThresholdEvent16
15 pascal -ret16 GetThresholdStatus() GetThresholdStatus16
16 pascal -ret16 SetVoiceThreshold(word word) SetVoiceThreshold16
17 pascal -ret16 DoBeep() DoBeep16
18 stub MYOPENSOUND # W1.1, W2.0

184
reactos/lib/winmm/sound16.c
View file

@ -1,184 +0,0 @@
/*
* 16-bit sound support
*
* Copyright Robert J. Amstadt, 1993
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*/
#include <stdarg.h>
#include <stdlib.h>
#include "windef.h"
#include "winbase.h"
#include "wine/windef16.h"
#include "wine/debug.h"
WINE_DEFAULT_DEBUG_CHANNEL(sound);
/***********************************************************************
* OpenSound (SOUND.1)
*/
INT16 WINAPI OpenSound16(void)
{
FIXME("(void): stub\n");
return -1;
}
/***********************************************************************
* CloseSound (SOUND.2)
*/
void WINAPI CloseSound16(void)
{
FIXME("(void): stub\n");
}
/***********************************************************************
* SetVoiceQueueSize (SOUND.3)
*/
INT16 WINAPI SetVoiceQueueSize16(INT16 nVoice, INT16 nBytes)
{
FIXME("(%d,%d): stub\n",nVoice,nBytes);
return 0;
}
/***********************************************************************
* SetVoiceNote (SOUND.4)
*/
INT16 WINAPI SetVoiceNote16(INT16 nVoice, INT16 nValue, INT16 nLength,
INT16 nCdots)
{
FIXME("(%d,%d,%d,%d): stub\n",nVoice,nValue,nLength,nCdots);
return 0;
}
/***********************************************************************
* SetVoiceAccent (SOUND.5)
*/
INT16 WINAPI SetVoiceAccent16(INT16 nVoice, INT16 nTempo, INT16 nVolume,
INT16 nMode, INT16 nPitch)
{
FIXME("(%d,%d,%d,%d,%d): stub\n", nVoice, nTempo,
nVolume, nMode, nPitch);
return 0;
}
/***********************************************************************
* SetVoiceEnvelope (SOUND.6)
*/
INT16 WINAPI SetVoiceEnvelope16(INT16 nVoice, INT16 nShape, INT16 nRepeat)
{
FIXME("(%d,%d,%d): stub\n",nVoice,nShape,nRepeat);
return 0;
}
/***********************************************************************
* SetSoundNoise (SOUND.7)
*/
INT16 WINAPI SetSoundNoise16(INT16 nSource, INT16 nDuration)
{
FIXME("(%d,%d): stub\n",nSource,nDuration);
return 0;
}
/***********************************************************************
* SetVoiceSound (SOUND.8)
*/
INT16 WINAPI SetVoiceSound16(INT16 nVoice, DWORD lFrequency, INT16 nDuration)
{
FIXME("(%d, %ld, %d): stub\n",nVoice,lFrequency, nDuration);
return 0;
}
/***********************************************************************
* StartSound (SOUND.9)
*/
INT16 WINAPI StartSound16(void)
{
return 0;
}
/***********************************************************************
* StopSound (SOUND.10)
*/
INT16 WINAPI StopSound16(void)
{
return 0;
}
/***********************************************************************
* WaitSoundState (SOUND.11)
*/
INT16 WINAPI WaitSoundState16(INT16 x)
{
FIXME("(%d): stub\n", x);
return 0;
}
/***********************************************************************
* SyncAllVoices (SOUND.12)
*/
INT16 WINAPI SyncAllVoices16(void)
{
FIXME("(void): stub\n");
return 0;
}
/***********************************************************************
* CountVoiceNotes (SOUND.13)
*/
INT16 WINAPI CountVoiceNotes16(INT16 x)
{
FIXME("(%d): stub\n", x);
return 0;
}
/***********************************************************************
* GetThresholdEvent (SOUND.14)
*/
LPINT16 WINAPI GetThresholdEvent16(void)
{
FIXME("(void): stub\n");
return NULL;
}
/***********************************************************************
* GetThresholdStatus (SOUND.15)
*/
INT16 WINAPI GetThresholdStatus16(void)
{
FIXME("(void): stub\n");
return 0;
}
/***********************************************************************
* SetVoiceThreshold (SOUND.16)
*/
INT16 WINAPI SetVoiceThreshold16(INT16 a, INT16 b)
{
FIXME("(%d,%d): stub\n", a, b);
return 0;
}
/***********************************************************************
* DoBeep (SOUND.17)
*/
void WINAPI DoBeep16(void)
{
FIXME("(void): stub!\n");
}

464
reactos/lib/winmm/time.c
View file

@ -1,464 +0,0 @@
/* -*- tab-width: 8; c-basic-offset: 4 -*- */
/*
* MMSYSTEM time functions
*
* Copyright 1993 Martin Ayotte
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*/
#include "config.h"
#include "wine/port.h"
#include <stdarg.h>
#include <time.h>
#ifdef HAVE_SYS_TIME_H
# include <sys/time.h>
#endif
#ifdef HAVE_UNISTD_H
# include <unistd.h>
#endif
#include "windef.h"
#include "winbase.h"
#include "mmsystem.h"
#include "winemm.h"
#include "wine/debug.h"
WINE_DEFAULT_DEBUG_CHANNEL(mmtime);
static HANDLE TIME_hMMTimer;
static LPWINE_TIMERENTRY TIME_TimersList;
static HANDLE TIME_hKillEvent;
static HANDLE TIME_hWakeEvent;
static BOOL TIME_TimeToDie = TRUE;
/*
* Some observations on the behavior of winmm on Windows.
* First, the call to timeBeginPeriod(xx) can never be used
* to raise the timer resolution, only lower it.
*
* Second, a brief survey of a variety of Win 2k and Win X
* machines showed that a 'standard' (aka default) timer
* resolution was 1 ms (Win9x is documented as being 1). However, one
* machine had a standard timer resolution of 10 ms.
*
* Further, if we set our default resolution to 1,
* the implementation of timeGetTime becomes GetTickCount(),
* and we can optimize the code to reduce overhead.
*
* Additionally, a survey of Event behaviors shows that
* if we request a Periodic event every 50 ms, then Windows
* makes sure to trigger that event 20 times in the next
* second. If delays prevent that from happening on exact
* schedule, Windows will trigger the events as close
* to the original schedule as is possible, and will eventually
* bring the event triggers back onto a schedule that is
* consistent with what would have happened if there were
* no delays.
*
* Jeremy White, October 2004
*/
#define MMSYSTIME_MININTERVAL (1)
#define MMSYSTIME_MAXINTERVAL (65535)
static void TIME_TriggerCallBack(LPWINE_TIMERENTRY lpTimer)
{
TRACE("%04lx:CallBack => lpFunc=%p wTimerID=%04X dwUser=%08lX dwTriggerTime %ld(delta %ld)\n",
GetCurrentThreadId(), lpTimer->lpFunc, lpTimer->wTimerID, lpTimer->dwUser,
lpTimer->dwTriggerTime, GetTickCount() - lpTimer->dwTriggerTime);
/* - TimeProc callback that is called here is something strange, under Windows 3.1x it is called
* during interrupt time, is allowed to execute very limited number of API calls (like
* PostMessage), and must reside in DLL (therefore uses stack of active application). So I
* guess current implementation via SetTimer has to be improved upon.
*/
switch (lpTimer->wFlags & 0x30) {
case TIME_CALLBACK_FUNCTION:
if (lpTimer->wFlags & WINE_TIMER_IS32)
(lpTimer->lpFunc)(lpTimer->wTimerID, 0, lpTimer->dwUser, 0, 0);
else if (pFnCallMMDrvFunc16)
pFnCallMMDrvFunc16((DWORD)lpTimer->lpFunc, lpTimer->wTimerID, 0,
lpTimer->dwUser, 0, 0);
break;
case TIME_CALLBACK_EVENT_SET:
SetEvent((HANDLE)lpTimer->lpFunc);
break;
case TIME_CALLBACK_EVENT_PULSE:
PulseEvent((HANDLE)lpTimer->lpFunc);
break;
default:
FIXME("Unknown callback type 0x%04x for mmtime callback (%p), ignored.\n",
lpTimer->wFlags, lpTimer->lpFunc);
break;
}
}
/**************************************************************************
* TIME_MMSysTimeCallback
*/
static DWORD CALLBACK TIME_MMSysTimeCallback(LPWINE_MM_IDATA iData)
{
static int nSizeLpTimers;
static LPWINE_TIMERENTRY lpTimers;
LPWINE_TIMERENTRY timer, *ptimer, *next_ptimer;
int idx;
DWORD cur_time;
DWORD delta_time;
DWORD ret_time = INFINITE;
DWORD adjust_time;
/* optimize for the most frequent case - no events */
if (! TIME_TimersList)
return(ret_time);
/* since timeSetEvent() and timeKillEvent() can be called
* from 16 bit code, there are cases where win16 lock is
* locked upon entering timeSetEvent(), and then the mm timer
* critical section is locked. This function cannot call the
* timer callback with the crit sect locked (because callback
* may need to acquire Win16 lock, thus providing a deadlock
* situation).
* To cope with that, we just copy the WINE_TIMERENTRY struct
* that need to trigger the callback, and call it without the
* mm timer crit sect locked.
* the hKillTimeEvent is used to mark the section where we
* handle the callbacks so we can do synchronous kills.
* EPP 99/07/13, updated 04/01/10
*/
idx = 0;
cur_time = GetTickCount();
EnterCriticalSection(&iData->cs);
for (ptimer = &TIME_TimersList; *ptimer != NULL; ) {
timer = *ptimer;
next_ptimer = &timer->lpNext;
if (cur_time >= timer->dwTriggerTime)
{
if (timer->lpFunc) {
if (idx == nSizeLpTimers) {
if (lpTimers)
lpTimers = (LPWINE_TIMERENTRY)
HeapReAlloc(GetProcessHeap(), 0, lpTimers,
++nSizeLpTimers * sizeof(WINE_TIMERENTRY));
else
lpTimers = (LPWINE_TIMERENTRY)
HeapAlloc(GetProcessHeap(), 0,
++nSizeLpTimers * sizeof(WINE_TIMERENTRY));
}
lpTimers[idx++] = *timer;
}
/* Update the time after we make the copy to preserve
the original trigger time */
timer->dwTriggerTime += timer->wDelay;
/* TIME_ONESHOT is defined as 0 */
if (!(timer->wFlags & TIME_PERIODIC))
{
/* unlink timer from timers list */
*ptimer = *next_ptimer;
HeapFree(GetProcessHeap(), 0, timer);
/* We don't need to trigger oneshots again */
delta_time = INFINITE;
}
else
{
/* Compute when this event needs this function
to be called again */
if (timer->dwTriggerTime <= cur_time)
delta_time = 0;
else
delta_time = timer->dwTriggerTime - cur_time;
}
}
else
delta_time = timer->dwTriggerTime - cur_time;
/* Determine when we need to return to this function */
ret_time = min(ret_time, delta_time);
ptimer = next_ptimer;
}
if (TIME_hKillEvent) ResetEvent(TIME_hKillEvent);
LeaveCriticalSection(&iData->cs);
while (idx > 0) TIME_TriggerCallBack(&lpTimers[--idx]);
if (TIME_hKillEvent) SetEvent(TIME_hKillEvent);
/* Finally, adjust the recommended wait time downward
by the amount of time the processing routines
actually took */
adjust_time = GetTickCount() - cur_time;
if (adjust_time > ret_time)
ret_time = 0;
else
ret_time -= adjust_time;
/* We return the amount of time our caller should sleep
before needing to check in on us again */
return(ret_time);
}
/**************************************************************************
* TIME_MMSysTimeThread
*/
static DWORD CALLBACK TIME_MMSysTimeThread(LPVOID arg)
{
LPWINE_MM_IDATA iData = (LPWINE_MM_IDATA)arg;
DWORD sleep_time;
DWORD rc;
TRACE("Starting main winmm thread\n");
/* FIXME: As an optimization, we could have
this thread die when there are no more requests
pending, and then get recreated on the first
new event; it's not clear if that would be worth
it or not. */
while (! TIME_TimeToDie)
{
sleep_time = TIME_MMSysTimeCallback(iData);
if (sleep_time == 0)
continue;
rc = WaitForSingleObject(TIME_hWakeEvent, sleep_time);
if (rc != WAIT_TIMEOUT && rc != WAIT_OBJECT_0)
{
FIXME("Unexpected error %ld(%ld) in timer thread\n", rc, GetLastError());
break;
}
}
TRACE("Exiting main winmm thread\n");
return 0;
}
/**************************************************************************
* TIME_MMTimeStart
*/
void TIME_MMTimeStart(void)
{
if (!TIME_hMMTimer) {
TIME_TimersList = NULL;
TIME_hWakeEvent = CreateEventW(NULL, FALSE, FALSE, NULL);
TIME_TimeToDie = FALSE;
TIME_hMMTimer = CreateThread(NULL, 0, TIME_MMSysTimeThread, WINMM_IData, 0, NULL);
}
}
/**************************************************************************
* TIME_MMTimeStop
*/
void TIME_MMTimeStop(void)
{
if (TIME_hMMTimer) {
TIME_TimeToDie = TRUE;
SetEvent(TIME_hWakeEvent);
/* FIXME: in the worst case, we're going to wait 65 seconds here :-( */
WaitForSingleObject(TIME_hMMTimer, INFINITE);
CloseHandle(TIME_hMMTimer);
CloseHandle(TIME_hWakeEvent);
TIME_hMMTimer = 0;
TIME_TimersList = NULL;
}
}
/**************************************************************************
* timeGetSystemTime [WINMM.@]
*/
MMRESULT WINAPI timeGetSystemTime(LPMMTIME lpTime, UINT wSize)
{
if (wSize >= sizeof(*lpTime)) {
lpTime->wType = TIME_MS;
lpTime->u.ms = GetTickCount();
}
return 0;
}
/**************************************************************************
* TIME_SetEventInternal [internal]
*/
WORD TIME_SetEventInternal(UINT wDelay, UINT wResol,
LPTIMECALLBACK lpFunc, DWORD dwUser, UINT wFlags)
{
WORD wNewID = 0;
LPWINE_TIMERENTRY lpNewTimer;
LPWINE_TIMERENTRY lpTimer;
TRACE("(%u, %u, %p, %08lX, %04X);\n", wDelay, wResol, lpFunc, dwUser, wFlags);
lpNewTimer = (LPWINE_TIMERENTRY)HeapAlloc(GetProcessHeap(), 0, sizeof(WINE_TIMERENTRY));
if (lpNewTimer == NULL)
return 0;
if (wDelay < MMSYSTIME_MININTERVAL || wDelay > MMSYSTIME_MAXINTERVAL)
return 0;
TIME_MMTimeStart();
lpNewTimer->wDelay = wDelay;
lpNewTimer->dwTriggerTime = GetTickCount() + wDelay;
/* FIXME - wResol is not respected, although it is not clear
that we could change our precision meaningfully */
lpNewTimer->wResol = wResol;
lpNewTimer->lpFunc = lpFunc;
lpNewTimer->dwUser = dwUser;
lpNewTimer->wFlags = wFlags;
EnterCriticalSection(&WINMM_IData->cs);
if ((wFlags & TIME_KILL_SYNCHRONOUS) && !TIME_hKillEvent)
TIME_hKillEvent = CreateEventW(NULL, TRUE, TRUE, NULL);
for (lpTimer = TIME_TimersList; lpTimer != NULL; lpTimer = lpTimer->lpNext) {
wNewID = max(wNewID, lpTimer->wTimerID);
}
lpNewTimer->lpNext = TIME_TimersList;
TIME_TimersList = lpNewTimer;
lpNewTimer->wTimerID = wNewID + 1;
LeaveCriticalSection(&WINMM_IData->cs);
/* Wake the service thread in case there is work to be done */
SetEvent(TIME_hWakeEvent);
TRACE("=> %u\n", wNewID + 1);
return wNewID + 1;
}
/**************************************************************************
* timeSetEvent [WINMM.@]
*/
MMRESULT WINAPI timeSetEvent(UINT wDelay, UINT wResol, LPTIMECALLBACK lpFunc,
DWORD_PTR dwUser, UINT wFlags)
{
if (wFlags & WINE_TIMER_IS32)
WARN("Unknown windows flag... wine internally used.. ooch\n");
return TIME_SetEventInternal(wDelay, wResol, lpFunc,
dwUser, wFlags|WINE_TIMER_IS32);
}
/**************************************************************************
* timeKillEvent [WINMM.@]
*/
MMRESULT WINAPI timeKillEvent(UINT wID)
{
LPWINE_TIMERENTRY lpSelf = NULL, *lpTimer;
TRACE("(%u)\n", wID);
EnterCriticalSection(&WINMM_IData->cs);
/* remove WINE_TIMERENTRY from list */
for (lpTimer = &TIME_TimersList; *lpTimer; lpTimer = &(*lpTimer)->lpNext) {
if (wID == (*lpTimer)->wTimerID) {
lpSelf = *lpTimer;
/* unlink timer of id 'wID' */
*lpTimer = (*lpTimer)->lpNext;
break;
}
}
LeaveCriticalSection(&WINMM_IData->cs);
if (!lpSelf)
{
WARN("wID=%u is not a valid timer ID\n", wID);
return MMSYSERR_INVALPARAM;
}
if (lpSelf->wFlags & TIME_KILL_SYNCHRONOUS)
WaitForSingleObject(TIME_hKillEvent, INFINITE);
HeapFree(GetProcessHeap(), 0, lpSelf);
return TIMERR_NOERROR;
}
/**************************************************************************
* timeGetDevCaps [WINMM.@]
*/
MMRESULT WINAPI timeGetDevCaps(LPTIMECAPS lpCaps, UINT wSize)
{
TRACE("(%p, %u)\n", lpCaps, wSize);
lpCaps->wPeriodMin = MMSYSTIME_MININTERVAL;
lpCaps->wPeriodMax = MMSYSTIME_MAXINTERVAL;
return 0;
}
/**************************************************************************
* timeBeginPeriod [WINMM.@]
*/
MMRESULT WINAPI timeBeginPeriod(UINT wPeriod)
{
if (wPeriod < MMSYSTIME_MININTERVAL || wPeriod > MMSYSTIME_MAXINTERVAL)
return TIMERR_NOCANDO;
if (wPeriod > MMSYSTIME_MININTERVAL)
{
FIXME("Stub; we set our timer resolution at minimum\n");
}
return 0;
}
/**************************************************************************
* timeEndPeriod [WINMM.@]
*/
MMRESULT WINAPI timeEndPeriod(UINT wPeriod)
{
if (wPeriod < MMSYSTIME_MININTERVAL || wPeriod > MMSYSTIME_MAXINTERVAL)
return TIMERR_NOCANDO;
if (wPeriod > MMSYSTIME_MININTERVAL)
{
FIXME("Stub; we set our timer resolution at minimum\n");
}
return 0;
}
/**************************************************************************
* timeGetTime [MMSYSTEM.607]
* timeGetTime [WINMM.@]
*/
DWORD WINAPI timeGetTime(void)
{
#if defined(COMMENTOUTPRIORTODELETING)
DWORD count;
/* FIXME: releasing the win16 lock here is a temporary hack (I hope)
* that lets mciavi.drv run correctly
*/
if (pFnReleaseThunkLock) pFnReleaseThunkLock(&count);
if (pFnRestoreThunkLock) pFnRestoreThunkLock(count);
#endif
return GetTickCount();
}

13
reactos/lib/winmm/wavemap/Makefile.in
View file

@ -1,13 +0,0 @@
TOPSRCDIR = @top_srcdir@
TOPOBJDIR = ../../..
SRCDIR = @srcdir@
VPATH = @srcdir@
MODULE = msacm.drv
IMPORTS = msacm32 winmm user32 kernel32
C_SRCS = \
wavemap.c
@MAKE_DLL_RULES@
### Dependencies:

23
reactos/lib/winmm/wavemap/Makefile.ros-template
View file

@ -1,23 +0,0 @@
# $Id: Makefile.ros-template,v 1.3 2004/12/03 23:37:43 blight Exp $
TARGET_NAME = msacm
TARGET_OBJECTS = @C_SRCS@
TARGET_CFLAGS = @EXTRADEFS@ -D__REACTOS__
TARGET_SDKLIBS = @IMPORTS@ winmm.a wine.a wine_uuid.a ntdll.a
TARGET_BASE = 0x76160000
TARGET_RC_SRCS = wavemap.rc
TARGET_RC_BINSRC = @RC_BINSRC@
TARGET_RC_BINARIES = @RC_BINARIES@
TARGET_EXTENSION = .drv
default: all
DEP_OBJECTS = $(TARGET_OBJECTS)
include $(TOOLS_PATH)/depend.mk

9
reactos/lib/winmm/wavemap/makefile
View file

@ -1,9 +0,0 @@
# $Id: makefile,v 1.1 2004/03/10 15:22:45 silverblade Exp $
PATH_TO_TOP = ../../..
TARGET_TYPE = winedll
include $(PATH_TO_TOP)/rules.mak
include $(TOOLS_PATH)/helper.mk

3
reactos/lib/winmm/wavemap/msacm.spec
View file

@ -1,3 +0,0 @@
@ stdcall DriverProc(long long long long long) WAVEMAP_DriverProc
@ stdcall widMessage(long long long long long) WAVEMAP_widMessage
@ stdcall wodMessage(long long long long long) WAVEMAP_wodMessage

1101
reactos/lib/winmm/wavemap/wavemap.c
View file

File diff suppressed because it is too large Load diff

7
reactos/lib/winmm/wavemap/wavemap.rc
View file

@ -1,7 +0,0 @@
/* $Id: wavemap.rc,v 1.2 2004/10/16 20:27:39 gvg Exp $ */
#define REACTOS_VERSION_DLL
#define REACTOS_STR_FILE_DESCRIPTION "ReactOS/WINE Wave Mapper\0"
#define REACTOS_STR_INTERNAL_NAME "wavemap\0"
#define REACTOS_STR_ORIGINAL_FILENAME "wavemap.drv\0"
#include <reactos/version.rc>

0
reactos/lib/winmm/wavemap/winehq2ros.patch
View file

140
reactos/lib/winmm/winehq2ros.patch
View file

@ -1,140 +0,0 @@
? Makefile
? Makefile.ros
? Makefile.ros-template
? winehq2ros.patch
? winmm.spec.def
Index: lolvldrv.c
===================================================================
RCS file: /home/wine/wine/dlls/winmm/lolvldrv.c,v
retrieving revision 1.62
diff -u -r1.62 lolvldrv.c
--- lolvldrv.c 1 Dec 2004 15:32:19 -0000 1.62
+++ lolvldrv.c 7 Dec 2004 21:01:01 -0000
@@ -761,11 +761,18 @@
{
TRACE("()\n");
/* first load hardware drivers */
+#ifndef __REACTOS__
MMDRV_Install("wineoss.drv", "wineoss.drv", FALSE);
+#endif /* __REACTOS__ */
+
+#ifdef __REACTOS__
+ // AG: TESTING:
+ MMDRV_Install("mmdrv.dll", "mmdrv.dll", FALSE);
+#endif
/* finish with mappers */
- MMDRV_Install("wavemapper", "msacm.drv", TRUE);
- MMDRV_Install("midimapper", "midimap.drv", TRUE);
+ MMDRV_Install("wavemapper", "msacm32.dll", TRUE);
+ MMDRV_Install("midimapper", "midimap.dll", TRUE);
return TRUE;
}
Index: winmm.c
===================================================================
RCS file: /home/wine/wine/dlls/winmm/winmm.c,v
retrieving revision 1.46
diff -u -r1.46 winmm.c
--- winmm.c 21 Nov 2004 15:37:04 -0000 1.46
+++ winmm.c 7 Dec 2004 21:01:02 -0000
@@ -94,7 +94,9 @@
return FALSE;
WINMM_IData->hWinMM32Instance = hInstDLL;
InitializeCriticalSection(&WINMM_IData->cs);
+/* FIXME crashes in ReactOS
WINMM_IData->cs.DebugInfo->Spare[1] = (DWORD)"WINMM_IData";
+*/
WINMM_IData->psStopEvent = CreateEventA(NULL, TRUE, FALSE, NULL);
WINMM_IData->psLastEvent = CreateEventA(NULL, TRUE, FALSE, NULL);
TRACE("Created IData (%p)\n", WINMM_IData);
@@ -137,10 +139,12 @@
loaded = -1;
if (h)
{
+#ifndef __REACTOS__
pGetModuleHandle16 = (void*)GetProcAddress(h, "GetModuleHandle16");
pLoadLibrary16 = (void*)GetProcAddress(h, "LoadLibrary16");
if (pGetModuleHandle16 && pLoadLibrary16 &&
(pGetModuleHandle16("MMSYSTEM.DLL") || pLoadLibrary16("MMSYSTEM.DLL")))
+#endif /* __REACTOS__ */
loaded = 1;
}
}
@@ -669,7 +673,7 @@
/**************************************************************************
* mixerMessage [WINMM.@]
*/
-UINT WINAPI mixerMessage(HMIXER hmix, UINT uMsg, DWORD_PTR dwParam1, DWORD_PTR dwParam2)
+DWORD WINAPI mixerMessage(HMIXER hmix, UINT uMsg, DWORD_PTR dwParam1, DWORD_PTR dwParam2)
{
LPWINE_MLD wmld;
@@ -2669,8 +2673,8 @@
* waveOutOpen [WINMM.@]
* All the args/structs have the same layout as the win16 equivalents
*/
-UINT WINAPI waveOutOpen(LPHWAVEOUT lphWaveOut, UINT uDeviceID,
- const LPWAVEFORMATEX lpFormat, DWORD_PTR dwCallback,
+MMRESULT WINAPI waveOutOpen(LPHWAVEOUT lphWaveOut, UINT uDeviceID,
+ LPCWAVEFORMATEX lpFormat, DWORD_PTR dwCallback,
DWORD_PTR dwInstance, DWORD dwFlags)
{
return WAVE_Open((HANDLE*)lphWaveOut, uDeviceID, MMDRV_WAVEOUT, lpFormat,
@@ -3054,8 +3058,8 @@
/**************************************************************************
* waveInOpen [WINMM.@]
*/
-UINT WINAPI waveInOpen(HWAVEIN* lphWaveIn, UINT uDeviceID,
- const LPWAVEFORMATEX lpFormat, DWORD_PTR dwCallback,
+MMRESULT WINAPI waveInOpen(HWAVEIN* lphWaveIn, UINT uDeviceID,
+ LPCWAVEFORMATEX lpFormat, DWORD_PTR dwCallback,
DWORD_PTR dwInstance, DWORD dwFlags)
{
return WAVE_Open((HANDLE*)lphWaveIn, uDeviceID, MMDRV_WAVEIN, lpFormat,
Index: winmm_res.rc
===================================================================
RCS file: /home/wine/wine/dlls/winmm/winmm_res.rc,v
retrieving revision 1.17
diff -u -r1.17 winmm_res.rc
--- winmm_res.rc 16 Aug 2004 20:02:09 -0000 1.17
+++ winmm_res.rc 7 Dec 2004 21:01:03 -0000
@@ -34,7 +34,7 @@
#include "winmm_Es.rc"
#include "winmm_Fr.rc"
#include "winmm_It.rc"
-#include "winmm_Ja.rc"
+/* #include "winmm_Ja.rc" */ /* Gives error during ReactOS build */
#include "winmm_Nl.rc"
#include "winmm_Pt.rc"
#include "winmm_Ru.rc"
Index: lib/winmm/joystick.c
===================================================================
RCS file: /CVS/ReactOS/reactos/lib/winmm/joystick.c,v
retrieving revision 1.2
diff -u -r1.2 joystick.c
--- lib/winmm/joystick.c 25 Feb 2004 20:00:41 -0000 1.2
+++ lib/winmm/joystick.c 20 Dec 2004 02:00:40 -0000
@@ -41,6 +41,7 @@
#include "wingdi.h"
#include "winuser.h"
#include "winnls.h"
+#include "winemm.h"
#include "mmddk.h"
Index: lib/winmm/winemm.h
===================================================================
RCS file: /CVS/ReactOS/reactos/lib/winmm/winemm.h,v
retrieving revision 1.6
diff -u -r1.6 winemm.h
--- lib/winmm/winemm.h 20 Oct 2004 17:42:11 -0000 1.6
+++ lib/winmm/winemm.h 20 Dec 2004 01:59:44 -0000
@@ -222,6 +222,7 @@
typedef WINMM_MapType (*MMDRV_MAPFUNC)(UINT wMsg, LPDWORD lpdwUser, LPDWORD lpParam1, LPDWORD lpParam2);
typedef WINMM_MapType (*MMDRV_UNMAPFUNC)(UINT wMsg, LPDWORD lpdwUser, LPDWORD lpParam1, LPDWORD lpParam2, MMRESULT ret);
+HDRVR WINAPI OpenDriverA(LPCSTR lpDriverName, LPCSTR lpSectionName, LPARAM lParam2);
LPWINE_DRIVER DRIVER_FindFromHDrvr(HDRVR hDrvr);
BOOL DRIVER_GetLibName(LPCSTR keyName, LPCSTR sectName, LPSTR buf, int sz);
LPWINE_DRIVER DRIVER_TryOpenDriver32(LPCSTR fn, LPARAM lParam2);

310
reactos/lib/winmm/winemm.h
View file

@ -1,310 +0,0 @@
/* -*- tab-width: 8; c-basic-offset: 4 -*- */
/*****************************************************************************
* Copyright 1998, Luiz Otavio L. Zorzella
* 1999, Eric Pouech
*
* Purpose: multimedia declarations (internal to WINMM & MMSYSTEM DLLs)
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*****************************************************************************
*/
#include <stdarg.h>
#include "windef.h"
#include "winbase.h"
#include "mmddk.h"
typedef DWORD (WINAPI *MessageProc16)(UINT16 wDevID, UINT16 wMsg, DWORD dwUser, DWORD dwParam1, DWORD dwParam2);
typedef DWORD (WINAPI *MessageProc32)(UINT wDevID, UINT wMsg, DWORD dwUser, DWORD dwParam1, DWORD dwParam2);
typedef enum {
WINMM_MAP_NOMEM, /* ko, memory problem */
WINMM_MAP_MSGERROR, /* ko, unknown message */
WINMM_MAP_OK, /* ok, no memory allocated. to be sent to the proc. */
WINMM_MAP_OKMEM, /* ok, some memory allocated, need to call UnMapMsg. to be sent to the proc. */
} WINMM_MapType;
/* Who said goofy boy ? */
#define WINE_DI_MAGIC 0x900F1B01
typedef struct tagWINE_DRIVER
{
DWORD dwMagic;
/* as usual LPWINE_DRIVER == hDriver32 */
DWORD dwFlags;
union {
struct {
HMODULE hModule;
DRIVERPROC lpDrvProc;
DWORD dwDriverID;
} d32;
struct {
UINT16 hDriver16;
} d16;
} d;
struct tagWINE_DRIVER* lpPrevItem;
struct tagWINE_DRIVER* lpNextItem;
} WINE_DRIVER, *LPWINE_DRIVER;
typedef DWORD (CALLBACK *WINEMM_msgFunc16)(UINT16, WORD, DWORD, DWORD, DWORD);
typedef DWORD (CALLBACK *WINEMM_msgFunc32)(UINT , UINT, DWORD, DWORD, DWORD);
/* for each loaded driver and each known type of driver, this structure contains
* the information needed to access it
*/
typedef struct tagWINE_MM_DRIVER_PART {
int nIDMin; /* lower bound of global indexes for this type */
int nIDMax; /* hhigher bound of global indexes for this type */
union {
WINEMM_msgFunc32 fnMessage32; /* pointer to function */
WINEMM_msgFunc16 fnMessage16;
} u;
} WINE_MM_DRIVER_PART;
#define MMDRV_AUX 0
#define MMDRV_MIXER 1
#define MMDRV_MIDIIN 2
#define MMDRV_MIDIOUT 3
#define MMDRV_WAVEIN 4
#define MMDRV_WAVEOUT 5
#define MMDRV_MAX 6
/* each low-level .drv will be associated with an instance of this structure */
typedef struct tagWINE_MM_DRIVER {
HDRVR hDriver;
LPSTR drvname; /* name of the driver */
BOOL bIs32 : 1, /* TRUE if 32 bit driver, FALSE for 16 */
bIsMapper : 1; /* TRUE if mapper */
WINE_MM_DRIVER_PART parts[MMDRV_MAX];/* Information for all known types */
} WINE_MM_DRIVER, *LPWINE_MM_DRIVER;
typedef struct tagWINE_MLD {
/* EPP struct tagWINE_MLD* lpNext; */ /* not used so far */
UINT uDeviceID;
UINT type;
UINT mmdIndex; /* index to low-level driver in MMDrvs table */
DWORD dwDriverInstance; /* this value is driver related, as opposed to
* opendesc.dwInstance which is client (callback) related */
WORD bFrom32;
WORD dwFlags;
DWORD dwCallback;
DWORD dwClientInstance;
} WINE_MLD, *LPWINE_MLD;
typedef struct {
WINE_MLD mld;
} WINE_WAVE, *LPWINE_WAVE;
typedef struct {
WINE_MLD mld;
MIDIOPENDESC mod; /* FIXME: should be removed */
} WINE_MIDI, *LPWINE_MIDI;
typedef struct {
WINE_MLD mld;
} WINE_MIXER, *LPWINE_MIXER;
#define WINE_MMTHREAD_CREATED 0x4153494C /* "BSIL" */
#define WINE_MMTHREAD_DELETED 0xDEADDEAD
typedef struct {
DWORD dwSignature; /* 00 "BSIL" when ok, 0xDEADDEAD when being deleted */
DWORD dwCounter; /* 04 > 1 when in mmThread functions */
HANDLE hThread; /* 08 hThread */
DWORD dwThreadID; /* 0C */
DWORD fpThread; /* 10 address of thread proc (segptr or lin depending on dwFlags) */
DWORD dwThreadPmt; /* 14 parameter to be passed upon thread creation to fpThread */
DWORD dwSignalCount; /* 18 counter used for signaling */
HANDLE hEvent; /* 1C event */
HANDLE hVxD; /* 20 return from OpenVxDHandle */
DWORD dwStatus; /* 24 0x00, 0x10, 0x20, 0x30 */
DWORD dwFlags; /* 28 dwFlags upon creation */
UINT16 hTask; /* 2C handle to created task */
} WINE_MMTHREAD;
typedef struct tagWINE_MCIDRIVER {
UINT wDeviceID;
UINT wType;
LPSTR lpstrElementName;
LPSTR lpstrDeviceType;
LPSTR lpstrAlias;
HDRVR hDriver;
DWORD dwPrivate;
YIELDPROC lpfnYieldProc;
DWORD dwYieldData;
BOOL bIs32;
DWORD CreatorThread;
UINT uTypeCmdTable;
UINT uSpecificCmdTable;
struct tagWINE_MCIDRIVER*lpNext;
} WINE_MCIDRIVER, *LPWINE_MCIDRIVER;
#define WINE_TIMER_IS32 0x80
typedef struct tagWINE_TIMERENTRY {
UINT wDelay;
UINT wResol;
LPTIMECALLBACK lpFunc; /* can be lots of things */
DWORD dwUser;
UINT16 wFlags;
UINT16 wTimerID;
DWORD dwTriggerTime;
struct tagWINE_TIMERENTRY* lpNext;
} WINE_TIMERENTRY, *LPWINE_TIMERENTRY;
enum mmioProcType {MMIO_PROC_16,MMIO_PROC_32A,MMIO_PROC_32W};
struct IOProcList
{
struct IOProcList*pNext; /* Next item in linked list */
FOURCC fourCC; /* four-character code identifying IOProc */
LPMMIOPROC pIOProc; /* pointer to IProc */
enum mmioProcType type; /* 16, 32A or 32W */
int count; /* number of objects linked to it */
};
typedef struct tagWINE_MMIO {
MMIOINFO info;
struct tagWINE_MMIO* lpNext;
struct IOProcList* ioProc;
BOOL bTmpIOProc : 1,
bBufferLoaded : 1;
DWORD segBuffer16;
DWORD dwFileSize;
} WINE_MMIO, *LPWINE_MMIO;
typedef struct tagWINE_PLAYSOUND {
BOOL bLoop : 1,
bAlloc : 1;
LPCWSTR pszSound;
HMODULE hMod;
DWORD fdwSound;
HANDLE hThread;
struct tagWINE_PLAYSOUND* lpNext;
} WINE_PLAYSOUND, *LPWINE_PLAYSOUND;
typedef struct tagWINE_MM_IDATA {
/* winmm part */
HANDLE hWinMM32Instance;
HANDLE hWinMM16Instance;
CRITICAL_SECTION cs;
/* mci part */
LPWINE_MCIDRIVER lpMciDrvs;
/* low level drivers (unused yet) */
/* LPWINE_WAVE lpWave; */
/* LPWINE_MIDI lpMidi; */
/* LPWINE_MIXER lpMixer; */
/* mmio part */
LPWINE_MMIO lpMMIO;
/* playsound and sndPlaySound */
WINE_PLAYSOUND* lpPlaySound;
HANDLE psLastEvent;
HANDLE psStopEvent;
} WINE_MM_IDATA, *LPWINE_MM_IDATA;
/* function prototypes */
typedef LONG (*MCIPROC)(DWORD, HDRVR, DWORD, DWORD, DWORD);
typedef WINMM_MapType (*MMDRV_MAPFUNC)(UINT wMsg, LPDWORD lpdwUser, LPDWORD lpParam1, LPDWORD lpParam2);
typedef WINMM_MapType (*MMDRV_UNMAPFUNC)(UINT wMsg, LPDWORD lpdwUser, LPDWORD lpParam1, LPDWORD lpParam2, MMRESULT ret);
HDRVR WINAPI OpenDriverA(LPCSTR lpDriverName, LPCSTR lpSectionName, LPARAM lParam2);
LPWINE_DRIVER DRIVER_FindFromHDrvr(HDRVR hDrvr);
BOOL DRIVER_GetLibName(LPCSTR keyName, LPCSTR sectName, LPSTR buf, int sz);
LPWINE_DRIVER DRIVER_TryOpenDriver32(LPCSTR fn, LPARAM lParam2);
void DRIVER_UnloadAll(void);
BOOL MMDRV_Init(void);
void MMDRV_Exit(void);
UINT MMDRV_GetNum(UINT);
LPWINE_MLD MMDRV_Alloc(UINT size, UINT type, LPHANDLE hndl, DWORD* dwFlags,
DWORD* dwCallback, DWORD* dwInstance, BOOL bFrom32);
void MMDRV_Free(HANDLE hndl, LPWINE_MLD mld);
DWORD MMDRV_Open(LPWINE_MLD mld, UINT wMsg, DWORD dwParam1, DWORD dwParam2);
DWORD MMDRV_Close(LPWINE_MLD mld, UINT wMsg);
LPWINE_MLD MMDRV_Get(HANDLE hndl, UINT type, BOOL bCanBeID);
LPWINE_MLD MMDRV_GetRelated(HANDLE hndl, UINT srcType, BOOL bSrcCanBeID, UINT dstTyped);
DWORD MMDRV_Message(LPWINE_MLD mld, UINT wMsg, DWORD_PTR dwParam1, DWORD_PTR dwParam2, BOOL bFrom32);
UINT MMDRV_PhysicalFeatures(LPWINE_MLD mld, UINT uMsg, DWORD dwParam1, DWORD dwParam2);
BOOL MMDRV_Is32(unsigned int);
void MMDRV_InstallMap(unsigned int, MMDRV_MAPFUNC, MMDRV_UNMAPFUNC,
MMDRV_MAPFUNC, MMDRV_UNMAPFUNC, LPDRVCALLBACK);
WINE_MCIDRIVER* MCI_GetDriver(UINT16 uDevID);
UINT MCI_GetDriverFromString(LPCSTR str);
DWORD MCI_WriteString(LPSTR lpDstStr, DWORD dstSize, LPCSTR lpSrcStr);
const char* MCI_MessageToString(UINT16 wMsg);
UINT WINAPI MCI_DefYieldProc(MCIDEVICEID wDevID, DWORD data);
LRESULT MCI_CleanUp(LRESULT dwRet, UINT wMsg, DWORD dwParam2);
DWORD MCI_SendCommand(UINT wDevID, UINT16 wMsg, DWORD dwParam1, DWORD dwParam2, BOOL bFrom32);
DWORD MCI_SendCommandFrom32(UINT wDevID, UINT16 wMsg, DWORD_PTR dwParam1, DWORD_PTR dwParam2);
DWORD MCI_SendCommandFrom16(UINT wDevID, UINT16 wMsg, DWORD_PTR dwParam1, DWORD_PTR dwParam2);
UINT MCI_SetCommandTable(void *table, UINT uDevType);
BOOL WINMM_CheckForMMSystem(void);
const char* WINMM_ErrorToString(MMRESULT error);
UINT MIXER_Open(LPHMIXER lphMix, UINT uDeviceID, DWORD_PTR dwCallback,
DWORD_PTR dwInstance, DWORD fdwOpen, BOOL bFrom32);
UINT MIDI_OutOpen(HMIDIOUT* lphMidiOut, UINT uDeviceID, DWORD_PTR dwCallback,
DWORD_PTR dwInstance, DWORD dwFlags, BOOL bFrom32);
UINT MIDI_InOpen(HMIDIIN* lphMidiIn, UINT uDeviceID, DWORD_PTR dwCallback,
DWORD_PTR dwInstance, DWORD dwFlags, BOOL bFrom32);
MMRESULT MIDI_StreamOpen(HMIDISTRM* lphMidiStrm, LPUINT lpuDeviceID,
DWORD cMidi, DWORD_PTR dwCallback,
DWORD_PTR dwInstance, DWORD fdwOpen, BOOL bFrom32);
UINT WAVE_Open(HANDLE* lphndl, UINT uDeviceID, UINT uType,
const LPWAVEFORMATEX lpFormat, DWORD_PTR dwCallback,
DWORD_PTR dwInstance, DWORD dwFlags, BOOL bFrom32);
HMMIO MMIO_Open(LPSTR szFileName, MMIOINFO* refmminfo,
DWORD dwOpenFlags, enum mmioProcType type);
LPMMIOPROC MMIO_InstallIOProc(FOURCC fccIOProc, LPMMIOPROC pIOProc,
DWORD dwFlags, enum mmioProcType type);
LRESULT MMIO_SendMessage(HMMIO hmmio, UINT uMessage, LPARAM lParam1,
LPARAM lParam2, enum mmioProcType type);
LPWINE_MMIO MMIO_Get(HMMIO h);
WORD TIME_SetEventInternal(UINT wDelay, UINT wResol, LPTIMECALLBACK lpFunc,
DWORD dwUser, UINT wFlags);
void TIME_MMTimeStart(void);
void TIME_MMTimeStop(void);
/* Global variables */
extern LPWINE_MM_IDATA WINMM_IData;
/* pointers to 16 bit functions (if sibling MMSYSTEM.DLL is loaded
* NULL otherwise
*/
extern WINE_MMTHREAD* (*pFnGetMMThread16)(UINT16);
extern LPWINE_DRIVER (*pFnOpenDriver16)(LPCSTR,LPCSTR,LPARAM);
extern LRESULT (*pFnCloseDriver16)(UINT16,LPARAM,LPARAM);
extern LRESULT (*pFnSendMessage16)(UINT16,UINT,LPARAM,LPARAM);
extern WINMM_MapType (*pFnMciMapMsg16To32A)(WORD,WORD,DWORD*);
extern WINMM_MapType (*pFnMciUnMapMsg16To32A)(WORD,WORD,DWORD);
extern WINMM_MapType (*pFnMciMapMsg32ATo16)(WORD,WORD,DWORD,DWORD*);
extern WINMM_MapType (*pFnMciUnMapMsg32ATo16)(WORD,WORD,DWORD,DWORD);
extern LRESULT (*pFnCallMMDrvFunc16)(DWORD /* in fact FARPROC16 */,WORD,WORD,LONG,LONG,LONG);
extern unsigned (*pFnLoadMMDrvFunc16)(LPCSTR,LPWINE_DRIVER, LPWINE_MM_DRIVER);
extern LRESULT (*pFnMmioCallback16)(DWORD,LPMMIOINFO,UINT,LPARAM,LPARAM);
extern void (WINAPI *pFnReleaseThunkLock)(DWORD*);
extern void (WINAPI *pFnRestoreThunkLock)(DWORD);
/* GetDriverFlags() returned bits is not documented (nor the call itself)
* Here are Wine only definitions of the bits
*/
#define WINE_GDF_EXIST 0x80000000
#define WINE_GDF_16BIT 0x10000000

59
reactos/lib/winmm/winemm16.h
View file

@ -1,59 +0,0 @@
/* -*- tab-width: 8; c-basic-offset: 4 -*- */
/*****************************************************************************
* Copyright 1998, Luiz Otavio L. Zorzella
* 1999, Eric Pouech
*
* Purpose: multimedia declarations (internal to WINMM & MMSYSTEM DLLs)
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*****************************************************************************
*/
#include "winemm.h"
#include "wine/mmsystem16.h"
#include "wownt32.h"
/* mmsystem (16 bit files) only functions */
void MMDRV_Init16(void);
void MMSYSTEM_MMTIME16to32(LPMMTIME mmt32, const MMTIME16* mmt16);
void MMSYSTEM_MMTIME32to16(LPMMTIME16 mmt16, const MMTIME* mmt32);
typedef LONG (*MCIPROC16)(DWORD, HDRVR16, WORD, DWORD, DWORD);
/* HANDLE16 -> HANDLE conversions */
#define HDRVR_32(h16) ((HDRVR)(ULONG_PTR)(h16))
#define HMIDI_32(h16) ((HMIDI)(ULONG_PTR)(h16))
#define HMIDIIN_32(h16) ((HMIDIIN)(ULONG_PTR)(h16))
#define HMIDIOUT_32(h16) ((HMIDIOUT)(ULONG_PTR)(h16))
#define HMIDISTRM_32(h16) ((HMIDISTRM)(ULONG_PTR)(h16))
#define HMIXER_32(h16) ((HMIXER)(ULONG_PTR)(h16))
#define HMIXEROBJ_32(h16) ((HMIXEROBJ)(ULONG_PTR)(h16))
#define HMMIO_32(h16) ((HMMIO)(ULONG_PTR)(h16))
#define HWAVE_32(h16) ((HWAVE)(ULONG_PTR)(h16))
#define HWAVEIN_32(h16) ((HWAVEIN)(ULONG_PTR)(h16))
#define HWAVEOUT_32(h16) ((HWAVEOUT)(ULONG_PTR)(h16))
/* HANDLE -> HANDLE16 conversions */
#define HDRVR_16(h32) (LOWORD(h32))
#define HMIDI_16(h32) (LOWORD(h32))
#define HMIDIIN_16(h32) (LOWORD(h32))
#define HMIDIOUT_16(h32) (LOWORD(h32))
#define HMIDISTRM_16(h32) (LOWORD(h32))
#define HMIXER_16(h32) (LOWORD(h32))
#define HMIXEROBJ_16(h32) (LOWORD(h32))
#define HMMIO_16(h32) (LOWORD(h32))
#define HWAVE_16(h32) (LOWORD(h32))
#define HWAVEIN_16(h32) (LOWORD(h32))
#define HWAVEOUT_16(h32) (LOWORD(h32))

3332
reactos/lib/winmm/winmm.c
View file

File diff suppressed because it is too large Load diff

192
reactos/lib/winmm/winmm.spec
View file

@ -1,192 +0,0 @@
# ordinal exports
1 stdcall @(ptr long long) PlaySoundA
3 stub @
4 stub @
@ stdcall PlaySoundA(ptr long long)
@ stdcall CloseDriver(long long long)
@ stdcall DefDriverProc(long long long long long)
@ stdcall DriverCallback(long long long long long long long)
@ stdcall DrvClose(long long long) CloseDriver
@ stdcall DrvDefDriverProc(long long long long long) DefDriverProc
@ stdcall DrvGetModuleHandle(long) GetDriverModuleHandle
@ stdcall DrvOpen(wstr wstr long) OpenDriverW
@ stdcall DrvOpenA(str str long) OpenDriverA
@ stdcall DrvSendMessage(long long long long) SendDriverMessage
@ stdcall GetDriverFlags(long)
@ stdcall GetDriverModuleHandle(long)
@ stdcall OpenDriver(wstr wstr long) OpenDriverW
@ stdcall OpenDriverA(str str long)
@ stdcall PlaySound(ptr long long) PlaySoundA
@ stdcall PlaySoundW(ptr long long)
@ stdcall SendDriverMessage(long long long long)
@ stdcall auxGetDevCapsA(long ptr long)
@ stdcall auxGetDevCapsW(long ptr long)
@ stdcall auxGetNumDevs()
@ stdcall auxGetVolume(long ptr)
@ stdcall auxOutMessage(long long long long)
@ stdcall auxSetVolume(long long)
@ stub joyConfigChanged
@ stdcall joyGetDevCapsA(long ptr long)
@ stdcall joyGetDevCapsW(long ptr long)
@ stdcall joyGetNumDevs()
@ stdcall joyGetPos(long ptr)
@ stdcall joyGetPosEx(long ptr)
@ stdcall joyGetThreshold(long ptr)
@ stdcall joyReleaseCapture(long)
@ stdcall joySetCapture(long long long long)
@ stdcall joySetThreshold(long long)
@ stdcall mciDriverNotify(long long long)
@ stdcall mciDriverYield(long)
@ stdcall mciExecute(str)
@ stdcall mciFreeCommandResource(long)
@ stdcall mciGetCreatorTask(long)
@ stdcall mciGetDeviceIDA(str)
@ stdcall mciGetDeviceIDFromElementIDW(long str)
@ stdcall mciGetDeviceIDW(str)
@ stdcall mciGetDriverData(long)
@ stdcall mciGetErrorStringA(long ptr long)
@ stdcall mciGetErrorStringW(long ptr long)
@ stdcall mciGetYieldProc(long ptr)
@ stdcall mciLoadCommandResource(long wstr long)
@ stdcall mciSendCommandA(long long long long)
@ stdcall mciSendCommandW(long long long long)
@ stdcall mciSendStringA(str ptr long long)
@ stdcall mciSendStringW(wstr ptr long long)
@ stdcall mciSetDriverData(long long)
@ stdcall mciSetYieldProc(long ptr long)
@ stub midiConnect
@ stub midiDisconnect
@ stdcall midiInAddBuffer(long ptr long)
@ stdcall midiInClose(long)
@ stdcall midiInGetDevCapsA(long ptr long)
@ stdcall midiInGetDevCapsW(long ptr long)
@ stdcall midiInGetErrorTextA(long ptr long)
@ stdcall midiInGetErrorTextW(long ptr long)
@ stdcall midiInGetID(long ptr)
@ stdcall midiInGetNumDevs()
@ stdcall midiInMessage(long long long long)
@ stdcall midiInOpen(ptr long long long long)
@ stdcall midiInPrepareHeader(long ptr long)
@ stdcall midiInReset(long)
@ stdcall midiInStart(long)
@ stdcall midiInStop(long)
@ stdcall midiInUnprepareHeader(long ptr long)
@ stdcall midiOutCacheDrumPatches(long long ptr long)
@ stdcall midiOutCachePatches(long long ptr long)
@ stdcall midiOutClose(long)
@ stdcall midiOutGetDevCapsA(long ptr long)
@ stdcall midiOutGetDevCapsW(long ptr long)
@ stdcall midiOutGetErrorTextA(long ptr long)
@ stdcall midiOutGetErrorTextW(long ptr long)
@ stdcall midiOutGetID(long ptr)
@ stdcall midiOutGetNumDevs()
@ stdcall midiOutGetVolume(long ptr)
@ stdcall midiOutLongMsg(long ptr long)
@ stdcall midiOutMessage(long long long long)
@ stdcall midiOutOpen(ptr long long long long)
@ stdcall midiOutPrepareHeader(long ptr long)
@ stdcall midiOutReset(long)
@ stdcall midiOutSetVolume(long ptr)
@ stdcall midiOutShortMsg(long long)
@ stdcall midiOutUnprepareHeader(long ptr long)
@ stdcall midiStreamClose(long)
@ stdcall midiStreamOpen(ptr ptr long long long long)
@ stdcall midiStreamOut(long ptr long)
@ stdcall midiStreamPause(long)
@ stdcall midiStreamPosition(long ptr long)
@ stdcall midiStreamProperty(long ptr long)
@ stdcall midiStreamRestart(long)
@ stdcall midiStreamStop(long)
@ stdcall mixerClose(long)
@ stdcall mixerGetControlDetailsA(long ptr long)
@ stdcall mixerGetControlDetailsW(long ptr long)
@ stdcall mixerGetDevCapsA(long ptr long)
@ stdcall mixerGetDevCapsW(long ptr long)
@ stdcall mixerGetID(long ptr long)
@ stdcall mixerGetLineControlsA(long ptr long)
@ stdcall mixerGetLineControlsW(long ptr long)
@ stdcall mixerGetLineInfoA(long ptr long)
@ stdcall mixerGetLineInfoW(long ptr long)
@ stdcall mixerGetNumDevs()
@ stdcall mixerMessage(long long long long)
@ stdcall mixerOpen(ptr long long long long)
@ stdcall mixerSetControlDetails(long ptr long)
@ stdcall mmGetCurrentTask()
@ stdcall mmioAdvance(long ptr long)
@ stdcall mmioAscend(long ptr long)
@ stdcall mmioClose(long long)
@ stdcall mmioCreateChunk(long ptr long)
@ stdcall mmioDescend(long ptr ptr long)
@ stdcall mmioFlush(long long)
@ stdcall mmioGetInfo(long ptr long)
@ stub mmioInstallIOProc16
@ stdcall mmioInstallIOProcA(long ptr long)
@ stdcall mmioInstallIOProcW(long ptr long)
@ stdcall mmioOpenA(str ptr long)
@ stdcall mmioOpenW(wstr ptr long)
@ stdcall mmioRead(long ptr long)
@ stdcall mmioRenameA(str str ptr long)
@ stdcall mmioRenameW(wstr wstr ptr long)
@ stdcall mmioSeek(long long long)
@ stdcall mmioSendMessage(long long long long)
@ stdcall mmioSetBuffer(long ptr long long)
@ stdcall mmioSetInfo(long ptr long)
@ stdcall mmioStringToFOURCCA(str long)
@ stdcall mmioStringToFOURCCW(wstr long)
@ stdcall mmioWrite(long ptr long)
@ stdcall mmsystemGetVersion()
@ stdcall mmTaskBlock(long)
@ stdcall mmTaskCreate(ptr ptr long)
@ stdcall mmTaskSignal(long)
@ stdcall mmTaskYield()
@ stdcall sndPlaySoundA(ptr long)
@ stdcall sndPlaySoundW(ptr long)
@ stdcall timeBeginPeriod(long)
@ stdcall timeEndPeriod(long)
@ stdcall timeGetDevCaps(ptr long)
@ stdcall timeGetSystemTime(ptr long)
@ stdcall timeGetTime()
@ stdcall timeKillEvent(long)
@ stdcall timeSetEvent(long long ptr long long)
@ stdcall waveInAddBuffer(long ptr long)
@ stdcall waveInClose(long)
@ stdcall waveInGetDevCapsA(long ptr long)
@ stdcall waveInGetDevCapsW(long ptr long)
@ stdcall waveInGetErrorTextA(long ptr long)
@ stdcall waveInGetErrorTextW(long ptr long)
@ stdcall waveInGetID(long ptr)
@ stdcall waveInGetNumDevs()
@ stdcall waveInGetPosition(long ptr long)
@ stdcall waveInMessage(long long long long)
@ stdcall waveInOpen(ptr long ptr long long long)
@ stdcall waveInPrepareHeader(long ptr long)
@ stdcall waveInReset(long)
@ stdcall waveInStart(long)
@ stdcall waveInStop(long)
@ stdcall waveInUnprepareHeader(long ptr long)
@ stdcall waveOutBreakLoop(long)
@ stdcall waveOutClose(long)
@ stdcall waveOutGetDevCapsA(long ptr long)
@ stdcall waveOutGetDevCapsW(long ptr long)
@ stdcall waveOutGetErrorTextA(long ptr long)
@ stdcall waveOutGetErrorTextW(long ptr long)
@ stdcall waveOutGetID(long ptr)
@ stdcall waveOutGetNumDevs()
@ stdcall waveOutGetPitch(long ptr)
@ stdcall waveOutGetPlaybackRate(long ptr)
@ stdcall waveOutGetPosition(long ptr long)
@ stdcall waveOutGetVolume(long ptr)
@ stdcall waveOutMessage(long long long long)
@ stdcall waveOutOpen(ptr long ptr long long long)
@ stdcall waveOutPause(long)
@ stdcall waveOutPrepareHeader(long ptr long)
@ stdcall waveOutReset(long)
@ stdcall waveOutRestart(long)
@ stdcall waveOutSetPitch(long long)
@ stdcall waveOutSetPlaybackRate(long long)
@ stdcall waveOutSetVolume(long long)
@ stdcall waveOutUnprepareHeader(long ptr long)
@ stdcall waveOutWrite(long ptr long)
@ stub winmmf_ThunkData32
@ stub winmmsl_ThunkData32

128
reactos/lib/winmm/winmm_Cs.rc
View file

@ -1,128 +0,0 @@
/*
* Czech resources for winmm
* Copyright 1999 Eric Pouech
* Copyright 2004 David Kredba
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*/
STRINGTABLE LANGUAGE LANG_CZECH, SUBLANG_NEUTRAL
BEGIN
/* MMSYS errors */
MMSYSERR_NOERROR, "Určený příkaz byl proveden."
MMSYSERR_ERROR, "Nedefinovaná vnější chyba."
MMSYSERR_BADDEVICEID, "Použité ID zařízení je mimo možnosti systému."
MMSYSERR_NOTENABLED, "Ovladač nebyl povolen."
MMSYSERR_ALLOCATED, "Zařízení je dosud používáno. Vyčkejte na jeho uvolnění a zkuste to znovu."
MMSYSERR_INVALHANDLE, "Ukazatel na zařízení je neplatný."
MMSYSERR_NODRIVER, "V systému není nainstalován žádný ovladač !\n"
MMSYSERR_NOMEM, "Není dost paměti pro tuto úlohu. Ukončete jednu nebo víc aplikací k získání více volné paměti a zkuste to znovu."
MMSYSERR_NOTSUPPORTED, "Tato funkce není podporována. Použijte funkci Capabilities k určení, jaké funkce a zprávy ovladač podporuje."
MMSYSERR_BADERRNUM, "Uvedené číslo chyby není v systému definováno."
MMSYSERR_INVALFLAG, "Systémové funkci byl předán neplatný příznak."
MMSYSERR_INVALPARAM, "Systémové funkci byl předán neplatný parametr."
/* WAVE errors */
WAVERR_BADFORMAT, "Tento formát není podporován nebo nemůže být přeložen. Použijte funkci Capabilities k určení podporovaného formátu."
WAVERR_STILLPLAYING, "Nemohu provést tuto operaci dokud jsou data přehrávána. Zresetujte multimediální zařízení nebo vyčkejte na konec přehrávání."
WAVERR_UNPREPARED, "Wave hlavička nebyla připravena. Použijte funkci Prepare k její konstrukci a pak to zkuste znovu."
WAVERR_SYNC, "Nemohu otevřít zařízení bez použití příznaku WAVE_ALLOWSYNC. Použijte ho a zkuste to znovu."
/* MIDI errors */
MIDIERR_UNPREPARED, "MIDI hlavička nebyla připravena. Použijte funkci Prepare k její konstrukci a pak to zkuste znovu."
MIDIERR_STILLPLAYING, "Nemohu provést tuto operaci dokud jsou data přehrávána. Zresetujte multimediální zařízení nebo vyčkejte na konec přehrávání."
MIDIERR_NOMAP, "MIDI map nebyla nalezena. To může ukazovat na problém s ovladačem nebo je soubor MIDIMAP.CFG poškozen či chybí."
MIDIERR_NOTREADY, "Port přenáší data na zařízení. Počkejte na dokončení přenosu a zkuste to znovu."
MIDIERR_NODEVICE, "Současné nastavení MIDI mapperu se odkazuje na MIDI zařízení nepřítomné v systému. Upravte nastavení MIDI mapperu."
MIDIERR_INVALIDSETUP, "Současné nastavení MIDI je poškozené. Přepište soubor MIDIMAP.CFG ve Windows složce SYSTEM originálem a zkuste to znovu."
/* MCI errors */
MCIERR_INVALID_DEVICE_ID, "Neplatný identifikátor MCI zařízení. Použijte identifikátor vrácený při otevření MCI zařízení."
MCIERR_UNRECOGNIZED_KEYWORD, "Ovladač nepřipouští použitý parametr příkazu."
MCIERR_UNRECOGNIZED_COMMAND, "Ovladač nepřipouští použitý příkaz."
MCIERR_HARDWARE, "S multimediálním zařízením něco není v pořádku. Ujistěte se, že pracuje jak má, případně oslovte jeho výrobce."
MCIERR_INVALID_DEVICE_NAME, "Uvedené zařízení není použitelné nebo není podporované MCI."
MCIERR_OUT_OF_MEMORY, "Není dost paměti na provedení této úlohy. \nUkončete jednu nebo víc aplikací a zkuste to znovu."
MCIERR_DEVICE_OPEN, "Jméno zařízení už je použito jako alias touto aplikací. Použijte unikátní alias."
MCIERR_CANNOT_LOAD_DRIVER, "Vyskytl se nerozpoznatelný problém při zavádění uvedeného ovladače."
MCIERR_MISSING_COMMAND_STRING, "Nebyl zadán žádný příkaz."
MCIERR_PARAM_OVERFLOW, "Výstupní řetězec se nevejde do výstupního zásobníku. Zvětšete velikost zásobníku."
MCIERR_MISSING_STRING_ARGUMENT, "Tento příkaz vyžaduje textový parametr. Zadejte jeden."
MCIERR_BAD_INTEGER, "Toto číslo je neplatné pro tento příkaz."
MCIERR_PARSER_INTERNAL, "Ovladač zařízení vrátil neplatný návratový typ. Zeptejte se dodavatele zařízení na nový ovladač."
MCIERR_DRIVER_INTERNAL, "Byl rozpoznán problém s ovladačem. Získejte od výrobce nový ovladač."
MCIERR_MISSING_PARAMETER, "Tento příkaz vyžaduje parametr. Zadejte ho."
MCIERR_UNSUPPORTED_FUNCTION, "Vámi použité MCI zařízení nepodporuje uvedený příkaz."
MCIERR_FILE_NOT_FOUND, "Soubor nebyl nalezen. Ujistěte se, že cesta k souboru a jeho jméno jsou platné."
MCIERR_DEVICE_NOT_READY, "Ovladač zařízení není připraven."
MCIERR_INTERNAL, "Při inicialiazaci MCI došlo k problémům. Zkuste zrestartovat Windows."
MCIERR_DRIVER, "Ovladač má problémy a ukončil svou činnost. Ovladač nevrátil popis chyby."
MCIERR_CANNOT_USE_ALL, "Nemohu použít 'all' jako jméno zařízení při provádění tohoto příkazu."
MCIERR_MULTIPLE, "Vyskytly se chyby na více zařízeních. Zadejte příkazy zvlášť pro každé jedno zařízeníify, aby bylo zjištěno, které zařízení chybuje."
MCIERR_EXTENSION_NOT_FOUND, "Nedokáži přiřadit soubor s touto příponou vhodnému zařízení."
MCIERR_OUTOFRANGE, "Uvedený parametr je mimo meze uvedeného příkazu."
MCIERR_FLAGS_NOT_COMPATIBLE, "Tyto parametry nemohou být požity spolu."
MCIERR_FILE_NOT_SAVED, "Nemohu uložit soubor. Ujistěte se, že je dost místa na disku nebo je-li Vaše síťové připojení průchozí."
MCIERR_DEVICE_TYPE_REQUIRED, "Nemohu najít požadované zařízení. Ujistěte se, že je nainstalováno, nebo že jste jeho název uvedli přesně."
MCIERR_DEVICE_LOCKED, "Toto zařízení je právě uzavíráno. Vyčkejte několik sekund a zkuste to znovu."
MCIERR_DUPLICATE_ALIAS, "Tento alias je už používán v této aplikaci. Použijte jiné jméno."
MCIERR_BAD_CONSTANT, "Uvedený parametr je neplatný pro tento příkaz."
MCIERR_MUST_USE_SHAREABLE, "Uvedené zařízení je už používáno. Chcete-li ho sdílet, použijte 'shareable' parametr s každým příkazem 'open'."
MCIERR_MISSING_DEVICE_NAME, "Tento příkaz vyžaduje alias, soubor, ovladač nebo název zařízení. Uveďte jeden prosím."
MCIERR_BAD_TIME_FORMAT, "Použitý formát času je neplatný. Nahlédněte do MCI dokumentace a zjistěte si platné formáty."
MCIERR_NO_CLOSING_QUOTE, "Hodnota parametru není uzavřena uvozovkami. Doplňte je."
MCIERR_DUPLICATE_FLAGS, "Parametr nebo hodnota byla zadána dvakrát. Zadejte jen jeden/jednu."
MCIERR_INVALID_FILE, "Tento soubor nemůže být přehrán na tomto MCI zařízení. Soubor může být poškozen nebo nemá správný formát."
MCIERR_NULL_PARAMETER_BLOCK, "MCI byl předán prázdný blok parametrů."
MCIERR_UNNAMED_RESOURCE, "Nemohu uložit soubor bez názvu. Zadejte název."
MCIERR_NEW_REQUIRES_ALIAS, "Při použití parametru 'new' musíte zadat alias."
MCIERR_NOTIFY_ON_AUTO_OPEN, "Nelze použít parametr 'notify' s automaticky otevřeným zařízením."
MCIERR_NO_ELEMENT_ALLOWED, "Nelze použít soubor s tímto zařízením."
MCIERR_NONAPPLICABLE_FUNCTION, "Nelze dokončit skupinu příkazů v tomto pořadí. Opravte pořadí příkazů a zkuste to znovu."
MCIERR_ILLEGAL_FOR_AUTO_OPEN, "Tento příkaz nelze dokončit na automaticky otevřeném zařízení. Vyčkejte na zavření zařízení a zkuste to znovu."
MCIERR_FILENAME_REQUIRED, "Název souboru je neplatný. Ujistěte se, že název souboru má 8 znaků následovaných tečkou a příponou."
MCIERR_EXTRA_CHARACTERS, "Nelze zadat znaky za řetězec uzavřený uvozovkami."
MCIERR_DEVICE_NOT_INSTALLED, "Toto zařízení není v systému nainstalováno. Nainstalujte ho v Ovládacím panelu, na záložce Ovladače."
MCIERR_GET_CD, "Nemohu přistoupit k uvedenému souboru nebo MCI zařízení. Změňte adresář nebo restartujte Váš počítač."
MCIERR_SET_CD, "Nemohu přistoupit k uvedenému souboru nebo MCI zařízení, protože aplikace nemůže změnit adresář."
MCIERR_SET_DRIVE, "Nemohu přistoupit k uvedenému souboru nebo MCI zařízení, protože aplikace nemůže změnit jednotku disku."
MCIERR_DEVICE_LENGTH, "Určete zařízení nebo ovladač jehož název je kratší než 79 znaků."
MCIERR_DEVICE_ORD_LENGTH, "Určete zařízení nebo ovladač jehož název je kratší než 69 znaků."
MCIERR_NO_INTEGER, "Tento příkaz vyžaduje celočíselný parametr. Použijte ho prosím."
MCIERR_WAVE_OUTPUTSINUSE, "Všechna wave zařízení, která by mohla přehrát soubory s tímto formátem jsou používána. Vyčkejte na uvolnění zařízení a zkuste to znovu."
MCIERR_WAVE_SETOUTPUTINUSE, "Nemohu nastavit toto wave zařízení na playback, jelikož je používáno. Vyčkejte na uvolnění zařízení a zkuste to znovu."
MCIERR_WAVE_INPUTSINUSE, "Všechna wave zařízení, která by mohla nahrávat oubory s tímto formátem jsou používána. Vyčkejte na uvolnění zařízení a zkuste to znovu."
MCIERR_WAVE_SETINPUTINUSE, "Nemohu nastavit toto wave zařízení na nahrávání, jelikož je používáno. Vyčkejte na uvolnění zařízení a zkuste to znovu."
MCIERR_WAVE_OUTPUTUNSPECIFIED, "Jakékoliv waveform kompatibilní přehrávací zařízení může být použito."
MCIERR_WAVE_INPUTUNSPECIFIED, "Jakékoliv waveform kompatibilní nahrávací zařízení může být použito."
MCIERR_WAVE_OUTPUTSUNSUITABLE, "Není nainstalováno žádné wave zařízení, které by bylo schopno přehrát soubory v tomto formátu. Použijte záložku Ovladače k instalaci wave zařízení."
MCIERR_WAVE_SETOUTPUTUNSUITABLE,"Přehrávací zařízení nedokázalo rozpoznat formát souboru."
MCIERR_WAVE_INPUTSUNSUITABLE, "Není nainstalováno žádné wave zařízení, které by bylo schopno nahrát soubory v tomto formátu. Použijte záložku Ovladače k instalaci wave zařízení."
MCIERR_WAVE_SETINPUTUNSUITABLE, "Zařízení, ze kterého zkoušíte nahrávat, nedokáže rozpoznat formát výstupního souboru."
MCIERR_NO_WINDOW, "Okno display chybí."
MCIERR_CREATEWINDOW, "Nemohu vytvořit nebo použít okno."
MCIERR_FILE_READ, "Nemohu přečíst zadaný soubor. Ujistěte se, že soubor stále existuje a zkontrolujte svůj disk nebo síťovou konektivitu."
MCIERR_FILE_WRITE, "Nemohu zapisovat do zadaného souboru. Ujistěte se, že máte dost místa na disku nebo zda jste připojeni k síti."
MCIERR_SEQ_DIV_INCOMPATIBLE, "Formáty času ""song pointer"" a SMPTE jsou vzájemně výlučné. Nemůžete je použít současně."
MCIERR_SEQ_NOMIDIPRESENT, "V systému nejsou nainstalovány MIDI zařízení. Nainstalujte je ze záložky Ovladač v Ovládacím panelu."
MCIERR_SEQ_PORT_INUSE, "Tento MIDI port je používán. Vyčkejte na jeho uvolnění; pak to zkuste znovu."
MCIERR_SEQ_PORT_MAPNODEVICE, "Nastavení MIDI mapperu odkazuje na MIDI zařízení, které není v systému nainstalováno. Nainstalujte ho pomocí záložky MIDI Mapper v Ovládacím panelu."
MCIERR_SEQ_PORT_MISCERROR, "Nastala chyba při práci s tímto portem."
MCIERR_SEQ_PORT_NONEXISTENT, "Toto MIDI zařízení není nainstalováno v systému. Nainstalujte ho v Ovládacím panelu na záložce Driver."
MCIERR_SEQ_PORTUNSPECIFIED, "Systém nezná tento MIDI port."
MCIERR_SEQ_TIMER, "Všechny časovače multimédií jsou používány aplikacemi. Ukončete jednu z těchto aplikací a zkuste to znovu."
END

126
reactos/lib/winmm/winmm_De.rc
View file

@ -1,126 +0,0 @@
/*
* Copyright 2004 Henning Gerhardt
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*/
STRINGTABLE LANGUAGE LANG_GERMAN, SUBLANG_DEFAULT
BEGIN
/* MMSYS errors */
MMSYSERR_NOERROR, "Der angeforderte Befehl wurde ausgeführt."
MMSYSERR_ERROR, "Unbekannter externer Fehler."
MMSYSERR_BADDEVICEID, "Die derzeit verwendete Gerätekennung ist außerhalb des zulässigen Bereichs für Ihr System."
MMSYSERR_NOTENABLED, "Der Treiber konnte nicht gestartet werden."
MMSYSERR_ALLOCATED, "Das Gerät wird bereits verwendet. Warten Sie, bis es freigegeben ist, und versuchen Sie es erneut."
MMSYSERR_INVALHANDLE, "Das angegebende Gerätehandle ist ungültig."
MMSYSERR_NODRIVER, "Es ist kein Treiber auf Ihrem System installiert !\n"
MMSYSERR_NOMEM, "Nicht genügend Speicher für diesen Befehl. Beenden Sie eine oder mehrere Anwendungen, und versuchen Sie es erneut."
MMSYSERR_NOTSUPPORTED, "Diese Funktion wird nicht unterstützt. Benutzen Sie die Funktion 'Capabilities', um zu ermitteln, welche Funktion dieser Treiber unterstützt."
MMSYSERR_BADERRNUM, "Die angegebene Fehlernummer ist für dieses System nicht definiert."
MMSYSERR_INVALFLAG, "Ein ungültiges Flag wurde an eine Systemfunktion übergeben."
MMSYSERR_INVALPARAM, "Ein ungültiger Parameter wurde an eine Systemfunktion übergeben."
/* WAVE errors */
WAVERR_BADFORMAT, "Dieses Format wird nicht unterstützt oder kann nicht übersetzt werden. Benutzen Sie die Funktion 'Capabilities', um die unterstützten Formate zu ermitteln."
WAVERR_STILLPLAYING, "Die Funktion kann nicht durchgeführt werden, wenn noch Mediendateien wiedergegeben werden. Starten Sie das Gerät neu, oder warten Sie bis keine Daten mehr wiedergegeben werden."
WAVERR_UNPREPARED, "Der WAVE - Header wurde nicht vorbereitet. Benutzen Sie die Funktion 'Prepare' zum Vorbereiten des Headers und versuchen Sie es erneut."
WAVERR_SYNC, "Das Gerät kann nicht ohne das WAVE_ALLOWSYNC - Flag geöffnet werden. Benutzen Sie dieses Flag und versuchen Sie es erneut."
/* MIDI errors */
MIDIERR_UNPREPARED, "Der MIDI - Header wurde nicht vorbereitet. Benutzen Sie die Funktion 'Prepare' zum Vorbereiten des Headers und versuchen Sie es erneut."
MIDIERR_STILLPLAYING, "Die Funktion kann nicht durchgeführt werden, wenn noch Mediendateien wiedergegeben werden. Starten Sie das Gerät neu, oder warten Sie bis keine Daten mehr wiedergegeben werden."
MIDIERR_NOMAP, "Es wurde keine MIDI - Map gefunden. Es könnte ein Problem mit dem Treiber geben oder die Datei MIDIMAP.CFG fehlt oder ist beschädigt."
MIDIERR_NOTREADY, "Der Anschluss ist mit der Datenausgabe belegt. Warten Sie, bis die Daten übertragen wurden und versuchen Sie es erneut."
MIDIERR_NODEVICE, "Das gegenwärtige MIDI - Mapper Setup benutzt ein MIDI - Gerät, das nicht installiert ist. Benutzen Sie den MIDI - Mapper, um das Setup zu ändern."
MIDIERR_INVALIDSETUP, "Das aktuelle MIDI Setup ist beschädigt. Kopieren sie die ursprüngliche Datei MIDIMAP.CFG ind das Windows - Systemverzeichnis und versuchen Sie es erneut."
/* MCI errors */
MCIERR_INVALID_DEVICE_ID, "Ungültige MCI - Gerätekennung. Benutzen Sie die zurückgegebene ID, wenn Sie das MCI - Gerät öffnen."
MCIERR_UNRECOGNIZED_KEYWORD, "Der Treiber kann den angegebenen Befehlsparameter nicht anerkennen."
MCIERR_UNRECOGNIZED_COMMAND, "Der Treiber kann den angegebenen Befehl nicht anerkennen."
MCIERR_HARDWARE, "Es gibt ein Problem mit Ihrem Media - Gerät. Stellen Sie sicher, dass es richtig arbeitet oder fragen Sie den Gerätehersteller."
MCIERR_INVALID_DEVICE_NAME, "Das angegebene Gerät ist nicht geöffnet oder wird vom MCI nicht erkannt."
MCIERR_OUT_OF_MEMORY, "Nicht genügend Speicher für den angeforderten Vorgang. \nBeenden Sie eine oder mehrere Anwendungen, und versuchen Sie es erneut."
MCIERR_DEVICE_OPEN, "Der Gerätename wird von dieser Anwendung bereits als Alias benutzt. Benutzen Sie einen eindeutigen Alias"
MCIERR_CANNOT_LOAD_DRIVER, "Es gibt ein unbekanntes Problem beim Laden des angegebenen Gerätetreibers."
MCIERR_MISSING_COMMAND_STRING, "Kein Befehl wurde angegeben."
MCIERR_PARAM_OVERFLOW, "Die Ausgabezeichenkennte war zu lang für den Rückgabepuffer. Erhöhen Sie die Puffergröße."
MCIERR_MISSING_STRING_ARGUMENT, "Der Befehl erfordert einen Zeichenkettenparameter. Bitte stellen Sie einen bereit."
MCIERR_BAD_INTEGER, "Die Angabe einer ganzen Zahl ist für diesen Befehl ungültig."
MCIERR_PARSER_INTERNAL, "Der Gerätetreiber hat einen ungültigen Rückgabewert geliefert. Fragen Sie den Gerätehersteller nach einem neuen Treiber."
MCIERR_DRIVER_INTERNAL, "Ein Treiberfehler ist aufgetreten. Fragen Sie den Gerätehersteller nach einem neuen Treiber."
MCIERR_MISSING_PARAMETER, "Der angegebene Befehl erfordert einen Parameter. Bitte geben Sie einen an."
MCIERR_UNSUPPORTED_FUNCTION, "Das verwendete MCI - Gerät unterstützt diesen Befehl nicht."
MCIERR_FILE_NOT_FOUND, "Die angeforderte Datei wurde nicht gefunden. Stellen Sie sicher, dass Pfad- und Dateiname richtig sind."
MCIERR_DEVICE_NOT_READY, "Der Gerätetreiber ist nicht bereit."
MCIERR_INTERNAL, "Ein Fehler ereignete sich beim Starten von MCI. Versuche Windows neu zu starten."
MCIERR_DRIVER, "Es gibt ein Problem mit dem Gerätetreiber. Der Treiber wird geschlossen. Ein Fehler kann nicht gemeldet werden."
MCIERR_CANNOT_USE_ALL, "Der Gerätename 'all' ist nicht in diesem Befehl erlaubt."
MCIERR_MULTIPLE, "Es traten Fehler in mehr als einem Gerät auf. Geben Sie jeden Befehl für jedes Gerät einzeln an, um zu bestimmen, welches Gerät die Fehler verursachte."
MCIERR_EXTENSION_NOT_FOUND, "Kann keinen Gerätetyp aus der angegebenen Dateinamenerweiterung ermitteln."
MCIERR_OUTOFRANGE, "Der angegebene Paramter liegt außerhalb des zulässigen Bereichs für diesen Befehl."
MCIERR_FLAGS_NOT_COMPATIBLE, "Die Paramter können nicht zusammen verwendet werden."
MCIERR_FILE_NOT_SAVED, "Die Datei kann nicht gespeichert werden. Stellen Sie sicher, dass genügend Platz auf dem Datenträger verfügbar ist oder Ihre Netzwerkverbindung noch besteht."
MCIERR_DEVICE_TYPE_REQUIRED, "Das angegebene Gerät wurde nicht gefunden. Stellen Sie sicher, dass es installiert ist oder der Gerätename richtig geschrieben ist."
MCIERR_DEVICE_LOCKED, "Das angegebene Gerät wird geschlossen. Warten Sie einige Sekunden, und versuchen Sie es erneut."
MCIERR_DUPLICATE_ALIAS, "Der angegebene Alias wird von dieser Anwendung bereits verwendet. Wählen Sie einen eindeutigen Alias."
MCIERR_BAD_CONSTANT, "Der angegebene Parameter für diesen Befehl ungültig."
MCIERR_MUST_USE_SHAREABLE, "Das Gerät ist bereits geöffnet. Benutzen Sie den 'shareable' - Parameter bei jedem 'open' - Befehl."
MCIERR_MISSING_DEVICE_NAME, "Der angegebene Befehl erfordert einen Alias-, Datei-, Treiber- oder Gerätenamen. Bitte geben Sie einen an."
MCIERR_BAD_TIME_FORMAT, "Der angegebene Wert für das Zeitformat ist ungültig. Lesen Sie in der MCI - Dokumentation nach gültigen Formaten nach."
MCIERR_NO_CLOSING_QUOTE, "Ein abschließendes Anführungszeichen fehlt im Parameter. Bitte geben Sie eins an."
MCIERR_DUPLICATE_FLAGS, "Ein Parameter oder Wert wurde zweimal angegeben. Geben Sie in nur einzeln an."
MCIERR_INVALID_FILE, "Die angegebene Datei kann auf dem MCI - Gerät nicht wiedergegeben werden. Die Datei ist wahrscheinlich beschädigt oder in einem ungültigen Format."
MCIERR_NULL_PARAMETER_BLOCK, "Der Parameterblock, der zu MCI übergeben wurde, war NULL."
MCIERR_UNNAMED_RESOURCE, "Es kann keine unbenannte Datei gespeichert werden. Geben Sie einen Dateinamen an."
MCIERR_NEW_REQUIRES_ALIAS, "Sie müssen einen Alias mit dem 'new' - Parameter angeben."
MCIERR_NOTIFY_ON_AUTO_OPEN, "Das 'notify' Flag ist unzulässig für selbstöffnende Geräte."
MCIERR_NO_ELEMENT_ALLOWED, "Ein Dateiname kann mit diesem Gerät nicht verwendet werden."
MCIERR_NONAPPLICABLE_FUNCTION, "Die Befehle sind in der angegebenen Reihenfolge nicht ausführbar. Ändern Sie die Reihenfolge, und versuchen Sie es erneut."
MCIERR_ILLEGAL_FOR_AUTO_OPEN, "Der Befehl kann nicht auf ein selbstöffnedes Gerät angewandt werden. Warten Sie, bis das Gerät geschlossen wurde und versuchen Sie es erneut."
MCIERR_FILENAME_REQUIRED, "Der Dateiname ist ungültig. Der Dateiname muss aus maximal 8 Zeichen, gefolgt von einem Punkt und einer Dateinamenerweiterung bestehen."
MCIERR_EXTRA_CHARACTERS, "Zusätzliche Zeichen nach einer Zeichenkette mit Anführungszeichen sind nicht erlaubt."
MCIERR_DEVICE_NOT_INSTALLED, "Das angegebene Gerät ist nicht auf Ihren System installiert. Benutzen Sie die Hardwareerkennung in der Systemsteuerung, um das Gerät zu installieren."
MCIERR_GET_CD, "Auf die angegebene Datei oder das MCI - Gerät kann nicht zugegriffen werden. Versuchen Sie, das Verzeichnis zu wechseln oder das System neu zu starten."
MCIERR_SET_CD, "Auf die angegebene Datei oder das MCI - Gerät kann nicht zugegriffen werden, weil die Anwendung nicht das Verzeichnis wechseln kann."
MCIERR_SET_DRIVE, "Auf die angegebene Datei oder das MCI - Gerät kann nicht zugegriffen werden, weil die Anwendung nicht das Laufwerk wechseln kann."
MCIERR_DEVICE_LENGTH, "Geben Sie einen Geräte- oder Treibernamen mit weniger als 79 Zeichen an."
MCIERR_DEVICE_ORD_LENGTH, "Geben Sie einen Geräte- oder Treibernamen mit weniger als 69 Zeichen an."
MCIERR_NO_INTEGER, "Der angegebene Befehl erfordert einen ganzzahligen Parameter. Bitte geben Sie einen an."
MCIERR_WAVE_OUTPUTSINUSE, "Alle Waveformgeräte, die diese Dateien in dem gegenwärtigen Format wiedergeben könnten, sind in Benutzung. Warten Sie, bis ein Waveformgerät frei ist, und wiederholen Sie den Vorgang."
MCIERR_WAVE_SETOUTPUTINUSE, "Das gegenwärtige Waveformgerät kann nicht wiedergeben, weil es gerade benutzt wird. Warten Sie, bis das Gerät frei ist, und wiederholen Sie den Vorgang."
MCIERR_WAVE_INPUTSINUSE, "Es ist kein Waveformgerät frei, das das gegenwärtige Format aufzeichnen könnte. Warten Sie, bis ein Waveformgerät frei ist, und wiederholen Sie den Vorgang."
MCIERR_WAVE_SETINPUTINUSE, "Das gegenwärtige Waveformgerät kann nicht aufzeichnen, weil es gerade verwendet wird. Warten Sie, bis das Gerät frei ist, und wiederholen Sie den Vorgang."
MCIERR_WAVE_OUTPUTUNSPECIFIED, "Jedes kompatible Waveform - Wiedergabegerät kann verwendet werden."
MCIERR_WAVE_INPUTUNSPECIFIED, "Jedes kompatible Waveform - Aufnahmegerät kann verwendet werden."
MCIERR_WAVE_OUTPUTSUNSUITABLE, "Es ist kein Waveformgerät installiert, das Dateien im aktuellen Format wiedergeben kann. Benutzen Sie die Hardwareerkennung in der Systemsteuerung, um ein Waveformgerät zu installieren."
MCIERR_WAVE_SETOUTPUTUNSUITABLE,"Das Wiedergabegerät erkennt das gegenwärtige Dateiformat nicht."
MCIERR_WAVE_INPUTSUNSUITABLE, "Es ist kein Waveformgerät installiert, das Dateien im aktuellen Format aufnehmen kann. Benutzen Sie die Hardwareerkennung in der Systemsteuerung, um ein Waveformgerät zu installieren."
MCIERR_WAVE_SETINPUTUNSUITABLE, "Das Gerät, mit dem Sie aufzeichnen möchten, erkennt das gegenwärtige Dateiformat nicht."
MCIERR_NO_WINDOW, "Es gibt kein Anzeigefenster."
MCIERR_CREATEWINDOW, "Fenster konnte nicht erzeugt oder verwendet werden."
MCIERR_FILE_READ, "Die Datei konnte nicht gelesen werden. Stellen Sie sicher, dass die Datei existiert oder Ihre Netzwerkverbindung noch besteht."
MCIERR_FILE_WRITE, "Die Datei konnte nicht geschrieben werden. Stellen Sie sicher, dass genügend Platz auf dem Datenträger verfügbar ist, oder dass die Netzwerkverbindung noch besteht."
MCIERR_SEQ_DIV_INCOMPATIBLE, "Die Zeitformate von ""song pointer"" und SMPTE schliessen sich gegenseitig aus. Sie können sie nicht zusammen verwenden."
MCIERR_SEQ_NOMIDIPRESENT, "Es sind keine MIDI - Geräte auf dem System installiert. Benutzen Sie die Hardwareerkennung in der Systemsteuerung, um einen MIDI - Treiber zu installieren."
MCIERR_SEQ_PORT_INUSE, "Der angegebene MIDI - Anschluss wird bereits verwendet. Warten Sie bis der Anschluss frei ist, und versuchen Sie es erneut."
MCIERR_SEQ_PORT_MAPNODEVICE, "Das gegenwärtige MIDI - Mapper Setup benutzt ein MIDI - Gerät, dass nicht auf Ihren System installiert ist. Benutzen Sie den MIDI - Mapper in der Systemsteuerung, um das Setup zu ändern."
MCIERR_SEQ_PORT_MISCERROR, "Beim Benutzen des angegebenen Anschlusses trat ein Fehler auf."
MCIERR_SEQ_PORT_NONEXISTENT, "Es sind keine angegebnen MIDI - Geräte auf dem System installiert. Benutzen Sie die Hardwareerkennung in der Systemsteuerung, um ein MIDI - Gerät zu installieren."
MCIERR_SEQ_PORTUNSPECIFIED, "Es gibt keinen aktuellen MIDI - Anschluss auf dem System."
MCIERR_SEQ_TIMER, "Alle Multimediazeitgeber werden von anderen Anwendungen verwendet. Beenden Sie eine dieser Anwendungen, und versuchen Sie es erneut."
END

126
reactos/lib/winmm/winmm_En.rc
View file

@ -1,126 +0,0 @@
/*
* Copyright 1999 Eric Pouech
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*/
STRINGTABLE LANGUAGE LANG_ENGLISH, SUBLANG_NEUTRAL
BEGIN
/* MMSYS errors */
MMSYSERR_NOERROR, "The specified command was carried out."
MMSYSERR_ERROR, "Undefined external error."
MMSYSERR_BADDEVICEID, "A device ID has been used that is out of range for your system."
MMSYSERR_NOTENABLED, "The driver was not enabled."
MMSYSERR_ALLOCATED, "The specified device is already in use. Wait until it is free, and then try again."
MMSYSERR_INVALHANDLE, "The specified device handle is invalid."
MMSYSERR_NODRIVER, "There is no driver installed on your system !\n"
MMSYSERR_NOMEM, "Not enough memory available for this task. Quit one or more applications to increase available memory, and then try again."
MMSYSERR_NOTSUPPORTED, "This function is not supported. Use the Capabilities function to determine which functions and messages the driver supports."
MMSYSERR_BADERRNUM, "An error number was specified that is not defined in the system."
MMSYSERR_INVALFLAG, "An invalid flag was passed to a system function."
MMSYSERR_INVALPARAM, "An invalid parameter was passed to a system function."
/* WAVE errors */
WAVERR_BADFORMAT, "The specified format is not supported or cannot be translated. Use the Capabilities function to determine the supported formats"
WAVERR_STILLPLAYING, "Cannot perform this operation while media data is still playing. Reset the device, or wait until the data is finished playing."
WAVERR_UNPREPARED, "The wave header was not prepared. Use the Prepare function to prepare the header, and then try again."
WAVERR_SYNC, "Cannot open the device without using the WAVE_ALLOWSYNC flag. Use the flag, and then try again."
/* MIDI errors */
MIDIERR_UNPREPARED, "The MIDI header was not prepared. Use the Prepare function to prepare the header, and then try again."
MIDIERR_STILLPLAYING, "Cannot perform this operation while media data is still playing. Reset the device, or wait until the data is finished playing."
MIDIERR_NOMAP, "A MIDI map was not found. There may be a problem with the driver, or the MIDIMAP.CFG file may be corrupt or missing."
MIDIERR_NOTREADY, "The port is transmitting data to the device. Wait until the data has been transmitted, and then try again."
MIDIERR_NODEVICE, "The current MIDI Mapper setup refers to a MIDI device that is not installed on the system. Use MIDI Mapper to edit the setup."
MIDIERR_INVALIDSETUP, "The current MIDI setup is damaged. Copy the original MIDIMAP.CFG file to the Windows SYSTEM directory, and then try again."
/* MCI errors */
MCIERR_INVALID_DEVICE_ID, "Invalid MCI device ID. Use the ID returned when opening the MCI device."
MCIERR_UNRECOGNIZED_KEYWORD, "The driver cannot recognize the specified command parameter."
MCIERR_UNRECOGNIZED_COMMAND, "The driver cannot recognize the specified command."
MCIERR_HARDWARE, "There is a problem with your media device. Make sure it is working correctly or contact the device manufacturer."
MCIERR_INVALID_DEVICE_NAME, "The specified device is not open or is not recognized by MCI."
MCIERR_OUT_OF_MEMORY, "Not enough memory available for this task. \nQuit one or more applications to increase available memory, and then try again."
MCIERR_DEVICE_OPEN, "The device name is already being used as an alias by this application. Use a unique alias."
MCIERR_CANNOT_LOAD_DRIVER, "There is an undetectable problem in loading the specified device driver."
MCIERR_MISSING_COMMAND_STRING, "No command was specified."
MCIERR_PARAM_OVERFLOW, "The output string was to large to fit in the return buffer. Increase the size of the buffer."
MCIERR_MISSING_STRING_ARGUMENT, "The specified command requires a character-string parameter. Please provide one."
MCIERR_BAD_INTEGER, "The specified integer is invalid for this command."
MCIERR_PARSER_INTERNAL, "The device driver returned an invalid return type. Check with the device manufacturer about obtaining a new driver."
MCIERR_DRIVER_INTERNAL, "There is a problem with the device driver. Check with the device manufacturer about obtaining a new driver."
MCIERR_MISSING_PARAMETER, "The specified command requires a parameter. Please supply one."
MCIERR_UNSUPPORTED_FUNCTION, "The MCI device you are using does not support the specified command."
MCIERR_FILE_NOT_FOUND, "Cannot find the specified file. Make sure the path and filename are correct."
MCIERR_DEVICE_NOT_READY, "The device driver is not ready."
MCIERR_INTERNAL, "A problem occurred in initializing MCI. Try restarting Windows."
MCIERR_DRIVER, "There is a problem with the device driver. The driver has closed. Cannot access error."
MCIERR_CANNOT_USE_ALL, "Cannot use 'all' as the device name with the specified command."
MCIERR_MULTIPLE, "Errors occurred in more than one device. Specify each command and device separately to determine which devices caused the error"
MCIERR_EXTENSION_NOT_FOUND, "Cannot determine the device type from the given filename extension."
MCIERR_OUTOFRANGE, "The specified parameter is out of range for the specified command."
MCIERR_FLAGS_NOT_COMPATIBLE, "The specified parameters cannot be used together."
MCIERR_FILE_NOT_SAVED, "Cannot save the specified file. Make sure you have enough disk space or are still connected to the network."
MCIERR_DEVICE_TYPE_REQUIRED, "Cannot find the specified device. Make sure it is installed or that the device name is spelled correctly."
MCIERR_DEVICE_LOCKED, "The specified device is now being closed. Wait a few seconds, and then try again."
MCIERR_DUPLICATE_ALIAS, "The specified alias is already being used in this application. Use a unique alias."
MCIERR_BAD_CONSTANT, "The specified parameter is invalid for this command."
MCIERR_MUST_USE_SHAREABLE, "The device driver is already in use. To share it, use the 'shareable' parameter with each 'open' command."
MCIERR_MISSING_DEVICE_NAME, "The specified command requires an alias, file, driver, or device name. Please supply one."
MCIERR_BAD_TIME_FORMAT, "The specified value for the time format is invalid. Refer to the MCI documentation for valid formats."
MCIERR_NO_CLOSING_QUOTE, "A closing double-quotation mark is missing from the parameter value. Please supply one."
MCIERR_DUPLICATE_FLAGS, "A parameter or value was specified twice. Only specify it once."
MCIERR_INVALID_FILE, "The specified file cannot be played on the specified MCI device. The file may be corrupt, or not in the correct format."
MCIERR_NULL_PARAMETER_BLOCK, "A null parameter block was passed to MCI."
MCIERR_UNNAMED_RESOURCE, "Cannot save an unnamed file. Supply a filename."
MCIERR_NEW_REQUIRES_ALIAS, "You must specify an alias when using the 'new' parameter."
MCIERR_NOTIFY_ON_AUTO_OPEN, "Cannot use the 'notify' flag with auto-opened devices."
MCIERR_NO_ELEMENT_ALLOWED, "Cannot use a filename with the specified device."
MCIERR_NONAPPLICABLE_FUNCTION, "Cannot carry out the commands in the order specified. Correct the command sequence, and then try again."
MCIERR_ILLEGAL_FOR_AUTO_OPEN, "Cannot carry out the specified command on an auto-opened device. Wait until the device is closed, and then try again."
MCIERR_FILENAME_REQUIRED, "The filename is invalid. Make sure the filename is not longer than 8 characters, followed by a period and an extension."
MCIERR_EXTRA_CHARACTERS, "Cannot specify extra characters after a string enclosed in quotation marks."
MCIERR_DEVICE_NOT_INSTALLED, "The specified device is not installed on the system. Use the Drivers option in Control Panel to install the device."
MCIERR_GET_CD, "Cannot access the specified file or MCI device. Try changing directories or restarting your computer."
MCIERR_SET_CD, "Cannot access the specified file or MCI device because the application cannot change directories."
MCIERR_SET_DRIVE, "Cannot access specified file or MCI device because the application cannot change drives."
MCIERR_DEVICE_LENGTH, "Specify a device or driver name that is less than 79 characters."
MCIERR_DEVICE_ORD_LENGTH, "Specify a device or driver name that is less than 69 characters."
MCIERR_NO_INTEGER, "The specified command requires an integer parameter. Please provide one."
MCIERR_WAVE_OUTPUTSINUSE, "All wave devices that can play files in the current format are in use. Wait until a wave device is free, and then try again."
MCIERR_WAVE_SETOUTPUTINUSE, "Cannot set the current wave device for play back because it is in use. Wait until the device is free, and then try again."
MCIERR_WAVE_INPUTSINUSE, "All wave devices that can record files in the current format are in use. Wait until a wave device is free, and then try again."
MCIERR_WAVE_SETINPUTINUSE, "Cannot set the current wave device for recording because it is in use. Wait until the device is free, and then try again."
MCIERR_WAVE_OUTPUTUNSPECIFIED, "Any compatible waveform playback device may be used."
MCIERR_WAVE_INPUTUNSPECIFIED, "Any compatible waveform recording device may be used."
MCIERR_WAVE_OUTPUTSUNSUITABLE, "No wave device that can play files in the current format is installed. Use the Drivers option to install the wave device."
MCIERR_WAVE_SETOUTPUTUNSUITABLE,"The device you are trying to play to cannot recognize the current file format."
MCIERR_WAVE_INPUTSUNSUITABLE, "No wave device that can record files in the current format is installed. Use the Drivers option to install the wave device."
MCIERR_WAVE_SETINPUTUNSUITABLE, "The device you are trying to record from cannot recognize the current file format."
MCIERR_NO_WINDOW, "There is no display window."
MCIERR_CREATEWINDOW, "Could not create or use window."
MCIERR_FILE_READ, "Cannot read the specified file. Make sure the file is still present, or check your disk or network connection."
MCIERR_FILE_WRITE, "Cannot write to the specified file. Make sure you have enough disk space or are still connected to the network."
MCIERR_SEQ_DIV_INCOMPATIBLE, "The time formats of the ""song pointer"" and SMPTE are mutually exclusive. You can't use them together."
MCIERR_SEQ_NOMIDIPRESENT, "The system has no installed MIDI devices. Use the Drivers option from the Control Panel to install a MIDI driver."
MCIERR_SEQ_PORT_INUSE, "The specified MIDI port is already in use. Wait until it is free; the try again."
MCIERR_SEQ_PORT_MAPNODEVICE, "The current MIDI Mapper setup refers to a MIDI device that is not installed on the system. Use the MIDI Mapper option from the Control Panel to edit the setup."
MCIERR_SEQ_PORT_MISCERROR, "An error occurred with the specified port."
MCIERR_SEQ_PORT_NONEXISTENT, "The specified MIDI device is not installed on the system. Use the Drivers option from the Control Panel to install a MIDI device."
MCIERR_SEQ_PORTUNSPECIFIED, "The system doesn't have a current MIDI port specified."
MCIERR_SEQ_TIMER, "All multimedia timers are being used by other applications. Quit one of these applications; then, try again."
END

126
reactos/lib/winmm/winmm_Es.rc
View file

@ -1,126 +0,0 @@
/*
* Copyright 1999 Julio Cesar Gazquez
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*/
STRINGTABLE LANGUAGE LANG_SPANISH, SUBLANG_DEFAULT
BEGIN
/* MMSYS errors */
MMSYSERR_NOERROR, "El comando especificado fue ejecutado."
MMSYSERR_ERROR, "Error externo indefinido."
MMSYSERR_BADDEVICEID, "Un identificador de dispositivo que ha sido usado está fuera de rango para su sistema."
MMSYSERR_NOTENABLED, "El controlador no fue activado."
MMSYSERR_ALLOCATED, "El dispositivo especificado aún está en uso. Espere hasta que esté libre e intente nuevamente."
MMSYSERR_INVALHANDLE, "El handle de dispositivo especificado es inválido."
MMSYSERR_NODRIVER, "No hay un controlador instalado en su sistema !\n"
MMSYSERR_NOMEM, "No hay suficiente memoria disponible para esta tarea. Cierre una o más aplicaciones para aumentar la memoria disponible e intente nuevamente."
MMSYSERR_NOTSUPPORTED, "Esta función no está soportada. Use la función Capacidades para determinar que funciones y mensajes soporta el controlador."
MMSYSERR_BADERRNUM, "Se ha especificado un número de error que no está definido en el sistema."
MMSYSERR_INVALFLAG, "Se ha pasado un flag no válido a una función del sistema."
MMSYSERR_INVALPARAM, "Se ha pasado un parámetro no válido a una función del sistema."
/* WAVE errors */
WAVERR_BADFORMAT, "El formato especificado no está soportado o no puede ser traducido. Use la función Capacidades para determinar los formatos soportados."
WAVERR_STILLPLAYING, "Esta operación no puede ejecutarse mientras continúa la reproducción. Reinicie el dispositivo, o espere hasta que la reproducción termine."
WAVERR_UNPREPARED, "La cabecera del forma de onda no está preparada. Use la función Preparar para preparar la cabecera, e intente nuevamente."
WAVERR_SYNC, "No puede abrirse el dispositivo sin usar el flag WAVE_ALLOWSYNC. Use el flag, e intente nuevamente."
/* MIDI errors */
MIDIERR_UNPREPARED, "La cabecera MIDI no está preparada. Use la función Preparar para preparar la cabecera, e intente nuevamente."
MIDIERR_STILLPLAYING, "Esta operación no puede ejecutarse mientras se continúa tocando. Reinicie el dispositivo, o espera hasta que termine de tocar."
MIDIERR_NOMAP, "No se encontró un mapa MIDI. Puede haber un problema con el controlador, el el fichero MIDIMAP.CFG puede faltar o estar corrupto."
MIDIERR_NOTREADY, "El puerto está transmitiendo datos al dispositivo. Espera hasta que los datos hayan sido transmitidos, e intente nuevamente."
MIDIERR_NODEVICE, "La configuración actual del mapeador MIDI refiere a un dispositivo MIDI que no está instalado en el sistema. Use el mapeador MIDI para editar la configuración."
MIDIERR_INVALIDSETUP, "La configuración actual de MIDI está dañada. Copie el fichero MIDIMAP.CFG original al directorio SYSTEM de Windows SYSTEM, e intente nuevamente."
/* MCI errors */
MCIERR_INVALID_DEVICE_ID, "Identificador de dispositivo MCI inválido. Use el identificador devuelto al abrir el dispositivo MCI."
MCIERR_UNRECOGNIZED_KEYWORD, "El controlador no puede reconocer el parámetro de comando especificado."
MCIERR_UNRECOGNIZED_COMMAND, "El controlador no puede reconocer el comando especificado."
MCIERR_HARDWARE, "Hay un problema con su dispositivo. Asegúrese de que esté funcionando correctamente o contacte al fabricante del dispositivo."
MCIERR_INVALID_DEVICE_NAME, "El dispositivo especificado no está abierto o no es reconocido por MCI."
MCIERR_OUT_OF_MEMORY, "No hay suficiente memoria para esta tarea.\nCierre una o más aplicaciones para aumentar la memoria disponible e intente nuevamente."
MCIERR_DEVICE_OPEN, "El nombre de dispositivo ya está siendo usado como un alias por esta aplicación. Use un alias único."
MCIERR_CANNOT_LOAD_DRIVER, "Hay un problema no detectable en la carga del controlador de dispositivo especificado."
MCIERR_MISSING_COMMAND_STRING, "No se ha especificado un comando."
MCIERR_PARAM_OVERFLOW, "La cadena de salida es muy grande para caber en el buffer de retorno. Aumente el tamaño del buffer."
MCIERR_MISSING_STRING_ARGUMENT, "El comando especificado requiere un parámetro de cadena de caracteres. Por favor provea uno."
MCIERR_BAD_INTEGER, "El entero especificado es inválido para este comando."
MCIERR_PARSER_INTERNAL, "El controlador de dispositivo devolvió un tipo de retorno inválido. Contacte al fabricante del dispositivo para obtener un nuevo controlador."
MCIERR_DRIVER_INTERNAL, "Hay un problema con el controlador de dispositivo. Contacte al fabricante del dispositivo para obtener un nuevo controlador."
MCIERR_MISSING_PARAMETER, "El comando especificado requiere un parámetro. Por favor provea uno."
MCIERR_UNSUPPORTED_FUNCTION, "El dispositivo MCI que está usando no soporta el comando especificado."
MCIERR_FILE_NOT_FOUND, "No se encuentra el fichero especificado. Asegúrese que el path y el nombre del fichero son correctos."
MCIERR_DEVICE_NOT_READY, "El controlador de dispositivo no está listo."
MCIERR_INTERNAL, "Un problema ha ocurrido inicializando el MCI. Intente reiniciar Windows."
MCIERR_DRIVER, "Hay un problema con el controlador del dispositivo. El controlador se ha cerrado. Intente reenviar el comando."
MCIERR_CANNOT_USE_ALL, "Utilice un nombre de dispositivo específico para este comando."
MCIERR_MULTIPLE, "Han ocurrido errores en más de un dispositivo. Especifique cada comando y dispositivo por separado para determinar que dispositivos causaron el error."
MCIERR_EXTENSION_NOT_FOUND, "No puede determinarse el tipo de dispositivo a partir de la extensión de fichero dada."
MCIERR_OUTOFRANGE, "El parámetro especificado está fuera del rango para el comando especificado."
MCIERR_FLAGS_NOT_COMPATIBLE, "Los parámetros especificados no pueden usarse juntos."
MCIERR_FILE_NOT_SAVED, "No puede grabarse el fichero especificado. Asegúrese de tener suficiente espacio en disco o de que permanece conectado a la red."
MCIERR_DEVICE_TYPE_REQUIRED, "No puede encontrarse el dispositivo especificado. Asegúrese de que está instalado o de que el nombre del dispositivo está escrito correctamente."
MCIERR_DEVICE_LOCKED, "El dispositivo especificado está siendo cerrado. Espere unos segundos e intente nuevamente."
MCIERR_DUPLICATE_ALIAS, "El alias especificado ya está siendo usado por esta aplicación. Use un alias único."
MCIERR_BAD_CONSTANT, "El parámetro especificado es inválido para este comando."
MCIERR_MUST_USE_SHAREABLE, "El controlador de dispositivo ya está en uso. Para compartirlo, use el parámetro 'compartible' ('shareable') con cada comando 'abrir' ('open')."
MCIERR_MISSING_DEVICE_NAME, "El comando especificado requiere un alias, fichero, controlador o nombre de dispositivo. Por favor provea uno."
MCIERR_BAD_TIME_FORMAT, "El valor especificado para el formato de tiempo es inválido. Verifique los formatos válidos en la documentación de MCI."
MCIERR_NO_CLOSING_QUOTE, "Una comilla de cierre está faltando en el valor del parámetro. Por favor provea una."
MCIERR_DUPLICATE_FLAGS, "Un parámetro o valor fue especificado dos veces. Especifíquelo una sola vez."
MCIERR_INVALID_FILE, "El fichero especificado no puede ser tocado en el dispositivo MCI especificado. El fichero puede estar corrupto o en un formato incorrecto."
MCIERR_NULL_PARAMETER_BLOCK, "Se ha pasado un bloque de parámetros nulo al MCI."
MCIERR_UNNAMED_RESOURCE, "No puede guardarse un fichero sin nombre. Provea un nombre para el fichero."
MCIERR_NEW_REQUIRES_ALIAS, "Debe especificar un alias cuando utilice el parámetro 'nuevo'."
MCIERR_NOTIFY_ON_AUTO_OPEN, "No puede usar el flag 'notificar' con dispositivos de apertura automática."
MCIERR_NO_ELEMENT_ALLOWED, "No puede usar un nombre de fichero con el dispositivo especificado."
MCIERR_NONAPPLICABLE_FUNCTION, "No pueden ejecutarse los comandos en el orden especificado. Corrija la secuencia de comandos e intente nuevamente."
MCIERR_ILLEGAL_FOR_AUTO_OPEN, "No puede ejecutarse el comando especificado en un dispositivo de apertura automática. Espere hasta que el dispositivo esté cerrado e intente nuevamente."
MCIERR_FILENAME_REQUIRED, "El nombre del fichero es inválido. Asegúrese de que el nombre del fichero no es mayor de 8 caracteres, seguido por un punto y una extensión."
MCIERR_EXTRA_CHARACTERS, "No puede especificar caracteres extra después de una cadena encerrada entre comillas."
MCIERR_DEVICE_NOT_INSTALLED, "El dispositivo especificado no está instalado en el sistema. Use la opción Controladores en el Panel de Control para instalar el dispositivo."
MCIERR_GET_CD, "No puede accederse al fichero o dispositivo MCI especificado. Intente cambiando de directorio o reiniciando el equipo."
MCIERR_SET_CD, "No puede accederse al fichero o dispositivo MCI especificado porque la aplicación no puede cambiar de directorio."
MCIERR_SET_DRIVE, "No puede accederse al fichero o dispositivo MCI especificado porque la aplicación no puede cambiar de unidad."
MCIERR_DEVICE_LENGTH, "Especifique un dispositivo o nombre de controlador de menos de 79 caracteres."
MCIERR_DEVICE_ORD_LENGTH, "Especifique un dispositivo o nombre de controlador de menos de 69 caracteres."
MCIERR_NO_INTEGER, "El comando especificado requiere un parámetro entero. Por favor provea uno."
MCIERR_WAVE_OUTPUTSINUSE, "Todos los dispositivos que pueden tocar ficheros en este formato están en uso. Espere hasta que se libere un dispositivo e intente nuevamente."
MCIERR_WAVE_SETOUTPUTINUSE, "No puede prepararse el dispositivo de forma de onda para reproducción porque está en uso. Espere hasta que el dispositivo esté libre e intente nuevamente."
MCIERR_WAVE_INPUTSINUSE, "Todos los dispositivos que pueden grabar ficheros en este formato están en uso. Espere hasta que se libere un dispositivo e intente nuevamente."
MCIERR_WAVE_SETINPUTINUSE, "No puede prepararse el dispositivo de forma de onda para grabación porque está en uso. Espere hasta que el dispositivo esté libre e intente nuevamente."
MCIERR_WAVE_OUTPUTUNSPECIFIED, "Cualquier dispositivo compatible de reproducción de forma de onda puede ser usado."
MCIERR_WAVE_INPUTUNSPECIFIED, "Cualquier dispositivo compatible de grabación de forma de onda puede ser usado."
MCIERR_WAVE_OUTPUTSUNSUITABLE, "No hay ningún dispositivo de forma de onda instalado capaz de reproducir ficheros en este formato. Use la opción Dispositivos para instalar el dispositivo de forma de onda."
MCIERR_WAVE_SETOUTPUTUNSUITABLE,"El dispositivo con el que intenta reproducir no puede reconocer el formato de fichero."
MCIERR_WAVE_INPUTSUNSUITABLE, "No hay ningún dispositivo de forma de onda instalado capaz de grabar ficheros en este formato. Use la opción Dispositivos para instalar el dispositivo de forma de onda."
MCIERR_WAVE_SETINPUTUNSUITABLE, "El dispositivo con el que intenta grabar no puede reconocer el formato de fichero."
MCIERR_NO_WINDOW, "No hay una ventana."
MCIERR_CREATEWINDOW, "No puede crearse o usar una ventana."
MCIERR_FILE_READ, "No puede leerse el fichero especificado. Asegúrese de que el fichero aún está presente, o revise su disco o conexión de red."
MCIERR_FILE_WRITE, "No puede grabarse el fichero especificado. Asegúrese de tener suficiente espacio en disco o de que permanece conectado a la red."
MCIERR_SEQ_DIV_INCOMPATIBLE, "Los formatos de tiempo de ""song pointer"" y SMPTE son mutuamente exclusivos. No pueden utilizarse a la vez."
MCIERR_SEQ_NOMIDIPRESENT, "El sistema no tiene dispositivos MIDI instalados. Use la opción Controladores en el Panel de Control para instalar el dispositivo."
MCIERR_SEQ_PORT_INUSE, "El puerto MIDI especificado ya está en uso. Espere hasta que esté libre e intente nuevamente."
MCIERR_SEQ_PORT_MAPNODEVICE, "La configuración actual del mapeador MIDI refiere a un dispositivo MIDI que no está instalado en el sistema. Use el la opción del mapeador MIDI en el Panel de Control para editar la configuración."
MCIERR_SEQ_PORT_MISCERROR, "Ha ocurrido un error con el puerto especificado."
MCIERR_SEQ_PORT_NONEXISTENT, "El dispositivo MIDI especificado no está instalado en el sistema. Use la opción Dispositivos en el Panel de Control para instalar un dispositivo MIDI."
MCIERR_SEQ_PORTUNSPECIFIED, "El sistema no tiene actualmente un puerto MIDI especificado."
MCIERR_SEQ_TIMER, "Todos los temporizadores de multimedia están siendo usados por otras aplicaciones. Cierre una de esas aplicaciones e intente nuevamente."
END

131
reactos/lib/winmm/winmm_Fr.rc
View file

@ -1,131 +0,0 @@
/*
* Winmm
* French language support
*
* Copyright 1999 Eric Pouech
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*/
LANGUAGE LANG_FRENCH, SUBLANG_NEUTRAL
STRINGTABLE
BEGIN
/* MMSYS errors */
MMSYSERR_NOERROR, "La commande spécifiée a été exécutée."
MMSYSERR_ERROR, "Erreur externe non définie."
MMSYSERR_BADDEVICEID, "Un identificateur de périphérique hors des limites pour votre système a été utilisé."
MMSYSERR_NOTENABLED, "Le pilote n'a pas été activé."
MMSYSERR_ALLOCATED, "Le périphérique spécifié est en cours d'utilisation. Attendez qu'il soit libre, puis essayez à nouveau."
MMSYSERR_INVALHANDLE, "Le handle de périphérique spécifié n'est pas valide."
MMSYSERR_NODRIVER, "Il n'y a pas de pilote installé sur votre système."
MMSYSERR_NOMEM, "Mémoire insuffisante pour cette tâche. Quittez un ou plusieurs programmes, puis essayez à nouveau."
MMSYSERR_NOTSUPPORTED, "Fonction non prise en charge. Utilisez la fonction Capacités pour obtenir les fonctions de ce pilote."
MMSYSERR_BADERRNUM, "Un numéro d'erreur non défini dans le système a été spécifié."
MMSYSERR_INVALFLAG, "Un indicateur non valide a été transmis à une fonction système."
MMSYSERR_INVALPARAM, "Un paramètre non valide a été passé à une fonction système."
/* WAVE errors */
WAVERR_BADFORMAT, "Le format choisi ne peut être traduit ou utilisé. Utilisez Capacités pour voir les formats pris en charge."
WAVERR_STILLPLAYING, "Le Lecteur multimédia continue à lire des données. Réinitialisez-le ou attendez que toutes les données aient été lues."
WAVERR_UNPREPARED, "L'en-tête du son n'a pas été préparé. Utilisez la fonction Préparer pour le faire, puis essayez à nouveau."
WAVERR_SYNC, "Impossible d'ouvrir le périphérique sans utiliser l'indicateur WAVE_ALLOWSYNC. Utilisez l'indicateur, puis essayez à nouveau."
/* MIDI errors */
MIDIERR_UNPREPARED, "L'en-tête MIDI n'a pas été préparé. Utilisez la fonction Préparer pour le faire, puis essayez à nouveau."
MIDIERR_STILLPLAYING, "Le Lecteur multimédia continue à lire des données. Réinitialisez-le ou attendez que toutes les données aient été. lues."
MIDIERR_NOMAP, "Il n'y a pas d'instrument défini pour un mappeur MIDI. Utiliser l'onglet MIDI dans Propriétés multimédia pour installer les instruments."
MIDIERR_NOTREADY, "Le port transmet des données au périphérique. Attendez la fin de la transmission, puis essayez à nouveau."
MIDIERR_NODEVICE, "Le fichier de description d'instrument MIDI (.IDF) n'est pas valide. Pour plus d'informations, contactez le constructeur de l'instrument."
MIDIERR_INVALIDSETUP, "Un appel MIDI non valide dans le mode d'ouverture en cours a été émis. Ouvrez à nouveau le périphérique en employant le mode correct."
/* MCI errors */
MCIERR_INVALID_DEVICE_ID, "ID de périphérique MCI non valide. Utilisez l'ID renvoyé lorsque vous avez ouvert le périphérique MCI."
MCIERR_UNRECOGNIZED_KEYWORD, "Le paramêtre de commande utilisé n'est pas défini dans l'ensemble de commandes MCI."
MCIERR_UNRECOGNIZED_COMMAND, "La commande utilisée n'est pas une commande MCI valide."
MCIERR_HARDWARE, "Votre périphérique multimédia présente un problème. Vérifiez qu'il fonctionne convenablement ou contactez le constructeur."
MCIERR_INVALID_DEVICE_NAME, "Ce n'est pas un périphérique MCI connu."
MCIERR_OUT_OF_MEMORY, "Mémoire insuffisante pour cette tâche. Quittez un ou plusieurs programmes, puis essayez à nouveau."
MCIERR_DEVICE_OPEN, "Cet alias est déjà utilisé par ce programme. Employez un alias unique plutôt que le nom du périphérique."
MCIERR_CANNOT_LOAD_DRIVER, "Le pilote de périphérique n'a pas pu être chargé. Vérifiez qu'il est installé correctement."
MCIERR_MISSING_COMMAND_STRING, "La chaîne de commande est vide."
MCIERR_PARAM_OVERFLOW, "La chaîne de sortie était trop grande pour tenir dans la mémoire tampon de retour. Augmentez la taille de la mémoire tampon."
MCIERR_MISSING_STRING_ARGUMENT, "La commande spécifiée nécessite un paramêtre chaîne de caractères : veuillez l'entrer."
MCIERR_BAD_INTEGER, "Le nombre entier que vous avez spécifié n'est pas valide pour cette commande. Entrez un nombre."
MCIERR_PARSER_INTERNAL, "Le pilote de périphérique a renvoyé une réponse de type non valide. Pour obtenir un nouveau pilote, contactez le constructeur du périphérique."
MCIERR_DRIVER_INTERNAL, "Le pilote de périphérique présente un problème. Demandez au constructeur du périphérique de vous fournir un nouveau pilote."
MCIERR_MISSING_PARAMETER, "Il manque un paramêtre dans la commande spécifiée : veuillez l'entrer."
MCIERR_UNSUPPORTED_FUNCTION, "Le périphérique MCI que vous utilisez ne prend pas en charge la commande spécifiée."
MCIERR_FILE_NOT_FOUND, "Le fichier spécifié est introuvable. Vérifiez que le chemin d'accès et le nom de fichier sont corrects."
MCIERR_DEVICE_NOT_READY, "Le pilote de périphérique n'est pas prêt. Attendez une minute avant d'essayer à nouveau."
MCIERR_INTERNAL, "Un problème est survenu lors de l'initialisation de MCI. Essayez de redémarrer Windows."
MCIERR_DRIVER, "Une erreur spécifique au pilote a provoqué sa fermeture. Essayez de relancer la commande."
MCIERR_CANNOT_USE_ALL, "Utilisez un nom de périphérique spécifique pour cette commande."
MCIERR_MULTIPLE, "Des erreurs se sont produites dans plusieurs périphériques. Spécifiez chaque commande et chaque périphérique séparément afin de déterminer les périphériques qui ont provoqué les erreurs."
MCIERR_EXTENSION_NOT_FOUND, "Impossible de jouer ce fichier. Vérifiez le nom de fichier ou installez un pilote qui reconnaît ce type de fichier."
MCIERR_OUTOFRANGE, "Le paramêtre est hors limites pour la commande spécifiée."
MCIERR_FLAGS_NOT_COMPATIBLE, "Les paramêtres spécifiés ne peuvent être utilisés ensemble."
MCIERR_FILE_NOT_SAVED, "Il est impossible d'enregistrer le fichier spécifié. Vérifiez que vous avez assez d'espace disque ou que vous êtes toujours connecté au réseau."
MCIERR_DEVICE_TYPE_REQUIRED, "Le périphérique spécifié est introuvable. Vérifiez s'il est installé ou si son nom est correctement orthographié."
MCIERR_DEVICE_LOCKED, "Le périphérique spécifié est en cours de fermeture. Attendez quelques secondes, puis essayez à nouveau."
MCIERR_DUPLICATE_ALIAS, "L'alias spécifié est déjà utilisé dans cette application. Utilisez un alias unique."
MCIERR_BAD_CONSTANT, "La constante utilisée n'est pas correcte pour cette commande."
MCIERR_MUST_USE_SHAREABLE, "Le pilote de périphérique est déjà utilisé en ce moment. Pour le partager, utilisez le paramêtre de partage ('shareable') dans chaque commande d'ouverture ('open')."
MCIERR_MISSING_DEVICE_NAME, "La commande spécifiée requiert un nom d'alias, de fichier, de pilote ou de périphérique : veuillez l'entrer."
MCIERR_BAD_TIME_FORMAT, "La valeur spécifiée comme format horaire n'est pas valide. Les formats valides sont indiqués dans la documentation MCI."
MCIERR_NO_CLOSING_QUOTE, "Un guillemet double fermant manque dans la valeur du paramêtre. Ajoutez-le."
MCIERR_DUPLICATE_FLAGS, "Un paramêtre ou une valeur a été spécifié deux fois et ne doit être spécifié qu'une seule fois."
MCIERR_INVALID_FILE, "Le fichier ne peut pas être exécuté sur un périphérique MCI spécifié. Le fichier est endommagé ou son format n'est pas correct."
MCIERR_NULL_PARAMETER_BLOCK, "Un bloc de paramêtres nuls a été passé à MCI."
MCIERR_UNNAMED_RESOURCE, "Impossible d'enregistrer un fichier sans nom. Entrez un nom de fichier."
MCIERR_NEW_REQUIRES_ALIAS, "Vous devez spécifier un alias lorsque vous employez le paramêtre 'nouveau'."
MCIERR_NOTIFY_ON_AUTO_OPEN, "Il est impossible d'utiliser l'indicateur 'notifier' avec les périphériques à ouverture automatique."
MCIERR_NO_ELEMENT_ALLOWED, "Impossible d'utiliser un nom de fichier avec le périphérique spécifié."
MCIERR_NONAPPLICABLE_FUNCTION, "Impossible d'exécuter les commandes dans l'ordre spécifié. Corrigez l'ordre des commandes, puis essayez à nouveau."
MCIERR_ILLEGAL_FOR_AUTO_OPEN, "Impossible d'exécuter cette commande sur un périphérique à ouverture automatique. Attendez que le périphérique soit fermé pour essayer à nouveau."
MCIERR_FILENAME_REQUIRED, "Le nom de fichier est incorrect."
MCIERR_EXTRA_CHARACTERS, "Il est impossible de spécifier des caractères supplémentaires après une chaîne placée entre guillemets."
MCIERR_DEVICE_NOT_INSTALLED, "Ce périphérique n'est pas installé. Pour installer un nouveau pilote, double-cliquez sur l'icône Ajout de périphérique dans le Panneau de configuration."
MCIERR_GET_CD, "Impossible d'accéder au fichier ou au périphérique MCI spécifié. Essayez de changer de répertoire ou de redémarrer votre ordinateur."
MCIERR_SET_CD, "Impossible d'accéder au fichier ou au périphérique MCI spécifié, car l'application ne peut pas changer de répertoire."
MCIERR_SET_DRIVE, "Impossible d'accéder au fichier ou au périphérique MCI spécifié, car l'application ne peut pas changer de lecteur."
MCIERR_DEVICE_LENGTH, "Spécifiez un nom de périphérique ou de pilote de moins de 79 caractères."
MCIERR_DEVICE_ORD_LENGTH, "Spécifiez un nom de périphérique ou de pilote comptant moins de 69 caractères."
MCIERR_NO_INTEGER, "La commande spécifiée nécessite un paramêtre numérique. Exemple : ""jouer jusqu'à 10"". Entrez ce paramêtre."
MCIERR_WAVE_OUTPUTSINUSE, "Tous les périphériques audio capables de jouer des fichiers sous ce format sont en cours d'utilisation. Attendez qu'un périphérique audio soit libre, puis essayez à nouveau."
MCIERR_WAVE_SETOUTPUTINUSE, "Le périphérique audio de lecture est en cours d'utilisation. Attendez qu'il soit libre, puis essayez à nouveau."
MCIERR_WAVE_INPUTSINUSE, "Tous les périphériques audio capables d'enregistrer des fichiers sous ce format sont en cours d'utilisation. Attendez qu'un périphérique audio soit libre, puis essayez à nouveau."
MCIERR_WAVE_SETINPUTINUSE, "Le périphérique audio d'enregistrement est en cours d'utilisation. Attendez qu'il soit libre, puis essayez à nouveau."
MCIERR_WAVE_OUTPUTUNSPECIFIED, "N'importe quel périphérique audio de lecture peut être utilisé."
MCIERR_WAVE_INPUTUNSPECIFIED, "N'importe quel périphérique audio d'enregistrement peut être utilisé."
MCIERR_WAVE_OUTPUTSUNSUITABLE, "Aucun périphérique audio capable de jouer des fichiers sous le format en cours n'a été installé."
MCIERR_WAVE_SETOUTPUTUNSUITABLE,"Ce périphérique ne parvient pas à reconnaître le format du fichier actuel. Sélectionnez un autre périphérique, puis essayez à nouveau."
MCIERR_WAVE_INPUTSUNSUITABLE, "Aucun périphérique audio capable d'enregistrer des fichiers sous le format en cours n'a été installé."
MCIERR_WAVE_SETINPUTUNSUITABLE, "Ce périphérique ne parvient pas à reconnaître le format du fichier actuel. Sélectionnez un autre périphérique, puis essayez à nouveau."
MCIERR_NO_WINDOW, "Il n'y pas de fenêtre d'affichage."
MCIERR_CREATEWINDOW, "Impossible d'utiliser ou de créer une fenêtre."
MCIERR_FILE_READ, "Impossible de lire ce fichier. Assurez-vous qu'il n'a pas été supprimé ou vérifiez votre disque ou votre connexion réseau."
MCIERR_FILE_WRITE, "Il est impossible d'écrire des informations dans le fichier spécifié. Vérifiez que vous avez assez d'espace disque ou que vous êtes toujours connecté au réseau."
MCIERR_SEQ_DIV_INCOMPATIBLE, "Il est impossible d'utiliser le format horaire pointeur de piste et le format horaire SMPTE en même temps."
MCIERR_SEQ_NOMIDIPRESENT, "Le système n'a pas de périphériques MIDI installés. Pour installer un nouveau pilote, double-cliquez sur l'icône Ajout de périphérique dans le Panneau de configuration."
MCIERR_SEQ_PORT_INUSE, "Le port MIDI spécifié est déjà utilisé. Attendez qu'il soit libre et essayez à nouveau."
MCIERR_SEQ_PORT_MAPNODEVICE, "La configuration actuelle du mappeur MIDI fait référence à un périphérique MIDI non installé sur votre système. Utilisez l'option mappeur MIDI dans le Control Panel pour changer la configuration."
MCIERR_SEQ_PORT_MISCERROR, "Une erreur est survenue sur le port spécifié."
MCIERR_SEQ_PORT_NONEXISTENT, "Ce périphérique n'est pas installé. Pour installer un nouveau pilote, double-cliquez sur l'icône Ajout de périphérique dans le Panneau de configuration."
MCIERR_SEQ_PORTUNSPECIFIED, "Le système n'a pas spécifié de port MIDI par défaut."
MCIERR_SEQ_TIMER, "Tous les timers multimédia sont en cours d'utilisation par d'autres applications. Quittez une de ces applications et essayez à nouveau."
END

127
reactos/lib/winmm/winmm_It.rc
View file

@ -1,127 +0,0 @@
/*
* Copyright 1999 Eric Pouech
* Copyright 2003 Ivan Leo Puoti
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*/
STRINGTABLE LANGUAGE LANG_ITALIAN, SUBLANG_NEUTRAL
BEGIN
/* MMSYS errors */
MMSYSERR_NOERROR, "Il comando specificato è stato eseguito."
MMSYSERR_ERROR, "Errore esterno sconosciuto."
MMSYSERR_BADDEVICEID, "E' stato usato l'ID di un dispositivo che è fuori dalla portata del sistema."
MMSYSERR_NOTENABLED, "Il driver non è abilitato."
MMSYSERR_ALLOCATED, "Il driver specificato è già in uso. Attendere che sia nuovamente disponibile, e riprovare."
MMSYSERR_INVALHANDLE, "Il handle del dispositivo specificato è invalido."
MMSYSERR_NODRIVER, "Non è installato nessun driver nel sistema !\n"
MMSYSERR_NOMEM, "Memoria insufficente per eseguire questa operazione. Chiudere una o più applicazioni per aumentare la memoria disponibile, e riprovare."
MMSYSERR_NOTSUPPORTED, "Questa funzione non è supportata. Usare la funzione Capabilities per determinare quali funzioni e messaggi sono supportati dal driver."
MMSYSERR_BADERRNUM, "E' stato specificato un numero di errore non definito dal sistema."
MMSYSERR_INVALFLAG, "Un flag invalido è stato passato a una funzione di sistema."
MMSYSERR_INVALPARAM, "Un parametro invalido è stato pasato a una funzione di sistema."
/* WAVE errors */
WAVERR_BADFORMAT, "Il formato specificato non è supportato o non può essere tradotto. Usare la funzione Capabilities per determinare le funzioni supportate"
WAVERR_STILLPLAYING, "Non è possibile effetuare questa operazione durante l'esecuzione. Reinizializzare il dispositivo, o attendere la fine dell'esecuzione."
WAVERR_UNPREPARED, "Il header wave non è stato preparato. Usare la funzione Prepare per preparale l'header, e riprovare."
WAVERR_SYNC, "Non è possibile aprire il dispositivo senza usare il flag WAVE_ALLOWSYNC. Usare il flag, e riprovare."
/* MIDI errors */
MIDIERR_UNPREPARED, "L'header MIDI non è stato preparato. Usare la funzione Prepare per preparare l'header, e riprovare."
MIDIERR_STILLPLAYING, "Non è possibile effetuare questa operazione durante l'esecuzione. Reinizializzare il dispositivo, o attendere la fine dell'esecuzione."
MIDIERR_NOMAP, "Non è stata trovata una mappa MIDI. Ci potrebbe essere un problema con il driver, o il file MIDIMAP.CFG potrebbe essere danneggiato o mancante."
MIDIERR_NOTREADY, "La porta sta trasmettendo dei dati al dispositivo. Attendere la trasmissione di tutti i dati, e riprovare."
MIDIERR_NODEVICE, "La configurazione attuale del Mapper MIDI si riferisce a un dispositivo MIDI che non è presente nel sistema. Usare il Mapper MIDI per modificare la configurazione."
MIDIERR_INVALIDSETUP, "La configutazione MIDI attuale è danneggiata. Copiare il file MIDIMAP.CFG nella directory SYSTEM di Windows, e riprovare."
/* MCI errors */
MCIERR_INVALID_DEVICE_ID, "ID del dispositivo MCI invalido. Usare l'ID restituito quando si è aperto il dispositivo MCI."
MCIERR_UNRECOGNIZED_KEYWORD, "Il driver non riconosce il parametro del comando specificato."
MCIERR_UNRECOGNIZED_COMMAND, "Il driver non riconosce il comando specificato."
MCIERR_HARDWARE, "C'è un problema con il dispositivo multimediale. Controllare che il funzionamento del dispositivo o contattare il produttore."
MCIERR_INVALID_DEVICE_NAME, "Il dispositivo specificato non è aperto o non è supportato da MCI."
MCIERR_OUT_OF_MEMORY, "Memoria insufficente per eseguire questa operazione. \nChiudere una o più applicazioni per aumentare la memoria disponibile, e riprovare."
MCIERR_DEVICE_OPEN, "Il nome del dispositivo è già in uso come alias da parte di questa applicazione. Usare un alias univoco."
MCIERR_CANNOT_LOAD_DRIVER, "Si è verificato un problema non rilevabile nel caricamento del driver specificato."
MCIERR_MISSING_COMMAND_STRING, "Non è stato specificato nessun comando."
MCIERR_PARAM_OVERFLOW, "La stringa di output è troppo grande per entrare nel buffer di ritorno. Aumentare la dimensione del buffer."
MCIERR_MISSING_STRING_ARGUMENT, "Il comando specificato richiede un parametro che sia una stringa di caratteri. Fornirne uno."
MCIERR_BAD_INTEGER, "Il numero intreo specificato non è valido per questo comando."
MCIERR_PARSER_INTERNAL, "Il driver ha restituito un tipo non valido. Contattare il produttore del dispositivo per ottenere un nuovo driver."
MCIERR_DRIVER_INTERNAL, "C'è un problema con il driver. Contattare il produttore del dispositivo per ottenere un nuovo driver."
MCIERR_MISSING_PARAMETER, "Il comando specificato richiede un parametro. Fornirne uno."
MCIERR_UNSUPPORTED_FUNCTION, "Il dispositivo MCI in uso non supporta il comando specificato."
MCIERR_FILE_NOT_FOUND, "Il file specificato non è stato trovato. Controllare che l'indirizzo e il nome del file siano corretti."
MCIERR_DEVICE_NOT_READY, "Il driver non è pronto."
MCIERR_INTERNAL, "Si è verificato un problema nell'inizializazione di MCI. Provare a riavviare Windows."
MCIERR_DRIVER, "Si è verificato un errore nel driver. Il driver è stato chiuso. Errore non accessibile."
MCIERR_CANNOT_USE_ALL, "Non è possibile usare 'all' come nome del dispositivo con il comando specificato."
MCIERR_MULTIPLE, "Si sono verificati degli errori in più di un dispositivo. Specificare ogni comando e dispositivo separatamente per determinare quale dispositivo ha causato l'errore"
MCIERR_EXTENSION_NOT_FOUND, "Impossibile determinare il tipo di dispositivo dall'estensione data."
MCIERR_OUTOFRANGE, "Il parametro specificato è fuori dalla portata del comando specificato."
MCIERR_FLAGS_NOT_COMPATIBLE, "I parametri specificati non possono essere usati insieme."
MCIERR_FILE_NOT_SAVED, "Impossibile salvare il file specificato. Controllare di avere abbastanza spazio libero e di essere ancora connessi alla rete."
MCIERR_DEVICE_TYPE_REQUIRED, "Impossibile trovare il dispositivo specificato. Controllare che sia installato e che il nome sia digitato correttamente."
MCIERR_DEVICE_LOCKED, "Il dispositivo specificato verrà chiuso. Attendere alcuni secondi e riprovare."
MCIERR_DUPLICATE_ALIAS, "L'alias specificato è già in uso da parte di questa applicazione. Usare un alias univoco."
MCIERR_BAD_CONSTANT, "Il parametro specificato è invalido per questo comando."
MCIERR_MUST_USE_SHAREABLE, "Il driver è già in uso. Per condividerlo, usare il parametro 'shareable' con ogni comando 'open'."
MCIERR_MISSING_DEVICE_NAME, "Il comando specificato richiede un alias, un file, un driver o il nome di un dispositivo. Fornirne uno."
MCIERR_BAD_TIME_FORMAT, "Il valore specificato è invalido per il formato dell'orario. Consultare la documentazione dell'MCI per i formati validi."
MCIERR_NO_CLOSING_QUOTE, "Manca una doppia vorgoletta di chiusura dal valore del parametro. Fornirne una."
MCIERR_DUPLICATE_FLAGS, "Un valore o parametro è stato specificato due volte. Specificarlo solo una volta."
MCIERR_INVALID_FILE, "Il file specificato non può essere aperto con il dispositivo MCI specificato. Il file potrebbe essere daneggiato, o in un formato errato."
MCIERR_NULL_PARAMETER_BLOCK, "Un null parameter block è stato passato a MCI."
MCIERR_UNNAMED_RESOURCE, "Non è possibile salvare un file senza nome. Fornire un nome al file."
MCIERR_NEW_REQUIRES_ALIAS, "E' necessario specificare un alias quando si usa il parametro 'new'."
MCIERR_NOTIFY_ON_AUTO_OPEN, "Non è possibile usare il flag 'notify' con dispositivi auto-aperti."
MCIERR_NO_ELEMENT_ALLOWED, "Non è possibile usare un nome file con il dispositivo specificato."
MCIERR_NONAPPLICABLE_FUNCTION, "Non è possibile eseguire i comandi nell'ordine specificato. Correggere la sequenza, e riprovare."
MCIERR_ILLEGAL_FOR_AUTO_OPEN, "Non è possibile eseguire il comando specificato con un dispositivo auto-aperto. Attendere che il dispositivo si sia chiuso, e riprovare."
MCIERR_FILENAME_REQUIRED, "Il nome del file è invalido. Controllare che il nome del file non sia più lungo di 8 caratteri, seguito da un periodo e un'estensione."
MCIERR_EXTRA_CHARACTERS, "Non è possibile specificare altri caratteri dopo una stringa compresa tra virgolette."
MCIERR_DEVICE_NOT_INSTALLED, "Il dispositivo specificato non è installato nel sistema. Usare l'opzione Drivers nel Pannello di Controllo per installare il dispositivo."
MCIERR_GET_CD, "Impossibile accedere al file o dispositivo MCI specificato. Provare a cambiare directory o riavviare il computer."
MCIERR_SET_CD, "Impossibile accedere al file o dispositivo MCI specificato perchè l'applicazione non può cambiare directory."
MCIERR_SET_DRIVE, "Impossibile accedere al file o dispositivo MCI specificato perchè l'applicazione non può cambiare drive."
MCIERR_DEVICE_LENGTH, "Specificare un driver o dispositivo con meno di 79 caratteri."
MCIERR_DEVICE_ORD_LENGTH, "Specificare un driver o dispositivo con meno di 69 caratteri."
MCIERR_NO_INTEGER, "Il comando specificato richiede un numero intero come parametro. Fornirne uno."
MCIERR_WAVE_OUTPUTSINUSE, "Tutti i dispositivi wave che possono leggere il file nel formato attuale sono in uso. Attendere che un dispositivo wave sia libero, e riprovare."
MCIERR_WAVE_SETOUTPUTINUSE, "Non è possibile impostare il dispositivo wave attuale per il play back perchè è in uso. Attendere che il dispositivo sia libero, e riprovare."
MCIERR_WAVE_INPUTSINUSE, "Tutti i dispositivi wave che possono registrare nel formato attuale sono in uso. Attendere che un dispositivo wave sia disponibile, e riprovare."
MCIERR_WAVE_SETINPUTINUSE, "Non è possibile impostare il dispositivo per registrare perchè è in uso. Attendere che il dispositivo sia disponibile, e riprovare."
MCIERR_WAVE_OUTPUTUNSPECIFIED, "Può essere usato qualunque dispositivo compatibile waveform per il playback."
MCIERR_WAVE_INPUTUNSPECIFIED, "Può essere usato qualunque dispositivo compatibile waveform per registrare."
MCIERR_WAVE_OUTPUTSUNSUITABLE, "Nessun dispositivo wave installato può leggere i file nel formato attuale. Usare l'opzione drivers per installare un dispositivo wave."
MCIERR_WAVE_SETOUTPUTUNSUITABLE,"Il dispositivo che si sta usando per leggere il file non risonosce il formato del file attuale."
MCIERR_WAVE_INPUTSUNSUITABLE, "Non è installato nessun dipositivo wave che possa registrare dei file nel formato attuale. Usare l'opzione Drivers per installare un dispositivo wave."
MCIERR_WAVE_SETINPUTUNSUITABLE, "Il dispositivo che si sta usando per registrare non risonosce il formato attuale."
MCIERR_NO_WINDOW, "Non c'è nessuna finestra di visualizzazione."
MCIERR_CREATEWINDOW, "Impossibile usare o creare la finestra."
MCIERR_FILE_READ, "Impossibile leggere il file specificato. Assicurarsi che il file sia ancora presente, o controllare il disco o la connessione di rete."
MCIERR_FILE_WRITE, "Impossibile scrivere il file specificato. Controllare di avere spazio libero sufficente sul disco o di essere ancora connessi alla rete."
MCIERR_SEQ_DIV_INCOMPATIBLE, "I formati dell'orario del ""song pointer"" e SMPTE si escludono vicendevolmente. Non si possono usare insieme."
MCIERR_SEQ_NOMIDIPRESENT, "Nel sistema non sono installati dispositivi MIDI. Usare l'opzione Drivers dal Pannello di Controllo per installare un driver MIDI."
MCIERR_SEQ_PORT_INUSE, "La porta MIDI specificata è già in uso. Attendere che sia libera, e riprovare."
MCIERR_SEQ_PORT_MAPNODEVICE, "La configurazione del Mapper MIDI si riferisce a un dispositivo MIDI che non è installato nel sistema. Usare l'opzione Mapper MIDI nel Pannello di Controllo per cambiare la configurazione."
MCIERR_SEQ_PORT_MISCERROR, "Si è verificato un errore con la porta specificata."
MCIERR_SEQ_PORT_NONEXISTENT, "Il dispositivo MIDI specificato non è installato nel sistema. Usare l'opzione DRIVERS nel Pannello di Controllo per installare un dispositivo MIDI."
MCIERR_SEQ_PORTUNSPECIFIED, "Non è stata specificata una porta MIDI nel sistema."
MCIERR_SEQ_TIMER, "Tutti i timer multimediali sono in uso da parte di altre applicazioni. Chiudere una di questa applicazioni, e riprovare."
END

126
reactos/lib/winmm/winmm_Ja.rc
View file

@ -1,126 +0,0 @@
/*
* Copyright 2004 Hajime Segawa
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*/
STRINGTABLE LANGUAGE LANG_JAPANESE, SUBLANG_NEUTRAL
BEGIN
/* MMSYS errors */
MMSYSERR_NOERROR, "指定されたコマンドを実行できませんでした。"
MMSYSERR_ERROR, "不明な外部エラーです。"
MMSYSERR_BADDEVICEID, "無効なデバイスIDです。"
MMSYSERR_NOTENABLED, "ドライバが有効になっていません。"
MMSYSERR_ALLOCATED, "指定されたデバイスは使用中です。デバイスが解放されるまで待ってからやり直して下さい。"
MMSYSERR_INVALHANDLE, "無効なデバイスハンドルです。"
MMSYSERR_NODRIVER, "システムにドライバがインストールされていません!\n"
MMSYSERR_NOMEM, "この操作を実行するためのメモリが不足しています。いくつかのアプリケーションを終了して空きメモリを増やしてやり直して下さい。"
MMSYSERR_NOTSUPPORTED, "この機能はサポートされていません。Capabilities関数を使用してドライバがサポートする機能とメッセージを確認して下さい。"
MMSYSERR_BADERRNUM, "指定されたエラー番号は定義されていません。"
MMSYSERR_INVALFLAG, "システム関数に無効なフラグが渡されました。"
MMSYSERR_INVALPARAM, "システム関数に無効なパラメータが渡されました。"
/* WAVE errors */
WAVERR_BADFORMAT, "指定されたフォーマットはサポートされていないか、解釈できません。Capabilities関数を使用してサポートされているフォーマットを確認して下さい。"
WAVERR_STILLPLAYING, "メディア再生中にはこの操作を実行できません。デバイスをリセットするか再生が終わるまで待って下さい。"
WAVERR_UNPREPARED, "waveヘッダが準備されていません。Prepare関数を使用してヘッダを準備してやり直して下さい。"
WAVERR_SYNC, "WAVE_ALLOWSYNCフラグなしではデバイスをオープンできません。フラグを指定してやり直して下さい。"
/* MIDI errors */
MIDIERR_UNPREPARED, "MIDIヘッダが準備されていません。Prepare関数を使用してヘッダを準備してやり直して下さい。"
MIDIERR_STILLPLAYING, "メディア再生中にはこの操作を実行できません。デバイスをリセットするか再生が終わるまで待って下さい。"
MIDIERR_NOMAP, "MIDIマップが見つかりません。ドライバの問題か、MIDIMAP.CFGファイルが破損しているか存在しない可能性があります。"
MIDIERR_NOTREADY, "ポートはデバイスにデータを送信中です。データの送信が終わるまで待ってからやり直して下さい。"
MIDIERR_NODEVICE, "MIDIマッパの設定がシステムに装着されていないデバイスを参照しています。設定を変更するにはコントロールパネルの「MIDIマッパ」アプレットを使用して下さい。"
MIDIERR_INVALIDSETUP, "MIDIの設定が破損しています。オリジナルのMIDIMAP.CFGファイルをWindowsのSYSTEMディレクトリからコピーしてやり直して下さい。"
/* MCI errors */
MCIERR_INVALID_DEVICE_ID, "無効なMCIデバイスIDです。MCIデバイスをオープンしたときに返されたIDを使用して下さい。"
MCIERR_UNRECOGNIZED_KEYWORD, "ドライバは指定されたコマンドのパラメータを認識できませんでした。"
MCIERR_UNRECOGNIZED_COMMAND, "ドライバは指定されたコマンドを認識できませんでした。"
MCIERR_HARDWARE, "メディアデバイスに問題が発生しました。デバイスが正常に動作しているか確認するか、製造元に問い合わせて下さい。"
MCIERR_INVALID_DEVICE_NAME, "指定されたデバイスはオープンされていないか、MCIに認識されていません。"
MCIERR_OUT_OF_MEMORY, "この操作を実行するためのメモリが不足しています。\nいくつかのアプリケーションを終了して空きメモリを増やしてやり直して下さい。"
MCIERR_DEVICE_OPEN, "デバイス名はこのアプリケーションによってエイリアスとして使用されています。独自のエイリアスを使用して下さい。"
MCIERR_CANNOT_LOAD_DRIVER, "指定されたデバイスドライバのロード中に不明なエラーが発生しました。"
MCIERR_MISSING_COMMAND_STRING, "コマンドが指定されていません。"
MCIERR_PARAM_OVERFLOW, "出力された文字列がバッファに入り切りません。バッファのサイズを増やして下さい。"
MCIERR_MISSING_STRING_ARGUMENT, "指定されたコマンドには文字列のパラメータが必要です。"
MCIERR_BAD_INTEGER, "指定された整数値はこのコマンドには無効です。"
MCIERR_PARSER_INTERNAL, "デバイスドライバが無効な形式の値を返しました。製造元に新しいドライバが無いか問い合わせて下さい。"
MCIERR_DRIVER_INTERNAL, "デバイスドライバに問題が発生しました。製造元に新しいドライバが無いか問い合わせて下さい。"
MCIERR_MISSING_PARAMETER, "指定されたコマンドにはパラメータが必要です。"
MCIERR_UNSUPPORTED_FUNCTION, "使用しているMCIデバイスは指定されたコマンドをサポートしていません。"
MCIERR_FILE_NOT_FOUND, "指定されたファイルは見つかりません。ファイル名とパスを確認して下さい。"
MCIERR_DEVICE_NOT_READY, "デバイスドライバの準備ができていません。"
MCIERR_INTERNAL, "MCIの初期化中に問題が発生しました。Windowsを再起動して下さい。"
MCIERR_DRIVER, "デバイスドライバに問題が発生しました。ドライバはクローズされています。エラーにアクセスできません。"
MCIERR_CANNOT_USE_ALL, "指定されたコマンドは「all」をデバイス名として使用することができません。"
MCIERR_MULTIPLE, "複数のデバイスでエラーが発生しました。どのデバイスでエラーが発生したか確認するには、コマンドとデバイスを別個に指定して下さい。"
MCIERR_EXTENSION_NOT_FOUND, "指定されたファイルの拡張子からデバイスの種類を特定できません。"
MCIERR_OUTOFRANGE, "指定されたコマンドに対して指定されたパラメータは範囲外です。"
MCIERR_FLAGS_NOT_COMPATIBLE, "指定されたパラメータは同時に使用できません。"
MCIERR_FILE_NOT_SAVED, "指定されたファイルは保存できませんでした。ディスクに十分な空き容量があるか、あるいはネットワークに接続されているか確認して下さい。"
MCIERR_DEVICE_TYPE_REQUIRED, "指定されたデバイスは見つかりませんでした。デバイスが装着されていて、デバイス名のつづりが正しいか確認して下さい。"
MCIERR_DEVICE_LOCKED, "指定されたデバイスはクローズ処理中です。数秒待ってからやり直して下さい。"
MCIERR_DUPLICATE_ALIAS, "指定されたエイリアスはこのアプリケーションによってエイリアスとして使用されています。独自のエイリアスを使用して下さい。"
MCIERR_BAD_CONSTANT, "指定されたパラメータはこのコマンドには無効です。"
MCIERR_MUST_USE_SHAREABLE, "デバイスドライバは使用中です。デバイスを共有するには「open」コマンドごとに「shareable」パラメータを指定して下さい。"
MCIERR_MISSING_DEVICE_NAME, "指定されたコマンドにはエイリアス、ファイル、ドライバまたはデバイス名を指定する必要があります。"
MCIERR_BAD_TIME_FORMAT, "指定された時間のフォーマットが無効です。使用できるフォーマットに関してはMCIのドキュメントを参照して下さい。"
MCIERR_NO_CLOSING_QUOTE, "ダブルクオーテーションが閉じていません。"
MCIERR_DUPLICATE_FLAGS, "パラメータが二重に指定されています。"
MCIERR_INVALID_FILE, "指定されたファイルは指定されたMCIデバイスでは再生できません。ファイルが破損しているか、フォーマットが不正です。"
MCIERR_NULL_PARAMETER_BLOCK, "ヌルパラメータがMCIに渡されました。"
MCIERR_UNNAMED_RESOURCE, "ファイル名が指定されていないため保存できません。ファイル名を指定して下さい。"
MCIERR_NEW_REQUIRES_ALIAS, "「new」パラメータを使用する場合はエイリアスを指定する必要があります。"
MCIERR_NOTIFY_ON_AUTO_OPEN, "オートオープンされたデバイスに「notify」フラグを使用することはできません。"
MCIERR_NO_ELEMENT_ALLOWED, "指定されたデバイスに対してファイル名を使用することはできません。"
MCIERR_NONAPPLICABLE_FUNCTION, "指定された順序でコマンドを実行できません。コマンドシーケンスを修正してやり直して下さい。"
MCIERR_ILLEGAL_FOR_AUTO_OPEN, "オートオープンされたデバイスに対して指定されたコマンドを実行できません。デバイスがクローズするまで待ってからやり直して下さい。"
MCIERR_FILENAME_REQUIRED, "ファイル名が無効です。ファイル名が半角8文字以内で、ピリオドに続いて拡張子が付いていることを確認して下さい。"
MCIERR_EXTRA_CHARACTERS, "クオーテーションマークに囲われた文字列に続く余分な文字を特定できません。"
MCIERR_DEVICE_NOT_INSTALLED, "指定されたデバイスはインストールされていません。デバイスをインストールするにはコントロールパネル内の「ハードウェアの追加と削除」アプレットを使用して下さい。"
MCIERR_GET_CD, "指定されたファイルまたはMCIデバイスにアクセスできません。ディレクトリを変更するか、コンピュータを再起動して下さい。"
MCIERR_SET_CD, "アプリケーションがディレクトリを変更できないため、指定されたファイルまたはMCIデバイスにアクセスできません。"
MCIERR_SET_DRIVE, "アプリケーションがドライブを変更できないため、指定されたファイルまたはMCIデバイスにアクセスできません。"
MCIERR_DEVICE_LENGTH, "デバイス名またはドライバ名は半角79文字以内で指定して下さい。"
MCIERR_DEVICE_ORD_LENGTH, "デバイス名またはドライバ名は半角69文字以内で指定して下さい。"
MCIERR_NO_INTEGER, "指定されたコマンドには整数値のパラメータが必要です。"
MCIERR_WAVE_OUTPUTSINUSE, "ファイルを現在のフォーマットで再生できるwaveデバイスは全て使用中です。デバイスが解放されるまで待ってからやり直して下さい。"
MCIERR_WAVE_SETOUTPUTINUSE, "現在のwaveデバイスは使用中なので再生モードに設定できません。デバイスが解放されるまで待ってからやり直して下さい。"
MCIERR_WAVE_INPUTSINUSE, "現在のフォーマットで録音が可能な全てのwaveデバイスは使用中です。デバイスが解放されるまで待ってからやり直して下さい。"
MCIERR_WAVE_SETINPUTINUSE, "現在のwaveデバイスは使用中なので録音モードに設定できません。デバイスが解放されるまで待ってからやり直して下さい。"
MCIERR_WAVE_OUTPUTUNSPECIFIED, "互換性のある再生デバイスのどれかが使用されます。"
MCIERR_WAVE_INPUTUNSPECIFIED, "互換性のある録音デバイスのどれかが使用されます。"
MCIERR_WAVE_OUTPUTSUNSUITABLE, "現在のフォーマットでファイルを再生できるwaveデバイスはインストールされていません。waveデバイスをインストールするにはコントロールパネル内の「ハードウェアの追加と削除」アプレットを使用して下さい。"
MCIERR_WAVE_SETOUTPUTUNSUITABLE,"再生しようとしているデバイスは現在のファイルフォーマットを認識できません。"
MCIERR_WAVE_INPUTSUNSUITABLE, "現在のフォーマットでファイルを録音できるwaveデバイスはインストールされていません。waveデバイスをインストールするにはコントロールパネル内の「ハードウェアの追加と削除」アプレットを使用して下さい。"
MCIERR_WAVE_SETINPUTUNSUITABLE, "録音しようとしているデバイスは現在のファイルフォーマットを認識できません。"
MCIERR_NO_WINDOW, "表示ウィンドウがありません。"
MCIERR_CREATEWINDOW, "ウィンドウの作成または使用ができません。"
MCIERR_FILE_READ, "指定したファイルを読み込めません。ファイルが存在するか確認して下さい、あるいはディスクかネットワーク接続を確認して下さい。"
MCIERR_FILE_WRITE, "指定されたファイルに書き込めません。ディスクに十分な空き容量があるか、あるいはネットワークに接続されているか確認して下さい。"
MCIERR_SEQ_DIV_INCOMPATIBLE, "「ソングポインタ」とSMPTEの時間フォーマットを同時に使用することはできません。"
MCIERR_SEQ_NOMIDIPRESENT, "MIDIデバイスはインストールされていません。MIDIドライバをインストールするにはコントロールパネル内の「ハードウェアの追加と削除」アプレットを使用して下さい。"
MCIERR_SEQ_PORT_INUSE, "指定されたMIDIポートは使用中です。MIDIポートが開放されるまで待ってからやり直して下さい。"
MCIERR_SEQ_PORT_MAPNODEVICE, "MIDIマッパの設定がシステムに装着されていないデバイスを参照しています。設定を変更するにはコントロールパネルの「MIDIマッパ」アプレットを使用して下さい。"
MCIERR_SEQ_PORT_MISCERROR, "指定されたポートでエラーが発生しました。"
MCIERR_SEQ_PORT_NONEXISTENT, "指定されたMIDIデバイスはシステムに装着されていません。MIDIデバイスをインストールするにはコントロールパネル内の「ハードウェアの追加と削除」アプレットを使用して下さい。"
MCIERR_SEQ_PORTUNSPECIFIED, "システムに現在のMIDIポートが指定されていません。"
MCIERR_SEQ_TIMER, "全てのマルチメディアタイマは他のアプリケーションによって使用されています。タイマを使用しているアプリケーションを一つ終了してからやり直して下さい。"
END

127
reactos/lib/winmm/winmm_Nl.rc
View file

@ -1,127 +0,0 @@
/*
* Copyright 1999 Klaas van Gend
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*/
STRINGTABLE LANGUAGE LANG_DUTCH, SUBLANG_DEFAULT
BEGIN
/* MMSYS errors */
MMSYSERR_NOERROR, "De gespecificeerde opdracht is uitgevoerd."
MMSYSERR_ERROR, "Ongedefinieerde fout van buitenaf."
MMSYSERR_BADDEVICEID, "Een apparaat ID werd gebruikt dat buiten de grenzen van uw systeem ligt."
MMSYSERR_NOTENABLED, "De driver is niet geactiveerd."
MMSYSERR_ALLOCATED, "Het gewenste apparaat is in gebruik. Wacht totdat het vrijkomt en probeer het dan opnieuw."
MMSYSERR_INVALHANDLE, "De gespecificeerde apparaatverwijzing is ongeldig."
MMSYSERR_NODRIVER, "Er is geen driver geinstalleerd op uw systeem !\n"
MMSYSERR_NOMEM, "Er is niet genoeg geheugen beschikbaar voor deze taak. Sluit enkele programma's af om meer geheugen vrij te krijgen en doe dan nog een poging."
MMSYSERR_NOTSUPPORTED, "Deze functie wordt niet ondersteund. Gebruik de 'Capabilities' functie om uit te zoeken welke toepassingen en boodschappen de driver ondersteund."
MMSYSERR_BADERRNUM, "Een niet binnen het systeem bekend foutnummer werd gebruikt."
MMSYSERR_INVALFLAG, "Een ongeldige vlag werd aan een systeemfunctie gevoerd."
MMSYSERR_INVALPARAM, "Een systeemfunctie kreeg een ongeldige parameter te eten."
/* WAVE errors */
WAVERR_BADFORMAT, "Het aangegeven formaat wordt niet ondersteund of geconverteerd. Gebruik de 'Capabilities' functie om de ondersteunde formaten te vinden"
WAVERR_STILLPLAYING, "Kan deze opdracht niet uitvoeren zolang afgespeeld wordt. Herstart het apparaat of wacht totdat het apparaat klaar is met spelen."
WAVERR_UNPREPARED, "De Wave Header was niet aanwezig. Gebruik de 'Prepare' functie om de Header te genereren en probeer het dan opnieuw."
WAVERR_SYNC, "Kan het apparaat niet openen zonder de WAVE_ALLOWSYNC vlag. Zet de vlag en probeer opnieuw."
/* MIDI errors */
MIDIERR_UNPREPARED, "De MIDI Header was niet aanwezig. Gebruik de 'Prepare' functie om de Header te genereren en probeer het dan opnieuw."
MIDIERR_STILLPLAYING, "Kan deze opdracht niet uitvoeren zolang afgespeeld wordt. Herstart het apparaat of wacht totdat het apparaat klaar is met spelen."
MIDIERR_NOMAP, "Er is geen MIDI Map gevonden. Er zou een driver probleem kunnen zijn of de MIDIMAP.CFG file is verminkt of afwezig."
MIDIERR_NOTREADY, "De poort is bezig data ter versturen naar het apparaat. Wacht totdat alle data is verstuurd en probeer het dan opnieuw."
MIDIERR_NODEVICE, "De huidige MIDI Mapper setup verwijst naar een MIDI apparaat dat niet op het systeem aanwezig is. Gebruik MIDI Mapper om de instellingen aan te passen."
MIDIERR_INVALIDSETUP, "De huidige MIDI setup is beschadigd. Kopieer de originele MIDIMAP.CFG file naar de Windows SYSTEM directory en probeer het daarna weer."
/* MCI errors */
MCIERR_INVALID_DEVICE_ID, "Ongeldige MCI apparaat ID. Gebruik de teruggegeven ID als u dit MCI apparaat opent."
MCIERR_UNRECOGNIZED_KEYWORD, "De driver kant de gegeven opdracht parameter niet herkennen."
MCIERR_UNRECOGNIZED_COMMAND, "De driver kant de gegeven opdracht niet herkennen."
MCIERR_HARDWARE, "ER is een probleem met uw media apparaat. Controleer of 't correct werkt of neem contact op met de leverancier."
MCIERR_INVALID_DEVICE_NAME, "The specified device is not open or is not recognized by MCI."
MCIERR_OUT_OF_MEMORY, "Er is niet genoeg geheugen beschikbaar voor deze taak. Sluit enkele programma's af om meer geheugen vrij te krijgen en probeer opnieuw."
MCIERR_DEVICE_OPEN, "Een apparaat met die naam is al in gebruik als alias door deze applicatie. Gebruik een uniek alias."
MCIERR_CANNOT_LOAD_DRIVER, "Er is een onbekende fout ontstaan tijdens het laden van de apparaat driver."
MCIERR_MISSING_COMMAND_STRING, "Er was geen opdracht opgegeven."
MCIERR_PARAM_OVERFLOW, "De output string was te groot om in de antwoordbuffer te passen. Vergroot de buffer."
MCIERR_MISSING_STRING_ARGUMENT, "De gegeven opdracht vereist een character-string parameter. Lever er dus een aan s.v.p."
MCIERR_BAD_INTEGER, "De gegeven integer is niet geldig bij dit commando."
MCIERR_PARSER_INTERNAL, "De apparaat driver retourneerde een ongeldige waarde. Vraag de fabrikant om een andere driver."
MCIERR_DRIVER_INTERNAL, "Er is een probleem met de apparaat driver. Vraag de fabrikant om een andere driver."
MCIERR_MISSING_PARAMETER, "De gegeven opdracht benodigt een parameter. Vult u die a.u.b. in."
MCIERR_UNSUPPORTED_FUNCTION, "Het MCI apparaat dat u gebruikt ondersteund het gegeven commando niet."
MCIERR_FILE_NOT_FOUND, "Kan het opgegeven bestand niet vinden. Zorg ervoor dat het pad en de bestandsnaam correct zijn."
MCIERR_DEVICE_NOT_READY, "De apparaat driver is niet gereed."
MCIERR_INTERNAL, "Tijdens het initialiseren van MCI onstond een probleem. Probeer dit te verhelpen door Windows opnieuw te starten."
MCIERR_DRIVER, "Er is een probleem met de apparaat driver. Daarom is de driver afgesloten. Derhalve een toegangsfout."
MCIERR_CANNOT_USE_ALL, "Kan 'all' niet gebruiken als apparaat naam bij het opgegeven commando."
MCIERR_MULTIPLE, "In meer dan een apparaat zijn fouten opgetreden. Geef elk commando en apparaat apart om te achterhalen welke apparaten fouten veroorzaken."
MCIERR_EXTENSION_NOT_FOUND, "Kan het apparaat type niet achterhalen uit de gegeven bestands-extensie."
MCIERR_OUTOFRANGE, "De gegeven parameter is buiten het bereik van het opgegeven commando."
MCIERR_FLAGS_NOT_COMPATIBLE, "De gegeven parameters kunnen niet samen gebruikt worden."
MCIERR_FILE_NOT_SAVED, "Kan de opgegeven file niet saven. Zorg ervoor dat er voldoende diskruimte is of dat u nog steeds met het netwerk verbonden bent."
MCIERR_DEVICE_TYPE_REQUIRED, "Kan het opgegeven apparaat niet vinden. Verzeker u ervan dat het correct geinstalleerd is en dat de apparaatnaam correct is opgegeven."
MCIERR_DEVICE_LOCKED, "Het opgegeven apparaat wordt nu gesloten. Wacht svp. enkele seconden en probeer het dan opnieuw."
MCIERR_DUPLICATE_ALIAS, "Het gegeven alias is al in gebruik door dit programma. Gebruik een unieke alias."
MCIERR_BAD_CONSTANT, "De gegeven parameters is ongeldig bij het gegeven commando."
MCIERR_MUST_USE_SHAREABLE, "De apparaat driver is al in gebruik. Om het te delen, gebruik de 'deelbaar' parameter met elk 'open' commando."
MCIERR_MISSING_DEVICE_NAME, "Het gegeven commando vereist een alias, bestand, driver of apparaatnaam. Geeft u er svp een in."
MCIERR_BAD_TIME_FORMAT, "De gegeven waarde voor het tijdsformaat is ongeldig. Zoek in de MCI handleidingen naar geldige formaten."
MCIERR_NO_CLOSING_QUOTE, "Een afsluitende dubbele apostroph ontbreekt van de parameter waarde. Geeft u er svp een in."
MCIERR_DUPLICATE_FLAGS, "Een parameter of waarde werd dubbel opgegeven. Doe dat svp maar een keer."
MCIERR_INVALID_FILE, "De gegeven file kan niet op het MCI apparaat worden afgespeeld. Het bestand is misschien corrupt of niet in het juiste formaat."
MCIERR_NULL_PARAMETER_BLOCK, "Een leeg parameter block werd doorgegeven aan MCI."
MCIERR_UNNAMED_RESOURCE, "Kan niet saven naar bestand zonder naam. Geef een bestandsnaam svp."
MCIERR_NEW_REQUIRES_ALIAS, "U moet een alias opgeven als u de 'new' parameter gebruikt."
MCIERR_NOTIFY_ON_AUTO_OPEN, "Kan de 'notify' vlag niet gebruiken met automatisch geopende apparaten."
MCIERR_NO_ELEMENT_ALLOWED, "Kan voor het huidige apparaat geen bestandsnaam gebruiken."
MCIERR_NONAPPLICABLE_FUNCTION, "Kan de opgegeven commando's niet in deze volgorde uitvoeren. Corrigeer de commandoreeks en probeer opnieuw."
MCIERR_ILLEGAL_FOR_AUTO_OPEN, "Kan het opgegeven commando niet uitvoeren op een automatisch geopend apparaat. Wacht todat het apparaat is afgesloten en probeer dan opnieuw."
MCIERR_FILENAME_REQUIRED, "De bestandsnaam is ongeldig. Zorg ervoor dat de bestandsnaam aan het 8.3 formaat voldoet."
MCIERR_EXTRA_CHARACTERS, "Het is niet mogelijk om extra lettertekens toe te voegen na een string in aanhalingstekens."
MCIERR_DEVICE_NOT_INSTALLED, "Het opgegeven apparaat is niet geinstalleerd op het systeem. Gebruik de 'Drivers'-optie in het Configuratiescherm om het apparaat te installeren."
MCIERR_GET_CD, "Kan het opgegeven bestand of MCI apparaat niet openen. Probeer de directory te wijzigen of de computer opnieuw te starten."
MCIERR_SET_CD, "Kan het opgegeven bestand of MCI apparaat niet openen omdat de applicatie de directory niet kan wijzigen."
MCIERR_SET_DRIVE, "Kan het opgegeven bestand of MCI apparaat niet openen omdat de applicatie de directory niet kan wijzigen."
MCIERR_DEVICE_LENGTH, "Geef een apparaat of driver naam op met minder dan 79 lettertekens."
MCIERR_DEVICE_ORD_LENGTH, "Geef een apparaat of driver naam op met minder dan 79 lettertekens."
MCIERR_NO_INTEGER, "Het gegeven commando vereist een integer parameter. Svp geef er eentje."
MCIERR_WAVE_OUTPUTSINUSE, "Alle WAVE-apparaten die in staat zijn om een bestand in dit formaat af te spelen, zijn in gebruik. Wacht totdat een WAVE apparaat vrij is en probeer het dan opnieuw."
MCIERR_WAVE_SETOUTPUTINUSE, "Kan het huidige WAVE-apparaat niet gebruiken omdat het in gebruik is. Wacht totdat het apparaat vrij is en probeer het dan opnieuw."
MCIERR_WAVE_INPUTSINUSE, "Alle WAVE-apparaten die in staat zijn om een bestand in dit formaat op te nemen, zijn in gebruik. Wacht totdat een WAVE apparaat vrij is en probeer het dan opnieuw."
MCIERR_WAVE_SETINPUTINUSE, "Kan het huidige WAVE-apparaat niet gebruiken om op te nemen omdat het in gebruik is. Wacht totdat het apparaat vrij is en probeer het dan opnieuw."
MCIERR_WAVE_OUTPUTUNSPECIFIED, "Elk compatible WAVE afspeelapparaat kan worden gebruikt."
MCIERR_WAVE_INPUTUNSPECIFIED, "Elk compatible WAVE opnameapparaat kan worden gebruikt."
MCIERR_WAVE_OUTPUTSUNSUITABLE, "Er is momenteel geen WAVE apparaat geinstalleerd dat bestanden in het huidige formaat kan afspelen. Gebruik de 'Drivers' optie om zo'n WAVE apparaat te installeren."
MCIERR_WAVE_SETOUTPUTUNSUITABLE,"Het apparaat waar u probeert mee af te spelen is niet in staat om het huidige formaat te herkennen."
MCIERR_WAVE_INPUTSUNSUITABLE, "Er is momenteel geen WAVE apparaat geinstalleerd dat bestanden in het huidige formaat kan opnemen. Gebruik de 'Drivers' optie om zo'n WAVE apparaat te installeren."
MCIERR_WAVE_SETINPUTUNSUITABLE, "Het apparaat waar u probeert mee op te nemen is niet in staat om het huidige formaat te herkennen."
MCIERR_NO_WINDOW, "Er is geen weergave venster."
MCIERR_CREATEWINDOW, "Kon geenvenster maken of gebruiken."
MCIERR_FILE_READ, "Kan het opgegeven bestand niet lezen. Contrleer of het bestand nog steeds bestaat, en controleer de verbinding naar de disk of het netwerk."
MCIERR_FILE_WRITE, "Kan het opgegeven bestand niet schrijven. Contrleer of er voldoende diskruimte is, en controleer de verbinding naar het netwerk."
MCIERR_SEQ_DIV_INCOMPATIBLE, "Van tijdformaten van 'song pointer' en SMPTE kan er maar een in gebruik zijn. U kunt ze niet beide tegelijkertijd gebruiken."
MCIERR_SEQ_NOMIDIPRESENT, "Het systeem heeft geen MIDI apparaten geinstalleerd. Gebruik de 'Drivers'-optie in het Configuratiescherm om een MIDI apparaat te installeren."
MCIERR_SEQ_PORT_INUSE, "De opgegeven MIDI poort is al in gebruik. Wacht totdat deze vrij is en probeer dan opnieuw."
MCIERR_SEQ_PORT_MAPNODEVICE, "De huidige MIDI Mapper setup verwijst naar een MIDI apparaat dat niet op het systeem is geinstalleerd. Gebruik de 'MIDI mapper'-optie in het Configuratiescherm om een MIDI apparaat te installeren."
MCIERR_SEQ_PORT_MISCERROR, "Er is error opgetreden bij de opgegeven poort."
MCIERR_SEQ_PORT_NONEXISTENT, "Het opgegeven MIDI Mapper apparaat is niet op het systeem geinstalleerd. Gebruik de 'MIDI mapper'-optie in het Configuratiescherm om het te installeren."
MCIERR_SEQ_PORTUNSPECIFIED, "Het systeem heeft momenteel geen aangewezen MIDI poort."
MCIERR_SEQ_TIMER, "Alle multimedia timers zijn in gebruik door andere applicaties. Sluit een van deze applicaties, probeer het dan opnieuw."
END

127
reactos/lib/winmm/winmm_Pt.rc
View file

@ -1,127 +0,0 @@
/*
* Copyright 1999 Gustavo Junior Alves
* Copyright 2003 Marcelo Duarte
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*/
STRINGTABLE LANGUAGE LANG_PORTUGUESE, SUBLANG_DEFAULT
BEGIN
/* MMSYS errors */
MMSYSERR_NOERROR, "O comando especificado foi descarregado."
MMSYSERR_ERROR, "Erro externo indefinido."
MMSYSERR_BADDEVICEID, "O ID do dispositivo utilizado está fora dos parâmetros do seu sistema."
MMSYSERR_NOTENABLED, "O driver não foi habilitado."
MMSYSERR_ALLOCATED, "O dispositivo especificado já está em uso. Aguarde até que seja liberado, e então tente novamente."
MMSYSERR_INVALHANDLE, "O handle do dispositivo especificado é inválido."
MMSYSERR_NODRIVER, "Não há nenhum driver instalado em seu sistema !\n"
MMSYSERR_NOMEM, "Não há memória disponível suficiente para essa tarefa. Feche uma ou mais aplicações para aumentar a memória disponível, e então tente novamente."
MMSYSERR_NOTSUPPORTED, "Essa função não é suportada. Utilize a função Capacidades para determinar quais funções e mensagens o driver suporta."
MMSYSERR_BADERRNUM, "Um número de erro foi especificado e não está definido em seu sistema."
MMSYSERR_INVALFLAG, "Um flag inválido foi passado para uma função do sistema."
MMSYSERR_INVALPARAM, "Um parâmetro inválido foi passado para uma função do sistema."
/* WAVE errors */
WAVERR_BADFORMAT, "O formato especificado não é suportado ou não pode ser traduzido. Use a função Capacidades para determinar os formatos suportados."
WAVERR_STILLPLAYING, "Não é possível executar esta operação enquando os dados de mídia estiverem tocando. Reinicie o dispositivo, ou aguarde até o término da execução."
WAVERR_UNPREPARED, "O cabeçalho do wave não está preparado. Use a função Preparar para preparar o cabeçalho, e então tente novamente."
WAVERR_SYNC, "Não é possível abrir o dispositivo sem utilizar a flag WAVE_ALLOWSYNC. Use a flag, e então tente novamente."
/* MIDI errors */
MIDIERR_UNPREPARED, "O cabeçalho MIDI não está preparado. Use a função Preparar para preparar o cabeçalho, e então tente novamente."
MIDIERR_STILLPLAYING, "Não é possível executar esta operação enquanto os dados da mídia estiverem sendo executados. Reinicie o dispositivo, ou aguarde até os dados terminarem de ser tocados."
MIDIERR_NOMAP, "O mapa MIDI não foi encontrado. Talvez seja um problema com o driver, ou o arquivo MIDIMAP.CFG pode estar corrompido ou faltando."
MIDIERR_NOTREADY, "A porta está transmitindo dados para o dispositivo. Aguarde até os dados terminarem de ser transmitidos, e então tente novamente."
MIDIERR_NODEVICE, "A configuração atual do MIDI Mapper refere-se a um dispositivo MIDI que não está instalado no sistema. Use MIDI Mapper para editar a configuração."
MIDIERR_INVALIDSETUP, "A configuração atual do MIDI está corrompida. Copie o arquivo original MIDIMAP.CFG para o diretório Windows SYSTEM, e então tente novamente."
/* MCI errors */
MCIERR_INVALID_DEVICE_ID, "ID inválido do dispositivo MCI. Use o ID retornado para abrir o dispositivo MCI."
MCIERR_UNRECOGNIZED_KEYWORD, "O driver não pode reconhecer o parâmetro de comando especificado."
MCIERR_UNRECOGNIZED_COMMAND, "O driver não pode reconhecer o comando especificado."
MCIERR_HARDWARE, "Há um problema com seu dispositivo de mídia. Tenha certeza que esteja funcionando corretamente ou contacte o fabricante do dispositivo."
MCIERR_INVALID_DEVICE_NAME, "O dispositivo especificado não está aberto ou não é reconhecido pelo MCI."
MCIERR_OUT_OF_MEMORY, "Não já memória disponível sufuciente para esta tarefa.\nFeche uma ou mais aplicações para aumentar a memória disponível, e então tente novamente."
MCIERR_DEVICE_OPEN, "O nome do dispositivo já está sendo usado como um alias por esta aplicação. Use um alias único."
MCIERR_CANNOT_LOAD_DRIVER, "Aconteceu um problema desconhecido enquanto carregava o driver do dispositivo especificado."
MCIERR_MISSING_COMMAND_STRING, "Nenhum comando foi especificado."
MCIERR_PARAM_OVERFLOW, "A string de saída foi muito grande para ser colocada no buffer de retorno. Aumente o tamanho do buffer."
MCIERR_MISSING_STRING_ARGUMENT, "O comando especificado requer como parâmetro uma string de caracters. Por favor, forneça-a."
MCIERR_BAD_INTEGER, "O inteiro especificado é inválido para este comando."
MCIERR_PARSER_INTERNAL, "O driver do dispositivo retornou um tipo inválido. Verifique com o fabricante do dispositivo como obter um novo driver."
MCIERR_DRIVER_INTERNAL, "Existe um problema com o seu driver de dispositivo. Verifique com o fabricante do dispositivo como obter um novo driver."
MCIERR_MISSING_PARAMETER, "O comando especificado requer um parâmetro. Por favor forneça-o."
MCIERR_UNSUPPORTED_FUNCTION, "O dispositivo MCI que você está usando não suporta o comando especificado."
MCIERR_FILE_NOT_FOUND, "Não é possível encontrar o arquivo especificado. Certifique-se que o caminho e o nome do arquivo estão corretos."
MCIERR_DEVICE_NOT_READY, "O driver do dispositivo não está preparado."
MCIERR_INTERNAL, "Um problema ocorreu na inicialização do MCI. Tente reiniciar o Windows."
MCIERR_DRIVER, "Há um problema com o driver do dispositivo. O driver foi fechado. Não é possível acessar o erro."
MCIERR_CANNOT_USE_ALL, "Não é possível usar 'all' como nome do dispositivo com o comando especificado."
MCIERR_MULTIPLE, "Erros ocorreram em mais de um dispositivo. Especifique cada comando e dispositivo separadamente para determinar quais dispositivos causaram o erro."
MCIERR_EXTENSION_NOT_FOUND, "Não é possível determinar o tipo de dispositivo dada a extensão de arquivo."
MCIERR_OUTOFRANGE, "O parâmetro especificado está fora da escala para o comando especificado."
MCIERR_FLAGS_NOT_COMPATIBLE, "Os parâmetros especificados não podem ser utilizados juntos."
MCIERR_FILE_NOT_SAVED, "Não é possível salvar o arquivo especificado. Certifique-se que tenha espaço em disco suficiente ou que ainda esteja conectado a rede."
MCIERR_DEVICE_TYPE_REQUIRED, "Não é possível encontrar o dispositivo especificado. Certifique-se que está instalado ou que o nome do dispositivo foi escrito corretamente."
MCIERR_DEVICE_LOCKED, "O dispositivo especificado está sendo fechado agora. Aguarde alguns segundos, e então tente novamente."
MCIERR_DUPLICATE_ALIAS, "O alias especificado já está sendo utilizado nesta aplicação. Use um alias único."
MCIERR_BAD_CONSTANT, "O parâmetro especificado é inválido para este comando."
MCIERR_MUST_USE_SHAREABLE, "O driver de dispositivo já está em uso. Para compartilha-lo, use o parâmetro 'shareable' para cada comando 'open'."
MCIERR_MISSING_DEVICE_NAME, "O comando especificado requer um alias, arquivo, driver ou nome de dispositivo. Por favor, forneça um."
MCIERR_BAD_TIME_FORMAT, "O valor especificado para o formato de hora é inválido. Verifique na documentação do MCI sobre formatos válidos."
MCIERR_NO_CLOSING_QUOTE, "A aspa-dupla de fechamento está faltando para o valor do parâmetro. Por favor forneça uma."
MCIERR_DUPLICATE_FLAGS, "Um parâmetro ou valor foi especificado duas vezes. Apenas especifique-o uma única vez."
MCIERR_INVALID_FILE, "O arquivo espeficidado não pode ser tocado no dispositivo MCI especificado. O arquivo pode estar corrompido, ou não estar no formato correto."
MCIERR_NULL_PARAMETER_BLOCK, "Um bloco de parâmetro nulo foi passado para o MCI.."
MCIERR_UNNAMED_RESOURCE, "Não é possível salvar um arquivo sem nome. Por favor forneça um nome de arquivo."
MCIERR_NEW_REQUIRES_ALIAS, "Você precisa especificar um alias quando utilizar o parâmetro 'new'."
MCIERR_NOTIFY_ON_AUTO_OPEN, "Não é possível utilizar o flag 'notify' em dispositivos abertos automaticamente."
MCIERR_NO_ELEMENT_ALLOWED, "Não é possível usar um nome de arquivo com o dispositivo especificado."
MCIERR_NONAPPLICABLE_FUNCTION, "Não é possível descarregar os comandos na ordem especificada. Corrija a sequência dos comandos, e então tente novamente."
MCIERR_ILLEGAL_FOR_AUTO_OPEN, "Não é possível descarregar o comando especificado em um dispositivo aberto automanticamente. Aguarde até o dispositivo ser fechado, e então tente novamente."
MCIERR_FILENAME_REQUIRED, "O nome do arquivo é inválido. Certifique-se que o nome do arquivo não é maior que 8 caracteres, seguido por um ponto e uma extensão."
MCIERR_EXTRA_CHARACTERS, "Não é possível especificar caracteres extras após uma string entre aspas."
MCIERR_DEVICE_NOT_INSTALLED, "O dispositivo especificado não esta instalado no sistema. Utilize o opção Drivers no Painel de Controle para instalar o dispositivo."
MCIERR_GET_CD, "Não é possível acessar o arquivo especificado ou o dispositivo MCI. Tente mudar de diretório ou reiniciar seu computador."
MCIERR_SET_CD, "Não é possível acessar o arquivo especificado ou o dispositivo MCI porque a aplicação não pode mudar de diretório."
MCIERR_SET_DRIVE, "Não posso acessar o arquivo especificado ou o dispositivo MCI porque a aplicação não pode mudar de drive."
MCIERR_DEVICE_LENGTH, "Especifique um dispositivo ou nome de driver que seja menor que 79 caracteres."
MCIERR_DEVICE_ORD_LENGTH, "Especifique um dispositivo ou nome de driver que seja menor que 69 caracteres."
MCIERR_NO_INTEGER, "O comando especificado requer um parâmetro inteiro. Por favor forneça um."
MCIERR_WAVE_OUTPUTSINUSE, "Todos os dispositivos wave que podem tocar arquivos no formato atual estão em uso. Aguarde até um dispositivo wave ficar ocioso e então tente novamente."
MCIERR_WAVE_SETOUTPUTINUSE, "Não é possível definir o dispositivo wave atual para tocar porque está em uso. Aguarde até o dispositivo ficar ocioso e então tente novamente."
MCIERR_WAVE_INPUTSINUSE, "Todos os dispositivos wave que podem gravar arquivos no formato atual estão em uso. Aguarde até o dispositivo wave ficar ocioso, e então tente novamente."
MCIERR_WAVE_SETINPUTINUSE, "Não foi possivel definir o dispositivo wave corrente para gravar porque ele está em uso. Aguarde até ele ficar livre, e então tente novamente."
MCIERR_WAVE_OUTPUTUNSPECIFIED, "Qualquer dispositivo tocador compatível com o formato wave pode ser utilizado."
MCIERR_WAVE_INPUTUNSPECIFIED, "Qualquer dispositivo gravador compatível com o formato wave pode ser utilizado."
MCIERR_WAVE_OUTPUTSUNSUITABLE, "Nenhum dispositivo wave que possa tocar arquivos no formato wave está instalado. Use a opção Drivers para instalar o dispositivo wave."
MCIERR_WAVE_SETOUTPUTUNSUITABLE,"O dispositivo que você está tentando tocar não reconhece o formato do arquivo atual."
MCIERR_WAVE_INPUTSUNSUITABLE, "Nenhum dispositivo wave que possa gravar arquivos no formato atual está instalado. Use o opção Drivers para instalar o dispositivo wave."
MCIERR_WAVE_SETINPUTUNSUITABLE, "O dispositivo de onde você está tentando gravar não pode reconhecer o formato do arquivo atual."
MCIERR_NO_WINDOW, "Não há nenhuma janela de visualização."
MCIERR_CREATEWINDOW, "Não é possível criar ou utilizar a janela."
MCIERR_FILE_READ, "Não é possível ler o arquivo especificado. Certifique-se que o arquivo ainda está presente, ou verifique seu disco ou conecção de rede."
MCIERR_FILE_WRITE, "Não é possível gravar no arquivo especificado. Certifique-se que você possui espaço em disco suficiente ou que ainda esteja conectado na rede."
MCIERR_SEQ_DIV_INCOMPATIBLE, "O formato de hora do ""song pointer"" e SMPTE são mutualmente exclusivos. Você não pode utilizá-los juntos."
MCIERR_SEQ_NOMIDIPRESENT, "O sistema não possui dispositivos MIDI instalados. Use a opção Drivers no Painel de Controle para instalar um driver MIDI."
MCIERR_SEQ_PORT_INUSE, "A porta MIDI especificada já esta em uso. Aguarde até que esteja livre, e tente novamente."
MCIERR_SEQ_PORT_MAPNODEVICE, "A configuração atual do MIDI Mapper refere-se a um dispositivo MIDI que não está instalado em seu sistema. Use a opção MIDI Mapper do Painel de Controle para editar a configuração."
MCIERR_SEQ_PORT_MISCERROR, "Um erro ocorreu com a porta especificada."
MCIERR_SEQ_PORT_NONEXISTENT, "O dispositivo MIDI especificado não está instalado em seu sistema. Use a opção Drivers no Painel de Controle para instalar um dispositivo MIDI."
MCIERR_SEQ_PORTUNSPECIFIED, "O sistema não têm atualmente uma porta MIDI especificada."
MCIERR_SEQ_TIMER, "Todos os temporizadores de multimídia estão sendo utilizados por outras aplicações. Feche uma dessas aplicações, então tente novamente."
END

130
reactos/lib/winmm/winmm_Ru.rc
View file

@ -1,130 +0,0 @@
/*
* Copyright 2000 Oleg Korda
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*/
STRINGTABLE LANGUAGE LANG_RUSSIAN, SUBLANG_NEUTRAL
BEGIN
/* Russian strings in CP1251 */
/* MMSYS errors */
MMSYSERR_NOERROR, "Нет ошибки."
MMSYSERR_ERROR, "Неизвестная ошибка."
MMSYSERR_BADDEVICEID, "Используемый код устройства (device ID) выходит за допустимые пределы."
MMSYSERR_NOTENABLED, "Драйвер не был подключен."
MMSYSERR_ALLOCATED, "Указанное устройство уже используется. Подождите пока оно освободится, затем попробуйте еще раз."
MMSYSERR_INVALHANDLE, "Указанный идентификатор устройства (device handle) неверен."
MMSYSERR_NODRIVER, "В системе не установлен драйвер! \n"
MMSYSERR_NOMEM, "Не хватает памяти для задачи. Закройте одно или несколько приложений и попробуйте заново."
MMSYSERR_NOTSUPPORTED, "Эта функция не поддерживается. Используйте функцию Capabilities, чтобы определить функции и сообщения, которые поддерживает драйвер."
MMSYSERR_BADERRNUM, "Указанный код ошибки не определен в системе."
MMSYSERR_INVALFLAG, "Недопустимый флажок передан системной функции."
MMSYSERR_INVALPARAM, "Недопустимый параметр передан системной функции."
/* WAVE errors */
WAVERR_BADFORMAT, "Указанный формат не поддерживается или не может быть оттранслирован. Используйте функцию Capabilities, чтобы определить поддерживаемые форматы."
WAVERR_STILLPLAYING, "Невозможно произвести операцию, пока устройство в режиме воспроизведения. Сбросьте устройство, или подождите пока устройство не окончит воспроизведение."
WAVERR_UNPREPARED, "Заголовок wave не был подготовлен. Используйте функцию Prepare, чтобы подготовить заголовок и попробуйте заново."
WAVERR_SYNC, "Невозможно открыть устройство, не используя флаг WAVE_ALLOWSYNC. Используйте флаг и попробуйте заново."
/* MIDI errors */
MIDIERR_UNPREPARED, "Заголовок MIDI не был подготовлен. Используйте функцию Prepare, чтобы подготовить заголовок и попробуйте заново."
MIDIERR_STILLPLAYING, "Невозможно произвести операцию, пока устройство в режиме воспроизведения. Сбросьте устройство, или подождите пока устройство не окончит воспроизведение."
MIDIERR_NOMAP, "Карта (map) MIDI не найдена. Возможно, это ошибка драйвера, или файл MIDIMAP.CFG отсутствует или поврежден."
MIDIERR_NOTREADY, "Порт передает информацию в устройство. Подождите, пока информация будет передана и попробуйте заново."
MIDIERR_NODEVICE, "Текущие установки MIDI Mapper ссылаются на устройство MIDI, которое не установлено в системе. Используйте MIDI Mapper для редактирования установок."
MIDIERR_INVALIDSETUP, "Текущие установки MIDI повреждены. Скопируйте исходный файл MIDIMAP.CFG в директорию Windows SYSTEM, и попробуйте заново."
/* MCI errors */
MCIERR_INVALID_DEVICE_ID, "Недопустимый код устройства MCI. Используйте код, возвращенный при открытии устройства MCI."
MCIERR_UNRECOGNIZED_KEYWORD, "Драйвер не может определить указанный параметр команды."
MCIERR_UNRECOGNIZED_COMMAND, "Драйвер не может определить указанную команду."
MCIERR_HARDWARE, "Ошибка мультимедиа устройства. Убедитесь, что устройство работает нормально или свяжитесь с изготовителем устройства."
MCIERR_INVALID_DEVICE_NAME, "Указанное устройство не открыто или не опознано MCI."
MCIERR_OUT_OF_MEMORY, "Не хватает памяти для задачи. \nЗакройте одно или несколько приложений, чтобы освободить память и попробуйте заново."
MCIERR_DEVICE_OPEN, "Название устройства уже используется приложением как псевдоним. Используйте уникальное имя."
MCIERR_CANNOT_LOAD_DRIVER, "Неопределенная ошибка при загрузке указанного драйвера."
MCIERR_MISSING_COMMAND_STRING, "Команда не указана."
MCIERR_PARAM_OVERFLOW, "Возвращаемая строка слишком велика, чтобы поместиться в буфере. Увеличьте размер буфера."
MCIERR_MISSING_STRING_ARGUMENT, "Указанная команда требует строковый параметр."
MCIERR_BAD_INTEGER, "Указанное целое недопустимо для этой команды."
MCIERR_PARSER_INTERNAL, "Драйвер устройства возвратил недопустимый при возвращении тип. Свяжитесь с изготовителем драйвера для получения новой версии драйвера."
MCIERR_DRIVER_INTERNAL, "Ошибка драйвера устройства. Свяжитесь с изготовителем драйвера для получения новой версии драйвера."
MCIERR_MISSING_PARAMETER, "Указанная команда требует параметр."
MCIERR_UNSUPPORTED_FUNCTION, "Используемое вами устройство MCI не поддерживает указанную команду."
MCIERR_FILE_NOT_FOUND, "Невозможно найти указанный файл. Убедитесь в правильности пути и имени файла."
MCIERR_DEVICE_NOT_READY, "Драйвер устройства не готов."
MCIERR_INTERNAL, "Ошибка при инициализации MCI. Попробуйте перезапустить Windows."
MCIERR_DRIVER, "Ошибка в драйвере устройства. Драйвер закрыт, сообщение об ошибке недоступно."
MCIERR_CANNOT_USE_ALL, "Невозможно использовать 'all' в качестве имени устройства в указанной команде."
MCIERR_MULTIPLE, "Ошибки в нескольких устройствах. Укажите отдельно каждую команду и устройство, чтобы определить, какие устройства вызывали ошибки."
MCIERR_EXTENSION_NOT_FOUND, "Невозможно определить тип устройства по данному расширению файла."
MCIERR_OUTOFRANGE, "Указанный параметр выходит за допустимые пределы для указанной команды."
MCIERR_FLAGS_NOT_COMPATIBLE, "Указанные параметры нельзя использовать вместе."
MCIERR_FILE_NOT_SAVED, "Невозможно сохранить указанный файл. Убедитесь, что на диске достаточно места, или проверьте сетевое подключение."
MCIERR_DEVICE_TYPE_REQUIRED, "Невозможно найти указанное устройство. Убедитесь, что оно установлено, и что устройство указано правильно."
MCIERR_DEVICE_LOCKED, "Указанное устройство сейчас закрывается. Подождите несколько секунд и попробуйте заново."
MCIERR_DUPLICATE_ALIAS, "Название устройства уже используется приложением как псевдоним. Используйте уникальное имя."
MCIERR_BAD_CONSTANT, "Указанный параметр недопустим для этой команды."
MCIERR_MUST_USE_SHAREABLE, "Драйвер устройства уже используется. Для совместного доступа используйте параметр 'shareable' в каждой команде 'open'."
MCIERR_MISSING_DEVICE_NAME, "Указанная команда требует псевдоним, файл, драйвер, или имя устройства. Укажите его."
MCIERR_BAD_TIME_FORMAT, "Указанное значение в формате времени неверно. Обратитесь к документации MCI для выяснения допустимых форматов."
MCIERR_NO_CLOSING_QUOTE, "Закрывающая кавычка отсутствует в значении параметра. Поставьте ее ;-)"
MCIERR_DUPLICATE_FLAGS, "Параметр или значение указано дважды. Требуется указывать только один раз."
MCIERR_INVALID_FILE, "Указанный файл не может быть проигран на выбранном устройстве MCI. Файл может быть поврежден или имеет некорректный формат."
MCIERR_NULL_PARAMETER_BLOCK, "MCI был передан пустой блок параметров."
MCIERR_UNNAMED_RESOURCE, "Невозможно сохранить неназванный файл. Назовите его."
MCIERR_NEW_REQUIRES_ALIAS, "Вы должны указать псевдоним при использовании параметра 'new'."
MCIERR_NOTIFY_ON_AUTO_OPEN, "Невозможно использовать флаг 'notify' с устройствами, открытыми автоматически."
MCIERR_NO_ELEMENT_ALLOWED, "Невозможно использовать имя файла с указанным устройством."
MCIERR_NONAPPLICABLE_FUNCTION, "Невозможно исполнить команды в указанном порядке. Исправьте последовательность команд и попробуйте заново."
MCIERR_ILLEGAL_FOR_AUTO_OPEN, "Невозможно исполнить команду для устройства, открытого автоматически. Подождите пока устройство не будет закрыто и попробуйте заново."
MCIERR_FILENAME_REQUIRED, "Недопустимое имя файла. Убедитесь, что имя файла не длиннее 8 символов, за ним следует точка и расширение."
MCIERR_EXTRA_CHARACTERS, "Нельзя указывать символы после строки, заключенной в кавычки."
MCIERR_DEVICE_NOT_INSTALLED, "Указанное устройство не установлено в системе. Используйте Control Panel для установки драйвера."
MCIERR_GET_CD, "Нет доступа к указанному файлу или устройству МCI. Попробуйте перезапустить компьютер ;-)"
MCIERR_SET_CD, "Нет доступа к указанному файлу или устройству MCI, потому что приложение не может менять директории."
MCIERR_SET_DRIVE, "Нет доступа к указанному файлу или устройству MCI, потому что приложение не может менять диски."
MCIERR_DEVICE_LENGTH, "Имя драйвера или устройства должно быть короче 79 символов."
MCIERR_DEVICE_ORD_LENGTH, "Имя драйвера или устройства должно быть короче 69 символов."
MCIERR_NO_INTEGER, "Указанная команда требует параметр целого типа."
MCIERR_WAVE_OUTPUTSINUSE, "Все wave-устройства, которые могут воспроизводить файлы в текущем формате, заняты. Подождите пока освободится wave-устройство, и попробуйте заново."
MCIERR_WAVE_SETOUTPUTINUSE, "Невозможно использовать текущее устройство для воспроизведения, т.к. оно занято. Подождите, пока устройство освободится, и попробуйте заново."
MCIERR_WAVE_INPUTSINUSE, "Невозможно использовать текущее устройство для записи, т.к. оно занято. Подождите, пока устройство освободится, и попробуйте заново."
MCIERR_WAVE_SETINPUTINUSE, "Невозможно использовать текущее устройство для воспроизведения, т.к. оно занято. Подождите, пока устройство освободится, и попробуйте заново."
MCIERR_WAVE_OUTPUTUNSPECIFIED, "Может быть использовано любое устройство для проигрывания звука."
MCIERR_WAVE_INPUTUNSPECIFIED, "Может быть использовано любое устройство для записи звука."
MCIERR_WAVE_OUTPUTSUNSUITABLE, "Нет устройства для воспроизведения файлов в текущем формате. Используйте опцию Drivers для установки звукового устройства."
MCIERR_WAVE_SETOUTPUTUNSUITABLE,"Устройство, на которое вы проигрываете, не поддерживает формат текущего файла."
MCIERR_WAVE_INPUTSUNSUITABLE, "Нет устройства для записи файлов в текущем формате. Используйте опцию Drivers для установки звукового устройства."
MCIERR_WAVE_SETINPUTUNSUITABLE, "Устройство, с которого вы записываете, не может распознать текущий формат файла."
MCIERR_NO_WINDOW, "Нет окна для отображения."
MCIERR_CREATEWINDOW, "Невозможно создать или использовать окно."
MCIERR_FILE_READ, "Невозможно прочитать указанный файл. Убедитесь, что файл существует, или проверьте диск или сетевое подключение. "
MCIERR_FILE_WRITE, "Невозможно записать в указанный файл. Убедитесь, что на диске достаточно места, или проверьте сетевое подключение."
MCIERR_SEQ_DIV_INCOMPATIBLE, "Форматы времени ""song pointer"" и SMPTE взаимно исключаемые. Нельзя использовать их вместе."
MCIERR_SEQ_NOMIDIPRESENT, "В системе не установлены устройства MIDI. Используйте Drivers в Control Panel, чтобы установить драйвер MIDI."
MCIERR_SEQ_PORT_INUSE, "Указанный порт MIDI уже используется. Подождите, пока он освободится, и попробуйте заново."
MCIERR_SEQ_PORT_MAPNODEVICE, "Текущие установки MIDI Mapper ссылаются на не установленное в системе устройство MIDI. Используйте MIDI Mapper в Control Panel, чтобы отредактировать установки."
MCIERR_SEQ_PORT_MISCERROR, "Ошибка указанного порта."
MCIERR_SEQ_PORT_NONEXISTENT, "В системе не установлены устройства MIDI. Используйте Drivers в Control Panel, чтобы установить драйвер MIDI."
MCIERR_SEQ_PORTUNSPECIFIED, "В системе не указан текущий порт MIDI."
MCIERR_SEQ_TIMER, "Все таймеры мультимедиа используются другими приложениями. Закройте одно из этих приложений и попробуйте заново."
END
/* translation by Zahar Hodoley (mail: zaharh@mail.ru) */

127
reactos/lib/winmm/winmm_Si.rc
View file

@ -1,127 +0,0 @@
/*
* Copyright 2002-2003 Rok Mandeljc <rok.mandeljc@gimb.org>
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*
*/
STRINGTABLE LANGUAGE LANG_SLOVENIAN, SUBLANG_DEFAULT
BEGIN
/* MMSYS errors */
MMSYSERR_NOERROR, "Navedeni ukaz je bil izveden."
MMSYSERR_ERROR, "Neznana zunanja napaka."
MMSYSERR_BADDEVICEID, "Uporabljena identifikacijska oznaka naprave je zunaj dopustnega obsega za vaš sistem."
MMSYSERR_NOTENABLED, "Gonilnik ni bil omogoèen."
MMSYSERR_ALLOCATED, "Navedena naprava je že v uporabi. Poèakajte, da bo spet prosta, in poskusite znova."
MMSYSERR_INVALHANDLE, "Navedena koda za dostop do naprave ni veljavna."
MMSYSERR_NODRIVER, "Noben gonilnik ni namešèen !\n"
MMSYSERR_NOMEM, "Za to opravilo ni na voljo dovolj pomnilnika. Konèajte enega ali veè programov in poskusite znova."
MMSYSERR_NOTSUPPORTED, "Ta funkcija ni podprta. Èe želite ugotoviti, katere funkcije podpira gonilnik, uporabite možnost 'Funkcije'."
MMSYSERR_BADERRNUM, "Navedena je bila številka napake, ki v sistemu ni definirana."
MMSYSERR_INVALFLAG, "Sistemska funkcija je prejela neveljavno zastavico."
MMSYSERR_INVALPARAM, "Sistemska funkcija je prejela neveljaven parameter."
/* WAVE errors */
WAVERR_BADFORMAT, "Navedena oblika zapisa ni podprta ali pa je ni mogoèe prevesti. Èe želite ugotoviti, katere oblike so podprte, uporabite možnost 'Funkcije'."
WAVERR_STILLPLAYING, "Predvajanje še traja. Ponastavite napravo ali pa poèakajte do konca predvajanja."
WAVERR_UNPREPARED, "Glava podatkov vrste wave ni bila pripravljena. Pripravite glavo, tako da uporabite funkcijo 'Pripravi' (Prepare), in poskusite znova."
WAVERR_SYNC, "Brez zastavice WAVE_ALLOWSYNC ni mogoèe odpreti naprave. Uporabite jo in poskusite znova."
/* MIDI errors */
MIDIERR_UNPREPARED, "MIDI glava ni bila pripravljena. Pripravite glavo, tako da uporabite funkcijo 'Pripravi' (Prepare), in poskusite znova."
MIDIERR_STILLPLAYING, "Predvajanje še traja. Ponastavite napravo ali pa poèakajte do konca predvajanja."
MIDIERR_NOMAP, "Razporeditve MIDI ni mogo1e najti. To je lahko posledica težav z gonilnikom, ali pa manjkajoè ali poškodovane datoteke MIDIMAP.CFG."
MIDIERR_NOTREADY, "Prek vrat poteka prenos podatkov do naprave. Poèakajte, da se prenos konèa in poskusite znova."
MIDIERR_NODEVICE, "Trenutna nastavitev MIDI se sklicuje na MIDI napravo, ki ni prisotna. Uporabite MIDI Mapper in spremenite nastavitve."
MIDIERR_INVALIDSETUP, "Trenutna nastavitev MIDI je pošodovana. Namestite originalno datoteko MIDIMAP.CFG v sistemsko mapo Windows (System) in poskusite znova."
/* MCI errors */
MCIERR_INVALID_DEVICE_ID, "Neveljavna identifikacijska oznaka MCI naprave. Uporabite oznako, ki jo vrne odpiranje MCI naprave."
MCIERR_UNRECOGNIZED_KEYWORD, "Naveden parameter ukaza ni definiran v naboru MCI ukazov."
MCIERR_UNRECOGNIZED_COMMAND, "Naveden ukaz ni veljaven MCI ukaz."
MCIERR_HARDWARE, "S predstavnostno napravo so težave. Preverite, ali naprava deluje pravilno ali pa se posvetujte z izdelovalcem."
MCIERR_INVALID_DEVICE_NAME, "To ni registrirana MCI naprava."
MCIERR_OUT_OF_MEMORY, "Za to opravilo ni na voljo dovolj pomnilnika. \nKonèajte enega ali veè programov in poskusite znova."
MCIERR_DEVICE_OPEN, "Ta program že uporablja ta vzdevek. Namesto imena naprave uporabite še neuporabljen vzdevek."
MCIERR_CANNOT_LOAD_DRIVER, "Naprave ni bilo mogoèe naložiti. Preverite, ali je gonilnik pravilno namešèen."
MCIERR_MISSING_COMMAND_STRING, "Ukazni niz je prazen."
MCIERR_PARAM_OVERFLOW, "Izhodni niz je bil prevelik, da bi ga bilo mogoèe shraniti v povratni medpomnilnik. Poveèajte medpomnilnik."
MCIERR_MISSING_STRING_ARGUMENT, "Navedeni ukaz zahteva parameter (niz znakov). Vnesite ga."
MCIERR_BAD_INTEGER, "Vneseno celo število za ta ukaz ni veljavno. Vnesite število."
MCIERR_PARSER_INTERNAL, "Gonilnik za napravo je vrnil neveljavno vrsto vrednosti. Od izdelovalca naprave poskusite dobiti nov gonilnik."
MCIERR_DRIVER_INTERNAL, "Z gonilnikom za napravo so težave. Od izdelovalca naprave poskusite dobiti nov gonilnik."
MCIERR_MISSING_PARAMETER, "V navedenem ukazu manjka parameter. Vnesite ga."
MCIERR_UNSUPPORTED_FUNCTION, "MCI naprava, ki jo uporabljate, ne podpira navedenega ukaza."
MCIERR_FILE_NOT_FOUND, "Navedene datoteke ni mogoèe najti. Preverite, ali ste pravilno vnesli ime in pot do datoteke."
MCIERR_DEVICE_NOT_READY, "Gonilnik za napravo ni pripravljen. Malo poèakajte in nato poskusite znova."
MCIERR_INTERNAL, "Pri inicializaciji MCI naprave je prišlo do težav. Znova zaženite Windows."
MCIERR_DRIVER, "Zaradi napake, znaèilne za gonilnik, je bil gonilnik zaprt. Ponovite ukaz."
MCIERR_CANNOT_USE_ALL, "V tem ukazu uporabite ime toèno doloèene naprave."
MCIERR_MULTIPLE, "V veè napravah je prišlo do napak. Loèeno vnesite vsak ukaz in vsako napravo. Tako boste lahko ugotovili, katere naprave povzroèajo napake."
MCIERR_EXTENSION_NOT_FOUND, "Iz pripone datoteke ni mogoèe ugotoviti vrste zahtevane naprave."
MCIERR_OUTOFRANGE, "Parameter je zunaj dovoljenega obsega za naveden ukaz."
MCIERR_FLAGS_NOT_COMPATIBLE, "Navedenih parametrov ne smete uporabiti hkrati."
MCIERR_FILE_NOT_SAVED, "Navedene datoteke ni mogoèe shraniti. Preverite, ali je na disku dovolj prostora oz. ali je vaš raèunalnik še povezan z omrežjem."
MCIERR_DEVICE_TYPE_REQUIRED, "Navedene naprave ni mogoèe najti. Preverite, ali je naprava namešèena oz. ali je bilo njeno ime pravilno navedeno."
MCIERR_DEVICE_LOCKED, "Poteka zapiranje navedene naprave. Malo poèakajte in poskusite znova."
MCIERR_DUPLICATE_ALIAS, "Ta program že uporablja navedeni vzdevek. Uporabite še neuporabljen vzdevek."
MCIERR_BAD_CONSTANT, "Uporabljena konstanta v tem ukazu ni veljavna."
MCIERR_MUST_USE_SHAREABLE, "Gonilnik naprave je že v uporabi. Èe ga želite dati v skupno rabo, z vsakim ukazom 'open' uporabite parameter 'shareable'."
MCIERR_MISSING_DEVICE_NAME, "Navedeni ukaz zahteva vzdevek, datoteko, gonilnik ali ime naprave. Vnesite ustrezno ime."
MCIERR_BAD_TIME_FORMAT, "Navedena vrednost za obliko zapisa èasa ni veljavna. Veljavne oblike poišèite v dokumentaciji MCI naprave."
MCIERR_NO_CLOSING_QUOTE, "V vrednosti za parameter manjka zakljuèni dvojni narekovaj. Vnesite ga."
MCIERR_DUPLICATE_FLAGS, "Parameter ali vrednost ste navedli dvakrat. Navedite ga samo enkrat."
MCIERR_INVALID_FILE, "Te datoteke ne morete predvajati z navedeno MCI napravo. Datoteka je morda poškodovana ali pa ima napaèno obliko zapisa."
MCIERR_NULL_PARAMETER_BLOCK, "MCI napravi je bil predan 'null parameter block'."
MCIERR_UNNAMED_RESOURCE, "Datoteke brez imena ni mogoèe shraniti. Vnesite ime."
MCIERR_NEW_REQUIRES_ALIAS, "Ko uporabljate parameter 'new', morate navesti vzdevek."
MCIERR_NOTIFY_ON_AUTO_OPEN, "Zastavice 'notify' ni mogoèe uporabiti pri napravah, ki se samodejno odpirajo."
MCIERR_NO_ELEMENT_ALLOWED, "V povezavi z navedeno napravo ne morete uporabiti imena datoteke."
MCIERR_NONAPPLICABLE_FUNCTION, "Ukazov v navedenem zaporedju ni mogoèe izvesti. Spremenite zaporedje in poskusite znova."
MCIERR_ILLEGAL_FOR_AUTO_OPEN, "Ukaza ni mogoèe izvesti v povezavi z napravo, ki se samodejno odpre. Poèakajte, da se naprava zapre, in poskusite znova."
MCIERR_FILENAME_REQUIRED, "Ime datoteke ni veljavno."
MCIERR_EXTRA_CHARACTERS, "Za nizom znakov, ki je obdan z narekovaji, ni mogoèe zapisati dodatnih znakov."
MCIERR_DEVICE_NOT_INSTALLED, "Naprava ni namešèena. Èe želite namestiti nov gonilnik, na nadzorni plošèi dvokliknite ikono 'Dodajanje strojne opreme'."
MCIERR_GET_CD, "Dostop do navedene datoteke ali MCI naprave ni mogoè. Zamenjajte imenik ali pa znova zaženite raèunalnik."
MCIERR_SET_CD, "Dostop do navedene datoteke ali MCI naprave ni mogoè, ker program ne more zamenjati imenika."
MCIERR_SET_DRIVE, "Dostop do navedene datoteke ali MCI naprave ni mogoè, ker program ne more zamenjati pogona."
MCIERR_DEVICE_LENGTH, "Navedite ime za napravo ali gonilnik, ki je krajše od 79 znakov."
MCIERR_DEVICE_ORD_LENGTH, "Navedite ime za napravo ali gonilnik, ki je krajše od 69 znakov."
MCIERR_NO_INTEGER, "Navedeni ukaz zahteva številèni parameter (npr. 'play to 10'). Vnesite ga."
MCIERR_WAVE_OUTPUTSINUSE, "Vse naprave, ki lahko predvajajo datoteke v obliki wave, so v uporabi. Poskusite znova, ko bo katera od njih na voljo."
MCIERR_WAVE_SETOUTPUTINUSE, "Trenutna wave naprava je v uporabi. Poèakajte, da bo prosta, in poskusite znova."
MCIERR_WAVE_INPUTSINUSE, "Vse naprave, ki lahko snemajo datoteke v obliki wave, so v uporabi. Poskusite znova, ko bo katera od njih na voljo."
MCIERR_WAVE_SETINPUTINUSE, "Trenutna wave naprava je v uporabi. Poèakajte, da bo prosta, in poskusite znova."
MCIERR_WAVE_OUTPUTUNSPECIFIED, "Predvajalna naprava je v uporabi. Poskusite znova, ko bo predvajanje konèano."
MCIERR_WAVE_INPUTUNSPECIFIED, "Snemalna naprava je v uporabi. Poskusite znova, ko bo snemanje konèano."
MCIERR_WAVE_OUTPUTSUNSUITABLE, "Namešèena ni nobena naprava za wave, ki bi lahko predvajala datoteke v trenutni obliki."
MCIERR_WAVE_SETOUTPUTUNSUITABLE,"Naprava ne prepozna trenutne oblike zapisa datoteke. Izberite drugo napravo in poskusite znova."
MCIERR_WAVE_INPUTSUNSUITABLE, "Namešèena ni nobena naprava za wave, ki bi lahko snemala datoteke v trenutni obliki."
MCIERR_WAVE_SETINPUTUNSUITABLE, "Naprava ne prepozna trenutne oblike zapisa datoteke. Izberite drugo napravo in poskusite znova."
MCIERR_NO_WINDOW, "Ni okna za prikaz."
MCIERR_CREATEWINDOW, "Okna ni bilo mogoèe ustvariti ali uporabiti."
MCIERR_FILE_READ, "Te datoteke ni mogoèe brati. Preverite, ali ni bila morda izbrisana. Preverite tudi svoj disk in omrežne povezave."
MCIERR_FILE_WRITE, "V navedeno datoteko ni mogoèe pisati. Preverite, ali je na disku še dovolj prostora oz. ali je vaš raèunalnik še povezan z omrežjem."
MCIERR_SEQ_DIV_INCOMPATIBLE, "Hkrati ni mogoèe uporabiti oblik zapisa èasa 'song-pointer' in SMPTE."
MCIERR_SEQ_NOMIDIPRESENT, "V sistemu ni namešèena nobena MIDI naprava. Za namestitev MIDI gonilnika uporabite možnost 'Drivers' na Nadzorni plošèi."
MCIERR_SEQ_PORT_INUSE, "Navedena MIDI naprava je že v uporabi. Poèakajte, da bo prosta, in poskusite znova."
MCIERR_SEQ_PORT_MAPNODEVICE, "Trenutna nastavitev MIDI se sklicuje na napravo, ki ni namešèena. Uporabite možnost 'MIDI Mapper' na Nadzorni plošèi in spremenite nastavitev."
MCIERR_SEQ_PORT_MISCERROR, "Na navedenih vratih je prišlo do napake."
MCIERR_SEQ_PORT_NONEXISTENT, "Ta naprava ni namešèena. Èe želite namestiti nov gonilnik, na nadzorni plošèi dvokliknite ikono 'Dodajanje strojne opreme'."
MCIERR_SEQ_PORTUNSPECIFIED, "Zahtevana MIDI vrata niso namešèena."
MCIERR_SEQ_TIMER, "Vsi veèpredstavnostni števci so zasedeni. Zaprite eno od aplikacij in poskusite znova."
END

126
reactos/lib/winmm/winmm_Sk.rc
View file

@ -1,126 +0,0 @@
/*
* Copyright 2000 Peter Ivanyi
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*/
STRINGTABLE LANGUAGE LANG_SLOVAK, SUBLANG_NEUTRAL
BEGIN
/* MMSYS errors */
MMSYSERR_NOERROR, "Špecifikovaný príkaz bol vykonaný."
MMSYSERR_ERROR, "Nedefinovaná externá chyba."
MMSYSERR_BADDEVICEID, "A device ID has been used that is out of range for your system."
MMSYSERR_NOTENABLED, "The driver was not enabled."
MMSYSERR_ALLOCATED, "The specified device is already in use. Wait until it is free, and then try again."
MMSYSERR_INVALHANDLE, "The specified device handle is invalid."
MMSYSERR_NODRIVER, "There is no driver installed on your system !\n"
MMSYSERR_NOMEM, "Not enough memory available for this task. Quit one or more applications to increase available memory, and then try again."
MMSYSERR_NOTSUPPORTED, "This function is not supported. Use the Capabilities function to determine which functions and messages the driver supports."
MMSYSERR_BADERRNUM, "An error number was specified that is not defined in the system."
MMSYSERR_INVALFLAG, "An invalid flag was passed to a system function."
MMSYSERR_INVALPARAM, "An invalid parameter was passed to a system function."
/* WAVE errors */
WAVERR_BADFORMAT, "The specified format is not supported or cannot be translated. Use the Capabilities function to determine the supported formats"
WAVERR_STILLPLAYING, "Cannot perform this operation while media data is still playing. Reset the device, or wait until the data is finished playing."
WAVERR_UNPREPARED, "The wave header was not prepared. Use the Prepare function to prepare the header, and then try again."
WAVERR_SYNC, "Cannot open the device without using the WAVE_ALLOWSYNC flag. Use the flag, and then try again."
/* MIDI errors */
MIDIERR_UNPREPARED, "The MIDI header was not prepared. Use the Prepare function to prepare the header, and then try again."
MIDIERR_STILLPLAYING, "Cannot perform this operation while media data is still playing. Reset the device, or wait until the data is finished playing."
MIDIERR_NOMAP, "A MIDI map was not found. There may be a problem with the driver, or the MIDIMAP.CFG file may be corrupt or missing."
MIDIERR_NOTREADY, "The port is transmitting data to the device. Wait until the data has been transmitted, and then try again."
MIDIERR_NODEVICE, "The current MIDI Mapper setup refers to a MIDI device that is not installed on the system. Use MIDI Mapper to edit the setup."
MIDIERR_INVALIDSETUP, "The current MIDI setup is damaged. Copy the original MIDIMAP.CFG file to the Windows SYSTEM directory, and then try again."
/* MCI errors */
MCIERR_INVALID_DEVICE_ID, "Invalid MCI device ID. Use the ID returned when opening the MCI device."
MCIERR_UNRECOGNIZED_KEYWORD, "The driver cannot recognize the specified command parameter."
MCIERR_UNRECOGNIZED_COMMAND, "The driver cannot recognize the specified command."
MCIERR_HARDWARE, "There is a problem with your media device. Make sure it is working correctly or contact the device manufacturer."
MCIERR_INVALID_DEVICE_NAME, "The specified device is not open or is not recognized by MCI."
MCIERR_OUT_OF_MEMORY, "Not enough memory available for this task. \nQuit one or more applications to increase available memory, and then try again."
MCIERR_DEVICE_OPEN, "The device name is already being used as an alias by this application. Use a unique alias."
MCIERR_CANNOT_LOAD_DRIVER, "There is an undetectable problem in loading the specified device driver."
MCIERR_MISSING_COMMAND_STRING, "Nebol špecifikovaný žiadny príkaz."
MCIERR_PARAM_OVERFLOW, "The output string was to large to fit in the return buffer. Increase the size of the buffer."
MCIERR_MISSING_STRING_ARGUMENT, "The specified command requires a character-string parameter. Please provide one."
MCIERR_BAD_INTEGER, "The specified integer is invalid for this command."
MCIERR_PARSER_INTERNAL, "The device driver returned an invalid return type. Check with the device manufacturer about obtaining a new driver."
MCIERR_DRIVER_INTERNAL, "There is a problem with the device driver. Check with the device manufacturer about obtaining a new driver."
MCIERR_MISSING_PARAMETER, "The specified command requires a parameter. Please supply one."
MCIERR_UNSUPPORTED_FUNCTION, "The MCI device you are using does not support the specified command."
MCIERR_FILE_NOT_FOUND, "Cannot find the specified file. Make sure the path and filename are correct."
MCIERR_DEVICE_NOT_READY, "Ovládaè zariadenia nie je pripravený."
MCIERR_INTERNAL, "A problem occurred in initializing MCI. Try restarting Windows."
MCIERR_DRIVER, "There is a problem with the device driver. The driver has closed. Cannot access error."
MCIERR_CANNOT_USE_ALL, "Cannot use 'all' as the device name with the specified command."
MCIERR_MULTIPLE, "Errors occurred in more than one device. Specify each command and device separately to determine which devices caused the error"
MCIERR_EXTENSION_NOT_FOUND, "Cannot determine the device type from the given filename extension."
MCIERR_OUTOFRANGE, "The specified parameter is out of range for the specified command."
MCIERR_FLAGS_NOT_COMPATIBLE, "The specified parameters cannot be used together."
MCIERR_FILE_NOT_SAVED, "Cannot save the specified file. Make sure you have enough disk space or are still connected to the network."
MCIERR_DEVICE_TYPE_REQUIRED, "Cannot find the specified device. Make sure it is installed or that the device name is spelled correctly."
MCIERR_DEVICE_LOCKED, "The specified device is now being closed. Wait a few seconds, and then try again."
MCIERR_DUPLICATE_ALIAS, "The specified alias is already being used in this application. Use a unique alias."
MCIERR_BAD_CONSTANT, "The specified parameter is invalid for this command."
MCIERR_MUST_USE_SHAREABLE, "The device driver is already in use. To share it, use the 'shareable' parameter with each 'open' command."
MCIERR_MISSING_DEVICE_NAME, "The specified command requires an alias, file, driver, or device name. Please supply one."
MCIERR_BAD_TIME_FORMAT, "The specified value for the time format is invalid. Refer to the MCI documentation for valid formats."
MCIERR_NO_CLOSING_QUOTE, "A closing double-quotation mark is missing from the parameter value. Please supply one."
MCIERR_DUPLICATE_FLAGS, "A parameter or value was specified twice. Only specify it once."
MCIERR_INVALID_FILE, "The specified file cannot be played on the specified MCI device. The file may be corrupt, or not in the correct format."
MCIERR_NULL_PARAMETER_BLOCK, "A null parameter block was passed to MCI."
MCIERR_UNNAMED_RESOURCE, "Cannot save an unnamed file. Supply a filename."
MCIERR_NEW_REQUIRES_ALIAS, "You must specify an alias when using the 'new' parameter."
MCIERR_NOTIFY_ON_AUTO_OPEN, "Cannot use the 'notify' flag with auto-opened devices."
MCIERR_NO_ELEMENT_ALLOWED, "Cannot use a filename with the specified device."
MCIERR_NONAPPLICABLE_FUNCTION, "Cannot carry out the commands in the order specified. Correct the command sequence, and then try again."
MCIERR_ILLEGAL_FOR_AUTO_OPEN, "Cannot carry out the specified command on an auto-opened device. Wait until the device is closed, and then try again."
MCIERR_FILENAME_REQUIRED, "The filename is invalid. Make sure the filename is not longer than 8 characters, followed by a period and an extension."
MCIERR_EXTRA_CHARACTERS, "Cannot specify extra characters after a string enclosed in quotation marks."
MCIERR_DEVICE_NOT_INSTALLED, "The specified device is not installed on the system. Use the Drivers option in Control Panel to install the device."
MCIERR_GET_CD, "Cannot access the specified file or MCI device. Try changing directories or restarting your computer."
MCIERR_SET_CD, "Cannot access the specified file or MCI device because the application cannot change directories."
MCIERR_SET_DRIVE, "Cannot access specified file or MCI device because the application cannot change drives."
MCIERR_DEVICE_LENGTH, "Specify a device or driver name that is less than 79 characters."
MCIERR_DEVICE_ORD_LENGTH, "Specify a device or driver name that is less than 69 characters."
MCIERR_NO_INTEGER, "The specified command requires an integer parameter. Please provide one."
MCIERR_WAVE_OUTPUTSINUSE, "All wave devices that can play files in the current format are in use. Wait until a wave device is free, and then try again."
MCIERR_WAVE_SETOUTPUTINUSE, "Cannot set the current wave device for play back because it is in use. Wait until the device is free, and then try again."
MCIERR_WAVE_INPUTSINUSE, "All wave devices that can record files in the current format are in use. Wait until a wave device is free, and then try again."
MCIERR_WAVE_SETINPUTINUSE, "Cannot set the current wave device for recording because it is in use. Wait until the device is free, and then try again."
MCIERR_WAVE_OUTPUTUNSPECIFIED, "Any compatible waveform playback device may be used."
MCIERR_WAVE_INPUTUNSPECIFIED, "Any compatible waveform recording device may be used."
MCIERR_WAVE_OUTPUTSUNSUITABLE, "No wave device that can play files in the current format is installed. Use the Drivers option to install the wave device."
MCIERR_WAVE_SETOUTPUTUNSUITABLE,"The device you are trying to play to cannot recognize the current file format."
MCIERR_WAVE_INPUTSUNSUITABLE, "No wave device that can record files in the current format is installed. Use the Drivers option to install the wave device."
MCIERR_WAVE_SETINPUTUNSUITABLE, "The device you are trying to record from cannot recognize the current file format."
MCIERR_NO_WINDOW, "There is no display window."
MCIERR_CREATEWINDOW, "Nemôžem vytvori<72> alebo použi<C5BE> okno."
MCIERR_FILE_READ, "Cannot read the specified file. Make sure the file is still present, or check your disk or network connection."
MCIERR_FILE_WRITE, "Cannot write to the specified file. Make sure you have enough disk space or are still connected to the network."
MCIERR_SEQ_DIV_INCOMPATIBLE, "The time formats of the ""song pointer"" and SMPTE are mutually exclusive. You can't use them together."
MCIERR_SEQ_NOMIDIPRESENT, "The system has no installed MIDI devices. Use the Drivers option from the Control Panel to install a MIDI driver."
MCIERR_SEQ_PORT_INUSE, "The specified MIDI port is already in use. Wait until it is free; the try again."
MCIERR_SEQ_PORT_MAPNODEVICE, "The current MIDI Mapper setup refers to a MIDI device that is not installed on the system. Use the MIDI Mapper option from the Control Panel to edit the setup."
MCIERR_SEQ_PORT_MISCERROR, "An error occurred with the specified port."
MCIERR_SEQ_PORT_NONEXISTENT, "The specified MIDI device is not installed on the system. Use the Drivers option from the Control Panel to install a MIDI device."
MCIERR_SEQ_PORTUNSPECIFIED, "The system doesnot have a current MIDI port specified."
MCIERR_SEQ_TIMER, "All multimedia timers are being used by other applications. Quit one of these applications; then, try again."
END

876
reactos/lib/winmm/winmm_res.rc
View file

@ -1,876 +0,0 @@
/* Multimedia resources (MMSYSTEM.DLL & WINMM.DLL)
*
* Copyright (c) 1999, Eric Pouech
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*
* Note: Win 9x (and of course Win 3.x) store their resources in MMSYSTEM.DLL
* Wine stores all resources in WINMM.DLL (as NT does)
* This shall be transparent to most apps (unless some look directly in
* MMSYSTEM...)
*/
#include "windef.h"
#include "winbase.h"
#include "mmddk.h"
#include "winnls.h"
/* Add your language specific defines here */
#include "winmm_Cs.rc"
#include "winmm_De.rc"
#include "winmm_En.rc"
#include "winmm_Es.rc"
#include "winmm_Fr.rc"
#include "winmm_It.rc"
/* #include "winmm_Ja.rc" */ /* Gives error during ReactOS build */
#include "winmm_Nl.rc"
#include "winmm_Pt.rc"
#include "winmm_Ru.rc"
#include "winmm_Si.rc"
#include "winmm_Sk.rc"
/* do not add NLS specific stuff below that line */
LANGUAGE LANG_NEUTRAL, SUBLANG_NEUTRAL
CORE RCDATA
BEGIN
"open\0", 0x00000803L, MCI_COMMAND_HEAD,
"\0", 0x00000002L, MCI_RETURN,
"notify\0", 0x00000001L, MCI_FLAG,
"wait\0", 0x00000002L, MCI_FLAG,
"type\0", 0x00002000L, MCI_STRING,
"element\0", 0x00000200L, MCI_STRING,
"alias\0", 0x00000400L, MCI_STRING,
"shareable\0", 0x00000100L, MCI_FLAG,
"\0", 0x00000000L, MCI_END_COMMAND,
"close\0", 0x00000804L, MCI_COMMAND_HEAD,
"notify\0", 0x00000001L, MCI_FLAG,
"wait\0", 0x00000002L, MCI_FLAG,
"\0", 0x00000000L, MCI_END_COMMAND,
"play\0", 0x00000806L, MCI_COMMAND_HEAD,
"notify\0", 0x00000001L, MCI_FLAG,
"wait\0", 0x00000002L, MCI_FLAG,
"from\0", 0x00000004L, MCI_INTEGER,
"to\0", 0x00000008L, MCI_INTEGER,
"\0", 0x00000000L, MCI_END_COMMAND,
"record\0", 0x0000080fL, MCI_COMMAND_HEAD,
"notify\0", 0x00000001L, MCI_FLAG,
"wait\0", 0x00000002L, MCI_FLAG,
"from\0", 0x00000004L, MCI_INTEGER,
"to\0", 0x00000008L, MCI_INTEGER,
"insert\0", 0x00000100L, MCI_FLAG,
"overwrite\0", 0x00000200L, MCI_FLAG,
"\0", 0x00000000L, MCI_END_COMMAND,
"seek\0", 0x00000807L, MCI_COMMAND_HEAD,
"notify\0", 0x00000001L, MCI_FLAG,
"wait\0", 0x00000002L, MCI_FLAG,
"to start\0", 0x00000100L, MCI_FLAG,
"to end\0", 0x00000200L, MCI_FLAG,
"to\0", 0x00000008L, MCI_INTEGER,
"\0", 0x00000000L, MCI_END_COMMAND,
"stop\0", 0x00000808L, MCI_COMMAND_HEAD,
"notify\0", 0x00000001L, MCI_FLAG,
"wait\0", 0x00000002L, MCI_FLAG,
"\0", 0x00000000L, MCI_END_COMMAND,
"pause\0", 0x00000809L, MCI_COMMAND_HEAD,
"notify\0", 0x00000001L, MCI_FLAG,
"wait\0", 0x00000002L, MCI_FLAG,
"\0", 0x00000000L, MCI_END_COMMAND,
"status\0", 0x00000814L, MCI_COMMAND_HEAD,
"\0", 0x00000002L, MCI_RETURN,
"notify\0", 0x00000001L, MCI_FLAG,
"wait\0", 0x00000002L, MCI_FLAG,
"\0", 0x00000100L, MCI_CONSTANT,
"position\0", 0x00000002L, MCI_INTEGER,
"length\0", 0x00000001L, MCI_INTEGER,
"number of tracks\0", 0x00000003L, MCI_INTEGER,
"ready\0", 0x00000007L, MCI_INTEGER,
"mode\0", 0x00000004L, MCI_INTEGER,
"time format\0", 0x00000006L, MCI_INTEGER,
"current track\0", 0x00000008L, MCI_INTEGER,
"\0", 0x00000000L, MCI_END_CONSTANT,
"track\0", 0x00000010L, MCI_INTEGER,
"start\0", 0x00000200L, MCI_FLAG,
"\0", 0x00000000L, MCI_END_COMMAND,
"capability\0", 0x0000080bL, MCI_COMMAND_HEAD,
"\0", 0x00000002L, MCI_RETURN,
"notify\0", 0x00000001L, MCI_FLAG,
"wait\0", 0x00000002L, MCI_FLAG,
"\0", 0x00000100L, MCI_CONSTANT,
"can record\0", 0x00000001L, MCI_INTEGER,
"has audio\0", 0x00000002L, MCI_INTEGER,
"has video\0", 0x00000003L, MCI_INTEGER,
"uses files\0", 0x00000005L, MCI_INTEGER,
"compound device\0", 0x00000006L, MCI_INTEGER,
"device type\0", 0x00000004L, MCI_INTEGER,
"can eject\0", 0x00000007L, MCI_INTEGER,
"can play\0", 0x00000008L, MCI_INTEGER,
"can save\0", 0x00000009L, MCI_INTEGER,
"\0", 0x00000000L, MCI_END_CONSTANT,
"\0", 0x00000000L, MCI_END_COMMAND,
"info\0", 0x0000080aL, MCI_COMMAND_HEAD,
"\0", 0x00000001L, MCI_RETURN,
"notify\0", 0x00000001L, MCI_FLAG,
"wait\0", 0x00000002L, MCI_FLAG,
"product\0", 0x00000100L, MCI_FLAG,
"\0", 0x00000000L, MCI_END_COMMAND,
"set\0", 0x0000080dL, MCI_COMMAND_HEAD,
"notify\0", 0x00000001L, MCI_FLAG,
"wait\0", 0x00000002L, MCI_FLAG,
"time format\0", 0x00000400L, MCI_CONSTANT,
"milliseconds\0", 0x00000000L, MCI_INTEGER,
"ms\0", 0x00000000L, MCI_INTEGER,
"\0", 0x00000000L, MCI_END_CONSTANT,
"door open\0", 0x00000100L, MCI_FLAG,
"door closed\0", 0x00000200L, MCI_FLAG,
"audio\0", 0x00000800L, MCI_CONSTANT,
"all\0", 0x00000000L, MCI_INTEGER,
"left\0", 0x00000001L, MCI_INTEGER,
"right\0", 0x00000002L, MCI_INTEGER,
"\0", 0x00000000L, MCI_END_CONSTANT,
"video\0", 0x00001000L, MCI_FLAG,
"on\0", 0x00002000L, MCI_FLAG,
"off\0", 0x00004000L, MCI_FLAG,
"\0", 0x00000000L, MCI_END_COMMAND,
"sysinfo\0", 0x00000810L, MCI_COMMAND_HEAD,
"\0", 0x00000001L, MCI_RETURN,
"notify\0", 0x00000001L, MCI_FLAG,
"wait\0", 0x00000002L, MCI_FLAG,
"quantity\0", 0x00000100L, MCI_FLAG,
"open\0", 0x00000200L, MCI_FLAG,
"installname\0", 0x00000800L, MCI_FLAG,
"name\0", 0x00000400L, MCI_INTEGER,
"\0", 0x00000000L, MCI_END_COMMAND,
"break\0", 0x00000811L, MCI_COMMAND_HEAD,
"notify\0", 0x00000001L, MCI_FLAG,
"wait\0", 0x00000002L, MCI_FLAG,
"on\0", 0x00000100L, MCI_INTEGER,
"off\0", 0x00000400L, MCI_FLAG,
"\0", 0x00000000L, MCI_END_COMMAND,
"sound\0", 0x00000812L, MCI_COMMAND_HEAD,
"notify\0", 0x00000001L, MCI_FLAG,
"wait\0", 0x00000002L, MCI_FLAG,
"\0", 0x00000000L, MCI_END_COMMAND,
"save\0", 0x00000813L, MCI_COMMAND_HEAD,
"notify\0", 0x00000001L, MCI_FLAG,
"wait\0", 0x00000002L, MCI_FLAG,
"\0", 0x00000100L, MCI_STRING,
"\0", 0x00000000L, MCI_END_COMMAND,
"load\0", 0x00000850L, MCI_COMMAND_HEAD,
"notify\0", 0x00000001L, MCI_FLAG,
"wait\0", 0x00000002L, MCI_FLAG,
"\0", 0x00000100L, MCI_STRING,
"\0", 0x00000000L, MCI_END_COMMAND,
"resume\0", 0x00000855L, MCI_COMMAND_HEAD,
"notify\0", 0x00000001L, MCI_FLAG,
"wait\0", 0x00000002L, MCI_FLAG,
"\0", 0x00000000L, MCI_END_COMMAND,
"\0", 0x00000000L, MCI_END_COMMAND_LIST
END
VIDEODISC RCDATA
BEGIN
"play\0", 0x00000806L, MCI_COMMAND_HEAD,
"notify\0", 0x00000001L, MCI_FLAG,
"wait\0", 0x00000002L, MCI_FLAG,
"from\0", 0x00000004L, MCI_INTEGER,
"to\0", 0x00000008L, MCI_INTEGER,
"fast\0", 0x00020000L, MCI_FLAG,
"slow\0", 0x00100000L, MCI_FLAG,
"speed\0", 0x00040000L, MCI_INTEGER,
"reverse\0", 0x00010000L, MCI_FLAG,
"scan\0", 0x00080000L, MCI_FLAG,
"\0", 0x00000000L, MCI_END_COMMAND,
"seek\0", 0x00000807L, MCI_COMMAND_HEAD,
"notify\0", 0x00000001L, MCI_FLAG,
"wait\0", 0x00000002L, MCI_FLAG,
"reverse\0", 0x00010000L, MCI_FLAG,
"to start\0", 0x00000100L, MCI_FLAG,
"to end\0", 0x00000200L, MCI_FLAG,
"to\0", 0x00000008L, MCI_INTEGER,
"\0", 0x00000000L, MCI_END_COMMAND,
"spin\0", 0x0000080cL, MCI_COMMAND_HEAD,
"notify\0", 0x00000001L, MCI_FLAG,
"wait\0", 0x00000002L, MCI_FLAG,
"up\0", 0x00010000L, MCI_FLAG,
"down\0", 0x00020000L, MCI_FLAG,
"\0", 0x00000000L, MCI_END_COMMAND,
"step\0", 0x0000080eL, MCI_COMMAND_HEAD,
"notify\0", 0x00000001L, MCI_FLAG,
"wait\0", 0x00000002L, MCI_FLAG,
"reverse\0", 0x00020000L, MCI_FLAG,
"by\0", 0x00010000L, MCI_INTEGER,
"\0", 0x00000000L, MCI_END_COMMAND,
"set\0", 0x0000080dL, MCI_COMMAND_HEAD,
"notify\0", 0x00000001L, MCI_FLAG,
"wait\0", 0x00000002L, MCI_FLAG,
"time format\0", 0x00000400L, MCI_CONSTANT,
"milliseconds\0", 0x00000000L, MCI_INTEGER,
"ms\0", 0x00000000L, MCI_INTEGER,
"frames\0", 0x00000003L, MCI_INTEGER,
"hms\0", 0x00000001L, MCI_INTEGER,
"track\0", 0x00004001L, MCI_INTEGER,
"\0", 0x00000000L, MCI_END_CONSTANT,
"door open\0", 0x00000100L, MCI_FLAG,
"door closed\0", 0x00000200L, MCI_FLAG,
"audio\0", 0x00000800L, MCI_CONSTANT,
"all\0", 0x00000000L, MCI_INTEGER,
"left\0", 0x00000001L, MCI_INTEGER,
"right\0", 0x00000002L, MCI_INTEGER,
"\0", 0x00000000L, MCI_END_CONSTANT,
"video\0", 0x00001000L, MCI_FLAG,
"on\0", 0x00002000L, MCI_FLAG,
"off\0", 0x00004000L, MCI_FLAG,
"\0", 0x00000000L, MCI_END_COMMAND,
"status\0", 0x00000814L, MCI_COMMAND_HEAD,
"\0", 0x00000002L, MCI_RETURN,
"notify\0", 0x00000001L, MCI_FLAG,
"wait\0", 0x00000002L, MCI_FLAG,
"\0", 0x00000100L, MCI_CONSTANT,
"position\0", 0x00000002L, MCI_INTEGER,
"length\0", 0x00000001L, MCI_INTEGER,
"number of tracks\0", 0x00000003L, MCI_INTEGER,
"mode\0", 0x00000004L, MCI_INTEGER,
"media present\0", 0x00000005L, MCI_INTEGER,
"speed\0", 0x00004002L, MCI_INTEGER,
"forward\0", 0x00004003L, MCI_INTEGER,
"media type\0", 0x00004004L, MCI_INTEGER,
"ready\0", 0x00000007L, MCI_INTEGER,
"side\0", 0x00004005L, MCI_INTEGER,
"disc size\0", 0x00004006L, MCI_INTEGER,
"time format\0", 0x00000006L, MCI_INTEGER,
"current track\0", 0x00000008L, MCI_INTEGER,
"\0", 0x00000000L, MCI_END_CONSTANT,
"track\0", 0x00000010L, MCI_INTEGER,
"start\0", 0x00000200L, MCI_FLAG,
"\0", 0x00000000L, MCI_END_COMMAND,
"capability\0", 0x0000080bL, MCI_COMMAND_HEAD,
"\0", 0x00000002L, MCI_RETURN,
"notify\0", 0x00000001L, MCI_FLAG,
"wait\0", 0x00000002L, MCI_FLAG,
"clv\0", 0x00010000L, MCI_FLAG,
"cav\0", 0x00020000L, MCI_FLAG,
"\0", 0x00000100L, MCI_CONSTANT,
"can record\0", 0x00000001L, MCI_INTEGER,
"has audio\0", 0x00000002L, MCI_INTEGER,
"has video\0", 0x00000003L, MCI_INTEGER,
"device type\0", 0x00000004L, MCI_INTEGER,
"uses files\0", 0x00000005L, MCI_INTEGER,
"compound device\0", 0x00000006L, MCI_INTEGER,
"can eject\0", 0x00000007L, MCI_INTEGER,
"can reverse\0", 0x00004002L, MCI_INTEGER,
"can play\0", 0x00000008L, MCI_INTEGER,
"can save\0", 0x00000009L, MCI_INTEGER,
"fast play rate\0", 0x00004003L, MCI_INTEGER,
"slow play rate\0", 0x00004004L, MCI_INTEGER,
"normal play rate\0", 0x00004005L, MCI_INTEGER,
"\0", 0x00000000L, MCI_END_CONSTANT,
"\0", 0x00000000L, MCI_END_COMMAND,
"escape\0", 0x00000805L, MCI_COMMAND_HEAD,
"notify\0", 0x00000001L, MCI_FLAG,
"wait\0", 0x00000002L, MCI_FLAG,
"\0", 0x00000100L, MCI_STRING,
"\0", 0x00000000L, MCI_END_COMMAND,
"info\0", 0x0000080aL, MCI_COMMAND_HEAD,
"\0", 0x00000001L, MCI_RETURN,
"notify\0", 0x00000001L, MCI_FLAG,
"wait\0", 0x00000002L, MCI_FLAG,
"product\0", 0x00000100L, MCI_FLAG,
"identity\0", 0x00000800L, MCI_FLAG,
"\0", 0x00000000L, MCI_END_COMMAND,
"\0", 0x00000000L, MCI_END_COMMAND_LIST
END
WAVEAUDIO RCDATA
BEGIN
"open\0", 0x00000803L, MCI_COMMAND_HEAD,
"\0", 0x00000002L, MCI_RETURN,
"notify\0", 0x00000001L, MCI_FLAG,
"wait\0", 0x00000002L, MCI_FLAG,
"type\0", 0x00002000L, MCI_STRING,
"element\0", 0x00000200L, MCI_STRING,
"alias\0", 0x00000400L, MCI_STRING,
"shareable\0", 0x00000100L, MCI_FLAG,
"buffer\0", 0x00010000L, MCI_INTEGER,
"\0", 0x00000000L, MCI_END_COMMAND,
"status\0", 0x00000814L, MCI_COMMAND_HEAD,
"\0", 0x00000002L, MCI_RETURN,
"notify\0", 0x00000001L, MCI_FLAG,
"wait\0", 0x00000002L, MCI_FLAG,
"\0", 0x00000100L, MCI_CONSTANT,
"position\0", 0x00000002L, MCI_INTEGER,
"length\0", 0x00000001L, MCI_INTEGER,
"number of tracks\0", 0x00000003L, MCI_INTEGER,
"media present\0", 0x00000005L, MCI_INTEGER,
"mode\0", 0x00000004L, MCI_INTEGER,
"format tag\0", 0x00004001L, MCI_INTEGER,
"channels\0", 0x00004002L, MCI_INTEGER,
"samplespersec\0", 0x00004003L, MCI_INTEGER,
"bytespersec\0", 0x00004004L, MCI_INTEGER,
"alignment\0", 0x00004005L, MCI_INTEGER,
"bitspersample\0", 0x00004006L, MCI_INTEGER,
"input\0", 0x00400000L, MCI_INTEGER,
"output\0", 0x00800000L, MCI_INTEGER,
"level\0", 0x00004007L, MCI_INTEGER,
"ready\0", 0x00000007L, MCI_INTEGER,
"time format\0", 0x00000006L, MCI_INTEGER,
"current track\0", 0x00000008L, MCI_INTEGER,
"\0", 0x00000000L, MCI_END_CONSTANT,
"track\0", 0x00000010L, MCI_INTEGER,
"start\0", 0x00000200L, MCI_FLAG,
"\0", 0x00000000L, MCI_END_COMMAND,
"set\0", 0x0000080dL, MCI_COMMAND_HEAD,
"notify\0", 0x00000001L, MCI_FLAG,
"wait\0", 0x00000002L, MCI_FLAG,
"any input\0", 0x04000000L, MCI_FLAG,
"any output\0", 0x08000000L, MCI_FLAG,
"time format\0", 0x00000400L, MCI_CONSTANT,
"milliseconds\0", 0x00000000L, MCI_INTEGER,
"ms\0", 0x00000000L, MCI_INTEGER,
"bytes\0", 0x00000008L, MCI_INTEGER,
"samples\0", 0x00000009L, MCI_INTEGER,
"\0", 0x00000000L, MCI_END_CONSTANT,
"audio\0", 0x00000800L, MCI_CONSTANT,
"all\0", 0x00000000L, MCI_INTEGER,
"left\0", 0x00000001L, MCI_INTEGER,
"right\0", 0x00000002L, MCI_INTEGER,
"\0", 0x00000000L, MCI_END_CONSTANT,
"video\0", 0x00001000L, MCI_FLAG,
"on\0", 0x00002000L, MCI_FLAG,
"off\0", 0x00004000L, MCI_FLAG,
"door open\0", 0x00000100L, MCI_FLAG,
"door closed\0", 0x00000200L, MCI_FLAG,
"input\0", 0x00400000L, MCI_INTEGER,
"output\0", 0x00800000L, MCI_INTEGER,
"format tag\0", 0x00010000L, MCI_CONSTANT,
"pcm\0", 0x00000001L, MCI_INTEGER,
"\0", 0x00000000L, MCI_END_CONSTANT,
"channels\0", 0x00020000L, MCI_INTEGER,
"samplespersec\0", 0x00040000L, MCI_INTEGER,
"bytespersec\0", 0x00080000L, MCI_INTEGER,
"alignment\0", 0x00100000L, MCI_INTEGER,
"bitspersample\0", 0x00200000L, MCI_INTEGER,
"\0", 0x00000000L, MCI_END_COMMAND,
"capability\0", 0x0000080bL, MCI_COMMAND_HEAD,
"\0", 0x00000002L, MCI_RETURN,
"notify\0", 0x00000001L, MCI_FLAG,
"wait\0", 0x00000002L, MCI_FLAG,
"\0", 0x00000100L, MCI_CONSTANT,
"can record\0", 0x00000001L, MCI_INTEGER,
"has audio\0", 0x00000002L, MCI_INTEGER,
"has video\0", 0x00000003L, MCI_INTEGER,
"device type\0", 0x00000004L, MCI_INTEGER,
"uses files\0", 0x00000005L, MCI_INTEGER,
"compound device\0", 0x00000006L, MCI_INTEGER,
"can eject\0", 0x00000007L, MCI_INTEGER,
"can play\0", 0x00000008L, MCI_INTEGER,
"can save\0", 0x00000009L, MCI_INTEGER,
"inputs\0", 0x00004001L, MCI_INTEGER,
"outputs\0", 0x00004002L, MCI_INTEGER,
"\0", 0x00000000L, MCI_END_CONSTANT,
"\0", 0x00000000L, MCI_END_COMMAND,
"info\0", 0x0000080aL, MCI_COMMAND_HEAD,
"\0", 0x00000001L, MCI_RETURN,
"notify\0", 0x00000001L, MCI_FLAG,
"wait\0", 0x00000002L, MCI_FLAG,
"product\0", 0x00000100L, MCI_FLAG,
"input\0", 0x00400000L, MCI_FLAG,
"output\0", 0x00800000L, MCI_FLAG,
"file\0", 0x00000200L, MCI_FLAG,
"\0", 0x00000000L, MCI_END_COMMAND,
"cue\0", 0x00000830L, MCI_COMMAND_HEAD,
"notify\0", 0x00000001L, MCI_FLAG,
"wait\0", 0x00000002L, MCI_FLAG,
"input\0", 0x00400000L, MCI_FLAG,
"output\0", 0x00800000L, MCI_FLAG,
"\0", 0x00000000L, MCI_END_COMMAND,
"delete\0", 0x00000856L, MCI_COMMAND_HEAD,
"notify\0", 0x00000001L, MCI_FLAG,
"wait\0", 0x00000002L, MCI_FLAG,
"from\0", 0x00000004L, MCI_INTEGER,
"to\0", 0x00000008L, MCI_INTEGER,
"\0", 0x00000000L, MCI_END_COMMAND,
"\0", 0x00000000L, MCI_END_COMMAND_LIST
END
CDAUDIO RCDATA
BEGIN
"status\0", 0x00000814L, MCI_COMMAND_HEAD,
"\0", 0x00000002L, MCI_RETURN,
"notify\0", 0x00000001L, MCI_FLAG,
"wait\0", 0x00000002L, MCI_FLAG,
"\0", 0x00000100L, MCI_CONSTANT,
"position\0", 0x00000002L, MCI_INTEGER,
"length\0", 0x00000001L, MCI_INTEGER,
"number of tracks\0", 0x00000003L, MCI_INTEGER,
"ready\0", 0x00000007L, MCI_INTEGER,
"mode\0", 0x00000004L, MCI_INTEGER,
"media present\0", 0x00000005L, MCI_INTEGER,
"time format\0", 0x00000006L, MCI_INTEGER,
"current track\0", 0x00000008L, MCI_INTEGER,
"type\0", 0x00004001L, MCI_INTEGER,
"\0", 0x00000000L, MCI_END_CONSTANT,
"track\0", 0x00000010L, MCI_INTEGER,
"start\0", 0x00000200L, MCI_FLAG,
"\0", 0x00000000L, MCI_END_COMMAND,
"set\0", 0x0000080dL, MCI_COMMAND_HEAD,
"notify\0", 0x00000001L, MCI_FLAG,
"wait\0", 0x00000002L, MCI_FLAG,
"time format\0", 0x00000400L, MCI_CONSTANT,
"msf\0", 0x00000002L, MCI_INTEGER,
"tmsf\0", 0x0000000aL, MCI_INTEGER,
"milliseconds\0", 0x00000000L, MCI_INTEGER,
"ms\0", 0x00000000L, MCI_INTEGER,
"\0", 0x00000000L, MCI_END_CONSTANT,
"audio\0", 0x00000800L, MCI_CONSTANT,
"all\0", 0x00000000L, MCI_INTEGER,
"left\0", 0x00000001L, MCI_INTEGER,
"right\0", 0x00000002L, MCI_INTEGER,
"\0", 0x00000000L, MCI_END_CONSTANT,
"video\0", 0x00001000L, MCI_FLAG,
"on\0", 0x00002000L, MCI_FLAG,
"off\0", 0x00004000L, MCI_FLAG,
"door open\0", 0x00000100L, MCI_FLAG,
"door closed\0", 0x00000200L, MCI_FLAG,
"\0", 0x00000000L, MCI_END_COMMAND,
"info\0", 0x0000080aL, MCI_COMMAND_HEAD,
"\0", 0x00000001L, MCI_RETURN,
"notify\0", 0x00000001L, MCI_FLAG,
"wait\0", 0x00000002L, MCI_FLAG,
"product\0", 0x00000100L, MCI_FLAG,
"upc\0", 0x00000400L, MCI_FLAG,
"identity\0", 0x00000800L, MCI_FLAG,
"\0", 0x00000000L, MCI_END_COMMAND,
"\0", 0x00000000L, MCI_END_COMMAND_LIST
END
SEQUENCER RCDATA
BEGIN
"status\0", 0x00000814L, MCI_COMMAND_HEAD,
"\0", 0x00000002L, MCI_RETURN,
"notify\0", 0x00000001L, MCI_FLAG,
"wait\0", 0x00000002L, MCI_FLAG,
"\0", 0x00000100L, MCI_CONSTANT,
"position\0", 0x00000002L, MCI_INTEGER,
"mode\0", 0x00000004L, MCI_INTEGER,
"length\0", 0x00000001L, MCI_INTEGER,
"number of tracks\0", 0x00000003L, MCI_INTEGER,
"media present\0", 0x00000005L, MCI_INTEGER,
"ready\0", 0x00000007L, MCI_INTEGER,
"tempo\0", 0x00004002L, MCI_INTEGER,
"port\0", 0x00004003L, MCI_INTEGER,
"slave\0", 0x00004007L, MCI_INTEGER,
"master\0", 0x00004008L, MCI_INTEGER,
"offset\0", 0x00004009L, MCI_INTEGER,
"division type\0", 0x0000400aL, MCI_INTEGER,
"time format\0", 0x00000006L, MCI_INTEGER,
"current track\0", 0x00000008L, MCI_INTEGER,
"\0", 0x00000000L, MCI_END_CONSTANT,
"track\0", 0x00000010L, MCI_INTEGER,
"start\0", 0x00000200L, MCI_FLAG,
"\0", 0x00000000L, MCI_END_COMMAND,
"set\0", 0x0000080dL, MCI_COMMAND_HEAD,
"notify\0", 0x00000001L, MCI_FLAG,
"wait\0", 0x00000002L, MCI_FLAG,
"time format\0", 0x00000400L, MCI_CONSTANT,
"milliseconds\0", 0x00000000L, MCI_INTEGER,
"ms\0", 0x00000000L, MCI_INTEGER,
"smpte 30 drop\0", 0x00000007L, MCI_INTEGER,
"smpte 30\0", 0x00000006L, MCI_INTEGER,
"smpte 25\0", 0x00000005L, MCI_INTEGER,
"smpte 24\0", 0x00000004L, MCI_INTEGER,
"song pointer\0", 0x00004001L, MCI_INTEGER,
"\0", 0x00000000L, MCI_END_CONSTANT,
"audio\0", 0x00000800L, MCI_CONSTANT,
"all\0", 0x00000000L, MCI_INTEGER,
"left\0", 0x00000001L, MCI_INTEGER,
"right\0", 0x00000002L, MCI_INTEGER,
"\0", 0x00000000L, MCI_END_CONSTANT,
"video\0", 0x00001000L, MCI_FLAG,
"on\0", 0x00002000L, MCI_FLAG,
"off\0", 0x00004000L, MCI_FLAG,
"tempo\0", 0x00010000L, MCI_INTEGER,
"port\0", 0x00020000L, MCI_CONSTANT,
"none\0", 0x0000fffdL, MCI_INTEGER,
"mapper\0", 0x0000ffffL, MCI_INTEGER,
"\0", 0x00000000L, MCI_END_CONSTANT,
"slave\0", 0x00040000L, MCI_CONSTANT,
"smpte\0", 0x00004004L, MCI_INTEGER,
"midi\0", 0x00004003L, MCI_INTEGER,
"none\0", 0x0000fffdL, MCI_INTEGER,
"file\0", 0x00004002L, MCI_INTEGER,
"\0", 0x00000000L, MCI_END_CONSTANT,
"master\0", 0x00080000L, MCI_CONSTANT,
"smpte\0", 0x00004004L, MCI_INTEGER,
"midi\0", 0x00004003L, MCI_INTEGER,
"none\0", 0x0000fffdL, MCI_INTEGER,
"\0", 0x00000000L, MCI_END_CONSTANT,
"offset\0", 0x01000000L, MCI_INTEGER,
"door open\0", 0x00000100L, MCI_FLAG,
"door closed\0", 0x00000200L, MCI_FLAG,
"\0", 0x00000000L, MCI_END_COMMAND,
"info\0", 0x0000080aL, MCI_COMMAND_HEAD,
"\0", 0x00000001L, MCI_RETURN,
"notify\0", 0x00000001L, MCI_FLAG,
"wait\0", 0x00000002L, MCI_FLAG,
"product\0", 0x00000100L, MCI_FLAG,
"file\0", 0x00000200L, MCI_FLAG,
"name\0", 0x00001000L, MCI_FLAG,
"copyright\0", 0x00002000L, MCI_FLAG,
"\0", 0x00000000L, MCI_END_COMMAND,
"\0", 0x00000000L, MCI_END_COMMAND_LIST
END
ANIMATION RCDATA
BEGIN
"open\0", 0x00000803L, MCI_COMMAND_HEAD,
"\0", 0x00000002L, MCI_RETURN,
"notify\0", 0x00000001L, MCI_FLAG,
"wait\0", 0x00000002L, MCI_FLAG,
"type\0", 0x00002000L, MCI_STRING,
"element\0", 0x00000200L, MCI_STRING,
"alias\0", 0x00000400L, MCI_STRING,
"shareable\0", 0x00000100L, MCI_FLAG,
"style\0", 0x00010000L, MCI_CONSTANT,
"overlapped\0", 0x00cf0000L, MCI_INTEGER,
"popup\0", 0x80880000L, MCI_INTEGER,
"child\0", 0x40000000L, MCI_INTEGER,
"\0", 0x00000000L, MCI_END_CONSTANT,
"parent\0", 0x00020000L, MCI_INTEGER,
"nostatic\0", 0x00040000L, MCI_FLAG,
"\0", 0x00000000L, MCI_END_COMMAND,
"play\0", 0x00000806L, MCI_COMMAND_HEAD,
"notify\0", 0x00000001L, MCI_FLAG,
"wait\0", 0x00000002L, MCI_FLAG,
"from\0", 0x00000004L, MCI_INTEGER,
"to\0", 0x00000008L, MCI_INTEGER,
"fast\0", 0x00040000L, MCI_FLAG,
"slow\0", 0x00080000L, MCI_FLAG,
"scan\0", 0x00100000L, MCI_FLAG,
"reverse\0", 0x00020000L, MCI_FLAG,
"speed\0", 0x00010000L, MCI_INTEGER,
"\0", 0x00000000L, MCI_END_COMMAND,
"step\0", 0x0000080eL, MCI_COMMAND_HEAD,
"notify\0", 0x00000001L, MCI_FLAG,
"wait\0", 0x00000002L, MCI_FLAG,
"reverse\0", 0x00010000L, MCI_FLAG,
"by\0", 0x00020000L, MCI_INTEGER,
"\0", 0x00000000L, MCI_END_COMMAND,
"set\0", 0x0000080dL, MCI_COMMAND_HEAD,
"notify\0", 0x00000001L, MCI_FLAG,
"wait\0", 0x00000002L, MCI_FLAG,
"time format\0", 0x00000400L, MCI_CONSTANT,
"milliseconds\0", 0x00000000L, MCI_INTEGER,
"ms\0", 0x00000000L, MCI_INTEGER,
"frames\0", 0x00000003L, MCI_INTEGER,
"\0", 0x00000000L, MCI_END_CONSTANT,
"audio\0", 0x00000800L, MCI_CONSTANT,
"all\0", 0x00000000L, MCI_INTEGER,
"left\0", 0x00000001L, MCI_INTEGER,
"right\0", 0x00000002L, MCI_INTEGER,
"\0", 0x00000000L, MCI_END_CONSTANT,
"video\0", 0x00001000L, MCI_FLAG,
"on\0", 0x00002000L, MCI_FLAG,
"off\0", 0x00004000L, MCI_FLAG,
"door open\0", 0x00000100L, MCI_FLAG,
"door closed\0", 0x00000200L, MCI_FLAG,
"\0", 0x00000000L, MCI_END_COMMAND,
"status\0", 0x00000814L, MCI_COMMAND_HEAD,
"\0", 0x00000002L, MCI_RETURN,
"notify\0", 0x00000001L, MCI_FLAG,
"wait\0", 0x00000002L, MCI_FLAG,
"\0", 0x00000100L, MCI_CONSTANT,
"position\0", 0x00000002L, MCI_INTEGER,
"length\0", 0x00000001L, MCI_INTEGER,
"number of tracks\0", 0x00000003L, MCI_INTEGER,
"mode\0", 0x00000004L, MCI_INTEGER,
"ready\0", 0x00000007L, MCI_INTEGER,
"speed\0", 0x00004001L, MCI_INTEGER,
"forward\0", 0x00004002L, MCI_INTEGER,
"window handle\0", 0x00004003L, MCI_INTEGER,
"palette handle\0", 0x00004004L, MCI_INTEGER,
"media present\0", 0x00000005L, MCI_INTEGER,
"time format\0", 0x00000006L, MCI_INTEGER,
"current track\0", 0x00000008L, MCI_INTEGER,
"stretch\0", 0x00004005L, MCI_INTEGER,
"\0", 0x00000000L, MCI_END_CONSTANT,
"track\0", 0x00000010L, MCI_INTEGER,
"start\0", 0x00000200L, MCI_FLAG,
"\0", 0x00000000L, MCI_END_COMMAND,
"info\0", 0x0000080aL, MCI_COMMAND_HEAD,
"\0", 0x00000001L, MCI_RETURN,
"notify\0", 0x00000001L, MCI_FLAG,
"wait\0", 0x00000002L, MCI_FLAG,
"product\0", 0x00000100L, MCI_FLAG,
"file\0", 0x00000200L, MCI_FLAG,
"window text\0", 0x00010000L, MCI_FLAG,
"\0", 0x00000000L, MCI_END_COMMAND,
"capability\0", 0x0000080bL, MCI_COMMAND_HEAD,
"\0", 0x00000002L, MCI_RETURN,
"notify\0", 0x00000001L, MCI_FLAG,
"wait\0", 0x00000002L, MCI_FLAG,
"\0", 0x00000100L, MCI_CONSTANT,
"can record\0", 0x00000001L, MCI_INTEGER,
"has audio\0", 0x00000002L, MCI_INTEGER,
"has video\0", 0x00000003L, MCI_INTEGER,
"device type\0", 0x00000004L, MCI_INTEGER,
"uses files\0", 0x00000005L, MCI_INTEGER,
"compound device\0", 0x00000006L, MCI_INTEGER,
"can eject\0", 0x00000007L, MCI_INTEGER,
"can play\0", 0x00000008L, MCI_INTEGER,
"can save\0", 0x00000009L, MCI_INTEGER,
"can reverse\0", 0x00004001L, MCI_INTEGER,
"fast play rate\0", 0x00004002L, MCI_INTEGER,
"slow play rate\0", 0x00004003L, MCI_INTEGER,
"normal play rate\0", 0x00004004L, MCI_INTEGER,
"uses palettes\0", 0x00004006L, MCI_INTEGER,
"can stretch\0", 0x00004007L, MCI_INTEGER,
"windows\0", 0x00004008L, MCI_INTEGER,
"\0", 0x00000000L, MCI_END_CONSTANT,
"\0", 0x00000000L, MCI_END_COMMAND,
"realize\0", 0x00000840L, MCI_COMMAND_HEAD,
"notify\0", 0x00000001L, MCI_FLAG,
"wait\0", 0x00000002L, MCI_FLAG,
"normal\0", 0x00010000L, MCI_FLAG,
"background\0", 0x00020000L, MCI_FLAG,
"\0", 0x00000000L, MCI_END_COMMAND,
"window\0", 0x00000841L, MCI_COMMAND_HEAD,
"notify\0", 0x00000001L, MCI_FLAG,
"wait\0", 0x00000002L, MCI_FLAG,
"handle\0", 0x00010000L, MCI_CONSTANT,
"default\0", 0x00000000L, MCI_INTEGER,
"\0", 0x00000000L, MCI_END_CONSTANT,
"state\0", 0x00040000L, MCI_CONSTANT,
"hide\0", 0x00000000L, MCI_INTEGER,
"minimize\0", 0x00000006L, MCI_INTEGER,
"show\0", 0x00000005L, MCI_INTEGER,
"maximized\0", 0x00000003L, MCI_INTEGER,
"minimized\0", 0x00000002L, MCI_INTEGER,
"iconic\0", 0x00000007L, MCI_INTEGER,
"no action\0", 0x00000008L, MCI_INTEGER,
"no activate\0", 0x00000004L, MCI_INTEGER,
"normal\0", 0x00000001L, MCI_INTEGER,
"\0", 0x00000000L, MCI_END_CONSTANT,
"text\0", 0x00080000L, MCI_STRING,
"stretch\0", 0x00100000L, MCI_FLAG,
"fixed\0", 0x00200000L, MCI_FLAG,
"\0", 0x00000000L, MCI_END_COMMAND,
"put\0", 0x00000842L, MCI_COMMAND_HEAD,
"notify\0", 0x00000001L, MCI_FLAG,
"wait\0", 0x00000002L, MCI_FLAG,
"at\0", 0x00010000L, MCI_RECT,
"source\0", 0x00020000L, MCI_FLAG,
"destination\0", 0x00040000L, MCI_FLAG,
"\0", 0x00000000L, MCI_END_COMMAND,
"where\0", 0x00000843L, MCI_COMMAND_HEAD,
"\0", 0x00000007L, MCI_RETURN,
"notify\0", 0x00000001L, MCI_FLAG,
"wait\0", 0x00000002L, MCI_FLAG,
"source\0", 0x00020000L, MCI_FLAG,
"destination\0", 0x00040000L, MCI_FLAG,
"\0", 0x00000000L, MCI_END_COMMAND,
"update\0", 0x00000854L, MCI_COMMAND_HEAD,
"notify\0", 0x00000001L, MCI_FLAG,
"wait\0", 0x00000002L, MCI_FLAG,
"at\0", 0x00010000L, MCI_RECT,
"hdc\0", 0x00020000L, MCI_INTEGER,
"\0", 0x00000000L, MCI_END_COMMAND,
"\0", 0x00000000L, MCI_END_COMMAND_LIST
END
OVERLAY RCDATA
BEGIN
"open\0", 0x00000803L, MCI_COMMAND_HEAD,
"\0", 0x00000002L, MCI_RETURN,
"notify\0", 0x00000001L, MCI_FLAG,
"wait\0", 0x00000002L, MCI_FLAG,
"type\0", 0x00002000L, MCI_STRING,
"element\0", 0x00000200L, MCI_STRING,
"alias\0", 0x00000400L, MCI_STRING,
"shareable\0", 0x00000100L, MCI_FLAG,
"style\0", 0x00010000L, MCI_CONSTANT,
"overlapped\0", 0x00cf0000L, MCI_INTEGER,
"popup\0", 0x80880000L, MCI_INTEGER,
"child\0", 0x40000000L, MCI_INTEGER,
"\0", 0x00000000L, MCI_END_CONSTANT,
"parent\0", 0x00020000L, MCI_INTEGER,
"\0", 0x00000000L, MCI_END_COMMAND,
"status\0", 0x00000814L, MCI_COMMAND_HEAD,
"\0", 0x00000002L, MCI_RETURN,
"notify\0", 0x00000001L, MCI_FLAG,
"wait\0", 0x00000002L, MCI_FLAG,
"\0", 0x00000100L, MCI_CONSTANT,
"position\0", 0x00000002L, MCI_INTEGER,
"length\0", 0x00000001L, MCI_INTEGER,
"number of tracks\0", 0x00000003L, MCI_INTEGER,
"mode\0", 0x00000004L, MCI_INTEGER,
"ready\0", 0x00000007L, MCI_INTEGER,
"window handle\0", 0x00004001L, MCI_INTEGER,
"media present\0", 0x00000005L, MCI_INTEGER,
"stretch\0", 0x00004002L, MCI_INTEGER,
"\0", 0x00000000L, MCI_END_CONSTANT,
"track\0", 0x00000010L, MCI_INTEGER,
"start\0", 0x00000200L, MCI_FLAG,
"\0", 0x00000000L, MCI_END_COMMAND,
"info\0", 0x0000080aL, MCI_COMMAND_HEAD,
"\0", 0x00000001L, MCI_RETURN,
"notify\0", 0x00000001L, MCI_FLAG,
"wait\0", 0x00000002L, MCI_FLAG,
"product\0", 0x00000100L, MCI_FLAG,
"file\0", 0x00000200L, MCI_FLAG,
"window text\0", 0x00010000L, MCI_FLAG,
"\0", 0x00000000L, MCI_END_COMMAND,
"capability\0", 0x0000080bL, MCI_COMMAND_HEAD,
"\0", 0x00000002L, MCI_RETURN,
"notify\0", 0x00000001L, MCI_FLAG,
"wait\0", 0x00000002L, MCI_FLAG,
"\0", 0x00000100L, MCI_CONSTANT,
"can record\0", 0x00000001L, MCI_INTEGER,
"has audio\0", 0x00000002L, MCI_INTEGER,
"has video\0", 0x00000003L, MCI_INTEGER,
"device type\0", 0x00000004L, MCI_INTEGER,
"uses files\0", 0x00000005L, MCI_INTEGER,
"compound device\0", 0x00000006L, MCI_INTEGER,
"can eject\0", 0x00000007L, MCI_INTEGER,
"can play\0", 0x00000008L, MCI_INTEGER,
"can save\0", 0x00000009L, MCI_INTEGER,
"can stretch\0", 0x00004001L, MCI_INTEGER,
"can freeze\0", 0x00004002L, MCI_INTEGER,
"windows\0", 0x00004003L, MCI_INTEGER,
"\0", 0x00000000L, MCI_END_CONSTANT,
"\0", 0x00000000L, MCI_END_COMMAND,
"window\0", 0x00000841L, MCI_COMMAND_HEAD,
"notify\0", 0x00000001L, MCI_FLAG,
"wait\0", 0x00000002L, MCI_FLAG,
"handle\0", 0x00010000L, MCI_CONSTANT,
"default\0", 0x00000000L, MCI_INTEGER,
"\0", 0x00000000L, MCI_END_CONSTANT,
"state\0", 0x00040000L, MCI_CONSTANT,
"hide\0", 0x00000000L, MCI_INTEGER,
"minimize\0", 0x00000006L, MCI_INTEGER,
"show\0", 0x00000005L, MCI_INTEGER,
"maximized\0", 0x00000003L, MCI_INTEGER,
"minimized\0", 0x00000002L, MCI_INTEGER,
"iconic\0", 0x00000007L, MCI_INTEGER,
"no action\0", 0x00000008L, MCI_INTEGER,
"no activate\0", 0x00000004L, MCI_INTEGER,
"normal\0", 0x00000001L, MCI_INTEGER,
"\0", 0x00000000L, MCI_END_CONSTANT,
"text\0", 0x00080000L, MCI_STRING,
"stretch\0", 0x00100000L, MCI_FLAG,
"fixed\0", 0x00200000L, MCI_FLAG,
"\0", 0x00000000L, MCI_END_COMMAND,
"put\0", 0x00000842L, MCI_COMMAND_HEAD,
"notify\0", 0x00000001L, MCI_FLAG,
"wait\0", 0x00000002L, MCI_FLAG,
"at\0", 0x00010000L, MCI_RECT,
"source\0", 0x00020000L, MCI_FLAG,
"destination\0", 0x00040000L, MCI_FLAG,
"frame\0", 0x00080000L, MCI_FLAG,
"video\0", 0x00100000L, MCI_FLAG,
"\0", 0x00000000L, MCI_END_COMMAND,
"where\0", 0x00000843L, MCI_COMMAND_HEAD,
"\0", 0x00000007L, MCI_RETURN,
"notify\0", 0x00000001L, MCI_FLAG,
"wait\0", 0x00000002L, MCI_FLAG,
"source\0", 0x00020000L, MCI_FLAG,
"destination\0", 0x00040000L, MCI_FLAG,
"frame\0", 0x00080000L, MCI_FLAG,
"video\0", 0x00100000L, MCI_FLAG,
"\0", 0x00000000L, MCI_END_COMMAND,
"save\0", 0x00000813L, MCI_COMMAND_HEAD,
"notify\0", 0x00000001L, MCI_FLAG,
"wait\0", 0x00000002L, MCI_FLAG,
"\0", 0x00000100L, MCI_STRING,
"at\0", 0x00010000L, MCI_RECT,
"\0", 0x00000000L, MCI_END_COMMAND,
"load\0", 0x00000850L, MCI_COMMAND_HEAD,
"notify\0", 0x00000001L, MCI_FLAG,
"wait\0", 0x00000002L, MCI_FLAG,
"\0", 0x00000100L, MCI_STRING,
"at\0", 0x00010000L, MCI_RECT,
"\0", 0x00000000L, MCI_END_COMMAND,
"freeze\0", 0x00000844L, MCI_COMMAND_HEAD,
"notify\0", 0x00000001L, MCI_FLAG,
"wait\0", 0x00000002L, MCI_FLAG,
"at\0", 0x00010000L, MCI_RECT,
"\0", 0x00000000L, MCI_END_COMMAND,
"unfreeze\0", 0x00000845L, MCI_COMMAND_HEAD,
"notify\0", 0x00000001L, MCI_FLAG,
"wait\0", 0x00000002L, MCI_FLAG,
"at\0", 0x00010000L, MCI_RECT,
"\0", 0x00000000L, MCI_END_COMMAND,
"\0", 0x00000000L, MCI_END_COMMAND_LIST
END
STRINGTABLE
BEGIN
MCI_DEVTYPE_VCR, "vcr"
MCI_DEVTYPE_VIDEODISC, "videodisc"
MCI_DEVTYPE_OVERLAY, "overlay"
MCI_DEVTYPE_CD_AUDIO, "cdaudio"
MCI_DEVTYPE_DAT, "dat"
MCI_DEVTYPE_SCANNER, "scanner"
MCI_DEVTYPE_ANIMATION, "animation"
MCI_DEVTYPE_DIGITAL_VIDEO, "digitalvideo"
MCI_DEVTYPE_OTHER, "other"
MCI_DEVTYPE_WAVEFORM_AUDIO, "waveaudio"
MCI_DEVTYPE_SEQUENCER, "sequencer"
MCI_MODE_NOT_READY, "not ready"
MCI_MODE_STOP, "stopped"
MCI_MODE_PLAY, "playing"
MCI_MODE_RECORD, "recording"
MCI_MODE_SEEK, "seeking"
MCI_MODE_PAUSE, "paused"
MCI_MODE_OPEN, "open"
MCI_FALSE, "false"
MCI_TRUE, "true"
MCI_FORMAT_MILLISECONDS_S, "milliseconds"
MCI_FORMAT_HMS_S, "hms"
MCI_FORMAT_MSF_S, "msf"
MCI_FORMAT_FRAMES_S, "frames"
MCI_FORMAT_SMPTE_24_S, "smpte 24"
MCI_FORMAT_SMPTE_25_S, "smpte 25"
MCI_FORMAT_SMPTE_30_S, "smpte 30"
MCI_FORMAT_SMPTE_30DROP_S, "smpte 30 drop"
MCI_FORMAT_BYTES_S, "bytes"
MCI_FORMAT_SAMPLES_S, "samples"
MCI_FORMAT_TMSF_S, "tmsf"
MCI_VD_MODE_PARK, "parked"
MCI_VD_MEDIA_CLV, "CLV"
MCI_VD_MEDIA_CAV, "CAV"
MCI_VD_MEDIA_OTHER "other"
MCI_VD_FORMAT_TRACK_S, "track"
MCI_SEQ_DIV_PPQN, "PPQN"
MCI_SEQ_DIV_SMPTE_24 "SMPTE 24 Frame"
MCI_SEQ_DIV_SMPTE_25 "SMPTE 25 Frame"
MCI_SEQ_DIV_SMPTE_30DROP "SMPTE 30 Drop Frame"
MCI_SEQ_DIV_SMPTE_30 "SMPTE 30 Frame"
MCI_SEQ_FILE_S, "file"
MCI_SEQ_MIDI_S, "midi"
MCI_SEQ_SMPTE_S, "smpte"
MCI_SEQ_FORMAT_SONGPTR_S, "song pointer"
MCI_SEQ_NONE_S, "none"
MCI_SEQ_MAPPER_S, "mapper"
WAVE_FORMAT_PCM_S, "pcm"
WAVE_MAPPER_S, "mapper"
END