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]);
}
}
}
