bool PA::get_device_info(const int &idx, PADeviceInfo &info)
{
int num = get_device_count();
if (idx < 0 || num <= idx) {
printf("error : PA::get_device_info() : out of index...idx=", idx);
return false;
}
info.set_device_idx_(idx);
return true;
}
std::vector<PADeviceInfo> PA::get_device_infos()
{
int num = get_device_count();
std::vector<PADeviceInfo> infos;
for (int i = 0; i < num; ++i) {
PADeviceInfo info;
if (get_device_info(i, info)) {
infos.push_back(info);
}
}
return infos;
}
bool PA::open_output(const int &dev_idx, const int &channels, const int &sampling_rate, const int &buf_size)
{
PaError err;
PaStreamParameters output_param;
if (is_open()) return false;
if (dev_idx < 0 || get_device_count() <= dev_idx) {
printf("error : PA::open_output() : out of index...dev_idx=%d", dev_idx);
return false;
}
output_param.device = dev_idx;
output_param.channelCount = channels;
output_param.sampleFormat = paFloat32;
output_param.suggestedLatency = Pa_GetDeviceInfo(output_param.device)->defaultLowOutputLatency;
output_param.hostApiSpecificStreamInfo = NULL;
err = Pa_OpenStream(
&stream_,
NULL,
&output_param,
sampling_rate,
buf_size, // frames_per_buffer
paClipOff,
play_callback_,
this);
if (err != paNoError) {
printf("error : PA::open_output() : Pa_OpenStream() failed...dev_idx=%d", dev_idx);
close();
return false;
}
err = Pa_StartStream(stream_);
if (err != paNoError) {
printf("error : PA::open_output() : Pa_StartStream() failed...dev_idx=%d", dev_idx);
close();
return false;
}
stream_type_ = PA_STREAM_TYPE_OUTPUT;
output_device_idx_ = dev_idx;
channels_ = channels;
PADeviceInfo info = output_device_info();
printf("PA::open_output() : open device...dev_idx=%d, name=%s\n", output_device_idx_, info.name().c_str());
return true;
}
// Costructor with specific cl_platform_id
platform(cl_platform_id m_platform_id)
{
// Initialise the clog object
m_log = clog::getInstance();
this->m_platform_id = m_platform_id;
//std::cout << "The platform name is " << name().c_str() << std::endl;
//std::cout << "The platform version is " << version().c_str() << std::endl;
m_log->write("The platform name is ");
m_log->write(name().c_str());
m_log->write("\n");
m_log->write(" The platform version is ");
m_log->write(version().c_str());
m_log->write("\n");
m_devices_count = get_device_count();
create_devices();
}
void *notifier_function()
{
struct udev *udev;
struct udev_monitor *mon;
struct udev_device *dev;
cancel = FALSE;
const GUID guid = {0x85980D83,0x32B9,0x4BA1,{0x8F,0xDF,0x12,0xA7,0x11,0xB9,0x9C,0xA2}};
DEV_BROADCAST_DEVICEINTERFACE_W DevBi;
DevBi.dbcc_size = sizeof(DEV_BROADCAST_DEVICEINTERFACE_W);
DevBi.dbcc_devicetype = DBT_DEVTYP_DEVICEINTERFACE;
DevBi.dbcc_classguid = guid;
udev = udev_new();
if (!udev) {
printf("Can't create udev\n");
return;
}
mon = udev_monitor_new_from_netlink(udev, "udev");
if(!mon)
{
printf("NetLink not available!\n");
return;
}
int count = get_device_count();
if(count == -1)
{
printf("udev error.\n");
return;
}
udev_monitor_filter_add_match_subsystem_devtype(mon, "usb", NULL);
udev_monitor_enable_receiving(mon);
int fd = udev_monitor_get_fd(mon);
while (!cancel) {
fd_set fds;
struct timeval tv;
int ret;
FD_ZERO(&fds);
FD_SET(fd, &fds);
tv.tv_sec = 0;
tv.tv_usec = 0;
ret = select(fd+1, &fds, NULL, NULL, &tv);
if (ret > 0 && FD_ISSET(fd, &fds)) {
dev = udev_monitor_receive_device(mon);
if(dev && !strcmp(udev_device_get_devtype(dev),"usb_device")){
int count_new;
if(!strcmp(udev_device_get_action(dev), "add"))
{
count_new = get_device_count();
if(count != count_new)
{
count = count_new;
//printf("device added.\n");
close_devices();
usleep(100000);
SendMessageW(hWnd, WM_DEVICECHANGE, DBT_DEVICEARRIVAL, (LPARAM)&DevBi);
RedrawWindow(hWnd, NULL, NULL, RDW_INVALIDATE);
}
}
else if(!strcmp(udev_device_get_action(dev), "remove"))
{
count_new = get_device_count();
if(count != count_new)
{
count = count_new;
//printf("device removed.\n");
close_devices();
usleep(100000);
SendMessageW(hWnd, WM_DEVICECHANGE, DBT_DEVICEREMOVECOMPLETE, (LPARAM)&DevBi);
RedrawWindow(hWnd, NULL, NULL, RDW_INVALIDATE);
}
}
udev_device_unref(dev);
}
}
usleep(10000);
}
}
int device::get_all_devices() {
int num_devices = get_device_count();
return num_devices;
}
void menu_setup_devices()
{
if(redraw)
{
clearDisplay();
clear_buttons();
redraw=0;
draw_filledRect(0,0,LCD_WIDTH,35,155,100,100);
draw_filledCircle(17,17,15,40,80,40);
draw_text_8x6(7,10,"Back",255,100,100);
uint16_t text_width = get_text_width_16pt("Setup Devices");
draw_text_16pt((LCD_WIDTH-text_width)>>1,9, "Setup Devices", 200,200,255);
init_lineitems();
char buf[30];
char buf2[30];
draw_lineitem("","<new>");
for(int i = 0; i < get_device_count();i++)
{
snprintf(buf,30,"%i",get_device(i)->base_address);
char classname[30];
if(get_device(i)->device_class_uuid == 0)
{
strncpy(classname,"<empty>",30);
}
else if(get_device_class_by_uuid(get_device(i)->device_class_uuid) == NULL)
{
strncpy(classname,"<missing>",30);
}
else
{
strncpy(classname,get_device_class_by_uuid(get_device(i)->device_class_uuid)->name,30);
}
snprintf(buf2,30,"%s - %s",classname,get_device(i)->name);
draw_lineitem(buf,buf2);
}
draw_scrollbar();
draw_button_h(257,45,52,42,"^",155,0,0,0,255,0);
if((get_device_count()<10)&&(active_row==0))
{
draw_button_h(257,92,52,42,"Add",155,0,0,0,255,0);
}
if(active_row>0)
{
draw_button_h(257,92,52,42,"Edit",155,0,0,0,255,0);
draw_button_h(257,139,52,42,"Delete",155,0,0,0,255,0);
}
draw_button_h(257,186,52,42,"v",155,0,0,0,255,0);
}
uint8_t field=0;
uint16_t x;
uint16_t y;
if(check_button_press(&x,&y)==1)
{
if(y > 41)
{
field=1;
if(y > 184)
{
field=4;
}else if(y > 136)
{
field=3;
}else if(y > 89)
{
field=2;
}
}
else
{
if(x < 40)
{
redraw=1;
set_current_execution(menu_setup);
}
}
if(field == 1)
{
if(active_row > 0)
{
if(active_row==scroll_offset)
{
scroll_offset--;
}
active_row--;
}
redraw=1;
}
if(field == 4)
{
if(active_row < (get_device_count()))
{
active_row++;
int drawline = active_row-scroll_offset;
if(drawline==10)
{
scroll_offset++;
}
}
redraw=1;
}
if(field == 2)
{
redraw=1;
if(active_row==0)
{
if(get_device_count()<50)
{
set_current_execution(menu_setup_devices_add);
}
}
else
{
set_current_execution(menu_setup_devices_edit);
set_device_to_edit(active_row-1);
}
}
if(field == 3)
{
redraw=1;
if(active_row > 0)
{
del_device(active_row-1);
if(active_row==scroll_offset)
{
scroll_offset--;
}
active_row--;
}
}
}
}
bool PA::open_wire(const int &input_dev_idx, const int &output_dev_idx, const int &sampling_rate, const int &buf_size)
{
PaError err;
PaStreamParameters input_param;
PaStreamParameters output_param;
if (is_open()) return false;
if (input_dev_idx < 0 || get_device_count() <= input_dev_idx) {
printf("error : PA::open_wire() : out of index...input_dev_idx=%d", input_dev_idx);
return false;
}
if (output_dev_idx < 0 || get_device_count() <= output_dev_idx) {
printf("error : PA::open_wire() : out of index...output_dev_idx=%d", output_dev_idx);
return false;
}
input_param.device = input_dev_idx;
input_param.channelCount = 2;
input_param.sampleFormat = paFloat32;
input_param.suggestedLatency = Pa_GetDeviceInfo(input_param.device)->defaultLowInputLatency;
input_param.hostApiSpecificStreamInfo = NULL;
output_param.device = output_dev_idx;
output_param.channelCount = 2;
output_param.sampleFormat = paFloat32;
output_param.suggestedLatency = Pa_GetDeviceInfo(output_param.device)->defaultLowInputLatency;
output_param.hostApiSpecificStreamInfo = NULL;
err = Pa_OpenStream(
&stream_,
&input_param,
&output_param,
sampling_rate,
buf_size, // frames_per_buffer
paClipOff,
wire_callback_,
this);
if (err != paNoError) {
printf("error : PA::open_wire() : Pa_OpenStream() failed...intput_dev_idx=%d, output_dev_idx=%d", input_dev_idx, output_dev_idx);
close();
return false;
}
err = Pa_StartStream(stream_);
if (err != paNoError) {
printf("error : PA::open_wire() : Pa_StartStream() failed...intput_dev_idx=%d, output_dev_idx=%d", input_dev_idx, output_dev_idx);
close();
return false;
}
stream_type_ = PA_STREAM_TYPE_WIRE;
input_device_idx_ = input_dev_idx;
output_device_idx_ = output_dev_idx;
channels_ = 2;
PADeviceInfo in_info = this->input_device_info();
PADeviceInfo out_info = this->output_device_info();
printf("PA::open_input() : open device...input=%d:%s, output=%d:%s\n",
input_dev_idx, in_info.name().c_str(),
output_dev_idx, out_info.name().c_str());
return true;
}
