void on_device_added(DBusGProxy* proxy, const char* obj_path, gpointer user_data)
{
GUDisksVolumeMonitor* mon = G_UDISKS_VOLUME_MONITOR(user_data);
add_device(mon, proxy, obj_path, TRUE);
}
static int /* O - 0 on success, -1 on error */
get_device(cupsd_backend_t *backend) /* I - Backend to read from */
{
char line[2048], /* Line from backend */
temp[2048], /* Copy of line */
*ptr, /* Pointer into line */
*dclass, /* Device class */
*uri, /* Device URI */
*make_model, /* Make and model */
*info, /* Device info */
*device_id, /* 1284 device ID */
*location; /* Physical location */
if (cupsFileGets(backend->pipe, line, sizeof(line)))
{
/*
* Each line is of the form:
*
* class URI "make model" "name" ["1284 device ID"] ["location"]
*/
strlcpy(temp, line, sizeof(temp));
/*
* device-class
*/
dclass = temp;
for (ptr = temp; *ptr; ptr ++)
if (isspace(*ptr & 255))
break;
while (isspace(*ptr & 255))
*ptr++ = '\0';
/*
* device-uri
*/
if (!*ptr)
goto error;
for (uri = ptr; *ptr; ptr ++)
if (isspace(*ptr & 255))
break;
while (isspace(*ptr & 255))
*ptr++ = '\0';
/*
* device-make-and-model
*/
if (*ptr != '\"')
goto error;
for (ptr ++, make_model = ptr; *ptr && *ptr != '\"'; ptr ++)
{
if (*ptr == '\\' && ptr[1])
_cups_strcpy(ptr, ptr + 1);
}
if (*ptr != '\"')
goto error;
for (*ptr++ = '\0'; isspace(*ptr & 255); *ptr++ = '\0');
/*
* device-info
*/
if (*ptr != '\"')
goto error;
for (ptr ++, info = ptr; *ptr && *ptr != '\"'; ptr ++)
{
if (*ptr == '\\' && ptr[1])
_cups_strcpy(ptr, ptr + 1);
}
if (*ptr != '\"')
goto error;
for (*ptr++ = '\0'; isspace(*ptr & 255); *ptr++ = '\0');
/*
* device-id
*/
if (*ptr == '\"')
{
for (ptr ++, device_id = ptr; *ptr && *ptr != '\"'; ptr ++)
{
if (*ptr == '\\' && ptr[1])
_cups_strcpy(ptr, ptr + 1);
}
if (*ptr != '\"')
goto error;
for (*ptr++ = '\0'; isspace(*ptr & 255); *ptr++ = '\0');
/*
* device-location
*/
if (*ptr == '\"')
{
for (ptr ++, location = ptr; *ptr && *ptr != '\"'; ptr ++)
{
if (*ptr == '\\' && ptr[1])
_cups_strcpy(ptr, ptr + 1);
}
if (*ptr != '\"')
goto error;
*ptr = '\0';
}
else
location = NULL;
}
else
{
device_id = NULL;
location = NULL;
}
/*
* Add the device to the array of available devices...
*/
if (!add_device(dclass, make_model, info, uri, device_id, location))
fprintf(stderr, "DEBUG: [cups-deviced] Found device \"%s\"...\n", uri);
return (0);
}
/*
* End of file...
*/
cupsFileClose(backend->pipe);
backend->pipe = NULL;
return (-1);
/*
* Bad format; strip trailing newline and write an error message.
*/
error:
if (line[strlen(line) - 1] == '\n')
line[strlen(line) - 1] = '\0';
fprintf(stderr, "ERROR: [cups-deviced] Bad line from \"%s\": %s\n",
backend->name, line);
return (0);
}
void all_devices_to_all_power(void)
{
unsigned int i;
for (i = 0; i < all_devices.size(); i++)
add_device(all_devices[i]);
}
void nl_convert_base_t::add_device(const pstring &atype, const pstring &aname, double aval)
{
add_device(plib::make_unique<dev_t>(atype, aname, aval));
}
int load_opus(char *name){
void *lib;
const char *msg;
int *num=NULL;
struct coreInfo_t **core;
SPICEdev **devs;
Evt_Udn_Info_t **udns;
funptr_t fetch;
lib = dlopen(name,RTLD_NOW);
if(!lib){
msg = dlerror();
printf("%s\n", msg);
return 1;
}
fetch = dlsym(lib,"CMdevNum");
if(fetch){
num = ((int * (*)(void)) fetch) ();
#ifdef TRACE
printf("Got %u devices.\n",*num);
#endif
}else{
msg = dlerror();
printf("%s\n", msg);
return 1;
}
fetch = dlsym(lib,"CMdevs");
if(fetch){
devs = ((SPICEdev ** (*)(void)) fetch) ();
}else{
msg = dlerror();
printf("%s\n", msg);
return 1;
}
fetch = dlsym(lib,"CMgetCoreItfPtr");
if(fetch){
core = ((struct coreInfo_t ** (*)(void)) fetch) ();
*core = &coreInfo;
}else{
msg = dlerror();
printf("%s\n", msg);
return 1;
}
add_device(*num,devs,1);
fetch = dlsym(lib,"CMudnNum");
if(fetch){
num = ((int * (*)(void)) fetch) ();
#ifdef TRACE
printf("Got %u udns.\n",*num);
#endif
}else{
msg = dlerror();
printf("%s\n", msg);
return 1;
}
fetch = dlsym(lib,"CMudns");
if(fetch){
udns = ((Evt_Udn_Info_t ** (*)(void)) fetch) ();
}else{
msg = dlerror();
printf("%s\n", msg);
return 1;
}
add_udn(*num,udns);
return 0;
}
void nl_convert_rinf_t::convert(const pstring &contents)
{
plib::pistringstream istrm(contents);
plib::putf8_reader reader(istrm);
tokenizer tok(*this, reader);
auto lm = read_lib_map(s_lib_map);
out("NETLIST_START(dummy)\n");
add_term("GND", "GND");
add_term("VCC", "VCC");
tokenizer::token_t token = tok.get_token();
while (true)
{
if (token.is_type(tokenizer::ENDOFFILE) || token.is(tok.m_tok_END))
{
dump_nl();
// FIXME: Parameter
out("NETLIST_END()\n");
return;
}
else if (token.is(tok.m_tok_HEA))
{
/* seems to be start token - ignore */
token = tok.get_token();
}
else if (token.is(tok.m_tok_APP))
{
/* version string */
pstring app = tok.get_string();
out("// APP: {}\n", app);
token = tok.get_token();
}
else if (token.is(tok.m_tok_TIM))
{
/* time */
out("// TIM:");
for (int i=0; i<6; i++)
{
long x = tok.get_number_long();
out(" {}", x);
}
out("\n");
token = tok.get_token();
}
else if (token.is(tok.m_tok_TYP))
{
pstring id(tok.get_identifier());
out("// TYP: {}\n", id);
token = tok.get_token();
}
else if (token.is(tok.m_tok_ADDC))
{
std::unordered_map<pstring, pstring> attr;
pstring id = tok.get_identifier();
pstring s1 = tok.get_string();
pstring s2 = tok.get_string();
token = tok.get_token();
while (token.is(tok.m_tok_ATTC))
{
pstring tid = tok.get_identifier();
if (tid != id)
{
out("Error: found {} expected {} in {}\n", tid, id, token.str());
return;
}
pstring at = tok.get_string();
pstring val = tok.get_string();
attr[at] = val;
token = tok.get_token();
}
pstring sim = attr["Simulation"];
pstring val = attr["Value"];
pstring com = attr["Comment"];
if (val == "")
val = com;
if (sim == "CAP")
{
add_device("CAP", id, get_sp_val(val));
}
else if (sim == "RESISTOR")
{
add_device("RES", id, get_sp_val(val));
}
else
{
pstring lib = attr["Library Reference"];
auto f = lm.find(lib);
if (f != lm.end())
add_device(f->second.dev, id);
else
add_device(lib, id);
}
}
else if (token.is(tok.m_tok_NET))
{
pstring dev = tok.get_identifier();
pstring pin = tok.get_identifier_or_number();
pstring net = tok.get_string();
add_term(net, dev + "." + pin);
token = tok.get_token();
if (token.is(tok.m_tok_TER))
{
token = tok.get_token();
while (token.is_type(plib::ptokenizer::IDENTIFIER))
{
pin = tok.get_identifier_or_number();
add_term(net, token.str() + "." + pin);
token = tok.get_token();
}
}
}
#if 0
token = tok.get_token();
/* skip to semicolon */
do
{
token = tok.get_token();
} while (!token.is(tok.m_tok_SEMICOLON));
token = tok.get_token();
pstring sval = "";
if (token.is(tok.m_tok_VALUE))
{
pstring vname = tok.get_string();
sval = tok.get_string();
tok.require_token(tok.m_tok_SEMICOLON);
token = tok.get_token();
}
switch (name.code_at(0))
{
case 'Q':
{
add_device("QBJT", name, sval);
}
break;
case 'R':
{
double val = get_sp_val(sval);
add_device("RES", name, val);
}
break;
case 'C':
{
double val = get_sp_val(sval);
add_device("CAP", name, val);
}
break;
case 'P':
if (sval.ucase() == "HIGH")
add_device("TTL_INPUT", name, 1);
else if (sval.ucase() == "LOW")
add_device("TTL_INPUT", name, 0);
else
add_device("ANALOG_INPUT", name, sval.as_double());
add_pin_alias(name, "1", "Q");
break;
case 'D':
/* Pin 1 = Anode, Pin 2 = Cathode */
add_device("DIODE", name, sval);
add_pin_alias(name, "1", "A");
add_pin_alias(name, "2", "K");
break;
case 'U':
case 'X':
{
pstring tname = "TTL_" + sval + "_DIP";
add_device(tname, name);
break;
}
default:
tok.error("// IGNORED " + name);
}
}
else if (token.is(tok.m_tok_SIGNAL))
//FIXME: should accept a stream as well
void nl_convert_eagle_t::convert(const pstring &contents)
{
plib::pistringstream istrm(contents);
plib::putf8_reader reader(istrm);
tokenizer tok(*this, reader);
out("NETLIST_START(dummy)\n");
add_term("GND", "GND");
add_term("VCC", "VCC");
tokenizer::token_t token = tok.get_token();
while (true)
{
if (token.is_type(tokenizer::ENDOFFILE))
{
dump_nl();
// FIXME: Parameter
out("NETLIST_END()\n");
return;
}
else if (token.is(tok.m_tok_SEMICOLON))
{
/* ignore empty statements */
token = tok.get_token();
}
else if (token.is(tok.m_tok_ADD))
{
pstring name = tok.get_string();
/* skip to semicolon */
do
{
token = tok.get_token();
} while (!token.is(tok.m_tok_SEMICOLON));
token = tok.get_token();
pstring sval = "";
if (token.is(tok.m_tok_VALUE))
{
pstring vname = tok.get_string();
sval = tok.get_string();
tok.require_token(tok.m_tok_SEMICOLON);
token = tok.get_token();
}
switch (name.at(0))
{
case 'Q':
{
add_device("QBJT", name, sval);
}
break;
case 'R':
{
double val = get_sp_val(sval);
add_device("RES", name, val);
}
break;
case 'C':
{
double val = get_sp_val(sval);
add_device("CAP", name, val);
}
break;
case 'P':
if (sval.ucase() == "HIGH")
add_device("TTL_INPUT", name, 1);
else if (sval.ucase() == "LOW")
add_device("TTL_INPUT", name, 0);
else
add_device("ANALOG_INPUT", name, sval.as_double());
add_pin_alias(name, "1", "Q");
break;
case 'D':
/* Pin 1 = Anode, Pin 2 = Cathode */
add_device("DIODE", name, sval);
add_pin_alias(name, "1", "A");
add_pin_alias(name, "2", "K");
break;
case 'U':
case 'X':
{
pstring tname = "TTL_" + sval + "_DIP";
add_device(tname, name);
break;
}
default:
tok.error("// IGNORED " + name);
}
}
else if (token.is(tok.m_tok_SIGNAL))
{
pstring netname = tok.get_string();
token = tok.get_token();
while (!token.is(tok.m_tok_SEMICOLON))
{
/* fixme: should check for string */
pstring devname = token.str();
pstring pin = tok.get_string();
add_term(netname, devname + "." + pin);
token = tok.get_token(); }
}
else
{
out("Unexpected {}\n", token.str().c_str());
return;
}
}
}
void nl_convert_spice_t::process_line(const pstring &line)
{
if (line != "")
{
std::vector<pstring> tt(plib::psplit(line, " ", true));
double val = 0.0;
switch (tt[0].at(0))
{
case ';':
out("// {}\n", line.substr(1));
break;
case '*':
out("// {}\n", line.substr(1).c_str());
break;
case '.':
if (tt[0].equals(".SUBCKT"))
{
out("NETLIST_START({})\n", tt[1].c_str());
for (std::size_t i=2; i<tt.size(); i++)
add_ext_alias(tt[i]);
}
else if (tt[0].equals(".ENDS"))
{
dump_nl();
out("NETLIST_END()\n");
}
else
out("// {}\n", line.c_str());
break;
case 'Q':
{
bool cerr = false;
/* check for fourth terminal ... should be numeric net
* including "0" or start with "N" (ltspice)
*/
ATTR_UNUSED long nval(tt[4].as_long(&cerr));
pstring model;
pstring pins ="CBE";
if ((!cerr || tt[4].startsWith("N")) && tt.size() > 5)
model = tt[5];
else
model = tt[4];
std::vector<pstring> m(plib::psplit(model,"{"));
if (m.size() == 2)
{
if (m[1].length() != 4)
fprintf(stderr, "error with model desc %s\n", model.c_str());
pins = m[1].left(3);
}
add_device("QBJT_EB", tt[0], m[0]);
add_term(tt[1], tt[0] + "." + pins.at(0));
add_term(tt[2], tt[0] + "." + pins.at(1));
add_term(tt[3], tt[0] + "." + pins.at(2));
}
break;
case 'R':
if (tt[0].startsWith("RV"))
{
val = get_sp_val(tt[4]);
add_device("POT", tt[0], val);
add_term(tt[1], tt[0] + ".1");
add_term(tt[2], tt[0] + ".2");
add_term(tt[3], tt[0] + ".3");
}
else
{
val = get_sp_val(tt[3]);
add_device("RES", tt[0], val);
add_term(tt[1], tt[0] + ".1");
add_term(tt[2], tt[0] + ".2");
}
break;
case 'C':
val = get_sp_val(tt[3]);
add_device("CAP", tt[0], val);
add_term(tt[1], tt[0] + ".1");
add_term(tt[2], tt[0] + ".2");
break;
case 'V':
// just simple Voltage sources ....
if (tt[2].equals("0"))
{
val = get_sp_val(tt[3]);
add_device("ANALOG_INPUT", tt[0], val);
add_term(tt[1], tt[0] + ".Q");
//add_term(tt[2], tt[0] + ".2");
}
else
fprintf(stderr, "Voltage Source %s not connected to GND\n", tt[0].c_str());
break;
case 'I': // Input pin special notation
{
val = get_sp_val(tt[2]);
add_device("ANALOG_INPUT", tt[0], val);
add_term(tt[1], tt[0] + ".Q");
}
break;
case 'D':
add_device("DIODE", tt[0], tt[3]);
/* FIXME ==> does Kicad use different notation from LTSPICE */
add_term(tt[1], tt[0] + ".K");
add_term(tt[2], tt[0] + ".A");
break;
case 'U':
case 'X':
{
// FIXME: specific code for KICAD exports
// last element is component type
// FIXME: Parameter
pstring xname = tt[0].replace_all(".", "_");
pstring tname = "TTL_" + tt[tt.size()-1] + "_DIP";
add_device(tname, xname);
for (std::size_t i=1; i < tt.size() - 1; i++)
{
pstring term = plib::pfmt("{1}.{2}")(xname)(i);
add_term(tt[i], term);
}
break;
}
default:
out("// IGNORED {}: {}\n", tt[0].c_str(), line.c_str());
}
}
}
static void *probe_stream( void *ptr )
{
obe_input_probe_t *probe_ctx = (obe_input_probe_t*)ptr;
obe_t *h = probe_ctx->h;
obe_input_t *user_opts = &probe_ctx->user_opts;
obe_device_t *device;
obe_int_input_stream_t *streams[MAX_STREAMS];
int cur_stream = 2;
obe_sdi_non_display_data_t *non_display_parser;
decklink_ctx_t *decklink_ctx;
decklink_opts_t *decklink_opts = (decklink_opts_t*)calloc( 1, sizeof(*decklink_opts) );
if( !decklink_opts )
{
fprintf( stderr, "Malloc failed\n" );
goto finish;
}
non_display_parser = &decklink_opts->decklink_ctx.non_display_parser;
/* TODO: support multi-channel */
decklink_opts->num_channels = 16;
decklink_opts->card_idx = user_opts->card_idx;
decklink_opts->video_conn = user_opts->video_connection;
decklink_opts->audio_conn = user_opts->audio_connection;
decklink_opts->video_format = user_opts->video_format;
decklink_opts->probe = non_display_parser->probe = 1;
decklink_ctx = &decklink_opts->decklink_ctx;
decklink_ctx->h = h;
decklink_ctx->last_frame_time = -1;
decklink_ctx = &decklink_opts->decklink_ctx;
if( open_card( decklink_opts ) < 0 )
goto finish;
sleep( 1 );
close_card( decklink_opts );
if( !decklink_opts->probe_success )
{
fprintf( stderr, "[decklink] No valid frames received - check input format\n" );
goto finish;
}
/* TODO: probe for SMPTE 337M */
/* TODO: factor some of the code below out */
for( int i = 0; i < 2; i++ )
{
streams[i] = (obe_int_input_stream_t*)calloc( 1, sizeof(*streams[i]) );
if( !streams[i] )
goto finish;
/* TODO: make it take a continuous set of stream-ids */
pthread_mutex_lock( &h->device_list_mutex );
streams[i]->input_stream_id = h->cur_input_stream_id++;
pthread_mutex_unlock( &h->device_list_mutex );
if( i == 0 )
{
streams[i]->stream_type = STREAM_TYPE_VIDEO;
streams[i]->stream_format = VIDEO_UNCOMPRESSED;
streams[i]->width = decklink_opts->width;
streams[i]->height = decklink_opts->height;
streams[i]->timebase_num = decklink_opts->timebase_num;
streams[i]->timebase_den = decklink_opts->timebase_den;
streams[i]->csp = PIX_FMT_YUV422P10;
streams[i]->interlaced = decklink_opts->interlaced;
streams[i]->tff = decklink_opts->tff;
streams[i]->sar_num = streams[i]->sar_den = 1; /* The user can choose this when encoding */
if( add_non_display_services( non_display_parser, streams[i], USER_DATA_LOCATION_FRAME ) < 0 )
goto finish;
}
else if( i == 1 )
{
streams[i]->stream_type = STREAM_TYPE_AUDIO;
streams[i]->stream_format = AUDIO_PCM;
streams[i]->num_channels = 16;
streams[i]->sample_format = AV_SAMPLE_FMT_S32P;
/* TODO: support other sample rates */
streams[i]->sample_rate = 48000;
}
}
if( non_display_parser->has_vbi_frame )
{
streams[cur_stream] = (obe_int_input_stream_t*)calloc( 1, sizeof(*streams[cur_stream]) );
if( !streams[cur_stream] )
goto finish;
pthread_mutex_lock( &h->device_list_mutex );
streams[cur_stream]->input_stream_id = h->cur_input_stream_id++;
pthread_mutex_unlock( &h->device_list_mutex );
streams[cur_stream]->stream_type = STREAM_TYPE_MISC;
streams[cur_stream]->stream_format = VBI_RAW;
streams[cur_stream]->vbi_ntsc = decklink_opts->video_format == INPUT_VIDEO_FORMAT_NTSC;
if( add_non_display_services( non_display_parser, streams[cur_stream], USER_DATA_LOCATION_DVB_STREAM ) < 0 )
goto finish;
cur_stream++;
}
if( non_display_parser->has_ttx_frame )
{
streams[cur_stream] = (obe_int_input_stream_t*)calloc( 1, sizeof(*streams[cur_stream]) );
if( !streams[cur_stream] )
goto finish;
pthread_mutex_lock( &h->device_list_mutex );
streams[cur_stream]->input_stream_id = h->cur_input_stream_id++;
pthread_mutex_unlock( &h->device_list_mutex );
streams[cur_stream]->stream_type = STREAM_TYPE_MISC;
streams[cur_stream]->stream_format = MISC_TELETEXT;
if( add_teletext_service( non_display_parser, streams[cur_stream] ) < 0 )
goto finish;
cur_stream++;
}
if( non_display_parser->num_frame_data )
free( non_display_parser->frame_data );
device = new_device();
if( !device )
goto finish;
device->num_input_streams = cur_stream;
memcpy( device->streams, streams, device->num_input_streams * sizeof(obe_int_input_stream_t**) );
device->device_type = INPUT_DEVICE_DECKLINK;
memcpy( &device->user_opts, user_opts, sizeof(*user_opts) );
/* add device */
add_device( h, device );
finish:
if( decklink_opts )
free( decklink_opts );
free( probe_ctx );
return NULL;
}
/* Name the devices. */
static void
name_devices (struct grub_efidisk_data *devices)
{
struct grub_efidisk_data *d;
/* First, identify devices by media device paths. */
for (d = devices; d; d = d->next)
{
grub_efi_device_path_t *dp;
dp = d->last_device_path;
if (! dp)
continue;
if (GRUB_EFI_DEVICE_PATH_TYPE (dp) == GRUB_EFI_MEDIA_DEVICE_PATH_TYPE)
{
int is_hard_drive = 0;
switch (GRUB_EFI_DEVICE_PATH_SUBTYPE (dp))
{
case GRUB_EFI_HARD_DRIVE_DEVICE_PATH_SUBTYPE:
is_hard_drive = 1;
/* Fall through by intention. */
case GRUB_EFI_CDROM_DEVICE_PATH_SUBTYPE:
{
struct grub_efidisk_data *parent;
parent = find_parent_device (devices, d);
if (parent)
{
if (is_hard_drive)
{
#if 0
grub_printf ("adding a hard drive by a partition: ");
grub_print_device_path (parent->device_path);
#endif
add_device (&hd_devices, parent);
}
else
{
#if 0
grub_printf ("adding a cdrom by a partition: ");
grub_print_device_path (parent->device_path);
#endif
add_device (&cd_devices, parent);
}
/* Mark the parent as used. */
parent->last_device_path = 0;
}
}
/* Mark itself as used. */
d->last_device_path = 0;
break;
default:
/* For now, ignore the others. */
break;
}
}
}
/* Let's see what can be added more. */
for (d = devices; d; d = d->next)
{
grub_efi_device_path_t *dp;
grub_efi_block_io_media_t *m;
dp = d->last_device_path;
if (! dp)
continue;
m = d->block_io->media;
if (m->logical_partition)
{
/* Only one partition in a non-media device. Assume that this
is a floppy drive. */
#if 0
grub_printf ("adding a floppy by guessing: ");
grub_print_device_path (d->device_path);
#endif
add_device (&fd_devices, d);
}
else if (m->read_only && m->block_size > GRUB_DISK_SECTOR_SIZE)
{
/* This check is too heuristic, but assume that this is a
CDROM drive. */
#if 0
grub_printf ("adding a cdrom by guessing: ");
grub_print_device_path (d->device_path);
#endif
add_device (&cd_devices, d);
}
else
{
/* The default is a hard drive. */
#if 0
grub_printf ("adding a hard drive by guessing: ");
grub_print_device_path (d->device_path);
#endif
add_device (&hd_devices, d);
}
}
}