HRESULT WINAPI PSPropertyKeyFromString(LPCWSTR pszString, PROPERTYKEY *pkey)
{
BOOL has_minus = FALSE, has_comma = FALSE;
TRACE("(%s, %p)\n", debugstr_w(pszString), pkey);
if (!pszString || !pkey)
return E_POINTER;
memset(pkey, 0, sizeof(PROPERTYKEY));
if (!string_to_guid(pszString, &pkey->fmtid))
return E_INVALIDARG;
pszString += GUIDSTRING_MAX - 1;
if (!*pszString)
return E_INVALIDARG;
/* Only the space seems to be recognized as whitespace. The comma is only
* recognized once and processing terminates if another comma is found. */
while (*pszString == ' ' || *pszString == ',')
{
if (*pszString == ',')
{
if (has_comma)
return S_OK;
else
has_comma = TRUE;
}
pszString++;
}
if (!*pszString)
return E_INVALIDARG;
/* Only two minus signs are recognized if no comma is detected. The first
* sign is ignored, and the second is interpreted. If a comma is detected
* before the minus sign, then only one minus sign counts, and property ID
* interpretation begins with the next character. */
if (has_comma)
{
if (*pszString == '-')
{
has_minus = TRUE;
pszString++;
}
}
else
{
if (*pszString == '-')
pszString++;
/* Skip any intermediate spaces after the first minus sign. */
while (*pszString == ' ')
pszString++;
if (*pszString == '-')
{
has_minus = TRUE;
pszString++;
}
/* Skip any remaining spaces after minus sign. */
while (*pszString == ' ')
pszString++;
}
/* Overflow is not checked. */
while (isdigitW(*pszString))
{
pkey->pid *= 10;
pkey->pid += (*pszString - '0');
pszString++;
}
if (has_minus)
pkey->pid = ~pkey->pid + 1;
return S_OK;
}
/* Module initialization/finalization handlers */
static int __init init(void)
{
int rcVBox;
int rcRet = 0;
int err;
TRACE();
if (sizeof(struct vbsf_mount_info_new) > PAGE_SIZE)
{
printk(KERN_ERR
"Mount information structure is too large %lu\n"
"Must be less than or equal to %lu\n",
(unsigned long)sizeof (struct vbsf_mount_info_new),
(unsigned long)PAGE_SIZE);
return -EINVAL;
}
err = register_filesystem(&vboxsf_fs_type);
if (err)
{
LogFunc(("register_filesystem err=%d\n", err));
return err;
}
rcVBox = VbglR0SfInit();
if (RT_FAILURE(rcVBox))
{
LogRelFunc(("VbglR0SfInit failed, rc=%d\n", rcVBox));
rcRet = -EPROTO;
goto fail0;
}
rcVBox = VbglR0SfConnect(&client_handle);
if (RT_FAILURE(rcVBox))
{
LogRelFunc(("VbglR0SfConnect failed, rc=%d\n", rcVBox));
rcRet = -EPROTO;
goto fail1;
}
rcVBox = VbglR0SfSetUtf8(&client_handle);
if (RT_FAILURE(rcVBox))
{
LogRelFunc(("VbglR0SfSetUtf8 failed, rc=%d\n", rcVBox));
rcRet = -EPROTO;
goto fail2;
}
#if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 0)
if (!follow_symlinks)
{
rcVBox = VbglR0SfSetSymlinks(&client_handle);
if (RT_FAILURE(rcVBox))
{
printk(KERN_WARNING
"vboxsf: Host unable to show symlinks, rc=%d\n",
rcVBox);
}
}
#endif
printk(KERN_DEBUG
"vboxsf: Successfully loaded version " VBOX_VERSION_STRING
" (interface " RT_XSTR(VMMDEV_VERSION) ")\n");
return 0;
fail2:
VbglR0SfDisconnect(&client_handle);
fail1:
VbglR0SfTerm();
fail0:
unregister_filesystem(&vboxsf_fs_type);
return rcRet;
}
static ULONG WINAPI ClassFactory_Release(IClassFactory *iface)
{
TRACE("(%p)\n", iface);
return 1;
}
STATIC void
evalcommand(union node *cmd, int flags, struct backcmd *backcmd)
{
struct stackmark smark;
union node *argp;
struct arglist arglist;
struct arglist varlist;
char **argv;
int argc;
char **envp;
int varflag;
struct strlist *sp;
int mode;
int pip[2];
struct cmdentry cmdentry;
struct job *jp;
struct jmploc jmploc;
struct jmploc *volatile savehandler;
char *volatile savecmdname;
volatile struct shparam saveparam;
struct localvar *volatile savelocalvars;
volatile int e;
char *lastarg;
const char *path = pathval();
volatile int temp_path;
#if __GNUC__
/* Avoid longjmp clobbering */
(void) &argv;
(void) &argc;
(void) &lastarg;
(void) &flags;
#endif
vforked = 0;
/* First expand the arguments. */
TRACE(("evalcommand(0x%lx, %d) called\n", (long)cmd, flags));
setstackmark(&smark);
back_exitstatus = 0;
arglist.lastp = &arglist.list;
varflag = 1;
/* Expand arguments, ignoring the initial 'name=value' ones */
for (argp = cmd->ncmd.args ; argp ; argp = argp->narg.next) {
char *p = argp->narg.text;
if (varflag && is_name(*p)) {
do {
p++;
} while (is_in_name(*p));
if (*p == '=')
continue;
}
expandarg(argp, &arglist, EXP_FULL | EXP_TILDE);
varflag = 0;
}
*arglist.lastp = NULL;
expredir(cmd->ncmd.redirect);
/* Now do the initial 'name=value' ones we skipped above */
varlist.lastp = &varlist.list;
for (argp = cmd->ncmd.args ; argp ; argp = argp->narg.next) {
char *p = argp->narg.text;
if (!is_name(*p))
break;
do
p++;
while (is_in_name(*p));
if (*p != '=')
break;
expandarg(argp, &varlist, EXP_VARTILDE);
}
*varlist.lastp = NULL;
argc = 0;
for (sp = arglist.list ; sp ; sp = sp->next)
argc++;
argv = stalloc(sizeof (char *) * (argc + 1));
for (sp = arglist.list ; sp ; sp = sp->next) {
TRACE(("evalcommand arg: %s\n", sp->text));
*argv++ = sp->text;
}
*argv = NULL;
lastarg = NULL;
if (iflag && funcnest == 0 && argc > 0)
lastarg = argv[-1];
argv -= argc;
/* Print the command if xflag is set. */
if (xflag) {
char sep = 0;
out2str(ps4val());
for (sp = varlist.list ; sp ; sp = sp->next) {
if (sep != 0)
outc(sep, &errout);
out2str(sp->text);
sep = ' ';
}
for (sp = arglist.list ; sp ; sp = sp->next) {
if (sep != 0)
outc(sep, &errout);
out2str(sp->text);
sep = ' ';
}
outc('\n', &errout);
flushout(&errout);
}
/* Now locate the command. */
if (argc == 0) {
cmdentry.cmdtype = CMDSPLBLTIN;
cmdentry.u.bltin = bltincmd;
} else {
static const char PATH[] = "PATH=";
int cmd_flags = DO_ERR;
/*
* Modify the command lookup path, if a PATH= assignment
* is present
*/
for (sp = varlist.list; sp; sp = sp->next)
if (strncmp(sp->text, PATH, sizeof(PATH) - 1) == 0)
path = sp->text + sizeof(PATH) - 1;
do {
int argsused, use_syspath;
find_command(argv[0], &cmdentry, cmd_flags, path);
if (cmdentry.cmdtype == CMDUNKNOWN) {
exitstatus = 127;
flushout(&errout);
goto out;
}
/* implement the 'command' builtin here */
if (cmdentry.cmdtype != CMDBUILTIN ||
cmdentry.u.bltin != bltincmd)
break;
cmd_flags |= DO_NOFUNC;
argsused = parse_command_args(argc, argv, &use_syspath);
if (argsused == 0) {
/* use 'type' builting to display info */
cmdentry.u.bltin = typecmd;
break;
}
argc -= argsused;
argv += argsused;
if (use_syspath)
path = syspath() + 5;
} while (argc != 0);
if (cmdentry.cmdtype == CMDSPLBLTIN && cmd_flags & DO_NOFUNC)
/* posix mandates that 'command <splbltin>' act as if
<splbltin> was a normal builtin */
cmdentry.cmdtype = CMDBUILTIN;
}
/* Fork off a child process if necessary. */
if (cmd->ncmd.backgnd
|| (cmdentry.cmdtype == CMDNORMAL && (flags & EV_EXIT) == 0)
|| ((flags & EV_BACKCMD) != 0
&& ((cmdentry.cmdtype != CMDBUILTIN && cmdentry.cmdtype != CMDSPLBLTIN)
|| cmdentry.u.bltin == dotcmd
|| cmdentry.u.bltin == evalcmd))) {
INTOFF;
jp = makejob(cmd, 1);
mode = cmd->ncmd.backgnd;
if (flags & EV_BACKCMD) {
mode = FORK_NOJOB;
if (sh_pipe(pip) < 0)
error("Pipe call failed");
}
#ifdef DO_SHAREDVFORK
/* It is essential that if DO_SHAREDVFORK is defined that the
* child's address space is actually shared with the parent as
* we rely on this.
*/
if (cmdentry.cmdtype == CMDNORMAL) {
pid_t pid;
savelocalvars = localvars;
localvars = NULL;
vforked = 1;
switch (pid = vfork()) {
case -1:
TRACE(("Vfork failed, errno=%d\n", errno));
INTON;
error("Cannot vfork");
break;
case 0:
/* Make sure that exceptions only unwind to
* after the vfork(2)
*/
if (setjmp(jmploc.loc)) {
if (exception == EXSHELLPROC) {
/* We can't progress with the vfork,
* so, set vforked = 2 so the parent
* knows, and _exit();
*/
vforked = 2;
_exit(0);
} else {
_exit(exerrno);
}
}
savehandler = handler;
handler = &jmploc;
listmklocal(varlist.list, VEXPORT | VNOFUNC);
forkchild(jp, cmd, mode, vforked);
break;
default:
handler = savehandler; /* restore from vfork(2) */
poplocalvars();
localvars = savelocalvars;
if (vforked == 2) {
vforked = 0;
(void)waitpid(pid, NULL, 0);
/* We need to progress in a normal fork fashion */
goto normal_fork;
}
vforked = 0;
forkparent(jp, cmd, mode, pid);
goto parent;
}
} else {
normal_fork:
#endif
if (forkshell(jp, cmd, mode) != 0)
goto parent; /* at end of routine */
FORCEINTON;
#ifdef DO_SHAREDVFORK
}
#endif
if (flags & EV_BACKCMD) {
if (!vforked) {
FORCEINTON;
}
close(pip[0]);
if (pip[1] != 1) {
close(1);
copyfd(pip[1], 1);
close(pip[1]);
}
}
flags |= EV_EXIT;
}
/* This is the child process if a fork occurred. */
/* Execute the command. */
switch (cmdentry.cmdtype) {
case CMDFUNCTION:
#ifdef DEBUG
trputs("Shell function: "); trargs(argv);
#endif
redirect(cmd->ncmd.redirect, REDIR_PUSH);
saveparam = shellparam;
shellparam.malloc = 0;
shellparam.reset = 1;
shellparam.nparam = argc - 1;
shellparam.p = argv + 1;
shellparam.optnext = NULL;
INTOFF;
savelocalvars = localvars;
localvars = NULL;
INTON;
if (setjmp(jmploc.loc)) {
if (exception == EXSHELLPROC) {
freeparam((volatile struct shparam *)
&saveparam);
} else {
freeparam(&shellparam);
shellparam = saveparam;
}
poplocalvars();
localvars = savelocalvars;
handler = savehandler;
longjmp(handler->loc, 1);
}
savehandler = handler;
handler = &jmploc;
listmklocal(varlist.list, 0);
/* stop shell blowing its stack */
if (++funcnest > 1000)
error("too many nested function calls");
evaltree(cmdentry.u.func, flags & EV_TESTED);
funcnest--;
INTOFF;
poplocalvars();
localvars = savelocalvars;
freeparam(&shellparam);
shellparam = saveparam;
handler = savehandler;
popredir();
INTON;
if (evalskip == SKIPFUNC) {
evalskip = 0;
skipcount = 0;
}
if (flags & EV_EXIT)
exitshell(exitstatus);
break;
case CMDBUILTIN:
case CMDSPLBLTIN:
#ifdef DEBUG
trputs("builtin command: "); trargs(argv);
#endif
mode = (cmdentry.u.bltin == execcmd) ? 0 : REDIR_PUSH;
if (flags == EV_BACKCMD) {
memout.nleft = 0;
memout.nextc = memout.buf;
memout.bufsize = 64;
mode |= REDIR_BACKQ;
}
e = -1;
savehandler = handler;
savecmdname = commandname;
handler = &jmploc;
if (!setjmp(jmploc.loc)) {
/* We need to ensure the command hash table isn't
* corruped by temporary PATH assignments.
* However we must ensure the 'local' command works!
*/
if (path != pathval() && (cmdentry.u.bltin == hashcmd ||
cmdentry.u.bltin == typecmd)) {
savelocalvars = localvars;
localvars = 0;
mklocal(path - 5 /* PATH= */, 0);
temp_path = 1;
} else
temp_path = 0;
redirect(cmd->ncmd.redirect, mode);
/* exec is a special builtin, but needs this list... */
cmdenviron = varlist.list;
/* we must check 'readonly' flag for all builtins */
listsetvar(varlist.list,
cmdentry.cmdtype == CMDSPLBLTIN ? 0 : VNOSET);
commandname = argv[0];
/* initialize nextopt */
argptr = argv + 1;
optptr = NULL;
/* and getopt */
#ifndef __linux__
optreset = 1;
#endif
optind = 1;
exitstatus = cmdentry.u.bltin(argc, argv);
} else {
e = exception;
exitstatus = e == EXINT ? SIGINT + 128 :
e == EXEXEC ? exerrno : 2;
}
handler = savehandler;
flushall();
out1 = &output;
out2 = &errout;
freestdout();
if (temp_path) {
poplocalvars();
localvars = savelocalvars;
}
cmdenviron = NULL;
if (e != EXSHELLPROC) {
commandname = savecmdname;
if (flags & EV_EXIT)
exitshell(exitstatus);
}
if (e != -1) {
if ((e != EXERROR && e != EXEXEC)
|| cmdentry.cmdtype == CMDSPLBLTIN)
exraise(e);
FORCEINTON;
}
if (cmdentry.u.bltin != execcmd)
popredir();
if (flags == EV_BACKCMD) {
backcmd->buf = memout.buf;
backcmd->nleft = memout.nextc - memout.buf;
memout.buf = NULL;
}
break;
default:
#ifdef DEBUG
trputs("normal command: "); trargs(argv);
#endif
clearredir(vforked);
redirect(cmd->ncmd.redirect, vforked ? REDIR_VFORK : 0);
if (!vforked)
for (sp = varlist.list ; sp ; sp = sp->next)
setvareq(sp->text, VEXPORT|VSTACK);
envp = environment();
shellexec(argv, envp, path, cmdentry.u.index, vforked);
break;
}
goto out;
parent: /* parent process gets here (if we forked) */
if (mode == FORK_FG) { /* argument to fork */
exitstatus = waitforjob(jp);
} else if (mode == FORK_NOJOB) {
backcmd->fd = pip[0];
close(pip[1]);
backcmd->jp = jp;
}
FORCEINTON;
out:
if (lastarg)
/* dsl: I think this is intended to be used to support
* '_' in 'vi' command mode during line editing...
* However I implemented that within libedit itself.
*/
setvar("_", lastarg, 0);
popstackmark(&smark);
if (eflag && exitstatus && !(flags & EV_TESTED))
exitshell(exitstatus);
}
static HRESULT WINAPI ClassFactory_LockServer(IClassFactory *iface, BOOL fLock)
{
TRACE("(%p)->(%x)\n", iface, fLock);
return S_OK;
}
static PWINE_ACMSTREAM ACM_GetStream(HACMSTREAM has)
{
TRACE("(%p)\n", has);
return (PWINE_ACMSTREAM)has;
}
bool CHotlineIcon::LoadItem( CFile* pFile )
{
if ( m_pIconData )
// Déjà chargée
return true;
if ( 0 == m_iFileOffset )
// Offset 0 -> erreur
return false;
TRY
{
int y;
struct {
char awpx[4];
unsigned __int16 iVersion;
unsigned __int16 iPad2;
unsigned __int32 iPad1;
unsigned __int32 iOne;
unsigned __int32 iRealWidth;
unsigned __int32 iHeight;
unsigned __int32 iWidthBytes;
unsigned __int32 iB, iC, iD, iDataSize;
unsigned char iRTrans, iGTrans, iBTrans, iATrans;
unsigned __int32 iNumColors;
unsigned __int32 iZero;
unsigned char iNumBits, iF, iG, iH;
unsigned __int16 iHasTrans, iZ;
} IconHeader;
pFile->Seek( m_iFileOffset, CFile::begin );
ASSERT( sizeof( IconHeader ) == 64 );
pFile->Read( &IconHeader, sizeof( IconHeader ) );
if ( strncmp( IconHeader.awpx, "AWPX", 4 ) != 0 )
{
TRACE( "CHotlineDatFile : load icon failed !\n" );
return false;
}
if ( INT16_FROM_BE( IconHeader.iVersion ) != 1 )
{
TRACE( "CHotlineDatFile : load icon failed !\n" );
return false;
}
if ( IconHeader.iNumBits != 8 )
{
TRACE( "CHotlineDatFile : load icon failed !\n" );
return false;
}
IconHeader.iHasTrans = INT16_FROM_BE( IconHeader.iHasTrans );
m_iNumberColors = INT32_FROM_BE( IconHeader.iNumColors );
m_iDataWidth = INT32_FROM_BE( IconHeader.iWidthBytes);
m_iWidth = INT32_FROM_BE( IconHeader.iRealWidth );
m_iHeight = INT32_FROM_BE( IconHeader.iHeight );
if ( m_iWidth > 32 )
{
m_iIconOffset = m_iWidth / 2 - 17;
m_iWidth = m_iWidth - m_iIconOffset;
}
m_pPalette = new PALETTEENTRY[ m_iNumberColors ];
pFile->Read( m_pPalette, 4 * m_iNumberColors );
if ( IconHeader.iHasTrans )
{
const unsigned char cRed = IconHeader.iRTrans;
const unsigned char cGreen = IconHeader.iGTrans;
const unsigned char cBlue = IconHeader.iBTrans;
for ( int iColor = 0; iColor < m_iNumberColors; iColor++ )
{
if ( ( cRed == m_pPalette[ iColor ].peRed ) &&
( cGreen == m_pPalette[ iColor ].peGreen ) &&
( cBlue == m_pPalette[ iColor ].peBlue ) )
{
m_iTransparentIndex = iColor;
break;
}
}
}
m_pIconData = new char*[ m_iHeight ];
for ( y = 0; y < m_iHeight; y++ )
{
m_pIconData[ y ] = new char[ m_iDataWidth ];
pFile->Read( m_pIconData[ y ], m_iDataWidth );
}
}
CATCH( CFileException, e )
{
e->Delete( );
TRACE( "HotlineDatFile : load icon failed !\n" );
return false;
}
void QEglGLPixmapData::setHasAlpha(bool val)
{
TRACE();
m_hasAlpha = val;
}
bool QEglGLPixmapData::hasAlphaChannel() const
{
TRACE();
return m_hasAlpha;
}
static VOID
WinLdrScanRegistry(IN OUT PLIST_ENTRY BootDriverListHead,
IN LPCSTR DirectoryPath)
{
LONG rc = 0;
HKEY hGroupKey, hOrderKey, hServiceKey, hDriverKey;
LPWSTR GroupNameBuffer;
WCHAR ServiceName[256];
ULONG OrderList[128];
ULONG BufferSize;
ULONG Index;
ULONG TagIndex;
LPWSTR GroupName;
ULONG ValueSize;
ULONG ValueType;
ULONG StartValue;
ULONG TagValue;
WCHAR DriverGroup[256];
ULONG DriverGroupSize;
CHAR ImagePath[256];
WCHAR TempImagePath[256];
BOOLEAN Success;
/* get 'service group order' key */
rc = RegOpenKey(NULL,
L"\\Registry\\Machine\\SYSTEM\\CurrentControlSet\\Control\\ServiceGroupOrder",
&hGroupKey);
if (rc != ERROR_SUCCESS) {
TRACE_CH(REACTOS, "Failed to open the 'ServiceGroupOrder' key (rc %d)\n", (int)rc);
return;
}
/* get 'group order list' key */
rc = RegOpenKey(NULL,
L"\\Registry\\Machine\\SYSTEM\\CurrentControlSet\\Control\\GroupOrderList",
&hOrderKey);
if (rc != ERROR_SUCCESS) {
TRACE_CH(REACTOS, "Failed to open the 'GroupOrderList' key (rc %d)\n", (int)rc);
return;
}
/* enumerate drivers */
rc = RegOpenKey(NULL,
L"\\Registry\\Machine\\SYSTEM\\CurrentControlSet\\Services",
&hServiceKey);
if (rc != ERROR_SUCCESS) {
TRACE_CH(REACTOS, "Failed to open the 'Services' key (rc %d)\n", (int)rc);
return;
}
/* Get the Name Group */
BufferSize = 4096;
GroupNameBuffer = FrLdrHeapAlloc(BufferSize, TAG_WLDR_NAME);
rc = RegQueryValue(hGroupKey, L"List", NULL, (PUCHAR)GroupNameBuffer, &BufferSize);
TRACE_CH(REACTOS, "RegQueryValue(): rc %d\n", (int)rc);
if (rc != ERROR_SUCCESS)
return;
TRACE_CH(REACTOS, "BufferSize: %d \n", (int)BufferSize);
TRACE_CH(REACTOS, "GroupNameBuffer: '%S' \n", GroupNameBuffer);
/* Loop through each group */
GroupName = GroupNameBuffer;
while (*GroupName)
{
TRACE("Driver group: '%S'\n", GroupName);
/* Query the Order */
BufferSize = sizeof(OrderList);
rc = RegQueryValue(hOrderKey, GroupName, NULL, (PUCHAR)OrderList, &BufferSize);
if (rc != ERROR_SUCCESS) OrderList[0] = 0;
/* enumerate all drivers */
for (TagIndex = 1; TagIndex <= OrderList[0]; TagIndex++)
{
Index = 0;
while (TRUE)
{
/* Get the Driver's Name */
ValueSize = sizeof(ServiceName);
rc = RegEnumKey(hServiceKey, Index, ServiceName, &ValueSize, &hDriverKey);
TRACE("RegEnumKey(): rc %d\n", (int)rc);
/* Make sure it's valid, and check if we're done */
if (rc == ERROR_NO_MORE_ITEMS)
break;
if (rc != ERROR_SUCCESS)
{
FrLdrHeapFree(GroupNameBuffer, TAG_WLDR_NAME);
return;
}
//TRACE_CH(REACTOS, "Service %d: '%S'\n", (int)Index, ServiceName);
/* Read the Start Value */
ValueSize = sizeof(ULONG);
rc = RegQueryValue(hDriverKey, L"Start", &ValueType, (PUCHAR)&StartValue, &ValueSize);
if (rc != ERROR_SUCCESS) StartValue = (ULONG)-1;
//TRACE_CH(REACTOS, " Start: %x \n", (int)StartValue);
/* Read the Tag */
ValueSize = sizeof(ULONG);
rc = RegQueryValue(hDriverKey, L"Tag", &ValueType, (PUCHAR)&TagValue, &ValueSize);
if (rc != ERROR_SUCCESS) TagValue = (ULONG)-1;
//TRACE_CH(REACTOS, " Tag: %x \n", (int)TagValue);
/* Read the driver's group */
DriverGroupSize = sizeof(DriverGroup);
rc = RegQueryValue(hDriverKey, L"Group", NULL, (PUCHAR)DriverGroup, &DriverGroupSize);
//TRACE_CH(REACTOS, " Group: '%S' \n", DriverGroup);
/* Make sure it should be started */
if ((StartValue == 0) &&
(TagValue == OrderList[TagIndex]) &&
(_wcsicmp(DriverGroup, GroupName) == 0))
{
/* Get the Driver's Location */
ValueSize = sizeof(TempImagePath);
rc = RegQueryValue(hDriverKey, L"ImagePath", NULL, (PUCHAR)TempImagePath, &ValueSize);
/* Write the whole path if it succeeded, else prepare to fail */
if (rc != ERROR_SUCCESS)
{
TRACE_CH(REACTOS, "ImagePath: not found\n");
TempImagePath[0] = 0;
sprintf(ImagePath, "%s\\system32\\drivers\\%S.sys", DirectoryPath, ServiceName);
}
else if (TempImagePath[0] != L'\\')
{
sprintf(ImagePath, "%s%S", DirectoryPath, TempImagePath);
}
else
{
sprintf(ImagePath, "%S", TempImagePath);
TRACE_CH(REACTOS, "ImagePath: '%s'\n", ImagePath);
}
TRACE("Adding boot driver: '%s'\n", ImagePath);
Success = WinLdrAddDriverToList(BootDriverListHead,
L"\\Registry\\Machine\\System\\CurrentControlSet\\Services\\",
TempImagePath,
ServiceName);
if (!Success)
ERR("Failed to add boot driver\n");
}
else
{
//TRACE(" Skipping driver '%S' with Start %d, Tag %d and Group '%S' (Current Tag %d, current group '%S')\n",
// ServiceName, StartValue, TagValue, DriverGroup, OrderList[TagIndex], GroupName);
}
Index++;
}
}
Index = 0;
while (TRUE)
{
/* Get the Driver's Name */
ValueSize = sizeof(ServiceName);
rc = RegEnumKey(hServiceKey, Index, ServiceName, &ValueSize, &hDriverKey);
//TRACE_CH(REACTOS, "RegEnumKey(): rc %d\n", (int)rc);
if (rc == ERROR_NO_MORE_ITEMS)
break;
if (rc != ERROR_SUCCESS)
{
FrLdrHeapFree(GroupNameBuffer, TAG_WLDR_NAME);
return;
}
TRACE("Service %d: '%S'\n", (int)Index, ServiceName);
/* Read the Start Value */
ValueSize = sizeof(ULONG);
rc = RegQueryValue(hDriverKey, L"Start", &ValueType, (PUCHAR)&StartValue, &ValueSize);
if (rc != ERROR_SUCCESS) StartValue = (ULONG)-1;
//TRACE_CH(REACTOS, " Start: %x \n", (int)StartValue);
/* Read the Tag */
ValueSize = sizeof(ULONG);
rc = RegQueryValue(hDriverKey, L"Tag", &ValueType, (PUCHAR)&TagValue, &ValueSize);
if (rc != ERROR_SUCCESS) TagValue = (ULONG)-1;
//TRACE_CH(REACTOS, " Tag: %x \n", (int)TagValue);
/* Read the driver's group */
DriverGroupSize = sizeof(DriverGroup);
rc = RegQueryValue(hDriverKey, L"Group", NULL, (PUCHAR)DriverGroup, &DriverGroupSize);
//TRACE_CH(REACTOS, " Group: '%S' \n", DriverGroup);
for (TagIndex = 1; TagIndex <= OrderList[0]; TagIndex++)
{
if (TagValue == OrderList[TagIndex]) break;
}
if ((StartValue == 0) &&
(TagIndex > OrderList[0]) &&
(_wcsicmp(DriverGroup, GroupName) == 0))
{
ValueSize = sizeof(TempImagePath);
rc = RegQueryValue(hDriverKey, L"ImagePath", NULL, (PUCHAR)TempImagePath, &ValueSize);
if (rc != ERROR_SUCCESS)
{
TRACE_CH(REACTOS, "ImagePath: not found\n");
TempImagePath[0] = 0;
sprintf(ImagePath, "%ssystem32\\drivers\\%S.sys", DirectoryPath, ServiceName);
}
else if (TempImagePath[0] != L'\\')
{
sprintf(ImagePath, "%s%S", DirectoryPath, TempImagePath);
}
else
{
sprintf(ImagePath, "%S", TempImagePath);
TRACE_CH(REACTOS, "ImagePath: '%s'\n", ImagePath);
}
TRACE(" Adding boot driver: '%s'\n", ImagePath);
Success = WinLdrAddDriverToList(BootDriverListHead,
L"\\Registry\\Machine\\System\\CurrentControlSet\\Services\\",
TempImagePath,
ServiceName);
if (!Success)
ERR(" Failed to add boot driver\n");
}
else
{
//TRACE(" Skipping driver '%S' with Start %d, Tag %d and Group '%S' (Current group '%S')\n",
// ServiceName, StartValue, TagValue, DriverGroup, GroupName);
}
Index++;
}
/* Move to the next group name */
GroupName = GroupName + wcslen(GroupName) + 1;
}
/* Free allocated memory */
FrLdrHeapFree(GroupNameBuffer, TAG_WLDR_NAME);
}
void Tapplication::BlankScreen()
{
TRACE("Blanking screen\n");
TAP_Osd_FillBox(screenRgn, 0, 0, MAX_SCREEN_X, MAX_SCREEN_Y, COLOR_None);
}
BOOLEAN
WinLdrLoadSystemHive(IN OUT PLOADER_PARAMETER_BLOCK LoaderBlock,
IN LPCSTR DirectoryPath,
IN LPCSTR HiveName)
{
ULONG FileId;
CHAR FullHiveName[256];
ARC_STATUS Status;
FILEINFORMATION FileInfo;
ULONG HiveFileSize;
ULONG_PTR HiveDataPhysical;
PVOID HiveDataVirtual;
ULONG BytesRead;
LPCWSTR FsService;
/* Concatenate path and filename to get the full name */
strcpy(FullHiveName, DirectoryPath);
strcat(FullHiveName, HiveName);
//Print(L"Loading %s...\n", FullHiveName);
Status = ArcOpen(FullHiveName, OpenReadOnly, &FileId);
if (Status != ESUCCESS)
{
UiMessageBox("Opening hive file failed!");
return FALSE;
}
/* Get the file length */
Status = ArcGetFileInformation(FileId, &FileInfo);
if (Status != ESUCCESS)
{
ArcClose(FileId);
UiMessageBox("Hive file has 0 size!");
return FALSE;
}
HiveFileSize = FileInfo.EndingAddress.LowPart;
/* Round up the size to page boundary and alloc memory */
HiveDataPhysical = (ULONG_PTR)MmAllocateMemoryWithType(
MM_SIZE_TO_PAGES(HiveFileSize + MM_PAGE_SIZE - 1) << MM_PAGE_SHIFT,
LoaderRegistryData);
if (HiveDataPhysical == 0)
{
ArcClose(FileId);
UiMessageBox("Unable to alloc memory for a hive!");
return FALSE;
}
/* Convert address to virtual */
HiveDataVirtual = PaToVa((PVOID)HiveDataPhysical);
/* Fill LoaderBlock's entries */
LoaderBlock->RegistryLength = HiveFileSize;
LoaderBlock->RegistryBase = HiveDataVirtual;
/* Finally read from file to the memory */
Status = ArcRead(FileId, (PVOID)HiveDataPhysical, HiveFileSize, &BytesRead);
if (Status != ESUCCESS)
{
ArcClose(FileId);
UiMessageBox("Unable to read from hive file!");
return FALSE;
}
// Add boot filesystem driver to the list
FsService = FsGetServiceName(FileId);
if (FsService)
{
BOOLEAN Success;
TRACE(" Adding filesystem service %S\n", FsService);
Success = WinLdrAddDriverToList(&LoaderBlock->BootDriverListHead,
L"\\Registry\\Machine\\System\\CurrentControlSet\\Services\\",
NULL,
(LPWSTR)FsService);
if (!Success)
TRACE(" Failed to add filesystem service\n");
}
else
{
TRACE(" No required filesystem service\n");
}
ArcClose(FileId);
return TRUE;
}
BOOLEAN
WinLdrLoadNLSData(IN OUT PLOADER_PARAMETER_BLOCK LoaderBlock,
IN LPCSTR DirectoryPath,
IN LPCSTR AnsiFileName,
IN LPCSTR OemFileName,
IN LPCSTR LanguageFileName)
{
CHAR FileName[255];
ULONG AnsiFileId;
ULONG OemFileId;
ULONG LanguageFileId;
ULONG AnsiFileSize, OemFileSize, LanguageFileSize;
ULONG TotalSize;
ULONG_PTR NlsDataBase;
PVOID NlsVirtual;
BOOLEAN AnsiEqualsOem = FALSE;
FILEINFORMATION FileInfo;
ULONG BytesRead;
ARC_STATUS Status;
/* There may be a case, when OEM and ANSI page coincide */
if (!strcmp(AnsiFileName, OemFileName))
AnsiEqualsOem = TRUE;
/* Open file with ANSI and store its size */
//Print(L"Loading %s...\n", Filename);
strcpy(FileName, DirectoryPath);
strcat(FileName, AnsiFileName);
Status = ArcOpen(FileName, OpenReadOnly, &AnsiFileId);
if (Status != ESUCCESS)
goto Failure;
Status = ArcGetFileInformation(AnsiFileId, &FileInfo);
if (Status != ESUCCESS)
goto Failure;
AnsiFileSize = FileInfo.EndingAddress.LowPart;
TRACE("AnsiFileSize: %d\n", AnsiFileSize);
ArcClose(AnsiFileId);
/* Open OEM file and store its length */
if (AnsiEqualsOem)
{
OemFileSize = 0;
}
else
{
//Print(L"Loading %s...\n", Filename);
strcpy(FileName, DirectoryPath);
strcat(FileName, OemFileName);
Status = ArcOpen(FileName, OpenReadOnly, &OemFileId);
if (Status != ESUCCESS)
goto Failure;
Status = ArcGetFileInformation(OemFileId, &FileInfo);
if (Status != ESUCCESS)
goto Failure;
OemFileSize = FileInfo.EndingAddress.LowPart;
ArcClose(OemFileId);
}
TRACE("OemFileSize: %d\n", OemFileSize);
/* And finally open the language codepage file and store its length */
//Print(L"Loading %s...\n", Filename);
strcpy(FileName, DirectoryPath);
strcat(FileName, LanguageFileName);
Status = ArcOpen(FileName, OpenReadOnly, &LanguageFileId);
if (Status != ESUCCESS)
goto Failure;
Status = ArcGetFileInformation(LanguageFileId, &FileInfo);
if (Status != ESUCCESS)
goto Failure;
LanguageFileSize = FileInfo.EndingAddress.LowPart;
ArcClose(LanguageFileId);
TRACE("LanguageFileSize: %d\n", LanguageFileSize);
/* Sum up all three length, having in mind that every one of them
must start at a page boundary => thus round up each file to a page */
TotalSize = MM_SIZE_TO_PAGES(AnsiFileSize) +
MM_SIZE_TO_PAGES(OemFileSize) +
MM_SIZE_TO_PAGES(LanguageFileSize);
/* Store it for later marking the pages as NlsData type */
TotalNLSSize = TotalSize;
NlsDataBase = (ULONG_PTR)MmAllocateMemoryWithType(TotalSize*MM_PAGE_SIZE, LoaderNlsData);
if (NlsDataBase == 0)
goto Failure;
NlsVirtual = PaToVa((PVOID)NlsDataBase);
LoaderBlock->NlsData->AnsiCodePageData = NlsVirtual;
LoaderBlock->NlsData->OemCodePageData = (PVOID)((PUCHAR)NlsVirtual +
(MM_SIZE_TO_PAGES(AnsiFileSize) << MM_PAGE_SHIFT));
LoaderBlock->NlsData->UnicodeCodePageData = (PVOID)((PUCHAR)NlsVirtual +
(MM_SIZE_TO_PAGES(AnsiFileSize) << MM_PAGE_SHIFT) +
(MM_SIZE_TO_PAGES(OemFileSize) << MM_PAGE_SHIFT));
/* Ansi and OEM data are the same - just set pointers to the same area */
if (AnsiEqualsOem)
LoaderBlock->NlsData->OemCodePageData = LoaderBlock->NlsData->AnsiCodePageData;
/* Now actually read the data into memory, starting with Ansi file */
strcpy(FileName, DirectoryPath);
strcat(FileName, AnsiFileName);
Status = ArcOpen(FileName, OpenReadOnly, &AnsiFileId);
if (Status != ESUCCESS)
goto Failure;
Status = ArcRead(AnsiFileId, VaToPa(LoaderBlock->NlsData->AnsiCodePageData), AnsiFileSize, &BytesRead);
if (Status != ESUCCESS)
goto Failure;
ArcClose(AnsiFileId);
/* OEM now, if it doesn't equal Ansi of course */
if (!AnsiEqualsOem)
{
strcpy(FileName, DirectoryPath);
strcat(FileName, OemFileName);
Status = ArcOpen(FileName, OpenReadOnly, &OemFileId);
if (Status != ESUCCESS)
goto Failure;
Status = ArcRead(OemFileId, VaToPa(LoaderBlock->NlsData->OemCodePageData), OemFileSize, &BytesRead);
if (Status != ESUCCESS)
goto Failure;
ArcClose(OemFileId);
}
/* finally the language file */
strcpy(FileName, DirectoryPath);
strcat(FileName, LanguageFileName);
Status = ArcOpen(FileName, OpenReadOnly, &LanguageFileId);
if (Status != ESUCCESS)
goto Failure;
Status = ArcRead(LanguageFileId, VaToPa(LoaderBlock->NlsData->UnicodeCodePageData), LanguageFileSize, &BytesRead);
if (Status != ESUCCESS)
goto Failure;
ArcClose(LanguageFileId);
//
// THIS IS HAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACK
// Should go to WinLdrLoadOemHalFont(), when it will be implemented
//
LoaderBlock->OemFontFile = VaToPa(LoaderBlock->NlsData->UnicodeCodePageData);
/* Convert NlsTables address to VA */
LoaderBlock->NlsData = PaToVa(LoaderBlock->NlsData);
return TRUE;
Failure:
UiMessageBox("Error reading NLS file %s", FileName);
return FALSE;
}
/**
Open the device.
At the first time:
- allocating internal memory for each new device
- initialize the device
- set up the interrupt
\return
0 - if no error,
otherwise error code
*/
static int cpc5621_open (
char *path, /**< pointer to the device path */
INT flags /**< flag of the open */
)
{
int result = 0;
int devNum, chNum;
CPC5621_DEV *pDev = NULL;
if (Get_Dev_Num(path, &devNum, &chNum) == ERR)
return -ENODEV;
/* check the device number */
if (chNum >= MAX_CHANNEL)
{
TRACE(CPC5621_DRV, DBG_LEVEL_HIGH, ("cpc5621_open: max. device number exceed\n"));
result = -ENODEV;
goto OPEN_ERROR;
}
Sem_Lock(CpcSemDrv);
pDev = CPC5621_Devices[devNum][chNum];
if (pDev == NULL)
{
pDev = (CPC5621_DEV*)Alloc_Mem(sizeof(CPC5621_DEV));
if (!pDev)
{
TRACE(CPC5621_DRV, DBG_LEVEL_HIGH,("cpc5621_open: no memory for device structure.\n"));
result = -ENOMEM;
goto OPEN_ERROR;
}
memset((char*)pDev, 0, sizeof(CPC5621_DEV));
/* The device number and channel number should be getted from upper layer */
if (Drv_CPC5621_Init(pDev, devNum, chNum) == ERR)
{
TRACE(CPC5621_DRV, DBG_LEVEL_HIGH,("cpc5621_open: driver init failed!\n"));
result = -ENOMEM;
goto OPEN_ERROR;
}
CPC5621_Devices[devNum][chNum] = pDev;
}
if (pDev->bOpen == TRUE)
{
TRACE(CPC5621_DRV, DBG_LEVEL_HIGH,("cpc5621_open: already opened!\n"));
return -EBUSY;
}
pDev->bOpen = TRUE;
pDev->nInUse++;
/* and use filp->private_data to point to the device data */
filp->private_data = pDev;
Sem_Unlock(CpcSemDrv);
return (int)(pDev);
OPEN_ERROR:
if (pDev != NULL)
{
Free_Mem(pDev);
CPC5621_Devices[devNum][chNum] = NULL;
}
Sem_Unlock(CpcSemDrv);
return result;
}
/***********************************************************************
* acmStreamOpen (MSACM32.@)
*/
MMRESULT WINAPI acmStreamOpen(PHACMSTREAM phas, HACMDRIVER had,
PWAVEFORMATEX pwfxSrc, PWAVEFORMATEX pwfxDst,
PWAVEFILTER pwfltr, DWORD_PTR dwCallback,
DWORD_PTR dwInstance, DWORD fdwOpen)
{
PWINE_ACMSTREAM was;
PWINE_ACMDRIVER wad;
MMRESULT ret;
int wfxSrcSize;
int wfxDstSize;
WAVEFORMATEX wfxSrc, wfxDst;
TRACE("(%p, %p, %p, %p, %p, %ld, %ld, %d)\n",
phas, had, pwfxSrc, pwfxDst, pwfltr, dwCallback, dwInstance, fdwOpen);
/* NOTE: pwfxSrc and/or pwfxDst can point to a structure smaller than
* WAVEFORMATEX so don't use them directly when not sure */
if (pwfxSrc->wFormatTag == WAVE_FORMAT_PCM) {
memcpy(&wfxSrc, pwfxSrc, sizeof(PCMWAVEFORMAT));
wfxSrc.wBitsPerSample = pwfxSrc->wBitsPerSample;
wfxSrc.cbSize = 0;
pwfxSrc = &wfxSrc;
}
if (pwfxDst->wFormatTag == WAVE_FORMAT_PCM) {
memcpy(&wfxDst, pwfxDst, sizeof(PCMWAVEFORMAT));
wfxDst.wBitsPerSample = pwfxDst->wBitsPerSample;
wfxDst.cbSize = 0;
pwfxDst = &wfxDst;
}
TRACE("src [wFormatTag=%u, nChannels=%u, nSamplesPerSec=%u, nAvgBytesPerSec=%u, nBlockAlign=%u, wBitsPerSample=%u, cbSize=%u]\n",
pwfxSrc->wFormatTag, pwfxSrc->nChannels, pwfxSrc->nSamplesPerSec, pwfxSrc->nAvgBytesPerSec,
pwfxSrc->nBlockAlign, pwfxSrc->wBitsPerSample, pwfxSrc->cbSize);
TRACE("dst [wFormatTag=%u, nChannels=%u, nSamplesPerSec=%u, nAvgBytesPerSec=%u, nBlockAlign=%u, wBitsPerSample=%u, cbSize=%u]\n",
pwfxDst->wFormatTag, pwfxDst->nChannels, pwfxDst->nSamplesPerSec, pwfxDst->nAvgBytesPerSec,
pwfxDst->nBlockAlign, pwfxDst->wBitsPerSample, pwfxDst->cbSize);
/* (WS) In query mode, phas should be NULL. If it is not, then instead
* of returning an error we are making sure it is NULL, preventing some
* applications that pass garbage for phas from crashing.
*/
if (fdwOpen & ACM_STREAMOPENF_QUERY) phas = NULL;
if (pwfltr && (pwfxSrc->wFormatTag != pwfxDst->wFormatTag)) {
WARN("invalid parameter\n");
return MMSYSERR_INVALPARAM;
}
wfxSrcSize = wfxDstSize = sizeof(WAVEFORMATEX);
if (pwfxSrc->wFormatTag != WAVE_FORMAT_PCM) wfxSrcSize += pwfxSrc->cbSize;
if (pwfxDst->wFormatTag != WAVE_FORMAT_PCM) wfxDstSize += pwfxDst->cbSize;
was = HeapAlloc(MSACM_hHeap, 0, sizeof(*was) + wfxSrcSize + wfxDstSize +
((pwfltr) ? sizeof(WAVEFILTER) : 0));
if (was == NULL) {
WARN("no memory\n");
return MMSYSERR_NOMEM;
}
was->drvInst.cbStruct = sizeof(was->drvInst);
was->drvInst.pwfxSrc = (PWAVEFORMATEX)((LPSTR)was + sizeof(*was));
memcpy(was->drvInst.pwfxSrc, pwfxSrc, wfxSrcSize);
was->drvInst.pwfxDst = (PWAVEFORMATEX)((LPSTR)was + sizeof(*was) + wfxSrcSize);
memcpy(was->drvInst.pwfxDst, pwfxDst, wfxDstSize);
if (pwfltr) {
was->drvInst.pwfltr = (PWAVEFILTER)((LPSTR)was + sizeof(*was) + wfxSrcSize + wfxDstSize);
memcpy(was->drvInst.pwfltr, pwfltr, sizeof(WAVEFILTER));
} else {
was->drvInst.pwfltr = NULL;
}
was->drvInst.dwCallback = dwCallback;
was->drvInst.dwInstance = dwInstance;
was->drvInst.fdwOpen = fdwOpen;
was->drvInst.fdwDriver = 0L;
was->drvInst.dwDriver = 0L;
/* real value will be stored once ACMDM_STREAM_OPEN succeeds */
was->drvInst.has = 0L;
if (had) {
if (!(wad = MSACM_GetDriver(had))) {
ret = MMSYSERR_INVALPARAM;
goto errCleanUp;
}
was->obj.dwType = WINE_ACMOBJ_STREAM;
was->obj.pACMDriverID = wad->obj.pACMDriverID;
was->pDrv = wad;
was->hAcmDriver = 0; /* not to close it in acmStreamClose */
ret = MSACM_Message((HACMDRIVER)wad, ACMDM_STREAM_OPEN, (LPARAM)&was->drvInst, 0L);
if (ret != MMSYSERR_NOERROR)
goto errCleanUp;
} else {
PWINE_ACMDRIVERID wadi;
ret = ACMERR_NOTPOSSIBLE;
for (wadi = MSACM_pFirstACMDriverID; wadi; wadi = wadi->pNextACMDriverID) {
if ((wadi->fdwSupport & ACMDRIVERDETAILS_SUPPORTF_DISABLED) ||
!MSACM_FindFormatTagInCache(wadi, pwfxSrc->wFormatTag, NULL) ||
!MSACM_FindFormatTagInCache(wadi, pwfxDst->wFormatTag, NULL))
continue;
ret = acmDriverOpen(&had, (HACMDRIVERID)wadi, 0L);
if (ret != MMSYSERR_NOERROR)
continue;
if ((wad = MSACM_GetDriver(had)) != 0) {
was->obj.dwType = WINE_ACMOBJ_STREAM;
was->obj.pACMDriverID = wad->obj.pACMDriverID;
was->pDrv = wad;
was->hAcmDriver = had;
ret = MSACM_Message((HACMDRIVER)wad, ACMDM_STREAM_OPEN, (LPARAM)&was->drvInst, 0L);
TRACE("%s => %08x\n", debugstr_w(wadi->pszDriverAlias), ret);
if (ret == MMSYSERR_NOERROR) {
if (fdwOpen & ACM_STREAMOPENF_QUERY) {
MSACM_Message((HACMDRIVER)wad, ACMDM_STREAM_CLOSE, (LPARAM)&was->drvInst, 0);
acmDriverClose(had, 0L);
}
break;
}
}
/* no match, close this acm driver and try next one */
acmDriverClose(had, 0L);
}
if (ret != MMSYSERR_NOERROR) {
ret = ACMERR_NOTPOSSIBLE;
goto errCleanUp;
}
}
ret = MMSYSERR_NOERROR;
was->drvInst.has = (HACMSTREAM)was;
if (!(fdwOpen & ACM_STREAMOPENF_QUERY)) {
if (phas)
*phas = (HACMSTREAM)was;
TRACE("=> (%d)\n", ret);
return ret;
}
errCleanUp:
if (phas)
*phas = NULL;
HeapFree(MSACM_hHeap, 0, was);
TRACE("=> (%d)\n", ret);
return ret;
}
QGLTexture * QEglGLPixmapData::texture() const
{
TRACE();
return &m_texture;
}
/***********************************************************************
* acmStreamPrepareHeader (MSACM32.@)
*/
MMRESULT WINAPI acmStreamPrepareHeader(HACMSTREAM has, PACMSTREAMHEADER pash,
DWORD fdwPrepare)
{
PWINE_ACMSTREAM was;
MMRESULT ret = MMSYSERR_NOERROR;
PACMDRVSTREAMHEADER padsh;
TRACE("(%p, %p, %d)\n", has, pash, fdwPrepare);
if ((was = ACM_GetStream(has)) == NULL) {
WARN("invalid handle\n");
return MMSYSERR_INVALHANDLE;
}
if (!pash || pash->cbStruct < sizeof(ACMSTREAMHEADER)) {
WARN("invalid parameter\n");
return MMSYSERR_INVALPARAM;
}
if (fdwPrepare) {
WARN("invalid use of reserved parameter\n");
return MMSYSERR_INVALFLAG;
}
if ((was->drvInst.pwfxSrc->wFormatTag == WAVE_FORMAT_ADPCM ||
was->drvInst.pwfxSrc->wFormatTag == WAVE_FORMAT_PCM) &&
pash->cbSrcLength < was->drvInst.pwfxSrc->nBlockAlign) {
WARN("source smaller than block align (%d < %d)\n",
pash->cbSrcLength, was->drvInst.pwfxSrc->nBlockAlign);
return pash->cbSrcLength ? ACMERR_NOTPOSSIBLE : MMSYSERR_INVALPARAM;
}
/* Note: the ACMSTREAMHEADER and ACMDRVSTREAMHEADER structs are of same
* size. some fields are private to msacm internals, and are exposed
* in ACMSTREAMHEADER in the dwReservedDriver array
*/
padsh = (PACMDRVSTREAMHEADER)pash;
padsh->fdwConvert = fdwPrepare;
padsh->padshNext = NULL;
padsh->fdwDriver = padsh->dwDriver = 0L;
padsh->fdwPrepared = 0;
padsh->dwPrepared = 0;
padsh->pbPreparedSrc = 0;
padsh->cbPreparedSrcLength = 0;
padsh->pbPreparedDst = 0;
padsh->cbPreparedDstLength = 0;
ret = MSACM_Message((HACMDRIVER)was->pDrv, ACMDM_STREAM_PREPARE, (LPARAM)&was->drvInst, (LPARAM)padsh);
if (ret == MMSYSERR_NOERROR || ret == MMSYSERR_NOTSUPPORTED) {
ret = MMSYSERR_NOERROR;
padsh->fdwStatus &= ~ACMSTREAMHEADER_STATUSF_INQUEUE;
padsh->fdwStatus |= ACMSTREAMHEADER_STATUSF_PREPARED;
padsh->fdwPrepared = padsh->fdwStatus;
padsh->dwPrepared = 0;
padsh->pbPreparedSrc = padsh->pbSrc;
padsh->cbPreparedSrcLength = padsh->cbSrcLength;
padsh->pbPreparedDst = padsh->pbDst;
padsh->cbPreparedDstLength = padsh->cbDstLength;
} else {
padsh->fdwPrepared = 0;
padsh->dwPrepared = 0;
padsh->pbPreparedSrc = 0;
padsh->cbPreparedSrcLength = 0;
padsh->pbPreparedDst = 0;
padsh->cbPreparedDstLength = 0;
}
TRACE("=> (%d)\n", ret);
return ret;
}
bool QEglGLPixmapData::isValid() const
{
TRACE();
return w > 0 && h > 0;
}
void binarySearchforview_networkcontroller(BYTE devLo, BYTE devHi)
{
// had_scaned=true;////////////////////////////////////////////////had scan
if(net_work_is_exist_or_not==true)
Sleep(200);
else
Sleep(10);//
int a=NetController_CheckTstatOnline(devLo,devHi);
TRACE("L:%d H:%d a:%d\n",devLo,devHi,a);
if(binary_search_crc(a))
return ;
char c_array_temp[5]={'0'};
CString temp="";
if(a>0)
{
///////****************************************************************8888888
// TRACE("L:%d H:%d\n",devLo,devHi);
// TRACE("%d\n",a);
/*
#if 1
binary_search_result temp;
temp.baudrate=m_baudrate2;
temp.id=a;
temp.product_class_id=read_one(a,7);
get_serialnumber(temp.serialnumber,temp.id );
temp.hardware_version=read_one(temp.id ,8);
m_binary_search_networkcontroller_background_thread.push_back(temp);
if(read_one(a,7)==NET_WORK_CONT_PRODUCT_MODEL)//net work controller
keep_back_mac_address(a);
#endif
*/
binary_search_result temp;
temp.baudrate=m_baudrate2;
unsigned short SerialNum[9];
memset(SerialNum,0,sizeof(SerialNum));
int nRet=0;
temp.id=a;
nRet=Read_Multi(temp.id,&SerialNum[0],0,9,3);
if(nRet>0)
{
//serial=SerialNum[0]&0x00ff+(SerialNum[0]&0xff00>>8)*256+(SerialNum[1]&0x00ff)*65536
// +(SerialNum[1]&0xff00>>8)*16777216;
if(SerialNum[0]==255&&SerialNum[1]==255&&SerialNum[2]==255&&SerialNum[3]==255)
{
srand((unsigned)time(NULL));
SerialNum[0]=rand()%255;
SerialNum[1]=rand()%255;
SerialNum[2]=rand()%255;
SerialNum[3]=rand()%255;
write_one(temp.id,0,SerialNum[0]);
write_one(temp.id,1,SerialNum[1]);
write_one(temp.id,2,SerialNum[2]);
write_one(temp.id,3,SerialNum[3]);
}
temp.serialnumber=SerialNum[0]+SerialNum[1]*256+SerialNum[2]*256*256+SerialNum[3]*256*256*256;
temp.product_class_id=SerialNum[7];
temp.hardware_version=SerialNum[8];
float tstat_version2;
tstat_version2=SerialNum[4];//tstat version
if(tstat_version2 >=240 && tstat_version2 <250)
tstat_version2 /=10;
else
{
tstat_version2 = SerialNum[5]*256+SerialNum[4];
tstat_version2 /=10;
}//tstat_version
temp.software_version=tstat_version2;
if(read_one(temp.id,185)==0)
temp.baudrate=9600;
else
{
temp.baudrate=19200;
}
temp.nEPsize=read_one(temp.id,326);
if(temp.serialnumber>0)
m_binary_search_networkcontroller_background_thread.push_back(temp);
}
}
switch(a)
{
case -2:
//crc error
if(devLo!=devHi)
{
binarySearchforview_networkcontroller(devLo,(devLo+devHi)/2);
binarySearchforview_networkcontroller((devLo+devHi)/2+1,devHi);
}
else
binarySearchforview_networkcontroller(devLo,devHi);
break;
case -3:
//more than 2 Tstat is connect
if(devLo!=devHi)
{
binarySearchforview_networkcontroller(devLo,(devLo+devHi)/2);
binarySearchforview_networkcontroller((devLo+devHi)/2+1,devHi);
}
else
{//Two Tstat have the same ID,fewness
do
{
Sleep(20);//////////////////////////////////for running is better
char c_temp_arr[100]={'\0'};
if(Read_One(devLo,10)!=-2)//one times
{
CString str_temp;
for(int j=254;j>=1;j--)
if(j!=devLo)
{
if(!found_same_net_work_controller_by_mac(a))
{
bool find=false;//false==no find;true==find
for(int w=0;w<m_binary_search_product_background_thread.size();w++)
if(j==m_binary_search_product_background_thread.at(w).id)
{
find=true;
break;
}
if(find==false)
{
//************************change the Id
// Sleep(20);//////////////////////////////////for running is better
if(Write_One(devLo,10,j)>0)//sometimes write failure ,so inspect,important
if(j<devLo)
{
/*
#if 1
binary_search_result temp;
temp.baudrate=m_baudrate2;
temp.id=j;
temp.product_class_id=read_one(j,7);
get_serialnumber(temp.serialnumber,j);
temp.hardware_version=read_one(j,8);
m_binary_search_networkcontroller_background_thread.push_back(temp);
if(read_one(j,7)==NET_WORK_CONT_PRODUCT_MODEL)//net work controller
keep_back_mac_address(j);
#endif
*/
binary_search_result temp;
temp.baudrate=m_baudrate2;
unsigned short SerialNum[9];
memset(SerialNum,0,sizeof(SerialNum));
int nRet=0;
temp.id=j;
nRet=Read_Multi(temp.id,&SerialNum[0],0,9,3);
if(nRet>0)
{
//serial=SerialNum[0]&0x00ff+(SerialNum[0]&0xff00>>8)*256+(SerialNum[1]&0x00ff)*65536
// +(SerialNum[1]&0xff00>>8)*16777216;
if(SerialNum[0]==255&&SerialNum[1]==255&&SerialNum[2]==255&&SerialNum[3]==255)
{
srand((unsigned)time(NULL));
SerialNum[0]=rand()%255;
SerialNum[1]=rand()%255;
SerialNum[2]=rand()%255;
SerialNum[3]=rand()%255;
write_one(temp.id,0,SerialNum[0]);
write_one(temp.id,1,SerialNum[1]);
write_one(temp.id,2,SerialNum[2]);
write_one(temp.id,3,SerialNum[3]);
}
temp.serialnumber=SerialNum[0]+SerialNum[1]*256+SerialNum[2]*256*256+SerialNum[3]*256*256*256;
temp.product_class_id=SerialNum[7];
temp.hardware_version=SerialNum[8];
float tstat_version2;
tstat_version2=SerialNum[4];//tstat version
if(tstat_version2 >=240 && tstat_version2 <250)
tstat_version2 /=10;
else
{
tstat_version2 = SerialNum[5]*256+SerialNum[4];
tstat_version2 /=10;
}//tstat_version
temp.software_version=tstat_version2;
if(read_one(temp.id,185)==0)
temp.baudrate=9600;
else
{
temp.baudrate=19200;
}
temp.nEPsize=read_one(temp.id,326);
if(temp.serialnumber>0)
m_binary_search_networkcontroller_background_thread.push_back(temp);
}
}
binarySearchforview_networkcontroller(devLo,devHi);
return;
}
}
else
{
return;
}
}
}
}while(1);
}
break;
case -4:break;
//no connection
case -5:break;
//the input error
}
}
ret_t
cherokee_socket_connect (cherokee_socket_t *sock)
{
int r;
TRACE (ENTRIES, "connect type=%s\n",
SOCKET_AF(sock) == AF_INET ? "AF_INET" :
SOCKET_AF(sock) == AF_INET6 ? "AF_INET6" :
SOCKET_AF(sock) == AF_UNIX ? "AF_UNIX" : "Unknown");
switch (SOCKET_AF(sock)) {
case AF_INET:
r = connect (SOCKET_FD(sock),
(struct sockaddr *) &SOCKET_ADDR(sock),
sizeof(struct sockaddr_in));
break;
#ifdef HAVE_IPV6
case AF_INET6:
r = connect (SOCKET_FD(sock),
(struct sockaddr *) &SOCKET_ADDR(sock),
sizeof(struct sockaddr_in6));
break;
#endif
#ifdef HAVE_SOCKADDR_UN
case AF_UNIX:
r = connect (SOCKET_FD(sock),
(struct sockaddr *) &SOCKET_ADDR(sock),
SUN_LEN (SOCKET_ADDR_UNIX(sock)));
break;
#endif
default:
SHOULDNT_HAPPEN;
return ret_no_sys;
}
if (r < 0) {
int err = SOCK_ERRNO();
TRACE (ENTRIES",connect", "connect error=%d '%s'\n", err, strerror(err));
switch (err) {
case EISCONN:
break;
case EINVAL:
case ENOENT:
case ECONNRESET:
case ECONNREFUSED:
case EADDRNOTAVAIL:
return ret_deny;
case ETIMEDOUT:
return ret_error;
case EAGAIN:
case EALREADY:
case EINPROGRESS:
#if defined(EWOULDBLOCK) && (EWOULDBLOCK != EAGAIN)
case EWOULDBLOCK:
#endif
return ret_eagain;
default:
LOG_ERRNO_S (errno, cherokee_err_error, CHEROKEE_ERROR_SOCKET_CONNECT);
return ret_error;
}
}
TRACE (ENTRIES",connect", "succeed %s", "\n");
sock->status = socket_reading;
return ret_ok;
}
void
evaltree(union node *n, int flags)
{
if (n == NULL) {
TRACE(("evaltree(NULL) called\n"));
exitstatus = 0;
goto out;
}
#ifdef WITH_HISTORY
displayhist = 1; /* show history substitutions done with fc */
#endif
TRACE(("pid %d, evaltree(%p: %d, %d) called\n",
getpid(), n, n->type, flags));
switch (n->type) {
case NSEMI:
evaltree(n->nbinary.ch1, flags & EV_TESTED);
if (evalskip)
goto out;
evaltree(n->nbinary.ch2, flags);
break;
case NAND:
evaltree(n->nbinary.ch1, EV_TESTED);
if (evalskip || exitstatus != 0)
goto out;
evaltree(n->nbinary.ch2, flags);
break;
case NOR:
evaltree(n->nbinary.ch1, EV_TESTED);
if (evalskip || exitstatus == 0)
goto out;
evaltree(n->nbinary.ch2, flags);
break;
case NREDIR:
expredir(n->nredir.redirect);
redirect(n->nredir.redirect, REDIR_PUSH);
evaltree(n->nredir.n, flags);
popredir();
break;
case NSUBSHELL:
evalsubshell(n, flags);
break;
case NBACKGND:
evalsubshell(n, flags);
break;
case NIF: {
evaltree(n->nif.test, EV_TESTED);
if (evalskip)
goto out;
if (exitstatus == 0)
evaltree(n->nif.ifpart, flags);
else if (n->nif.elsepart)
evaltree(n->nif.elsepart, flags);
else
exitstatus = 0;
break;
}
case NWHILE:
case NUNTIL:
evalloop(n, flags);
break;
case NFOR:
evalfor(n, flags);
break;
case NCASE:
evalcase(n, flags);
break;
case NDEFUN:
defun(n->narg.text, n->narg.next);
exitstatus = 0;
break;
case NNOT:
evaltree(n->nnot.com, EV_TESTED);
exitstatus = !exitstatus;
break;
case NPIPE:
evalpipe(n);
break;
case NCMD:
evalcommand(n, flags, (struct backcmd *)NULL);
break;
default:
out1fmt("Node type = %d\n", n->type);
flushout(&output);
break;
}
out:
if (pendingsigs)
dotrap();
if ((flags & EV_EXIT) != 0)
exitshell(exitstatus);
}
ret_t
cherokee_socket_set_cork (cherokee_socket_t *socket, cherokee_boolean_t enable)
{
int re;
int tmp = 0;
int fd = socket->socket;
if (enable) {
tmp = 0;
do {
re = setsockopt (fd, IPPROTO_TCP, TCP_NODELAY, &tmp, sizeof(tmp));
} while ((re == -1) && (errno == EINTR));
if (unlikely (re < 0)) {
LOG_ERRNO (errno, cherokee_err_error,
CHEROKEE_ERROR_SOCKET_RM_NODELAY, fd);
return ret_error;
}
TRACE(ENTRIES",cork,nodelay", "Set TCP_NODELAY on fd %d\n", fd);
#ifdef TCP_CORK
tmp = 1;
do {
re = setsockopt (fd, IPPROTO_TCP, TCP_CORK, &tmp, sizeof(tmp));
} while ((re == -1) && (errno == EINTR));
if (unlikely (re < 0)) {
LOG_ERRNO (errno, cherokee_err_error,
CHEROKEE_ERROR_SOCKET_SET_CORK, fd);
return ret_error;
}
TRACE(ENTRIES",cork", "Set TCP_CORK on fd %d\n", fd);
#endif
return ret_ok;
}
#ifdef TCP_CORK
tmp = 0;
do {
re = setsockopt (fd, IPPROTO_TCP, TCP_CORK, &tmp, sizeof(tmp));
} while ((re == -1) && (errno == EINTR));
if (unlikely (re < 0)) {
LOG_ERRNO (errno, cherokee_err_error,
CHEROKEE_ERROR_SOCKET_RM_CORK, fd);
return ret_error;
}
TRACE(ENTRIES",cork", "Removed TCP_CORK on fd %d\n", fd);
#endif
tmp = 1;
do {
re = setsockopt (fd, IPPROTO_TCP, TCP_NODELAY, &tmp, sizeof(tmp));
} while ((re == -1) && (errno == EINTR));
if (unlikely (re < 0)) {
LOG_ERRNO (errno, cherokee_err_error,
CHEROKEE_ERROR_SOCKET_SET_NODELAY, fd);
return ret_error;
}
TRACE(ENTRIES",cork,nodelay", "Removed TCP_NODELAY on fd %d\n", fd);
return ret_ok;
}
/***********************************************************************
* macdrv_handle_event
*/
void macdrv_handle_event(const macdrv_event *event)
{
HWND hwnd = macdrv_get_window_hwnd(event->window);
const macdrv_event *prev;
struct macdrv_thread_data *thread_data = macdrv_thread_data();
TRACE("%s for hwnd/window %p/%p\n", dbgstr_event(event->type), hwnd,
event->window);
prev = thread_data->current_event;
thread_data->current_event = event;
switch (event->type)
{
case APP_DEACTIVATED:
macdrv_app_deactivated();
break;
case APP_QUIT_REQUESTED:
macdrv_app_quit_requested(event);
break;
case DISPLAYS_CHANGED:
macdrv_displays_changed(event);
break;
case HOTKEY_PRESS:
macdrv_hotkey_press(event);
break;
case IM_SET_TEXT:
macdrv_im_set_text(event);
break;
case KEY_PRESS:
case KEY_RELEASE:
macdrv_key_event(hwnd, event);
break;
case KEYBOARD_CHANGED:
macdrv_keyboard_changed(event);
break;
case MOUSE_BUTTON:
macdrv_mouse_button(hwnd, event);
break;
case MOUSE_MOVED:
case MOUSE_MOVED_ABSOLUTE:
macdrv_mouse_moved(hwnd, event);
break;
case MOUSE_SCROLL:
macdrv_mouse_scroll(hwnd, event);
break;
case QUERY_EVENT:
macdrv_query_event(hwnd, event);
break;
case RELEASE_CAPTURE:
macdrv_release_capture(hwnd, event);
break;
case STATUS_ITEM_MOUSE_BUTTON:
macdrv_status_item_mouse_button(event);
break;
case STATUS_ITEM_MOUSE_MOVE:
macdrv_status_item_mouse_move(event);
break;
case WINDOW_BROUGHT_FORWARD:
macdrv_window_brought_forward(hwnd);
break;
case WINDOW_CLOSE_REQUESTED:
macdrv_window_close_requested(hwnd);
break;
case WINDOW_DID_UNMINIMIZE:
macdrv_window_did_unminimize(hwnd);
break;
case WINDOW_FRAME_CHANGED:
macdrv_window_frame_changed(hwnd, event);
break;
case WINDOW_GOT_FOCUS:
macdrv_window_got_focus(hwnd, event);
break;
case WINDOW_LOST_FOCUS:
macdrv_window_lost_focus(hwnd, event);
break;
case WINDOW_MINIMIZE_REQUESTED:
macdrv_window_minimize_requested(hwnd);
break;
case WINDOW_RESIZE_ENDED:
macdrv_window_resize_ended(hwnd);
break;
default:
TRACE(" ignoring\n");
break;
}
thread_data->current_event = prev;
}
/* WARNING: all parameters MUST be valid,
* NULL pointers lead to a crash.
*/
ret_t
cherokee_socket_read (cherokee_socket_t *socket,
char *buf,
int buf_size,
size_t *pcnt_read)
{
ret_t ret;
ssize_t len;
*pcnt_read = 0;
/* There must be something to read, otherwise behaviour is undefined
* and as we don't want this case, we have to enforce assertions.
*/
return_if_fail (buf != NULL && buf_size > 0, ret_error);
if (unlikely (socket->status == socket_closed)) {
TRACE(ENTRIES, "Reading a closed socket: fd=%d (TLS=%d)\n", SOCKET_FD(socket), (socket->is_tls == TLS));
return ret_eof;
}
if (likely (socket->is_tls != TLS)) {
/* Plain read
*/
len = recv (SOCKET_FD(socket), buf, buf_size, 0);
if (likely (len > 0)) {
*pcnt_read = len;
return ret_ok;
}
if (len == 0) {
socket->status = socket_closed;
return ret_eof;
}
{ /* len < 0 */
int err = SOCK_ERRNO();
TRACE(ENTRIES",read", "Socket read error fd=%d: '%s'\n",
SOCKET_FD(socket), strerror(errno));
switch (err) {
#if defined(EWOULDBLOCK) && (EWOULDBLOCK != EAGAIN)
case EWOULDBLOCK:
#endif
case EINTR:
case EAGAIN:
return ret_eagain;
case EPIPE:
#ifdef ENOTCONN
case ENOTCONN:
#endif
case ECONNRESET:
socket->status = socket_closed;
case ETIMEDOUT:
case EHOSTUNREACH:
return ret_error;
}
LOG_ERRNO (errno, cherokee_err_error,
CHEROKEE_ERROR_SOCKET_READ, SOCKET_FD(socket));
}
return ret_error;
} else if (socket->cryptor != NULL) {
ret = cherokee_cryptor_socket_read (socket->cryptor,
buf, buf_size, pcnt_read);
switch (ret) {
case ret_ok:
case ret_error:
case ret_eagain:
return ret;
case ret_eof:
socket->status = socket_closed;
return ret_eof;
default:
RET_UNKNOWN(ret);
return ret;
}
}
return ret_error;
}
HRESULT WINAPI PSStringFromPropertyKey(REFPROPERTYKEY pkey, LPWSTR psz, UINT cch)
{
static const WCHAR guid_fmtW[] = {'{','%','0','8','X','-','%','0','4','X','-',
'%','0','4','X','-','%','0','2','X','%','0','2','X','-',
'%','0','2','X','%','0','2','X','%','0','2','X',
'%','0','2','X','%','0','2','X','%','0','2','X','}',0};
static const WCHAR pid_fmtW[] = {'%','u',0};
WCHAR pidW[PKEY_PIDSTR_MAX + 1];
LPWSTR p = psz;
int len;
TRACE("(%p, %p, %u)\n", pkey, psz, cch);
if (!psz)
return E_POINTER;
/* GUIDSTRING_MAX accounts for null terminator, +1 for space character. */
if (cch <= GUIDSTRING_MAX + 1)
return HRESULT_FROM_WIN32(ERROR_INSUFFICIENT_BUFFER);
if (!pkey)
{
psz[0] = '\0';
return HRESULT_FROM_WIN32(ERROR_INSUFFICIENT_BUFFER);
}
sprintfW(psz, guid_fmtW, pkey->fmtid.Data1, pkey->fmtid.Data2,
pkey->fmtid.Data3, pkey->fmtid.Data4[0], pkey->fmtid.Data4[1],
pkey->fmtid.Data4[2], pkey->fmtid.Data4[3], pkey->fmtid.Data4[4],
pkey->fmtid.Data4[5], pkey->fmtid.Data4[6], pkey->fmtid.Data4[7]);
/* Overwrite the null terminator with the space character. */
p += GUIDSTRING_MAX - 1;
*p++ = ' ';
cch -= GUIDSTRING_MAX - 1 + 1;
len = sprintfW(pidW, pid_fmtW, pkey->pid);
if (cch >= len + 1)
{
strcpyW(p, pidW);
return S_OK;
}
else
{
WCHAR *ptr = pidW + len - 1;
psz[0] = '\0';
*p++ = '\0';
cch--;
/* Replicate a quirk of the native implementation where the contents
* of the property ID string are written backwards to the output
* buffer, skipping the rightmost digit. */
if (cch)
{
ptr--;
while (cch--)
*p++ = *ptr--;
}
return HRESULT_FROM_WIN32(ERROR_INSUFFICIENT_BUFFER);
}
}
static HRESULT WINAPI WaveTrackCF_CreateInstance(LPCLASSFACTORY iface, LPUNKNOWN pOuter, REFIID riid, LPVOID *ppobj) {
TRACE ("(%p, %s, %p)\n", pOuter, debugstr_dmguid(riid), ppobj);
return DMUSIC_CreateDirectMusicWaveTrack (riid, ppobj, pOuter);
}
static ULONG WINAPI ClassFactory_AddRef(IClassFactory *iface)
{
TRACE("(%p)\n", iface);
return 2;
}
/******************************************************************
* DllGetClassObject (DMIME.@)
*
*
*/
HRESULT WINAPI DllGetClassObject(REFCLSID rclsid, REFIID riid, LPVOID *ppv)
{
TRACE("(%s, %s, %p)\n", debugstr_dmguid(rclsid), debugstr_dmguid(riid), ppv);
if (IsEqualCLSID (rclsid, &CLSID_DirectMusicPerformance) && IsEqualIID (riid, &IID_IClassFactory)) {
*ppv = &Performance_CF;
IClassFactory_AddRef((IClassFactory*)*ppv);
return S_OK;
} else if (IsEqualCLSID (rclsid, &CLSID_DirectMusicSegment) && IsEqualIID (riid, &IID_IClassFactory)) {
*ppv = &Segment_CF;
IClassFactory_AddRef((IClassFactory*)*ppv);
return S_OK;
} else if (IsEqualCLSID (rclsid, &CLSID_DirectMusicSegmentState) && IsEqualIID (riid, &IID_IClassFactory)) {
*ppv = &SegmentState_CF;
IClassFactory_AddRef((IClassFactory*)*ppv);
return S_OK;
} else if (IsEqualCLSID (rclsid, &CLSID_DirectMusicGraph) && IsEqualIID (riid, &IID_IClassFactory)) {
*ppv = &Graph_CF;
IClassFactory_AddRef((IClassFactory*)*ppv);
return S_OK;
} else if (IsEqualCLSID (rclsid, &CLSID_DirectMusicTempoTrack) && IsEqualIID (riid, &IID_IClassFactory)) {
*ppv = &TempoTrack_CF;
IClassFactory_AddRef((IClassFactory*)*ppv);
return S_OK;
} else if (IsEqualCLSID (rclsid, &CLSID_DirectMusicSeqTrack) && IsEqualIID (riid, &IID_IClassFactory)) {
*ppv = &SeqTrack_CF;
IClassFactory_AddRef((IClassFactory*)*ppv);
return S_OK;
} else if (IsEqualCLSID (rclsid, &CLSID_DirectMusicSysExTrack) && IsEqualIID (riid, &IID_IClassFactory)) {
*ppv = &SysExTrack_CF;
IClassFactory_AddRef((IClassFactory*)*ppv);
return S_OK;
} else if (IsEqualCLSID (rclsid, &CLSID_DirectMusicTimeSigTrack) && IsEqualIID (riid, &IID_IClassFactory)) {
*ppv = &TimeSigTrack_CF;
IClassFactory_AddRef((IClassFactory*)*ppv);
return S_OK;
} else if (IsEqualCLSID (rclsid, &CLSID_DirectMusicParamControlTrack) && IsEqualIID (riid, &IID_IClassFactory)) {
*ppv = &ParamControlTrack_CF;
IClassFactory_AddRef((IClassFactory*)*ppv);
return S_OK;
} else if (IsEqualCLSID (rclsid, &CLSID_DirectMusicMarkerTrack) && IsEqualIID (riid, &IID_IClassFactory)) {
*ppv = &MarkerTrack_CF;
IClassFactory_AddRef((IClassFactory*)*ppv);
return S_OK;
} else if (IsEqualCLSID (rclsid, &CLSID_DirectMusicLyricsTrack) && IsEqualIID (riid, &IID_IClassFactory)) {
*ppv = &LyricsTrack_CF;
IClassFactory_AddRef((IClassFactory*)*ppv);
return S_OK;
} else if (IsEqualCLSID (rclsid, &CLSID_DirectMusicSegTriggerTrack) && IsEqualIID (riid, &IID_IClassFactory)) {
*ppv = &SegTriggerTrack_CF;
IClassFactory_AddRef((IClassFactory*)*ppv);
return S_OK;
} else if (IsEqualCLSID (rclsid, &CLSID_DirectMusicAudioPath) && IsEqualIID (riid, &IID_IClassFactory)) {
*ppv = &AudioPath_CF;
IClassFactory_AddRef((IClassFactory*)*ppv);
return S_OK;
} else if (IsEqualCLSID (rclsid, &CLSID_DirectMusicWaveTrack) && IsEqualIID (riid, &IID_IClassFactory)) {
*ppv = &WaveTrack_CF;
IClassFactory_AddRef((IClassFactory*)*ppv);
return S_OK;
}
WARN("(%s, %s, %p): no interface found.\n", debugstr_dmguid(rclsid), debugstr_dmguid(riid), ppv);
return CLASS_E_CLASSNOTAVAILABLE;
}
static void
init_interrupt_handler(intel_info &info)
{
info.shared_info->vblank_sem = create_sem(0, "intel extreme vblank");
if (info.shared_info->vblank_sem < B_OK)
return;
status_t status = B_OK;
// We need to change the owner of the sem to the calling team (usually the
// app_server), because userland apps cannot acquire kernel semaphores
thread_id thread = find_thread(NULL);
thread_info threadInfo;
if (get_thread_info(thread, &threadInfo) != B_OK
|| set_sem_owner(info.shared_info->vblank_sem, threadInfo.team)
!= B_OK) {
status = B_ERROR;
}
// Find the right interrupt vector, using MSIs if available.
info.irq = 0xff;
info.use_msi = false;
if (info.pci->u.h0.interrupt_pin != 0x00)
info.irq = info.pci->u.h0.interrupt_line;
if (gPCIx86Module != NULL && gPCIx86Module->get_msi_count(info.pci->bus,
info.pci->device, info.pci->function) >= 1) {
uint8 msiVector = 0;
if (gPCIx86Module->configure_msi(info.pci->bus, info.pci->device,
info.pci->function, 1, &msiVector) == B_OK
&& gPCIx86Module->enable_msi(info.pci->bus, info.pci->device,
info.pci->function) == B_OK) {
ERROR("using message signaled interrupts\n");
info.irq = msiVector;
info.use_msi = true;
}
}
if (status == B_OK && info.irq != 0xff) {
// we've gotten an interrupt line for us to use
info.fake_interrupts = false;
status = install_io_interrupt_handler(info.irq,
&intel_interrupt_handler, (void*)&info, 0);
if (status == B_OK) {
write32(info, INTEL_DISPLAY_A_PIPE_STATUS,
DISPLAY_PIPE_VBLANK_STATUS | DISPLAY_PIPE_VBLANK_ENABLED);
write32(info, INTEL_DISPLAY_B_PIPE_STATUS,
DISPLAY_PIPE_VBLANK_STATUS | DISPLAY_PIPE_VBLANK_ENABLED);
write16(info, find_reg(info, INTEL_INTERRUPT_IDENTITY), ~0);
// enable interrupts - we only want VBLANK interrupts
bool hasPCH = info.device_type.HasPlatformControlHub();
uint16 enable = hasPCH
? (PCH_INTERRUPT_VBLANK_PIPEA | PCH_INTERRUPT_VBLANK_PIPEB)
: (INTERRUPT_VBLANK_PIPEA | INTERRUPT_VBLANK_PIPEB);
write16(info, find_reg(info, INTEL_INTERRUPT_ENABLED), enable);
write16(info, find_reg(info, INTEL_INTERRUPT_MASK), ~enable);
}
}
if (status < B_OK) {
// There is no interrupt reserved for us, or we couldn't install our
// interrupt handler, let's fake the vblank interrupt for our clients
// using a timer interrupt
info.fake_interrupts = true;
// TODO: fake interrupts!
TRACE("Fake interrupt mode (no PCI interrupt line assigned\n");
status = B_ERROR;
}
if (status < B_OK) {
delete_sem(info.shared_info->vblank_sem);
info.shared_info->vblank_sem = B_ERROR;
}
}
static struct dentry *sf_mount(struct file_system_type *fs_type, int flags,
const char *dev_name, void *data)
{
TRACE();
return mount_nodev(fs_type, flags, data, sf_read_super_26);
}