static VALUE rb_ool_conmin_function_set(int argc, VALUE *argv, VALUE obj)
{
ool_conmin_function *F;
Data_Get_Struct(obj, ool_conmin_function, F);
switch (argc) {
case 0:
break;
case 1:
rb_ool_conmin_function_set_n(obj, argv[0]);
break;
case 4:
set_functions(argc, argv, F);
break;
case 5:
if (FIXNUM_P(argv[0])) {
rb_ool_conmin_function_set_n(obj, argv[0]);
set_functions(argc-1, argv+1, F);
} else {
set_functions(argc-1, argv, F);
set_params(F, argv[argc-1]);
}
break;
case 6:
rb_ool_conmin_function_set_n(obj, argv[0]);
set_functions(argc-2, argv+1, F);
set_params(F, argv[argc-1]);
break;
default:
rb_raise(rb_eArgError, "Wrong number of arguments.");
}
return obj;
}
static void
cb_dialog_so_size_apply_clicked (G_GNUC_UNUSED GtkWidget *button,
SOSizeState *state)
{
char const *name;
GOUndo *undo = NULL, *redo = NULL;
char const *undo_name = NULL;
int cnt = 0;
if (state->so_size_needs_restore || state->so_pos_needs_restore) {
char const *label = state->so_pos_needs_restore ?
_("Move Object") : _("Resize Object");
sheet_object_set_anchor (state->so, state->old_anchor);
if (!cmd_objects_move (WORKBOOK_CONTROL (state->wbcg),
g_slist_prepend (NULL, state->so),
g_slist_prepend
(NULL, sheet_object_anchor_dup
(state->active_anchor)),
FALSE, label))
dialog_so_size_load (state);
}
name = gtk_entry_get_text (state->nameentry);
if (name == NULL)
name = "";
if (strcmp (name, state->old_name) != 0) {
char *old_name, *new_name;
g_object_get (G_OBJECT (state->so), "name", &old_name, NULL);
undo = go_undo_combine (undo, set_params (state->so, old_name));
new_name = (*name == '\0') ? NULL : g_strdup (name);
redo = go_undo_combine (redo, set_params (state->so, new_name));
undo_name = _("Set Object Name");
cnt++;
}
if (state->so_print_check_changed) {
gboolean val = ((state->so->flags & SHEET_OBJECT_PRINT) != 0);
undo = go_undo_combine (undo, set_print_flag
(state->so, val));
redo = go_undo_combine (redo, set_print_flag
(state->so, !val));
undo_name = _("Set Object Print Property");
cnt++;
}
if (cnt > 0) {
if (cnt > 1)
undo_name = _("Set Object Properties");
state->so_name_changed = state->so_print_check_changed =
cmd_generic (WORKBOOK_CONTROL (state->wbcg),
undo_name, undo, redo);
}
dialog_so_size_button_sensitivity (state);
return;
}
BM::BetaModel(double a, double b)
: ParamPolicy(new UnivParams(a), new UnivParams(b)),
DataPolicy(new BS),
PriorPolicy()
{
set_params(a, b);
}
static VALUE rb_ool_conmin_function_set_params(VALUE obj, VALUE p)
{
ool_conmin_function *F;
Data_Get_Struct(obj, ool_conmin_function, F);
set_params(F, p);
return p;
}
t_color compute_light(t_scene *scene, t_ray *ray)
{
t_list *current;
t_ray lray;
t_color color[3];
t_phpa ph;
current = scene->lights;
ph.normal = get_normal(*ray);
set_ambiant_light(&ph, scene, ray, color);
while (current)
{
lray.pos = ((t_light *)current->content)->pos;
lray.dir = norm_vect(mtx_add(mtx_sub(mtx_mult(ray->dir, ray->t),
lray.pos), ray->pos));
lray.invdir = get_inv_vect(&lray.dir);
if (find_closest(scene, &lray) && ray->closest == lray.closest
&& near_enough(ray, &lray))
{
set_params(&ph, &lray, ray);
ph.camera = scene->camera;
ph.light = (t_light *)current->content;
phong(&ph);
}
current = current->next;
}
set_color_max(&ph);
return (*color);
}
static int source_config_props(AVFilterLink *outlink)
{
AVFilterContext *ctx = outlink->src;
Frei0rContext *s = ctx->priv;
if (av_image_check_size(s->w, s->h, 0, ctx) < 0)
return AVERROR(EINVAL);
outlink->w = s->w;
outlink->h = s->h;
outlink->time_base = s->time_base;
outlink->frame_rate = av_inv_q(s->time_base);
if (s->destruct && s->instance)
s->destruct(s->instance);
if (!(s->instance = s->construct(outlink->w, outlink->h))) {
av_log(ctx, AV_LOG_ERROR, "Impossible to load frei0r instance.\n");
return AVERROR(EINVAL);
}
if (!s->params) {
av_log(ctx, AV_LOG_ERROR, "frei0r filter parameters not set.\n");
return AVERROR(EINVAL);
}
return set_params(ctx, s->params);
}
//---------------------------------------------------------------------------
ObjectTracker::ObjectTracker(const ObjectTrackerParams& params)
:
initialized_(false),
tracker_(NULL)
{
// Store configurable parameters internally
set_params(params);
// Allocate the proper tracking algorithm (note: error-checking that a valid
// tracking algorithm parameter is used is done in the ObjectTrackerParams
// constructor, so at this point we are confident it's valid).
switch (params.algorithm_)
{
case ObjectTrackerParams::CV_ONLINEBOOSTING:
tracker_ = new OnlineBoostingAlgorithm();
break;
case ObjectTrackerParams::CV_SEMIONLINEBOOSTING:
tracker_ = new SemiOnlineBoostingAlgorithm();
break;
case ObjectTrackerParams::CV_ONLINEMIL:
tracker_ = new OnlineMILAlgorithm();
break;
case ObjectTrackerParams::CV_LINEMOD:
tracker_ = new LINEMODAlgorithm();
break;
default:
// By default, if an invalid choice somehow gets through lets use online boosting?
// Or throw an error and don't continue?
tracker_ = new OnlineBoostingAlgorithm();
break;
}
}
/* find parameter set in file, and use it */
static void
find_params(int cmd,int fd,char *name) {
FILE *file;
char line[MAXLINE+2],this[MAXLINE+2],param[9][MAXLINE+2];
char *params[9],*start;
int count;
if ((file = fopen(FDPRMFILE,"r")) == NULL) {
perror(FDPRMFILE);
exit(1);
}
while (fgets(line,MAXLINE,file)) {
for (start = line; *start == ' ' || *start == '\t'; start++);
if (*start && *start != '\n' && *start != '#') {
if (sscanf(start,"%s %s %s %s %s %s %s %s %s %s",this,param[0],
param[1],param[2],param[3],param[4],param[5],param[6],param[7],
param[8]) != 10) {
fprintf(stderr,_("Syntax error: '%s'\n"),line);
exit(1);
}
if (!strcmp(this,name)) {
for (count = 0; count < 9; count++)
params[count] = param[count];
set_params(cmd,fd,params);
}
}
}
fprintf(stderr,_("No such parameter set: '%s'\n"),name);
exit(1);
}
/* *********************
* set params in ntw
* *********************/
tee_stat_t tee_msgm_set_params(tee_msgm_t msgm, tee_msg_op_info_t *params)
{
tee_msgm_ntw_struct *ntw_handle = NULL;
tee_stat_t set_params_stat = TEEC_SUCCESS;
uint32_t times = PARAM_NUMBERS, idx = 0, type = TEEC_NONE;
OSA_ASSERT((msgm && params));
ntw_handle = (tee_msgm_ntw_struct *) msgm;
OSA_ASSERT(IS_MAGIC_VALID(ntw_handle->magic));
while (times--) {
type = TEEC_PARAM_TYPE_GET(params->paramTypes, idx);
if (!IS_PARAMTYPES_TYPE_VALID(type)) {
TZDD_DBG("tee_msgm_set_params: bad paramsTypes\n");
return TEEC_ERROR_BAD_PARAMETERS;
}
if (IS_TYPE_MEMREF(type)) {
if (!IS_NTW_MEM_FLAG_VALID(params->params[idx].memref.parent->flags)) {
TZDD_DBG("tee_msgm_set_params: un-compatible arg\n");
return TEEC_ERROR_BAD_PARAMETERS;
}
}
idx++;
}
set_params_stat = set_params(msgm, params);
return set_params_stat;
}
void ParamsDialog::OnOK(wxCommandEvent & event) {
const bool changed = pg_->CommitChangesFromEditor(); // ?
wxArrayString params = invalid_params();
if (!params.empty()) {display_invalid_params(params); return;}
set_params();
EndModal(wxID_OK);
Close();
}
int command::bind_query(std::auto_ptr<sybase_query> &q, const QoreListNode *args, ExceptionSink *xsink) {
query.reset(q.release());
initiate_language_command(query->buff(), xsink);
if (args) set_params(*query, args, xsink);
return 0;
}
void
login_dialog::init_settings()
{
QSettings settings("Manitou-Mail", "manitou-ui");
set_login(settings.value("login").toString());
set_dbname(settings.value("dbname").toString());
set_host(settings.value("host").toString());
set_params(settings.value("params").toString());
}
friend void set_dimensions(sink& s, resolution r, aspect_ratio a) {
rect dest = {0, 0, width(s.p->vm), height(s.p->vm)};
double picture_aspect_ratio = r.width * a.n / r.height;
auto w = dest.h * picture_aspect_ratio;
if(w > dest.w) dest.h = dest.w / picture_aspect_ratio;
if(dest.w < width(s.p->vm)) dest.x = (width(s.p->vm) - dest.w) / 2;
if(dest.h < height(s.p->vm)) dest.y = (height(s.p->vm) - dest.h) / 2;
set_params(s, s.p->vm, rect{0,0,r.width,r.height}, dest);
}
static void
check_for_changed_options (SolverState *state)
{
Sheet *sheet = state->sheet;
if (!gnm_solver_param_equal (sheet->solver_parameters,
state->orig_params)) {
GOUndo *undo = set_params (sheet, state->orig_params);
GOUndo *redo = set_params (sheet, sheet->solver_parameters);
cmd_generic (GNM_WBC (state->wbcg),
_("Changing solver parameters"),
undo, redo);
g_object_unref (state->orig_params);
state->orig_params =
gnm_solver_param_dup (sheet->solver_parameters,
sheet);
}
}
MvReg::MultivariateRegressionModel(const Matrix &X, const Matrix &Y)
: ParamPolicy(),
DataPolicy(new MvRegSuf(X, Y)),
PriorPolicy(),
LoglikeModel() {
uint nx = X.ncol();
uint ny = Y.ncol();
set_params(new MatrixGlmCoefs(nx, ny), new SpdParams(ny));
mle();
}
void delete_event (GtkWidget *widget, gpointer data)
{
set_params();//retrieve parameters from entry fields
do_synthesis();
//free(param_list);
//gtk_widget_destroy (GTK_WIDGET (data));
}
/*
* tee_invoke_command - invoke TEE to invoke a GP TEE command
*/
static int tz_invoke(struct tee_session *sess, struct tee_cmd *cmd)
{
struct tee *tee;
struct tee_tz *ptee;
int ret = 0;
struct teesmc32_arg *arg32;
uintptr_t parg32;
struct teesmc32_param *params32;
BUG_ON(!sess->ctx->tee);
BUG_ON(!sess->ctx->tee->priv);
tee = sess->ctx->tee;
ptee = tee->priv;
dev_dbg(DEV, "> sessid %x cmd %x type %x\n",
sess->sessid, cmd->cmd, cmd->param.type);
if (!CAPABLE(tee)) {
dev_dbg(tee->dev, "< not capable\n");
return -EBUSY;
}
arg32 = (typeof(arg32))alloc_tee_arg(ptee, &parg32,
TEESMC32_GET_ARG_SIZE(TEEC_CONFIG_PAYLOAD_REF_COUNT));
if (!arg32) {
free_tee_arg(ptee, parg32);
return TEEC_ERROR_OUT_OF_MEMORY;
}
memset(arg32, 0, sizeof(*arg32));
arg32->num_params = TEEC_CONFIG_PAYLOAD_REF_COUNT;
params32 = TEESMC32_GET_PARAMS(arg32);
arg32->cmd = TEESMC_CMD_INVOKE_COMMAND;
arg32->session = sess->sessid;
arg32->ta_func = cmd->cmd;
set_params(ptee, params32, cmd->param.type, &cmd->param);
call_tee(ptee, parg32, arg32);
get_params(&cmd->param, params32);
if (arg32->ret != TEEC_ERROR_COMMUNICATION) {
cmd->err = arg32->ret;
cmd->origin = arg32->ret_origin;
} else
ret = -EBUSY;
free_tee_arg(ptee, parg32);
dev_dbg(DEV, "< %x:%d\n", arg32->ret, ret);
return ret;
}
bool ASERDPort::configure(uint16 config)
{
D(bug(" configure %04lx\n", (uint32)config));
if (is_parallel)
return true;
// Set number of stop bits
switch (config & 0xc000) {
case stop10:
control_io->io_StopBits = 1;
break;
case stop20:
control_io->io_StopBits = 2;
break;
default:
return false;
}
// Set parity mode
switch (config & 0x3000) {
case noParity:
control_io->io_SerFlags &= ~SERF_PARTY_ON;
break;
case oddParity:
control_io->io_SerFlags |= SERF_PARTY_ON | SERF_PARTY_ODD;
break;
case evenParity:
control_io->io_SerFlags |= SERF_PARTY_ON;
control_io->io_SerFlags &= ~SERF_PARTY_ODD;
break;
default:
return false;
}
// Set number of data bits
switch (config & 0x0c00) {
case data5:
control_io->io_ReadLen = control_io->io_WriteLen = 5;
break;
case data6:
control_io->io_ReadLen = control_io->io_WriteLen = 6;
break;
case data7:
control_io->io_ReadLen = control_io->io_WriteLen = 7;
break;
case data8:
control_io->io_ReadLen = control_io->io_WriteLen = 8;
break;
}
// Set baud rate
control_io->io_Baud = 115200 / ((config & 0x03ff) + 2);
return set_params();
}
static void playback(char *name)
{
printf("name : %s\n",name);
int fd;
fd = open(name, O_RDONLY, 0);
/* read the file header */
WaveTotalInfo *waveTotalInfo=(WaveTotalInfo *)malloc(WAVE_HEAD_LENGTH);
int a;
a=read(fd, waveTotalInfo, WAVE_HEAD_LENGTH);
printf("1. a= %d WAVE_HEAD_LENGTH: %d\n",a,WAVE_HEAD_LENGTH);
/* read data*/
int rawDataSize=waveTotalInfo->waveDataStart.dataSize;
uint8_t *rawData=(uint8_t *)malloc(rawDataSize);
a=read(fd, rawData, rawDataSize);
printf("2. a= %d rawDataSize: %d\n",a,rawDataSize);
sleep(1);
int i;
#if 0
printf("0000020 : ");
for(i=0;i<rawDataSize;i++)
{
if(rawData[i]==0)
{
printf("0x00 ");
}
else
{
printf("%#02x ",rawData[i]);
}
if((i%16)==15)
{
printf("\n");
printf("%06x0 : ",i/16+3);
}
}
#endif
#define CUT_PART 10
#define DATA_UNIT_NUMBER (16/8)*2 /*(16bit/8bit) * 2 channel*/
set_params();
for(i=0;i<CUT_PART;i++)
{
printf("%d\n",(rawDataSize/CUT_PART)*i);
writei_func(handle, &rawData[(rawDataSize/CUT_PART)*i],rawDataSize/(CUT_PART*DATA_UNIT_NUMBER));
}
}
GeoConnection::GeoConnection(SpikingGroup *source, NeuronGroup *destination, AurynWeight conWeight, AurynWeight lrcWeight,
bool isSourceInhibitory, bool isDestInhibitory, unsigned int fieldWidth, double sigma,
TransmitterType transmitter, string name)
:SparseConnection(source,destination,transmitter)
{
set_weights(conWeight,lrcWeight);
set_params(fieldWidth,fieldWidth/2,5,isSourceInhibitory,isDestInhibitory);
set_probability(sigma,0.4);
allocateMEM(source,destination);
connectLikeInVC((source==destination));
}
static int config_input_props(AVFilterLink *inlink)
{
AVFilterContext *ctx = inlink->dst;
Frei0rContext *frei0r = ctx->priv;
if (!(frei0r->instance = frei0r->construct(inlink->w, inlink->h))) {
av_log(ctx, AV_LOG_ERROR, "Impossible to load frei0r instance");
return AVERROR(EINVAL);
}
return set_params(ctx, frei0r->params);
}
void JKQTPxQFFitFunctionLineGraph::collectParameters()
{
JKQTPxFunctionLineGraph::collectParameters();
intParam->function=fitFunction;
intParam->param=iparams;
intParam->scaleX=scaleX;
intParam->offsetX=offsetX;
if (subfunction>=0) {
fitFunction->transformParametersForAdditionalPlot(subfunction, intParam->param);
}
set_plotFunction(JKQTPxQFFitFunctionLineGraph_func);
set_params((void*)intParam);
}
/* ===================================================================*/
void flash_Init() {
if (ButtonPressed) {
// button pressed on power on -> Restore factory settings
set_led(TOPSIDE, 0, MAGENTA);
LEDred_ClrVal();
LEDblue_ClrVal();
write_ledColumn(TOPSIDE);
wait_ledColumn();
set_params();
save_params();
// initialize some images and scripts
images_Init();
script_Init();
while (!ButtonReleased) {
;
}
set_led(TOPSIDE, 0, BLACK);
LEDred_SetVal();
LEDblue_SetVal();
write_ledColumn(TOPSIDE);
wait_ledColumn();
} else {
get_params();
if (configParameter.valid == FLASH_RECORD_VALID) {
set_config();
} else {
// no valid data in Flash -> initialize from global variables
set_params();
save_params();
// initialize some images and scripts
images_Init();
script_Init();
}
}
}
static int
rdpsnd_alsa_set_format(rdpsndDevicePlugin * devplugin, char * snd_format, int size)
{
struct alsa_device_data * alsa_data;
int nChannels;
int wBitsPerSample;
int nSamplesPerSec;
int wFormatTag;
int nBlockAlign;
alsa_data = (struct alsa_device_data *) devplugin->device_data;
wFormatTag = GET_UINT16(snd_format, 0);
nChannels = GET_UINT16(snd_format, 2);
nSamplesPerSec = GET_UINT32(snd_format, 4);
nBlockAlign = GET_UINT16(snd_format, 12);
wBitsPerSample = GET_UINT16(snd_format, 14);
LLOGLN(0, ("rdpsnd_alsa_set_format: wFormatTag=%d nChannels=%d "
"nSamplesPerSec=%d wBitsPerSample=%d nBlockAlign=%d",
wFormatTag, nChannels, nSamplesPerSec, wBitsPerSample, nBlockAlign));
alsa_data->source_rate = nSamplesPerSec;
alsa_data->actual_rate = nSamplesPerSec;
alsa_data->source_channels = nChannels;
alsa_data->actual_channels = nChannels;
switch (wFormatTag)
{
case 1: /* PCM */
switch (wBitsPerSample)
{
case 8:
alsa_data->format = SND_PCM_FORMAT_S8;
alsa_data->bytes_per_channel = 1;
break;
case 16:
alsa_data->format = SND_PCM_FORMAT_S16_LE;
alsa_data->bytes_per_channel = 2;
break;
}
break;
case 0x11: /* IMA ADPCM */
alsa_data->format = SND_PCM_FORMAT_S16_LE;
alsa_data->bytes_per_channel = 2;
break;
}
alsa_data->wformat = wFormatTag;
alsa_data->block_size = nBlockAlign;
set_params(alsa_data);
return 0;
}
void poc(){
OSSpinLockLock(&lock);
pthread_t t;
pthread_create(&t, NULL, thread_func, NULL);
mach_port_t conn = get_user_client("IntelAccelerator", 6);
set_params(conn);
OSSpinLockUnlock(&lock);
IOServiceClose(conn);
pthread_join(t, NULL);
}
/****************************************************************************
* op_cmos_set_params_file
*
* -p INPUT_FILE
*
* Set parameters according to INPUT_FILE.
****************************************************************************/
static void op_cmos_set_params_file(void)
{
FILE *f;
if ((f = fopen(nvramtool_op.param, "r")) == NULL) {
fprintf(stderr, "%s: Can not open file %s for reading: %s\n",
prog_name, nvramtool_op.param, strerror(errno));
exit(1);
}
get_cmos_layout();
set_params(f);
fclose(f);
}
static void playback_go(int fd, size_t loaded, off64_t count, int rtype, char *name)
{
int l, r;
off64_t written = 0;
off64_t c;
set_params();
while (loaded > chunk_bytes && written < count) {
if (pcm_write(audiobuf + written, chunk_size) <= 0)
return;
written += chunk_bytes;
loaded -= chunk_bytes;
}
if (written > 0 && loaded > 0)
memmove(audiobuf, audiobuf + written, loaded);
l = loaded;
while (written < count) {
do {
c = count - written;
if (c > chunk_bytes)
c = chunk_bytes;
c -= l;
if (c == 0)
break;
r = safe_read(fd, audiobuf + l, c);
if (r < 0) {
perror(name);
exit(EXIT_FAILURE);
}
fdcount += r;
if (r == 0)
break;
l += r;
} while ((size_t)l < chunk_bytes);
l = l * 8 / bits_per_frame;
r = pcm_write(audiobuf, l);
if (r != l)
break;
r = r * bits_per_frame / 8;
written += r;
l = 0;
}
snd_pcm_nonblock(handle, 0);
snd_pcm_drain(handle);
snd_pcm_nonblock(handle, nonblock);
}
int main(int argc, char** argv){
OSSpinLockLock(&lock);
pthread_t t;
pthread_create(&t, NULL, thread_func, NULL);
mach_port_t conn = get_user_client("IOHDIXController", 0);
set_params(conn);
for(;;) {
OSSpinLockUnlock(&lock);
make_iokit_call();
}
return 0;
}
int unit_init(unsigned play_rate, unsigned play_channels, unsigned rec_rate, unsigned rec_channels, unsigned flags)
{
int ret = open_files(flags);
if(ret != 0)
{
return -1;
}
ret = set_params(play_rate, play_channels, rec_rate, rec_channels, flags);
if(ret != 0)
{
return -1;
}
LOGI("Init success\n");
return 1;
}
void ASERDPort::set_handshake(uint32 s, bool with_dtr)
{
D(bug(" set_handshake %02x %02x %02x %02x %02x %02x %02x %02x\n",
ReadMacInt8(s + 0), ReadMacInt8(s + 1), ReadMacInt8(s + 2), ReadMacInt8(s + 3),
ReadMacInt8(s + 4), ReadMacInt8(s + 5), ReadMacInt8(s + 6), ReadMacInt8(s + 7)));
err_mask = ReadMacInt8(s + shkErrs);
if (is_parallel) {
// Parallel handshake
if (with_dtr) {
if (ReadMacInt8(s + shkFCTS) || ReadMacInt8(s + shkFDTR))
((IOExtPar *)control_io)->io_ParFlags |= PARF_ACKMODE;
else
((IOExtPar *)control_io)->io_ParFlags &= ~PARF_ACKMODE;
} else {
if (ReadMacInt8(s + shkFCTS))
((IOExtPar *)control_io)->io_ParFlags |= PARF_ACKMODE;
else
((IOExtPar *)control_io)->io_ParFlags &= ~PARF_ACKMODE;
}
set_par_params();
} else {
// Serial handshake
if (ReadMacInt8(s + shkFXOn) || ReadMacInt8(s + shkFInX))
control_io->io_SerFlags &= ~SERF_XDISABLED;
else
control_io->io_SerFlags |= SERF_XDISABLED;
if (with_dtr) {
if (ReadMacInt8(s + shkFCTS) || ReadMacInt8(s + shkFDTR))
control_io->io_SerFlags |= SERF_7WIRE;
else
control_io->io_SerFlags &= ~SERF_7WIRE;
} else {
if (ReadMacInt8(s + shkFCTS))
control_io->io_SerFlags |= SERF_7WIRE;
else
control_io->io_SerFlags &= ~SERF_7WIRE;
}
control_io->io_CtlChar = ReadMacInt16(s + shkXOn) << 16;
set_params();
}
}
