static int
COREAUDIO_DetectDevices(int iscapture)
{
if (iscapture) {
build_device_list(1, &inputDevices, &inputDeviceCount);
return inputDeviceCount;
} else {
build_device_list(0, &outputDevices, &outputDeviceCount);
return outputDeviceCount;
}
return 0; /* shouldn't ever hit this. */
}
static void
reprocess_device_list(const int iscapture, AudioDeviceList **list)
{
AudioDeviceList *item;
AudioDeviceList *prev = NULL;
for (item = *list; item != NULL; item = item->next) {
item->alive = SDL_FALSE;
}
build_device_list(iscapture, build_device_change_list, list);
/* free items in the list that aren't still alive. */
item = *list;
while (item != NULL) {
AudioDeviceList *next = item->next;
if (item->alive) {
prev = item;
} else {
SDL_RemoveAudioDevice(iscapture, (void *) ((size_t) item->devid));
if (prev) {
prev->next = item->next;
} else {
*list = item->next;
}
SDL_free(item);
}
item = next;
}
}
static int
find_device_by_name(_THIS, const char *devname, int iscapture)
{
AudioDeviceID devid = 0;
OSStatus result = noErr;
UInt32 size = 0;
UInt32 alive = 0;
pid_t pid = 0;
AudioObjectPropertyAddress addr = {
0,
kAudioObjectPropertyScopeGlobal,
kAudioObjectPropertyElementMaster
};
if (devname == NULL) {
size = sizeof (AudioDeviceID);
addr.mSelector =
((iscapture) ? kAudioHardwarePropertyDefaultInputDevice :
kAudioHardwarePropertyDefaultOutputDevice);
result = AudioObjectGetPropertyData(kAudioObjectSystemObject, &addr,
0, NULL, &size, &devid);
CHECK_RESULT("AudioHardwareGetProperty (default device)");
} else {
FindDevIdData data;
SDL_zero(data);
data.findname = devname;
build_device_list(iscapture, findDevId, &data);
if (!data.found) {
SDL_SetError("CoreAudio: No such audio device.");
return 0;
}
devid = data.devId;
}
addr.mSelector = kAudioDevicePropertyDeviceIsAlive;
addr.mScope = iscapture ? kAudioDevicePropertyScopeInput :
kAudioDevicePropertyScopeOutput;
size = sizeof (alive);
result = AudioObjectGetPropertyData(devid, &addr, 0, NULL, &size, &alive);
CHECK_RESULT
("AudioDeviceGetProperty (kAudioDevicePropertyDeviceIsAlive)");
if (!alive) {
SDL_SetError("CoreAudio: requested device exists, but isn't alive.");
return 0;
}
addr.mSelector = kAudioDevicePropertyHogMode;
size = sizeof (pid);
result = AudioObjectGetPropertyData(devid, &addr, 0, NULL, &size, &pid);
/* some devices don't support this property, so errors are fine here. */
if ((result == noErr) && (pid != -1)) {
SDL_SetError("CoreAudio: requested device is being hogged.");
return 0;
}
this->hidden->deviceID = devid;
return 1;
}
static void
COREAUDIO_DetectDevices(int iscapture, SDL_AddAudioDevice addfn)
{
build_device_list(iscapture, addToDevList, addfn);
}
static inline void
build_device_lists(void)
{
build_device_list(0, &outputDevices, &outputDeviceCount);
build_device_list(1, &inputDevices, &inputDeviceCount);
}
static void
COREAUDIO_DetectDevices(void)
{
build_device_list(SDL_TRUE, addToDevList, NULL);
build_device_list(SDL_FALSE, addToDevList, NULL);
}
static void
rdpusb_process(STREAM s)
{
int rc;
uint32 len;
uint8 code;
uint32 devid;
PUSBPROXYDEV proxy = NULL;
#ifdef RDPUSB_DEBUG
Log(("RDPUSB recv:\n"));
hexdump(s->p, s->end - s->p);
#endif
in_uint32_le (s, len);
if (len > s->end - s->p)
{
error("RDPUSB: not enough data len = %d, bytes left %d\n", len, s->end - s->p);
return;
}
in_uint8(s, code);
Log(("RDPUSB recv: len = %d, code = %d\n", len, code));
switch (code)
{
case RDPUSB_REQ_OPEN:
{
PUSBDEVICE pDevice;
in_uint32_le(s, devid);
proxy = (PUSBPROXYDEV )xmalloc (sizeof (USBPROXYDEV));
if (!proxy)
{
error("RDPUSB: Out of memory allocating proxy backend data\n");
return;
}
memset (proxy, 0, sizeof (USBPROXYDEV));
proxy->pvInstanceDataR3 = xmalloc(g_USBProxyDeviceHost.cbBackend);
if (!proxy->pvInstanceDataR3)
{
xfree (proxy);
error("RDPUSB: Out of memory allocating proxy backend data\n");
return;
}
proxy->Dev.pszName = "Remote device";
proxy->devid = devid;
for (pDevice = g_pUsbDevices; pDevice; pDevice = pDevice->pNext)
if ((pDevice->bPort << 8) + pDevice->bBus == devid)
break;
rc = pDevice ? op_usbproxy_back_open(proxy, pDevice->pszAddress)
: VERR_NOT_FOUND;
if (rc != VINF_SUCCESS)
{
rdpusb_send_access_denied (code, devid);
xfree (proxy);
proxy = NULL;
}
else
{
if (g_proxies)
{
g_proxies->pPrev = proxy;
}
proxy->pNext = g_proxies;
g_proxies = proxy;
}
} break;
case RDPUSB_REQ_CLOSE:
{
in_uint32_le(s, devid);
proxy = devid2proxy (devid);
if (proxy)
{
op_usbproxy_back_close(proxy);
if (proxy->pPrev)
{
proxy->pPrev->pNext = proxy->pNext;
}
else
{
g_proxies = proxy->pNext;
}
if (proxy->pNext)
{
proxy->pNext->pPrev = proxy->pPrev;
}
xfree (proxy->pvInstanceDataR3);
xfree (proxy);
proxy = NULL;
}
/* No reply. */
} break;
case RDPUSB_REQ_RESET:
{
in_uint32_le(s, devid);
proxy = devid2proxy (devid);
if (!proxy)
{
rdpusb_send_access_denied (code, devid);
break;
}
rc = op_usbproxy_back_reset(proxy);
if (rc != VINF_SUCCESS)
{
rdpusb_send_reply (code, vrdp_usb_status (!rc, &proxy->Dev), devid);
}
} break;
case RDPUSB_REQ_SET_CONFIG:
{
uint8 cfg;
in_uint32_le(s, devid);
proxy = devid2proxy (devid);
if (!proxy)
{
rdpusb_send_access_denied (code, devid);
break;
}
in_uint8(s, cfg);
rc = op_usbproxy_back_set_config(proxy, cfg);
if (RT_FAILURE(rc))
{
rdpusb_send_reply (code, vrdp_usb_status (rc, &proxy->Dev), devid);
}
} break;
case RDPUSB_REQ_CLAIM_INTERFACE:
{
uint8 ifnum;
in_uint32_le(s, devid);
proxy = devid2proxy (devid);
if (!proxy)
{
rdpusb_send_access_denied (code, devid);
break;
}
in_uint8(s, ifnum);
in_uint8(s, ifnum);
rc = op_usbproxy_back_claim_interface(proxy, ifnum);
if (RT_FAILURE(rc))
{
rdpusb_send_reply (code, vrdp_usb_status (rc, &proxy->Dev), devid);
}
} break;
case RDPUSB_REQ_RELEASE_INTERFACE:
{
uint8 ifnum;
in_uint32_le(s, devid);
proxy = devid2proxy (devid);
if (!proxy)
{
rdpusb_send_access_denied (code, devid);
break;
}
in_uint8(s, ifnum);
rc = op_usbproxy_back_release_interface(proxy, ifnum);
if (RT_FAILURE(rc))
{
rdpusb_send_reply (code, vrdp_usb_status (rc, &proxy->Dev), devid);
}
} break;
case RDPUSB_REQ_INTERFACE_SETTING:
{
uint8 ifnum;
uint8 setting;
in_uint32_le(s, devid);
proxy = devid2proxy (devid);
if (!proxy)
{
rdpusb_send_access_denied (code, devid);
break;
}
in_uint8(s, ifnum);
in_uint8(s, setting);
rc = op_usbproxy_back_interface_setting(proxy, ifnum, setting);
if (RT_FAILURE(rc))
{
rdpusb_send_reply (code, vrdp_usb_status (rc, &proxy->Dev), devid);
}
} break;
case RDPUSB_REQ_QUEUE_URB:
{
uint32 handle;
uint8 type;
uint8 ep;
uint8 dir;
uint32 urblen;
uint32 datalen;
PVUSBURB pUrb; // struct vusb_urb *urb;
in_uint32_le(s, devid);
proxy = devid2proxy (devid);
if (!proxy)
{
/* No reply. */
break;
}
in_uint32(s, handle);
in_uint8(s, type);
in_uint8(s, ep);
in_uint8(s, dir);
in_uint32(s, urblen);
in_uint32(s, datalen);
/* Allocate a single block for URB description and data buffer */
pUrb = (PVUSBURB)xmalloc (sizeof (VUSBURB) +
(urblen <= sizeof (pUrb->abData)? 0: urblen - sizeof (pUrb->abData))
);
memset (pUrb, 0, sizeof (VUSBURB));
pUrb->pDev = &proxy->Dev;
pUrb->handle = handle;
pUrb->enmType = type;
pUrb->enmStatus = 0;
pUrb->EndPt = ep;
pUrb->enmDir = dir;
pUrb->cbData = urblen;
Log(("RDPUSB: queued URB handle = %d\n", handle));
if (datalen)
{
in_uint8a (s, pUrb->abData, datalen);
}
rc = op_usbproxy_back_queue_urb(proxy, pUrb);
/* No reply required. */
if (RT_SUCCESS(rc))
{
if (proxy->pUrbs)
{
proxy->pUrbs->pPrev = pUrb;
}
pUrb->pNext = proxy->pUrbs;
proxy->pUrbs = pUrb;
}
else
{
xfree (pUrb);
}
} break;
case RDPUSB_REQ_REAP_URB:
{
rdpusb_reap_urbs ();
} break;
case RDPUSB_REQ_CLEAR_HALTED_EP:
{
uint8 ep;
in_uint32_le(s, devid);
proxy = devid2proxy (devid);
if (!proxy)
{
rdpusb_send_access_denied (code, devid);
break;
}
in_uint8(s, ep);
rc = op_usbproxy_back_clear_halted_ep(proxy, ep);
if (RT_FAILURE(rc))
{
rdpusb_send_reply (code, vrdp_usb_status (rc, &proxy->Dev), devid);
}
} break;
case RDPUSB_REQ_CANCEL_URB:
{
uint32 handle;
PVUSBURB pUrb = NULL;
in_uint32_le(s, devid);
proxy = devid2proxy (devid);
if (!proxy)
{
rdpusb_send_access_denied (code, devid);
break;
}
in_uint32_le(s, handle);
pUrb = proxy->pUrbs;
while (pUrb && pUrb->handle != handle)
{
pUrb = pUrb->pNext;
}
if (pUrb)
{
op_usbproxy_back_cancel_urb(proxy, pUrb);
/* No reply required. */
/* Remove URB from list. */
if (pUrb->pPrev)
{
pUrb->pPrev->pNext = pUrb->pNext;
}
else
{
proxy->pUrbs = pUrb->pNext;
}
if (pUrb->pNext)
{
pUrb->pNext->pPrev = pUrb->pPrev;
}
pUrb->pNext = pUrb->pPrev = NULL;
Log(("Cancelled URB %p\n", pUrb));
// xfree (pUrb);
}
} break;
case RDPUSB_REQ_DEVICE_LIST:
{
void *buf = NULL;
int len = 0;
buf = build_device_list (&len);
s = rdpusb_init_packet(len? len: 2, code);
if (len)
{
out_uint8p (s, buf, len);
}
else
{
out_uint16_le(s, 0);
}
s_mark_end(s);
rdpusb_send(s);
if (buf)
{
free (buf);
}
} break;
case RDPUSB_REQ_NEGOTIATE:
{
s = rdpusb_init_packet(1, code);
out_uint8(s, VRDP_USB_CAPS_FLAG_ASYNC);
s_mark_end(s);
rdpusb_send(s);
} break;
default:
unimpl("RDPUSB code %d\n", code);
break;
}
}
