A1(PUBLIC, void, RAMSDClose, SPortSel, port) /* IMII-250 */ { switch (port) { case sPortA: (void) CloseDriver(AINREFNUM); (void) CloseDriver(AOUTREFNUM); break; case sPortB: (void) CloseDriver(BINREFNUM); (void) CloseDriver(BOUTREFNUM); break; } }
void ndiSerialClose(long serial_port) { int i; /* restore the comm port state to from before it was opened */ for (i = 0; i < NDI_MAX_SAVE_STATE; i++) { if (ndi_open_handles[i] == serial_port && ndi_open_handles[i] != -1) { ndi_open_handles[i] = -1; break; } } CloseDriver(input_file(serial_port)); CloseDriver(output_file(serial_port)); }
/****************************************************************** * DRIVER_UnloadAll * * */ void DRIVER_UnloadAll(void) { LPWINE_DRIVER lpDrv; LPWINE_DRIVER lpNextDrv = NULL; unsigned count = 0; restart: EnterCriticalSection( &mmdriver_lock ); for (lpDrv = lpDrvItemList; lpDrv != NULL; lpDrv = lpNextDrv) { lpNextDrv = lpDrv->lpNextItem; /* session instances will be unloaded automatically */ if (!(lpDrv->dwFlags & WINE_GDF_SESSION)) { LeaveCriticalSection( &mmdriver_lock ); CloseDriver((HDRVR)lpDrv, 0, 0); count++; /* restart from the beginning of the list */ goto restart; } } LeaveCriticalSection( &mmdriver_lock ); TRACE("Unloaded %u drivers\n", count); }
/*********************************************************************** * acmDriverClose (MSACM32.4) */ MMRESULT WINAPI acmDriverClose(HACMDRIVER had, DWORD fdwClose) { PWINE_ACMDRIVER p; PWINE_ACMDRIVER* tp; if (fdwClose) return MMSYSERR_INVALFLAG; p = MSACM_GetDriver(had); if (!p) return MMSYSERR_INVALHANDLE; for (tp = &(p->obj.pACMDriverID->pACMDriverList); *tp; *tp = (*tp)->pNextACMDriver) { if (*tp == p) { *tp = (*tp)->pNextACMDriver; break; } } if (p->hDrvr && !p->obj.pACMDriverID->pACMDriverList) CloseDriver(p->hDrvr); HeapFree(MSACM_hHeap, 0, p); return MMSYSERR_NOERROR; }
long ndiSerialOpen(const char *device) { short serial_out, serial_in; /* macintosh device handles */ long serial_port; /* hold them both, packed into 32 bits */ char namein[64], nameout[64]; int i; sprintf(namein,"%sIn",device); sprintf(nameout,"%sOut",device); if (OpenDriver(namein, &serial_in) != noErr) { return -1; } if (OpenDriver(nameout,&serial_out) != noErr) { CloseDriver(serial_in); return -1; } /* combine the two shorts into one long */ serial_port = ((serial_in << 0) | (serial_out << 16)); /* save the serial port state so that it can be restored when the serial port is closed in ndiSerialClose() */ for (i = 0; i < NDI_MAX_SAVE_STATE; i++) { if (ndi_open_handles[i] == serial_port || ndi_open_handles[i] == -1) { ndi_open_handles[i] = serial_port; break; } } return serial_port; }
/*********************************************************************** * ICClose [MSVFW32.@] */ LRESULT WINAPI ICClose(HIC hic) { WINE_HIC* whic = MSVIDEO_GetHicPtr(hic); WINE_HIC** p; TRACE("(%p)\n",hic); if (!whic) return ICERR_BADHANDLE; if (whic->driverproc) { MSVIDEO_SendMessage(whic, DRV_CLOSE, 0, 0); MSVIDEO_SendMessage(whic, DRV_DISABLE, 0, 0); MSVIDEO_SendMessage(whic, DRV_FREE, 0, 0); } else { CloseDriver(whic->hdrv, 0, 0); } /* remove whic from list */ for (p = &MSVIDEO_FirstHic; *p != NULL; p = &((*p)->next)) { if ((*p) == whic) { *p = whic->next; break; } } HeapFree(GetProcessHeap(), 0, whic); return 0; }
MidiInputDeviceMidiShare::~MidiInputDeviceMidiShare() { #if defined(MIDISHARE_DRIVER) CloseDriver(); #else CloseAppl(); #endif MidiFreeFilter(hMidiFilter); }
/* find all drivers that can be loaded */ static void findAudioDrivers(void) { int numFound = 0; const AUDIO_DRIVER *pAudioDrv = NULL; HCURSOR old_cursor; /* delete an existing list */ HeapFree(GetProcessHeap(), 0, loadedAudioDrv); loadedAudioDrv = 0; /* change to the wait cursor because this can take a while if there is a * misbehaving driver that takes a long time to open */ old_cursor = SetCursor(LoadCursor(0, IDC_WAIT)); for (pAudioDrv = sAudioDrivers; pAudioDrv->nameID; pAudioDrv++) { if (strlen(pAudioDrv->szDriver)) { HDRVR hdrv; char driver[MAX_PATH]; sprintf(driver, "wine%s.drv", pAudioDrv->szDriver); if ((hdrv = OpenDriverA(driver, 0, 0))) { CloseDriver(hdrv, 0, 0); if (loadedAudioDrv) loadedAudioDrv = HeapReAlloc(GetProcessHeap(), 0, loadedAudioDrv, (numFound + 1) * sizeof(AUDIO_DRIVER)); else loadedAudioDrv = HeapAlloc(GetProcessHeap(), 0, sizeof(AUDIO_DRIVER)); CopyMemory(&loadedAudioDrv[numFound], pAudioDrv, sizeof(AUDIO_DRIVER)); numFound++; } } } /* restore the original cursor */ SetCursor(old_cursor); /* terminate list with empty driver */ if (numFound) { loadedAudioDrv = HeapReAlloc(GetProcessHeap(), 0, loadedAudioDrv, (numFound + 1) * sizeof(AUDIO_DRIVER)); CopyMemory(&loadedAudioDrv[numFound], pAudioDrv, sizeof(AUDIO_DRIVER)); } else { loadedAudioDrv = HeapAlloc(GetProcessHeap(), 0, sizeof(AUDIO_DRIVER)); CopyMemory(&loadedAudioDrv[0], pAudioDrv, sizeof(AUDIO_DRIVER)); } }
/*********************************************************************** * acmDriverClose (MSACM32.@) */ MMRESULT WINAPI acmDriverClose(HACMDRIVER had, DWORD fdwClose) { PWINE_ACMDRIVER pad; PWINE_ACMDRIVERID padid; PWINE_ACMDRIVER* tpad; TRACE("(%p, %08x)\n", had, fdwClose); if (fdwClose) { WARN("invalid flag\n"); return MMSYSERR_INVALFLAG; } pad = MSACM_GetDriver(had); if (!pad) { WARN("invalid handle\n"); return MMSYSERR_INVALHANDLE; } padid = pad->obj.pACMDriverID; /* remove driver from list */ for (tpad = &(padid->pACMDriverList); *tpad; tpad = &((*tpad)->pNextACMDriver)) { if (*tpad == pad) { *tpad = (*tpad)->pNextACMDriver; break; } } /* close driver if it has been opened */ if (pad->hDrvr && !pad->pLocalDrvrInst) CloseDriver(pad->hDrvr, 0, 0); else if (pad->pLocalDrvrInst) MSACM_CloseLocalDriver(pad->pLocalDrvrInst); pad->obj.dwType = 0; HeapFree(MSACM_hHeap, 0, pad); return MMSYSERR_NOERROR; }
/* display a driver specific configuration dialog */ static void configureAudioDriver(HWND hDlg) { const AUDIO_DRIVER *pAudioDrv = &loadedAudioDrv[toConfigure]; if (strlen(pAudioDrv->szDriver) != 0) { HDRVR hdrvr; char wine_driver[MAX_NAME_LENGTH + 9]; sprintf(wine_driver, "wine%s.drv", pAudioDrv->szDriver); hdrvr = OpenDriverA(wine_driver, 0, 0); if (hdrvr != 0) { if (SendDriverMessage(hdrvr, DRV_QUERYCONFIGURE, 0, 0) != 0) { DRVCONFIGINFO dci; LONG lRes; dci.dwDCISize = sizeof (dci); dci.lpszDCISectionName = NULL; dci.lpszDCIAliasName = NULL; lRes = SendDriverMessage(hdrvr, DRV_CONFIGURE, 0, (LONG_PTR)&dci); } CloseDriver(hdrvr, 0, 0); } else { WCHAR wine_driverW[MAX_NAME_LENGTH+9]; WCHAR messageStr[256]; WCHAR str[1024]; MultiByteToWideChar (CP_ACP, 0, wine_driver, -1, wine_driverW, sizeof (wine_driverW)/sizeof(wine_driverW[0])); LoadStringW (GetModuleHandle (NULL), IDS_OPEN_DRIVER_ERROR, messageStr, sizeof(messageStr)/sizeof(messageStr[0])); wsprintfW (str, messageStr, wine_driverW); MessageBoxW (hDlg, str, NULL, MB_OK | MB_ICONERROR); } } }
/************************************************************************** * DRIVER_TryOpenDriver32 [internal] * * Tries to load a 32 bit driver whose DLL's (module) name is fn */ LPWINE_DRIVER DRIVER_TryOpenDriver32(LPCWSTR fn, LPARAM lParam2) { LPWINE_DRIVER lpDrv = NULL; HMODULE hModule = 0; LPWSTR ptr; LPCSTR cause = 0; TRACE("(%s, %08lX);\n", debugstr_w(fn), lParam2); if ((ptr = strchrW(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 = LoadLibraryW(fn)) == 0) {cause = "Not a 32 bit lib"; goto exit;} lpDrv->lpDrvProc = (DRIVERPROC)GetProcAddress(hModule, "DriverProc"); if (lpDrv->lpDrvProc == NULL) {cause = "no DriverProc"; goto exit;} lpDrv->dwFlags = 0; lpDrv->hModule = hModule; lpDrv->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->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; } lpDrv->dwFlags |= WINE_GDF_SESSION; 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_w(fn), cause); return NULL; }
P1(PUBLIC pascal trap, void, CloseDeskAcc, INTEGER, rn) { CloseDriver(rn); }
static void initAudioDeviceTree(HWND hDlg) { const AUDIO_DRIVER *pAudioDrv = NULL; int i, j; TVINSERTSTRUCTW insert; HTREEITEM root, driver[10]; HWND tree = NULL; HIMAGELIST hImageList; HBITMAP hBitMap; HCURSOR old_cursor; WCHAR driver_type[64], dev_type[64]; tree = GetDlgItem(hDlg, IDC_AUDIO_TREE); if (!tree) return; /* set tree view style */ SetWindowLong(tree, GWL_STYLE, GetWindowLong(tree, GWL_STYLE) | TVS_HASBUTTONS | TVS_HASLINES | TVS_LINESATROOT); /* state checkbox */ hImageList = ImageList_Create(16, 16, FALSE, 3, 0); hBitMap = LoadBitmap(GetModuleHandle(NULL), MAKEINTRESOURCE(IDB_CHECKBOX)); ImageList_Add(hImageList, hBitMap, NULL); DeleteObject(hBitMap); SendMessageW( tree, TVM_SETIMAGELIST, TVSIL_STATE, (LPARAM)hImageList ); /* root item */ LoadStringW (GetModuleHandle (NULL), IDS_SOUNDDRIVERS, driver_type, sizeof(driver_type)/sizeof(driver_type[0])); insert.hParent = TVI_ROOT; insert.hInsertAfter = TVI_LAST; insert.u.item.mask = TVIF_TEXT | TVIF_CHILDREN; insert.u.item.pszText = driver_type; insert.u.item.cChildren = 1; root = (HTREEITEM)SendDlgItemMessageW (hDlg, IDC_AUDIO_TREE, TVM_INSERTITEMW, 0, (LPARAM)&insert); /* change to the wait cursor because this can take a while if there is a * misbehaving driver that takes a long time to open */ old_cursor = SetCursor(LoadCursor(0, IDC_WAIT)); /* iterate over list of loaded drivers */ for (pAudioDrv = loadedAudioDrv, i = 0; pAudioDrv->nameID; i++, pAudioDrv++) { HDRVR hdrv; char name[MAX_PATH]; WCHAR text[MAX_PATH]; sprintf(name, "wine%s.drv", pAudioDrv->szDriver); LoadStringW (GetModuleHandle (NULL), pAudioDrv->nameID, text, sizeof(text)/sizeof(text[0])); if ((hdrv = OpenDriverA(name, 0, 0))) { HMODULE lib; if ((lib = GetDriverModuleHandle(hdrv))) { int num_wod = 0, num_wid = 0, num_mod = 0, num_mid = 0, num_aux = 0, num_mxd = 0; MessagePtr wodMessagePtr = (MessagePtr)GetProcAddress(lib, "wodMessage"); MessagePtr widMessagePtr = (MessagePtr)GetProcAddress(lib, "widMessage"); MessagePtr modMessagePtr = (MessagePtr)GetProcAddress(lib, "modMessage"); MessagePtr midMessagePtr = (MessagePtr)GetProcAddress(lib, "midMessage"); MessagePtr auxMessagePtr = (MessagePtr)GetProcAddress(lib, "auxMessage"); MessagePtr mxdMessagePtr = (MessagePtr)GetProcAddress(lib, "mxdMessage"); if (wodMessagePtr) num_wod = wodMessagePtr(0, WODM_GETNUMDEVS, 0, 0, 0); if (widMessagePtr) num_wid = widMessagePtr(0, WIDM_GETNUMDEVS, 0, 0, 0); if (modMessagePtr) num_mod = modMessagePtr(0, MODM_GETNUMDEVS, 0, 0, 0); if (midMessagePtr) num_mid = midMessagePtr(0, MIDM_GETNUMDEVS, 0, 0, 0); if (auxMessagePtr) num_aux = auxMessagePtr(0, AUXDM_GETNUMDEVS, 0, 0, 0); if (mxdMessagePtr) num_mxd = mxdMessagePtr(0, MXDM_GETNUMDEVS, 0, 0, 0); if (num_wod == 0 && num_wid == 0 && num_mod == 0 && num_mid == 0 && num_aux == 0 && num_mxd == 0) { insert.hParent = root; insert.u.item.mask = TVIF_TEXT | TVIF_STATE | TVIF_PARAM; insert.u.item.pszText = text; insert.u.item.stateMask = TVIS_STATEIMAGEMASK; insert.u.item.lParam = i + DRIVER_MASK; if (isDriverSet(pAudioDrv->szDriver)) insert.u.item.state = INDEXTOSTATEIMAGEMASK(2); else insert.u.item.state = INDEXTOSTATEIMAGEMASK(1); driver[i] = (HTREEITEM)SendDlgItemMessageW (hDlg, IDC_AUDIO_TREE, TVM_INSERTITEMW, 0, (LPARAM)&insert); } else { HTREEITEM type; insert.hParent = root; insert.u.item.mask = TVIF_TEXT | TVIF_CHILDREN | TVIF_STATE | TVIF_PARAM; insert.u.item.pszText = text; insert.u.item.cChildren = 1; insert.u.item.stateMask = TVIS_STATEIMAGEMASK; insert.u.item.lParam = i + DRIVER_MASK; if (isDriverSet(pAudioDrv->szDriver)) insert.u.item.state = INDEXTOSTATEIMAGEMASK(2); else insert.u.item.state = INDEXTOSTATEIMAGEMASK(1); driver[i] = (HTREEITEM)SendDlgItemMessageW (hDlg, IDC_AUDIO_TREE, TVM_INSERTITEMW, 0, (LPARAM)&insert); if (num_wod) { LoadStringW (GetModuleHandle (NULL), IDS_DEVICES_WAVEOUT, dev_type, sizeof(dev_type)/sizeof(dev_type[0])); insert.hParent = driver[i]; insert.u.item.mask = TVIF_TEXT | TVIF_CHILDREN; insert.u.item.pszText = dev_type; insert.u.item.cChildren = 1; type = (HTREEITEM)SendDlgItemMessageW (hDlg, IDC_AUDIO_TREE, TVM_INSERTITEMW, 0, (LPARAM)&insert); for (j = 0; j < num_wod; j++) { WAVEOUTCAPSW caps; wodMessagePtr(j, WODM_GETDEVCAPS, 0, (DWORD_PTR)&caps, sizeof(caps)); insert.hParent = type; insert.u.item.mask = TVIF_TEXT | TVIF_PARAM; insert.u.item.pszText = caps.szPname; insert.u.item.lParam = j + DEVICE_MASK; SendDlgItemMessageW (hDlg, IDC_AUDIO_TREE, TVM_INSERTITEMW, 0, (LPARAM)&insert); } } if (num_wid) { LoadStringW (GetModuleHandle (NULL), IDS_DEVICES_WAVEIN, dev_type, sizeof(dev_type)/sizeof(dev_type[0])); insert.hParent = driver[i]; insert.u.item.mask = TVIF_TEXT | TVIF_CHILDREN; insert.u.item.pszText = dev_type; insert.u.item.cChildren = 1; type = (HTREEITEM)SendDlgItemMessageW (hDlg, IDC_AUDIO_TREE, TVM_INSERTITEMW, 0, (LPARAM)&insert); for (j = 0; j < num_wid; j++) { WAVEINCAPSW caps; widMessagePtr(j, WIDM_GETDEVCAPS, 0, (DWORD_PTR)&caps, sizeof(caps)); insert.hParent = type; insert.u.item.mask = TVIF_TEXT | TVIF_PARAM; insert.u.item.pszText = caps.szPname; insert.u.item.lParam = j + DEVICE_MASK; SendDlgItemMessageW (hDlg, IDC_AUDIO_TREE, TVM_INSERTITEMW, 0, (LPARAM)&insert); } } if (num_mod) { LoadStringW (GetModuleHandle (NULL), IDS_DEVICES_MIDIOUT, dev_type, sizeof(dev_type)/sizeof(dev_type[0])); insert.hParent = driver[i]; insert.u.item.mask = TVIF_TEXT | TVIF_CHILDREN; insert.u.item.pszText = dev_type; insert.u.item.cChildren = 1; type = (HTREEITEM)SendDlgItemMessageW (hDlg, IDC_AUDIO_TREE, TVM_INSERTITEMW, 0, (LPARAM)&insert); for (j = 0; j < num_mod; j++) { MIDIOUTCAPSW caps; modMessagePtr(j, MODM_GETDEVCAPS, 0, (DWORD_PTR)&caps, sizeof(caps)); insert.hParent = type; insert.u.item.mask = TVIF_TEXT | TVIF_PARAM; insert.u.item.pszText = caps.szPname; insert.u.item.lParam = j + DEVICE_MASK; SendDlgItemMessageW (hDlg, IDC_AUDIO_TREE, TVM_INSERTITEMW, 0, (LPARAM)&insert); } } if (num_mid) { LoadStringW (GetModuleHandle (NULL), IDS_DEVICES_MIDIIN, dev_type, sizeof(dev_type)/sizeof(dev_type[0])); insert.hParent = driver[i]; insert.u.item.mask = TVIF_TEXT | TVIF_CHILDREN; insert.u.item.pszText = dev_type; insert.u.item.cChildren = 1; type = (HTREEITEM)SendDlgItemMessageW (hDlg, IDC_AUDIO_TREE, TVM_INSERTITEMW, 0, (LPARAM)&insert); for (j = 0; j < num_mid; j++) { MIDIINCAPSW caps; midMessagePtr(j, MIDM_GETDEVCAPS, 0, (DWORD_PTR)&caps, sizeof(caps)); insert.hParent = type; insert.u.item.mask = TVIF_TEXT | TVIF_PARAM; insert.u.item.pszText = caps.szPname; insert.u.item.lParam = j + DEVICE_MASK; SendDlgItemMessageW (hDlg, IDC_AUDIO_TREE, TVM_INSERTITEMW, 0, (LPARAM)&insert); } } if (num_aux) { LoadStringW (GetModuleHandle (NULL), IDS_DEVICES_AUX, dev_type, sizeof(dev_type)/sizeof(dev_type[0])); insert.hParent = driver[i]; insert.u.item.mask = TVIF_TEXT | TVIF_CHILDREN; insert.u.item.pszText = dev_type; insert.u.item.cChildren = 1; type = (HTREEITEM)SendDlgItemMessageW (hDlg, IDC_AUDIO_TREE, TVM_INSERTITEMW, 0, (LPARAM)&insert); for (j = 0; j < num_aux; j++) { AUXCAPSW caps; auxMessagePtr(j, AUXDM_GETDEVCAPS, 0, (DWORD_PTR)&caps, sizeof(caps)); insert.hParent = type; insert.u.item.mask = TVIF_TEXT | TVIF_PARAM; insert.u.item.pszText = caps.szPname; insert.u.item.lParam = j + DEVICE_MASK; SendDlgItemMessageW (hDlg, IDC_AUDIO_TREE, TVM_INSERTITEMW, 0, (LPARAM)&insert); } } if (num_mxd) { LoadStringW (GetModuleHandle (NULL), IDS_DEVICES_MIXER, dev_type, sizeof(dev_type)/sizeof(dev_type[0])); insert.hParent = driver[i]; insert.u.item.mask = TVIF_TEXT | TVIF_CHILDREN; insert.u.item.pszText = dev_type; insert.u.item.cChildren = 1; type = (HTREEITEM)SendDlgItemMessageW (hDlg, IDC_AUDIO_TREE, TVM_INSERTITEMW, 0, (LPARAM)&insert); for (j = 0; j < num_mxd; j++) { MIXERCAPSW caps; mxdMessagePtr(j, MXDM_GETDEVCAPS, 0, (DWORD_PTR)&caps, sizeof(caps)); insert.hParent = type; insert.u.item.mask = TVIF_TEXT | TVIF_PARAM; insert.u.item.pszText = caps.szPname; insert.u.item.lParam = j + DEVICE_MASK; SendDlgItemMessageW (hDlg, IDC_AUDIO_TREE, TVM_INSERTITEMW, 0, (LPARAM)&insert); } } } } CloseDriver(hdrv, 0, 0); } } /* restore the original cursor */ SetCursor(old_cursor); SendDlgItemMessage(hDlg, IDC_AUDIO_TREE, TVM_SELECTITEM, 0, 0); SendDlgItemMessage(hDlg, IDC_AUDIO_TREE, TVM_EXPAND, TVE_EXPAND, (LPARAM)root); for (j = 0; j < i; j++) SendDlgItemMessage(hDlg, IDC_AUDIO_TREE, TVM_EXPAND, TVE_EXPAND, (LPARAM)driver[j]); }
CGPIODriver::~CGPIODriver() { CloseDriver(); }
XNSDriverClient::~XNSDriverClient() { CloseDriver(); }
CPWMDriver::~CPWMDriver() { CloseDriver(); }
/* * REQUIREMENTS * CLSemaphore must be obtained and the clusters mutex must * not be exclusive locked. The link must not be freed before calling. * NOTE * A cluster can never have both a hardware receiver and sender. */ void LinkHasBeenRemovedFromCluster(struct MidiCluster *cluster,struct CamdBase *CamdBase){ struct Node *node; struct DriverData *driverdata; if( ! (IsListEmpty(&cluster->mcl_Receivers))){ node=cluster->mcl_Receivers.lh_Head; while(node->ln_Succ!=NULL){ if(node->ln_Type==NT_USER-MLTYPE_NTypes){ /* We now know that the cluster has a hardware-receiver. */ if(IsListEmpty(&cluster->mcl_Senders)){ /* And we now know that the cluster has no senders. */ driverdata=(struct DriverData *)cluster->mcl_Receivers.lh_Head; /* We mark the hardware-receiver not to be in use. */ if(driverdata->isOutOpen==TRUE){ driverdata->isOutOpen=FALSE; /* And we close it if the hardware-sender is not in use either. */ if(driverdata->isInOpen==FALSE){ CloseDriver(driverdata,CamdBase); } } } break; } node=node->ln_Succ; } } if( ! (IsListEmpty(&cluster->mcl_Senders))){ node=cluster->mcl_Senders.lh_Head; while(node->ln_Succ!=NULL){ if(node->ln_Type==NT_USER-MLTYPE_NTypes){ /* We now now that the cluster only has a hardware-sender. */ if(IsListEmpty(&cluster->mcl_Receivers)){ /* And we now know that the cluster has no senders. */ driverdata=(struct DriverData *)cluster->mcl_Senders.lh_Head; driverdata=(struct DriverData *)(((char *)driverdata-sizeof(struct Node))); /* We mark the hardware-sender not to be in use. */ if(driverdata->isInOpen==TRUE){ driverdata->isInOpen=FALSE; /* And we close it if the hardware-receiver is not in use either. */ if(driverdata->isOutOpen==FALSE){ CloseDriver(driverdata,CamdBase); } } } break; } node=node->ln_Succ; } return; } if( (IsListEmpty(&cluster->mcl_Receivers)) && (IsListEmpty(&cluster->mcl_Senders)) ){ RemoveCluster(cluster,CamdBase); } }
void AudioDriver::Close() { CloseDriver() ; };
/*********************************************************************** * ICOpen [MSVFW32.@] * Opens an installable compressor. Return special handle. */ HIC VFWAPI ICOpen(DWORD fccType, DWORD fccHandler, UINT wMode) { WCHAR codecname[10]; ICOPEN icopen; HDRVR hdrv; WINE_HIC* whic; static const WCHAR drv32W[] = {'d','r','i','v','e','r','s','3','2','\0'}; reg_driver* driver; TRACE("(%s,%s,0x%08x)\n", wine_dbgstr_fcc(fccType), wine_dbgstr_fcc(fccHandler), wMode); /* Check if there is a registered driver that matches */ driver = reg_driver_list; while(driver) if (!compare_fourcc(fccType, driver->fccType) && !compare_fourcc(fccHandler, driver->fccHandler)) break; else driver = driver->next; if (driver && driver->proc) /* The driver has been registered at runtime with its driverproc */ return ICOpenFunction(fccType, fccHandler, wMode, driver->proc); /* Well, lParam2 is in fact a LPVIDEO_OPEN_PARMS, but it has the * same layout as ICOPEN */ icopen.dwSize = sizeof(ICOPEN); icopen.fccType = fccType; icopen.fccHandler = fccHandler; icopen.dwVersion = 0x00001000; /* FIXME */ icopen.dwFlags = wMode; icopen.dwError = 0; icopen.pV1Reserved = NULL; icopen.pV2Reserved = NULL; icopen.dnDevNode = 0; /* FIXME */ if (!driver) { /* The driver is registered in the registry */ fourcc_to_string(codecname, fccType); codecname[4] = '.'; fourcc_to_string(codecname + 5, fccHandler); codecname[9] = '\0'; hdrv = OpenDriver(codecname, drv32W, (LPARAM)&icopen); if (!hdrv) return 0; } else { /* The driver has been registered at runtime with its name */ hdrv = OpenDriver(driver->name, NULL, (LPARAM)&icopen); if (!hdrv) return 0; } whic = HeapAlloc(GetProcessHeap(), 0, sizeof(WINE_HIC)); if (!whic) { CloseDriver(hdrv, 0, 0); return FALSE; } whic->hdrv = hdrv; whic->driverproc = NULL; whic->type = fccType; whic->handler = fccHandler; while (MSVIDEO_GetHicPtr((HIC)(ULONG_PTR)IC_HandleRef) != NULL) IC_HandleRef++; whic->hic = (HIC)(ULONG_PTR)IC_HandleRef++; whic->next = MSVIDEO_FirstHic; MSVIDEO_FirstHic = whic; TRACE("=> %p\n", whic->hic); return whic->hic; }
int main(int argc, char *argv[]) { char *driver = NULL; char *fourcc = NULL; char *filename = NULL; unsigned char mode = 0; DWORD dwFCC = 0; ICOPEN icopen; HRESULT coinit = S_FALSE; /* ICINFO icinfo; */ wchar_t drvfile[MAX_PATH]; HDRVR hDriver = NULL; int ret = 0; int c = -1, long_options_index = -1; if (argc < 2) { help(argv[0]); ret = -1; goto cleanup; } while ((c = getopt_long(argc, argv, "hd:f:s:c:v", long_options, &long_options_index)) != -1) { switch (c) { case 'h': help(argv[0]); ret = 0; goto cleanup; case 'd': driver = strdup(optarg); break; case 'f': fourcc = strdup(optarg); if (strlen(optarg) != 4) BAIL("Fourcc must be exactly 4 chars"); break; case 's': if (mode != MODE_NONE) BAIL("Incompatible arguments"); filename = strdup(optarg); mode = MODE_SAVE; break; case 'c': if (mode != MODE_NONE) BAIL("Incompatible arguments"); filename = strdup(optarg); mode = MODE_CHECK; break; case 'v': if (mode != MODE_NONE) BAIL("Incompatible arguments"); mode = MODE_VIEW; break; default: printf("Wrong arguments!\n"); help(argv[0]); goto cleanup; } } if (!(argc == optind) && (mode != MODE_NONE) && driver && (filename || (mode == MODE_VIEW))) { help(argv[0]); goto cleanup; } if (!MultiByteToWideChar(CP_ACP, 0, driver, -1, drvfile, MAX_PATH)) BAIL("MultiByteToWideChar() failed\n"); if (fourcc) memcpy(&dwFCC, fourcc, 4); memset(&icopen, 0, sizeof(icopen)); icopen.dwSize = sizeof(icopen); icopen.fccType = ICTYPE_VIDEO; /* VIDC */ icopen.fccHandler = dwFCC; icopen.dwVersion = 0x00001000; /* FIXME */ icopen.dwFlags = ICMODE_COMPRESS; icopen.dwError = 0; icopen.pV1Reserved = NULL; icopen.pV2Reserved = NULL; icopen.dnDevNode = -1; /* FIXME */ coinit = CoInitialize(NULL); if (!(hDriver = OpenDriver(drvfile, NULL, (LPARAM) &icopen))) BAIL("OpenDriver() failed\n"); /* memset(&icinfo, 0, sizeof(ICINFO)); icinfo.dwSize = sizeof(ICINFO); SendDriverMessage(hDriver, ICM_GETINFO, (LPARAM) &icinfo, sizeof(ICINFO)); */ if (SendDriverMessage(hDriver, ICM_CONFIGURE, -1, 0) != ICERR_OK) BAIL("The driver doesn't provide a configure dialog"); switch(mode) { case MODE_CHECK: if (load_settings(hDriver, filename)) BAIL("Cannot load settings from file"); if (SendDriverMessage(hDriver, ICM_CONFIGURE, 0, 0) != ICERR_OK) BAIL("ICM_CONFIGURE failed"); break; case MODE_SAVE: if (SendDriverMessage(hDriver, ICM_CONFIGURE, 0, 0) != ICERR_OK) BAIL("ICM_CONFIGURE failed"); if (save_settings(hDriver, filename)) BAIL("Cannot save settings to file"); break; case MODE_VIEW: { HWND hwnd = GetDesktopWindow(); if (SendDriverMessage(hDriver, ICM_CONFIGURE, (LPARAM) hwnd, 0) != ICERR_OK) BAIL("ICM_CONFIGURE failed"); } break; default: BAIL("This should not happen :)"); } cleanup: if (driver) free(driver); if (fourcc) free(fourcc); if (filename) free(filename); if (hDriver) CloseDriver(hDriver, 0, 0); if (coinit == S_OK) CoUninitialize(); return ret; }
/*********************************************************************** * ICOpen [MSVFW32.@] * Opens an installable compressor. Return special handle. */ HIC VFWAPI ICOpen(DWORD fccType, DWORD fccHandler, UINT wMode) { WCHAR codecname[10]; ICOPEN icopen; HDRVR hdrv; WINE_HIC* whic; static const WCHAR drv32W[] = {'d','r','i','v','e','r','s','3','2','\0'}; reg_driver* driver; TRACE("(%s,%s,0x%08x)\n", wine_dbgstr_fcc(fccType), wine_dbgstr_fcc(fccHandler), wMode); if (!fccHandler) /* No specific handler, return the first valid for wMode */ { HIC local; ICINFO info; DWORD loop = 0; info.dwSize = sizeof(info); while(ICInfo(fccType, loop++, &info)) { /* Ensure fccHandler is not 0x0 because we will recurse on ICOpen */ if(!info.fccHandler) continue; local = ICOpen(fccType, info.fccHandler, wMode); if (local != 0) { TRACE("Returning %s as default handler for %s\n", wine_dbgstr_fcc(info.fccHandler), wine_dbgstr_fcc(fccType)); return local; } } } /* Check if there is a registered driver that matches */ driver = reg_driver_list; while(driver) if (!compare_fourcc(fccType, driver->fccType) && !compare_fourcc(fccHandler, driver->fccHandler)) { fccType = driver->fccType; fccHandler = driver->fccHandler; break; } else driver = driver->next; if (driver && driver->proc) /* The driver has been registered at runtime with its driverproc */ return ICOpenFunction(fccType, fccHandler, wMode, driver->proc); /* Well, lParam2 is in fact a LPVIDEO_OPEN_PARMS, but it has the * same layout as ICOPEN */ icopen.dwSize = sizeof(ICOPEN); icopen.fccType = fccType; icopen.fccHandler = fccHandler; icopen.dwVersion = 0x00001000; /* FIXME */ icopen.dwFlags = wMode; icopen.dwError = 0; icopen.pV1Reserved = NULL; icopen.pV2Reserved = NULL; icopen.dnDevNode = 0; /* FIXME */ if (!driver) { /* normalize to lower case as in 'vidc' */ ((char*)&fccType)[0] = tolower(((char*)&fccType)[0]); ((char*)&fccType)[1] = tolower(((char*)&fccType)[1]); ((char*)&fccType)[2] = tolower(((char*)&fccType)[2]); ((char*)&fccType)[3] = tolower(((char*)&fccType)[3]); icopen.fccType = fccType; /* Seek the driver in the registry */ fourcc_to_string(codecname, fccType); codecname[4] = '.'; fourcc_to_string(codecname + 5, fccHandler); codecname[9] = '\0'; hdrv = OpenDriver(codecname, drv32W, (LPARAM)&icopen); if (!hdrv) return 0; } else { /* The driver has been registered at runtime with its name */ hdrv = OpenDriver(driver->name, NULL, (LPARAM)&icopen); if (!hdrv) return 0; } whic = HeapAlloc(GetProcessHeap(), 0, sizeof(WINE_HIC)); if (!whic) { CloseDriver(hdrv, 0, 0); return FALSE; } whic->hdrv = hdrv; whic->driverproc = NULL; whic->type = fccType; whic->handler = fccHandler; while (MSVIDEO_GetHicPtr((HIC)(ULONG_PTR)IC_HandleRef) != NULL) IC_HandleRef++; whic->hic = (HIC)(ULONG_PTR)IC_HandleRef++; whic->next = MSVIDEO_FirstHic; MSVIDEO_FirstHic = whic; TRACE("=> %p\n", whic->hic); return whic->hic; }