int Cns_utime(const char *path, struct utimbuf *times) { /* Basic checks for path validity */ if(basic_path_checks(path) != NE_OK) return -1; /* try to open a session if there is no existing one */ if(!connection) if (dav_startsess(NULL,NULL) != NE_OK) return -1; time_t rawtime; struct tm *timeinfo; char strtime[64]; const char davdate_mask[] = "%a, %d %b %Y %H:%M:%S GMT"; time(&rawtime); timeinfo = localtime(&rawtime); strftime(strtime, 64, davdate_mask, timeinfo); /* Try to set the property */ set_parameter(path, "DAV:getlastmodified", strtime); timeinfo = localtime(&(times->actime)); strftime(strtime, 64, davdate_mask, timeinfo); set_parameter(path, "LCGDM:lastaccessed", strtime); return 0; }
EFFECT_REVERB::EFFECT_REVERB (CHAIN_OPERATOR::parameter_t delay_time, int surround_mode, CHAIN_OPERATOR::parameter_t feedback_percent) { set_parameter(1, delay_time); set_parameter(2, surround_mode); set_parameter(3, feedback_percent); }
template<> void GncSqlColumnTableEntryImpl<CT_ADDRESS>::load (const GncSqlBackend* sql_be, GncSqlRow& row, QofIdTypeConst obj_name, gpointer pObject) const noexcept { const gchar* s; g_return_if_fail (sql_be != NULL); g_return_if_fail (pObject != NULL); auto addr = gncAddressCreate (sql_be->book(), QOF_INSTANCE(pObject)); for (auto const& subtable_row : col_table) { auto buf = std::string{m_col_name} + "_" + subtable_row->m_col_name; try { auto val = row.get_string_at_col (buf.c_str()); auto sub_setter = subtable_row->get_setter(GNC_ID_ADDRESS); set_parameter (addr, val.c_str(), sub_setter, subtable_row->m_gobj_param_name); } catch (std::invalid_argument) { return; } } set_parameter (pObject, addr, reinterpret_cast<AddressSetterFunc>(get_setter(obj_name)), m_gobj_param_name); }
int TemperatureCalibrationBaro::finish_sensor_instance(PerSensorData &data, int sensor_index) { if (!data.hot_soaked || data.tempcal_complete) { return 0; } double res[POLYFIT_ORDER + 1] = {}; data.P[0].fit(res); res[POLYFIT_ORDER] = 0.0; // normalise the correction to be zero at the reference temperature by setting the X^0 coefficient to zero PX4_INFO("Result baro %u %.20f %.20f %.20f %.20f %.20f %.20f", sensor_index, (double)res[0], (double)res[1], (double)res[2], (double)res[3], (double)res[4], (double)res[5]); data.tempcal_complete = true; char str[30]; float param = 0.0f; int result = PX4_OK; set_parameter("TC_B%d_ID", sensor_index, &data.device_id); for (unsigned coef_index = 0; coef_index <= POLYFIT_ORDER; coef_index++) { sprintf(str, "TC_B%d_X%d", sensor_index, (POLYFIT_ORDER - coef_index)); param = (float)res[coef_index]; result = param_set_no_notification(param_find(str), ¶m); if (result != PX4_OK) { PX4_ERR("unable to reset %s", str); } } set_parameter("TC_B%d_TMAX", sensor_index, &data.high_temp); set_parameter("TC_B%d_TMIN", sensor_index, &data.low_temp); set_parameter("TC_B%d_TREF", sensor_index, &data.ref_temp); return 0; }
Light::Light(VisualServer::LightType p_type) { type=p_type; light=VisualServer::get_singleton()->light_create(p_type); set_parameter(PARAM_SPOT_ATTENUATION,1.0); set_parameter(PARAM_SPOT_ANGLE,30.0); set_parameter(PARAM_RADIUS,2.0); set_parameter(PARAM_ENERGY,1.0); set_parameter(PARAM_ATTENUATION,1.0); set_parameter(PARAM_SHADOW_DARKENING,0.0); set_parameter(PARAM_SHADOW_Z_OFFSET,0.05); set_parameter(PARAM_SHADOW_Z_SLOPE_SCALE,0); set_parameter(PARAM_SHADOW_ESM_MULTIPLIER,60); set_parameter(PARAM_SHADOW_BLUR_PASSES,1); set_color( COLOR_DIFFUSE, Color(1,1,1)); set_color( COLOR_SPECULAR, Color(1,1,1)); op=OPERATOR_ADD; set_project_shadows( false ); set_base(light); enabled=true; editor_only=false; bake_mode=BAKE_MODE_DISABLED; }
void Light::approximate_opengl_attenuation(float p_constant, float p_linear, float p_quadratic,float p_radius_treshold) { //this is horrible and must never be used float a = p_quadratic * p_radius_treshold; float b = p_linear * p_radius_treshold; float c = p_constant * p_radius_treshold -1; float radius=10000; if(a == 0) { // solve linear float d = Math::abs(-c/b); if(d<radius) radius=d; } else { // solve quadratic // now ad^2 + bd + c = 0, solve quadratic equation: float denominator = 2*a; if(denominator != 0) { float root = b*b - 4*a*c; if(root >=0) { root = sqrt(root); float solution1 = fabs( (-b + root) / denominator); float solution2 = fabs( (-b - root) / denominator); if(solution1 > radius) solution1 = radius; if(solution2 > radius) solution2 = radius; radius = (solution1 > solution2 ? solution1 : solution2); } } } float energy=1.0; if (p_constant>0) energy=1.0/p_constant; //energy is this else energy=8.0; // some high number.. if (radius==10000) radius=100; //bug? set_parameter(PARAM_RADIUS,radius); set_parameter(PARAM_ENERGY,energy); }
ADVANCED_REVERB::ADVANCED_REVERB (parameter_t roomsize, parameter_t feedback_percent, parameter_t wet_percent) { set_parameter(1, roomsize); set_parameter(2, feedback_percent); set_parameter(3, wet_percent); }
EFFECT_INVERSE_COMB_FILTER::EFFECT_INVERSE_COMB_FILTER (int delay_in_samples, CHAIN_OPERATOR::parameter_t radius) { // // delay in number of samples // circle radius // set_parameter(1, (CHAIN_OPERATOR::parameter_t)delay_in_samples); set_parameter(2, radius); }
int main() { std::vector<X> xs(10); set_parameter(xs, 42, &X::foo); set_parameter(xs, "hello world", &X::splurgle); for (auto const& x : xs) std::cout << x.foo << ", " << x.splurgle << "\n"; }
EFFECT_RESONATOR::EFFECT_RESONATOR (CHAIN_OPERATOR::parameter_t centerf, CHAIN_OPERATOR::parameter_t w) : cona(1), conb(2) { /* to avoid accessing uninitialized data */ width = 1; center = 1; set_parameter(1, centerf); set_parameter(2, w); }
EFFECT_RESONANT_BANDPASS::EFFECT_RESONANT_BANDPASS (CHAIN_OPERATOR::parameter_t centerf, CHAIN_OPERATOR::parameter_t w) { /* to avoid accessing uninitialized data */ width = 1; center = 1; set_parameter(1, centerf); set_parameter(2, w); }
EFFECT_MODULATING_DELAY::EFFECT_MODULATING_DELAY(CHAIN_OPERATOR::parameter_t delay_time, long int vartime_in_samples, CHAIN_OPERATOR::parameter_t feedback_percent, CHAIN_OPERATOR::parameter_t lfo_freq) { set_parameter(1, delay_time); set_parameter(2, vartime_in_samples); set_parameter(3, feedback_percent); set_parameter(4, lfo_freq); }
EFFECT_MULTITAP_DELAY::EFFECT_MULTITAP_DELAY (CHAIN_OPERATOR::parameter_t delay_time, int num_of_delays, CHAIN_OPERATOR::parameter_t mix_percent) : delay_index(0), filled (0), buffer (0) { set_parameter(1, delay_time); set_parameter(2, num_of_delays); set_parameter(3, mix_percent); }
EFFECT_DELAY::EFFECT_DELAY (CHAIN_OPERATOR::parameter_t delay_time, int surround_mode, int num_of_delays, CHAIN_OPERATOR::parameter_t mix_percent, CHAIN_OPERATOR::parameter_t feedback_percent) { laskuri = 0.0; set_parameter(1, delay_time); set_parameter(2, surround_mode); set_parameter(3, num_of_delays); set_parameter(4, mix_percent); set_parameter(5, feedback_percent); }
LennardJones () { strength = 1.; sr_lr_split = 1.; scale = 2.; set_parameter ("cutoff", INFINITY); }
void LR_MsgHandler_PARM::process_message(uint8_t *msg) { const uint8_t parameter_name_len = AP_MAX_NAME_SIZE + 1; // null-term char parameter_name[parameter_name_len]; uint64_t time_us; if (field_value(msg, "TimeUS", time_us)) { wait_timestamp_usec(time_us); } else { // older logs can have a lot of FMT and PARM messages up the // front which don't have timestamps. Since in Replay we run // DataFlash's IO only when stop_clock is called, we can // overflow DataFlash's ringbuffer. This should force us to // do IO: hal.scheduler->stop_clock(last_timestamp_usec); } require_field(msg, "Name", parameter_name, parameter_name_len); float value = require_field_float(msg, "Value"); if (globals.no_params) { printf("Not changing %s to %f\n", parameter_name, value); } else { set_parameter(parameter_name, value); } }
int TemperatureCalibrationAccel::finish_sensor_instance(PerSensorData &data, int sensor_index) { if (!data.hot_soaked || data.tempcal_complete) { return 0; } double res[3][4] = {}; data.P[0].fit(res[0]); res[0][3] = 0.0; // normalise the correction to be zero at the reference temperature PX4_INFO("Result Accel %d Axis 0: %.20f %.20f %.20f %.20f", sensor_index, (double)res[0][0], (double)res[0][1], (double)res[0][2], (double)res[0][3]); data.P[1].fit(res[1]); res[1][3] = 0.0; // normalise the correction to be zero at the reference temperature PX4_INFO("Result Accel %d Axis 1: %.20f %.20f %.20f %.20f", sensor_index, (double)res[1][0], (double)res[1][1], (double)res[1][2], (double)res[1][3]); data.P[2].fit(res[2]); res[2][3] = 0.0; // normalise the correction to be zero at the reference temperature PX4_INFO("Result Accel %d Axis 2: %.20f %.20f %.20f %.20f", sensor_index, (double)res[2][0], (double)res[2][1], (double)res[2][2], (double)res[2][3]); data.tempcal_complete = true; char str[30]; float param = 0.0f; int result = PX4_OK; set_parameter("TC_A%d_ID", sensor_index, &data.device_id); for (unsigned axis_index = 0; axis_index < 3; axis_index++) { for (unsigned coef_index = 0; coef_index <= 3; coef_index++) { sprintf(str, "TC_A%d_X%d_%d", sensor_index, 3 - coef_index, axis_index); param = (float)res[axis_index][coef_index]; result = param_set_no_notification(param_find(str), ¶m); if (result != PX4_OK) { PX4_ERR("unable to reset %s", str); } } } set_parameter("TC_A%d_TMAX", sensor_index, &data.high_temp); set_parameter("TC_A%d_TMIN", sensor_index, &data.low_temp); set_parameter("TC_A%d_TREF", sensor_index, &data.ref_temp); return 0; }
LennardJonesGauss () { inv_temperature = 5; gauss_epsilon = 1.8; gauss_r0 = 1.52; gauss_sigma_sq = .02; set_parameter ("cutoff", 3.6); }
static void read_parameter_file (param_t *params, FILE *file) /* * Read parameter settings from 'file'. * * No return value. * * Side effects: * 'params [].value' are changed if specified in 'file' */ { char buffer [MAXSTRLEN]; int n = 0; assert (params && file); while (fgets (buffer, MAXSTRLEN, file) != NULL) { char *b; /* temporary variable */ char *name; /* parameter name */ char *value; /* parameter value */ int pind; /* current argument number */ b = strchr (buffer, '#'); if (b != NULL) /* Strip comments. */ *b = '\0'; b = strchr (buffer, '='); if (b == NULL) /* Strip lines that contain no '=' */ continue; *b = '\0'; /* Replace '=' by string terminator */ /* * Extract value of parameter */ for (value = b + 1; ISSPACE (*value); value++) ; /* Delete leading spaces */ for (b = value + strlen (value) - 1; b >= value && ISSPACE (*b); b--) *b = '\0'; /* Delete trailing spaces. */ /* * Extract parameter name */ for (name = buffer; ISSPACE (*name); name++) ; /* Delete leading spaces */ for (b = name + strlen (name) - 1; b >= name && ISSPACE (*b); b--) *b = '\0'; /* Delete trailing spaces. */ pind = get_parameter_index (params, name); if (pind >= 0) set_parameter (¶ms [pind], value); n++; } }
OMX_ERRORTYPE omx_vdec::set_vendor_extension_config( OMX_CONFIG_ANDROID_VENDOR_EXTENSIONTYPE *ext) { ALOGI("set_vendor_extension_config"); if (ext->nIndex >= mVendorExtensionStore.size()) { DEBUG_PRINT_ERROR("unrecognized vendor extension index (%u) max(%u)", ext->nIndex, mVendorExtensionStore.size()); return OMX_ErrorBadParameter; } const VendorExtension& vExt = mVendorExtensionStore[ext->nIndex]; DEBUG_PRINT_LOW("VendorExt: setConfig: index=%u (%s)", ext->nIndex, vExt.name()); OMX_ERRORTYPE err = OMX_ErrorNone; err = vExt.isConfigValid(ext); if (err != OMX_ErrorNone) { return err; } // mark this as set, regardless of set_config succeeding/failing. // App will know by inconsistent values in output-format vExt.set(); bool valueSet = false; switch ((OMX_U32)vExt.extensionIndex()) { case OMX_QcomIndexParamVideoDecoderPictureOrder: { OMX_S32 pic_order_enable = 0; valueSet |= vExt.readParamInt32(ext, "enable", &pic_order_enable); if (!valueSet) { break; } DEBUG_PRINT_HIGH("VENDOR-EXT: set_config: OMX_QcomIndexParamVideoDecoderPictureOrder : %d", pic_order_enable); QOMX_VIDEO_DECODER_PICTURE_ORDER decParam; OMX_INIT_STRUCT(&decParam, QOMX_VIDEO_DECODER_PICTURE_ORDER); decParam.eOutputPictureOrder = pic_order_enable ? QOMX_VIDEO_DECODE_ORDER : QOMX_VIDEO_DISPLAY_ORDER; err = set_parameter( NULL, (OMX_INDEXTYPE)OMX_QcomIndexParamVideoDecoderPictureOrder, &decParam); if (err != OMX_ErrorNone) { DEBUG_PRINT_ERROR("set_config: OMX_QcomIndexParamVideoDecoderPictureOrder failed !"); } break; } default: { return OMX_ErrorNotImplemented; } } return err; }
void EFFECT_FAKE_STEREO::init(SAMPLE_BUFFER* insample) { l.init(insample); r.init(insample); EFFECT_BASE::init(insample); set_parameter(1, dtime_msec); buffer.resize(2); }
void EFFECT_DELAY::init(SAMPLE_BUFFER* insample) { l.init(insample); r.init(insample); EFFECT_BASE::init(insample); set_parameter(1, dtime_msec); buffer.resize(2, std::vector<SINGLE_BUFFER> (static_cast<unsigned int>(dnum))); }
ADVANCED_COMPRESSOR::ADVANCED_COMPRESSOR (double peak_limit, double release_time, double cfrate, double crate) : rlevelsqn(ADVANCED_COMPRESSOR::NFILT), rlevelsqe(ADVANCED_COMPRESSOR::NEFILT) { init_values(); set_parameter(1, peak_limit); set_parameter(2, release_time); set_parameter(3, cfrate); set_parameter(4, crate); MESSAGE_ITEM otemp; otemp.setprecision(2); otemp << "(audiofx_compressor) Advanced compressor enabled;"; otemp << " peak limit " << peakpercent; otemp << " release time " << release_time; otemp << " cfrate " << fastgaincompressionratio; otemp << " crate " << compressionratio << "."; ECA_LOG_MSG(ECA_LOGGER::info, otemp.to_string()); }
void EFFECT_MULTITAP_DELAY::init(SAMPLE_BUFFER* insample) { i.init(insample); EFFECT_BASE::init(insample); set_parameter(1, dtime_msec); delay_index.resize(channels(), dtime * dnum - 1); filled.resize(channels(), std::vector<bool> (dnum, false)); buffer.resize(channels(), std::vector<SAMPLE_SPECS::sample_t> (dtime * dnum)); }
void reset(){ const int num_parameters = COMP_EFF_BYPASS; // Warning, reset() doesn't quite work if bypass is handled by faust. (this only happens in the standalone jack version though, which doesn't use reset()) float parms[num_parameters]; // Must store parameter values before calling init, since init overwrites them. for(int i=0;i<num_parameters;i++) parms[i] = get_parameter(i); init(fSamplingFreq); // Set back. for(int i=0;i<num_parameters;i++) set_parameter(i,parms[i]); }
void EFFECT_MODULATING_DELAY::init(SAMPLE_BUFFER* insample) { i.init(insample); lfo.init(); if (samples_per_second() > 0) advance_len_secs_rep = ((double)insample->length_in_samples()) / samples_per_second(); else advance_len_secs_rep = 0; set_parameter(1, dtime_msec); EFFECT_BASE::init(insample); filled.resize(channels(), false); delay_index.resize(channels(), 2 * dtime); buffer.resize(channels(), std::vector<SAMPLE_SPECS::sample_t> (2 * dtime)); }
void TemperatureCalibrationAccel::reset_calibration() { /* reset all driver level calibrations */ float offset = 0.0f; float scale = 1.0f; for (unsigned s = 0; s < 3; s++) { set_parameter("CAL_ACC%u_XOFF", s, &offset); set_parameter("CAL_ACC%u_YOFF", s, &offset); set_parameter("CAL_ACC%u_ZOFF", s, &offset); set_parameter("CAL_ACC%u_XSCALE", s, &scale); set_parameter("CAL_ACC%u_YSCALE", s, &scale); set_parameter("CAL_ACC%u_ZSCALE", s, &scale); } }
void ask_and_set (param_t *params, const char *name, const char *msg) /* * Ask user (print given message 'msg') for missing mandatory * parameter 'name' of the given parameters 'params'. * * No return value. * * Side effects: * 'params ['name'].value' is changed */ { char answer [MAXSTRLEN]; int index = get_parameter_index (params, name); if (index < 0) error ("Invalid parameter %s.", name); if (msg) fprintf (stderr, "%s\n", msg); switch (params [index].type) { case PFLAG: /* Unusual, at least. */ warning ("Flags should be initialized and set on demand, " "not request"); case PINT: case PSTR: case POSTR: case PFLOAT: scanf (MAXSTRLEN_SCANF, answer); set_parameter (¶ms [index], answer); break; default: error ("Invalid parameter type for %s", name); } }
int main(int argc, char **argv) { int i = 0; int *result = (int *)malloc(sizeof(int) * argc); int *opt = (int *)malloc(sizeof(int) * argc); parameter =(int *)malloc(sizeof(int) * 256); bzero(result, sizeof(int) * argc); bzero(opt, sizeof(int) * argc); bzero(parameter, sizeof(int) * 256); set_parameter(parameter); argv_process(result, opt, argv, argc, parameter); for(i = 1; i < result[0]; ++i){ cp_select(argv[result[i]], argv[result[result[0]]]); } free(result); free(opt); free(parameter); return 0; }
void EFFECT_BASE::set_samples_per_second(SAMPLE_SPECS::sample_rate_t new_rate) { ECA_LOG_MSG(ECA_LOGGER::user_objects, "Setting samplerate to " + kvu_numtostr(new_rate) + " for object " + name() + ". Old value " + kvu_numtostr(samples_per_second()) + "."); /* note: changing the sample rate might change values of * of parameters, so we want to preserve the values */ if (samples_per_second() != new_rate) { std::vector<parameter_t> old_values (number_of_params()); for(int n = 0; n < number_of_params(); n++) { old_values[n] = get_parameter(n + 1); } ECA_SAMPLERATE_AWARE::set_samples_per_second(new_rate); for(int n = 0; n < number_of_params(); n++) { set_parameter(n + 1, old_values[n]); } } }