int IFSEXPORT
FS_FINDFIRST(
struct cdfsi far * pcdfsi,
struct cdfsd far * pcdfsd,
char far * pszName,
unsigned short iCurDirEnd,
unsigned short fsAttr,
struct fsfsi far * pfsfsi,
struct fsfsd far * pfsfsd,
char far * pData,
unsigned short cbData,
unsigned short far * pcMatch,
unsigned short usLevel,
unsigned short fsFlags
)
{
int rc, rc2;
struct findfirst far * p = &pRequest->data.findfirst;
if (rc = requestExchangeXS()) return rc;
pRequest->rq = FSRQ_FINDFIRST;
COPYPTR(&p->pVolData, queryVPFSD(pcdfsi->cdi_hVPB));
p->cdfsi = *pcdfsi;
p->cdfsd = *pcdfsd;
if (strlen(pszName) >= CCHMAXPATH)
RELEASE_AND_EXIT(ERROR_INVALID_PARAMETER);
strcpy(p->szName, pszName);
p->iCurDirEnd = iCurDirEnd;
p->fsAttr = fsAttr;
p->cbData = cbData;
p->cMatch = *pcMatch;
p->usLevel = usLevel;
p->fsFlags = fsFlags;
if (usLevel == FIL_QUERYEASFROMLIST) {
rc = copyEAOP((PEAOP) pData, CEA_GEAS_TO_BUF, 0);
if (rc) return rc;
p->cbData -= sizeof(EAOP);
}
if (rc = signalDaemonAndWait()) RELEASE_AND_EXIT(rc);
if (!pRequest->rc || pRequest->rc == ERROR_EAS_DIDNT_FIT) {
rc = FSH_PROBEBUF(PB_OPWRITE, pData, cbData);
if (rc) {
rc2 = undoFindFirst(pcdfsi);
if (rc2) RELEASE_AND_EXIT(rc2);
RELEASE_AND_EXIT(ERROR_INVALID_PARAMETER);
}
if (usLevel == FIL_QUERYEASFROMLIST) {
rc = copyEAOP((PEAOP) pData, CEA_SET_OERROR, p->oError);
if (rc) {
rc2 = undoFindFirst(pcdfsi);
if (rc2) RELEASE_AND_EXIT(rc2);
RELEASE_AND_EXIT(rc);
}
pData += sizeof(EAOP);
cbData -= sizeof(EAOP);
}
memcpy(pData, pFSData, cbData);
}
COPYPTR(pfsfsd, &p->pSearchData);
*pcMatch = p->cMatch;
RELEASE_AND_EXIT(pRequest->rc);
}
/******************************************************************
* MSVIDEO_MapMsg16To32
*
*
*/
static LPVOID MSVIDEO_MapMsg16To32(UINT msg, LPDWORD lParam1, LPDWORD lParam2)
{
LPVOID ret = 0;
TRACE("Mapping %d\n", msg);
switch (msg)
{
case DRV_LOAD:
case DRV_ENABLE:
case DRV_CLOSE:
case DRV_DISABLE:
case DRV_FREE:
case ICM_ABOUT:
case ICM_CONFIGURE:
case ICM_COMPRESS_END:
case ICM_DECOMPRESS_END:
case ICM_DECOMPRESSEX_END:
case ICM_SETQUALITY:
case ICM_DRAW_START_PLAY:
case ICM_DRAW_STOP_PLAY:
case ICM_DRAW_REALIZE:
case ICM_DRAW_RENDERBUFFER:
case ICM_DRAW_END:
break;
case DRV_OPEN:
case ICM_GETDEFAULTQUALITY:
case ICM_GETQUALITY:
case ICM_SETSTATE:
case ICM_DRAW_WINDOW:
case ICM_GETBUFFERSWANTED:
*lParam1 = (DWORD)MapSL(*lParam1);
break;
case ICM_GETINFO:
{
ICINFO *ici = HeapAlloc(GetProcessHeap(), 0, sizeof(ICINFO));
ICINFO16 *ici16;
ici16 = MapSL(*lParam1);
ret = ici16;
ici->dwSize = sizeof(ICINFO);
COPY(ici, fccType);
COPY(ici, fccHandler);
COPY(ici, dwFlags);
COPY(ici, dwVersion);
COPY(ici, dwVersionICM);
MultiByteToWideChar( CP_ACP, 0, ici16->szName, -1, ici->szName, 16 );
MultiByteToWideChar( CP_ACP, 0, ici16->szDescription, -1, ici->szDescription, 128 );
MultiByteToWideChar( CP_ACP, 0, ici16->szDriver, -1, ici->szDriver, 128 );
*lParam1 = (DWORD)(ici);
*lParam2 = sizeof(ICINFO);
}
break;
case ICM_COMPRESS:
{
ICCOMPRESS *icc = HeapAlloc(GetProcessHeap(), 0, sizeof(ICCOMPRESS));
ICCOMPRESS *icc16;
icc16 = MapSL(*lParam1);
ret = icc16;
COPY(icc, dwFlags);
COPYPTR(icc, lpbiOutput);
COPYPTR(icc, lpOutput);
COPYPTR(icc, lpbiInput);
COPYPTR(icc, lpInput);
COPYPTR(icc, lpckid);
COPYPTR(icc, lpdwFlags);
COPY(icc, lFrameNum);
COPY(icc, dwFrameSize);
COPY(icc, dwQuality);
COPYPTR(icc, lpbiPrev);
COPYPTR(icc, lpPrev);
*lParam1 = (DWORD)(icc);
*lParam2 = sizeof(ICCOMPRESS);
}
break;
case ICM_DECOMPRESS:
{
ICDECOMPRESS *icd = HeapAlloc(GetProcessHeap(), 0, sizeof(ICDECOMPRESS));
ICDECOMPRESS *icd16; /* Same structure except for the pointers */
icd16 = MapSL(*lParam1);
ret = icd16;
COPY(icd, dwFlags);
COPYPTR(icd, lpbiInput);
COPYPTR(icd, lpInput);
COPYPTR(icd, lpbiOutput);
COPYPTR(icd, lpOutput);
COPY(icd, ckid);
*lParam1 = (DWORD)(icd);
*lParam2 = sizeof(ICDECOMPRESS);
}
break;
case ICM_COMPRESS_BEGIN:
case ICM_COMPRESS_GET_FORMAT:
case ICM_COMPRESS_GET_SIZE:
case ICM_COMPRESS_QUERY:
case ICM_DECOMPRESS_GET_FORMAT:
case ICM_DECOMPRESS_QUERY:
case ICM_DECOMPRESS_BEGIN:
case ICM_DECOMPRESS_SET_PALETTE:
case ICM_DECOMPRESS_GET_PALETTE:
*lParam1 = (DWORD)MapSL(*lParam1);
*lParam2 = (DWORD)MapSL(*lParam2);
break;
case ICM_DECOMPRESSEX_QUERY:
if ((*lParam2 != sizeof(ICDECOMPRESSEX16)) && (*lParam2 != 0))
WARN("*lParam2 has unknown value %p\n", (ICDECOMPRESSEX16*)*lParam2);
/* FIXME: *lParm2 is meant to be 0 or an ICDECOMPRESSEX16*, but is sizeof(ICDECOMRPESSEX16)
* This is because of ICMessage(). Special case it?
{
LPVOID* addr = HeapAlloc(GetProcessHeap(), 0, 2*sizeof(LPVOID));
addr[0] = MSVIDEO_MapICDEX16To32(lParam1);
if (*lParam2)
addr[1] = MSVIDEO_MapICDEX16To32(lParam2);
else
addr[1] = 0;
ret = addr;
}
break;*/
case ICM_DECOMPRESSEX_BEGIN:
case ICM_DECOMPRESSEX:
ret = MSVIDEO_MapICDEX16To32(lParam1);
*lParam2 = sizeof(ICDECOMPRESSEX);
break;
case ICM_DRAW_BEGIN:
{
ICDRAWBEGIN *icdb = HeapAlloc(GetProcessHeap(), 0, sizeof(ICDRAWBEGIN));
ICDRAWBEGIN16 *icdb16 = MapSL(*lParam1);
ret = icdb16;
COPY(icdb, dwFlags);
icdb->hpal = HPALETTE_32(icdb16->hpal);
icdb->hwnd = HWND_32(icdb16->hwnd);
icdb->hdc = HDC_32(icdb16->hdc);
COPY(icdb, xDst);
COPY(icdb, yDst);
COPY(icdb, dxDst);
COPY(icdb, dyDst);
COPYPTR(icdb, lpbi);
COPY(icdb, xSrc);
COPY(icdb, ySrc);
COPY(icdb, dxSrc);
COPY(icdb, dySrc);
COPY(icdb, dwRate);
COPY(icdb, dwScale);
*lParam1 = (DWORD)(icdb);
*lParam2 = sizeof(ICDRAWBEGIN);
}
break;
case ICM_DRAW_SUGGESTFORMAT:
{
ICDRAWSUGGEST *icds = HeapAlloc(GetProcessHeap(), 0, sizeof(ICDRAWSUGGEST));
ICDRAWSUGGEST16 *icds16 = MapSL(*lParam1);
ret = icds16;
COPY(icds, dwFlags);
COPYPTR(icds, lpbiIn);
COPYPTR(icds, lpbiSuggest);
COPY(icds, dxSrc);
COPY(icds, dySrc);
COPY(icds, dxDst);
COPY(icds, dyDst);
icds->hicDecompressor = HIC_32(icds16->hicDecompressor);
*lParam1 = (DWORD)(icds);
*lParam2 = sizeof(ICDRAWSUGGEST);
}
break;
case ICM_DRAW:
{
ICDRAW *icd = HeapAlloc(GetProcessHeap(), 0, sizeof(ICDRAW));
ICDRAW *icd16 = MapSL(*lParam1);
ret = icd16;
COPY(icd, dwFlags);
COPYPTR(icd, lpFormat);
COPYPTR(icd, lpData);
COPY(icd, cbData);
COPY(icd, lTime);
*lParam1 = (DWORD)(icd);
*lParam2 = sizeof(ICDRAW);
}
break;
case ICM_DRAW_START:
case ICM_DRAW_STOP:
break;
default:
FIXME("%d is not yet handled. Expect a crash.\n", msg);
}
return ret;
}
