Chorus::Chorus(dspCreationStruct data):
DSPEffect(data),
m_delayUnitL(2048),
m_delayUnitR(2048),
m_modTable(512),
m_modPhasor(44100,1)
{
set_effect_name("Chorus");
set_meta(get_tutId(),"link to html");
m_modTable.fill_sine();
add_parameter("Chorus Amount",0.0,1.0,0.5);
get_parameter("Chorus Amount")->set_meta("GuiHint","soCustomFader");
add_parameter("Depth",0.0,1.0,0.5);
get_parameter("Depth")->set_meta("GuiHint","soCustomFader");
add_parameter("Frequency",0.01,5.0,1.0);
get_parameter("Frequency")->set_meta("GuiHint","soCustomFader");
set_implementation();
}
void Get_image::inizialize_parameters (string path) {
(*this).path = path;
add_parameter (IN, String);
add_parameter (OUT, Buffer);
string command = "mkdir -p " + path;
if (system(command.c_str())) cerr << "ERROR - Can't create the service directory" << endl;
}
void stream(T4C* t4c, sds url, Parameters* paramsArgument, size_t (*callback)(void*, size_t, size_t, void*)) {
Parameters* oauthParams = new_parameters();
genOAuthParams(t4c, oauthParams);
Parameters* params = new_parameters();
buildParams(params, oauthParams, paramsArgument);
sds oauthSignature = signature(t4c->consumerSecret, t4c->accessTokenSecret, GET, url, params);
sds encodedSignature = url_encode(oauthSignature);
add_parameter(oauthParams, sdsnew("oauth_signature"), encodedSignature);
add_parameter(params, sdsnew("oauth_signature"), encodedSignature);
sds authorizeChild = join_parameters(oauthParams, ",");
sds authorize = sdscatprintf(sdsempty(), "Authorization: OAuth %s", authorizeChild);
sds path = join_parameters(params, "&");
if (DEBUG) {
printf("----------------------------\n");
printf("STREAMING API");
printf("URL: %s\n", url);
printf("path: %s\n", path);
printf("authorize: %s\n", authorize);
printf("----------------------------\n");
}
CURL* curl;
curl = curl_easy_init();
sds reqURL = sdscatprintf(sdsempty(), "%s?%s", url, path);
curl_easy_setopt(curl, CURLOPT_URL, reqURL);
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, authorize);
curl_easy_setopt(curl, CURLOPT_HEADER, headers);
curl_easy_setopt(curl, CURLOPT_SSL_VERIFYPEER, 0);
curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, callback);
curl_easy_setopt(curl, CURLOPT_TIMEOUT, 0);
curl_easy_perform(curl);
curl_easy_cleanup(curl);
sdsfree(oauthSignature);
sdsfree(encodedSignature);
sdsfree(reqURL);
sdsfree(url);
sdsfree(path);
sdsfree(authorize);
sdsfree(authorizeChild);
free_parameters(oauthParams);
}
static void buildParams(Parameters* params, Parameters* oauthParams, Parameters* additionalParam) {
for (Node* thisNode = oauthParams->firstNode; thisNode != NULL; thisNode = thisNode->next) {
add_parameter(params, thisNode->value->key, thisNode->value->value);
}
if (additionalParam != NULL && !is_parameters_empty(additionalParam)) {
Parameters* adParams = additionalParam;
for (Node* thisNode = adParams->firstNode; thisNode != NULL; thisNode = thisNode->next) {
add_parameter(params, thisNode->value->key, url_encode(thisNode->value->value));
}
}
}
Delay::Delay(dspCreationStruct data):
DSPEffect(data),
m_delayUnitL(44100*10),
m_delayUnitR(44100*10)
{
set_effect_name("Delay");
set_meta(get_tutId(),"link to html");
add_parameter("Delay Time",0.01,10.0,1.0);
// get_parameter("Delay Time")->set_meta("GuiHint","soCustomFader");
add_parameter("Delay Volume",0.01,1,0.9);
// get_parameter("Delay Volume")->set_meta("GuiHint","soCustomFader");
set_meta(get_tutId(),"learning/gaintree.xml");
set_implementation();
data.attatchedRegion->set_extension(44100*15);
}
void add_parameters(const std::vector<Species>& params)
{
for (std::vector<Species>::const_iterator i(params.begin());
i != params.end(); ++i)
{
add_parameter(*i);
}
}
void dds::sub::TQuery<DELEGATE>::parameters(
const FWIterator& begin,
const FWIterator end)
{
ISOCPP_REPORT_STACK_DDS_BEGIN(*this);
for (FWIterator it = begin; it != end; ++it) {
add_parameter(*it);
}
}
// Argument parsing
void add_all_parameters(ParamSource& args) {
// first parameter is the graph
graph = args.get_matrix_argument();
// then come the optional parameters
while (!args.end()) {
string key = args.get_parameter_name();
normalize_key(key);
add_parameter(key, args);
}
}
void Sip_Header_Value_Proxy_Authenticate::init(const std::string& build_from, const bool &authMethodPresent)
{
if( authMethodPresent )
{
size_t pos = build_from.find_first_not_of(" \t\r\n");
size_t last = build_from.find_first_of(" \t\r\n", pos);
if( last != std::string::npos )
{
_auth_method = build_from.substr( pos, last - pos );
add_parameter( new Sip_Header_Parameter( build_from.substr( last )));
}
}
else
{
if(!build_from.empty())
add_parameter(new Sip_Header_Parameter(build_from));
}
}
Pan::Pan(dspCreationStruct data):
DSPEffect(data)
{
set_effect_name("Pan");
add_parameter("Pan",-1.0f,1.0,0);
set_meta(get_tutId(),"learning/pantree.xml");
get_parameter("Pan")->set_meta("GuiHint","soCustomFader");
set_implementation();
}
void ParameterSet::add_parameters(ParameterSet ¶ms, bool replace_existing)
{
for (unsigned int i = 0; i < params.size(); i++)
{
EParameter *param = params.get_parameter(i);
if (param != nullptr)
add_parameter(*param, replace_existing);
else
LOG(WARNING) << __FILE__ << "(" << __LINE__ << ") : Null pointer";
}
}
Reverb::Reverb(dspCreationStruct data):
DSPEffect(data)
{
set_effect_name("Reverb");
add_parameter("Roomsize",0,1,0.5);
get_parameter("Roomsize")->set_meta("GuiHint","soCustomFader");
add_parameter("Damping",0,1,0.5);
get_parameter("Damping")->set_meta("GuiHint","soCustomFader");
add_parameter("Reverb Amount",0,1,0.8);
get_parameter("Reverb Amount")->set_meta("GuiHint","soCustomFader");
// add_parameter("Freeze Amount",0,1,0.1);
set_implementation();
data.attatchedRegion->set_extension(44100*10);
}
Fade::Fade(dspCreationStruct data):
DSPEffect(data), m_currentAmp(0.0)
{
m_duration = data.attatchedRegion->get_duration();
set_effect_name("Fade");
set_meta(get_tutId(),"link to html");
add_parameter("Fade In Time(ms)",10,m_duration/44.1,1000.0);
get_parameter("Fade In Time(ms)")->set_meta("GuiHint","soCustomFader");
add_parameter("Fade Out Time(ms)",10,m_duration/44.1,1000.0);
get_parameter("Fade Out Time(ms)")->set_meta("GuiHint","soCustomFader");
m_fadeUnit.add_breakpoint(TVPair(0, 0));
m_fadeUnit.add_breakpoint(TVPair(get_parameter("Fade In Time(ms)")->get_value()*44.1, 1.0));
m_fadeUnit.add_breakpoint(TVPair(get_parameter("Fade Out Time(ms)")->get_value()*44.10, 1.0));
m_fadeUnit.add_breakpoint(TVPair(m_duration, 0));
set_implementation();
}
ParameterSet::ParameterSet(ParameterSet ¶ms)
{
for (unsigned int i = 0; i<params.size(); i++)
{
EParameter *p = params.get_parameter(i);
if (p != nullptr)
add_parameter(*p, true);
else
LOG(WARNING) << __FILE__ << "(" << __LINE__ << ") : Null pointer";
delete p;
}
}
/**
* Add a new unnamed constant to the parameter list.
* \param paramList - the parameter list
* \param values - four float values
* \return index of the new parameter.
*/
GLint
_mesa_add_unnamed_constant(struct program_parameter_list *paramList,
const GLfloat values[4])
{
/* generate a new dummy name */
static GLuint n = 0;
char name[20];
_mesa_sprintf(name, "constant%d", n);
n++;
/* store it */
return add_parameter(paramList, name, values, CONSTANT);
}
AsymmetricDelay::AsymmetricDelay(dspCreationStruct data):
DSPEffect(data),
m_delayUnitL(44100*10),
m_delayUnitR(44100*10)
{
set_effect_name("AsymmetricDelay");
set_meta(get_tutId(),"link to html");
add_parameter("First Delay Time",0,10,1);
get_parameter("First Delay Time")->set_meta("GuiHint","soCustomFader");
add_parameter("First Delay Volume",0,1,0.5);
get_parameter("First Delay Volume")->set_meta("GuiHint","soCustomFader");
add_parameter("Second Delay Time",0,10,3);
get_parameter("Second Delay Time")->set_meta("GuiHint","soCustomFader");
add_parameter("Second Delay Volume",0,1,0.5);
get_parameter("Second Delay Volume")->set_meta("GuiHint","soCustomFader");
add_parameter("Third Delay Time",0,10,5);
get_parameter("Third Delay Time")->set_meta("GuiHint","soCustomFader");
add_parameter("Third Delay Volume",0,1,0.5);
get_parameter("Third Delay Volume")->set_meta("GuiHint","soCustomFader");
data.attatchedRegion->set_extension(44100*15);
set_implementation();
set_implementation();
}
dds::sub::TQuery<DELEGATE>::TQuery(
const dds::sub::AnyDataReader& dr,
const std::string& expression,
const FWIterator& params_begin,
const FWIterator& params_end) :
dds::core::Reference<DELEGATE>(new DELEGATE(AnyDataReader(dr), expression))
{
ISOCPP_REPORT_STACK_DDS_BEGIN(dr);
for (FWIterator it = params_begin; it != params_end; ++it) {
add_parameter(*it);
}
}
void
TopologyModule::Add_P_PFunction::execute( SLIInterpreter* i ) const
{
i->assert_stack_load( 2 );
ParameterDatum param1 = getValue< ParameterDatum >( i->OStack.pick( 1 ) );
ParameterDatum param2 = getValue< ParameterDatum >( i->OStack.pick( 0 ) );
ParameterDatum newparam = add_parameter( param1, param2 );
i->OStack.pop( 2 );
i->OStack.push( newparam );
i->EStack.pop();
}
SimpleReverb::SimpleReverb(dspCreationStruct data):
DSPEffect(data)
{
set_effect_name("SimpleReverb");
add_parameter("Roomsize",0,1,0.5);
set_meta(get_tutId(),"link to html");
get_parameter("Roomsize")->set_meta("GuiHint","soCustomFader");
set_implementation();
data.attatchedRegion->set_extension(44100*10);
}
/**
* Add a new state reference to the parameter list.
* \param paramList - the parameter list
* \param state - an array of 6 state tokens
*
* \return index of the new parameter.
*/
GLint
_mesa_add_state_reference(struct program_parameter_list *paramList,
GLint *stateTokens)
{
/* XXX Should we parse <stateString> here and produce the parameter's
* list of STATE_* tokens here, or in the parser?
*/
GLint a, idx;
idx = add_parameter(paramList, "Some State", NULL, STATE);
for (a=0; a<6; a++)
paramList->Parameters[idx].StateIndexes[a] = (enum state_index) stateTokens[a];
return idx;
}
int parse_one_parameter ( char *buffer)
{
char name[MAXPARAMLINELENGTH+1];
char data[MAXPARAMLINELENGTH+1];
int i, j, k, l;
int n, d;
k = -1;
j = 0;
l = strlen ( buffer );
/** scan for a equals sign. **/
for ( i = 0; i < l; ++i )
{
/* j records whether or not we have found a nonwhitespace
character. */
j += (buffer[i] != ' ' && buffer[i] != '\t' && buffer[i] != '\n');
if ( buffer[i] == '=' )
{
k = i;
/* copy the name part. */
strncpy ( name, buffer, k );
name[k] = 0;
/* copy the value part. */
strcpy ( data, buffer+k+1 );
break;
}
}
/* if we found no '=', return an error unless the line was
completely blank. */
if ( k == -1 )
return !!j;
/* trim leading and trailing whitespace. */
n = trim_string ( name );
d = trim_string ( data );
/** if either section is blank, return an error, otherwise add
the pair as a parameter. **/
if ( n == 0 || d == 0 )
return 1;
else
add_parameter ( name, data, PARAM_COPY_NAME|PARAM_COPY_VALUE );
return 0;
}
static void genOAuthParams(T4C* t4c, Parameters* params) {
time_t now = time(NULL);
char* now_str = MALLOC_TS(char, sizeof(now));
sprintf(now_str, "%d", (int)now);
add_parameter(params, sdsnew("oauth_consumer_key"), t4c->consumerKey);
add_parameter(params, sdsnew("oauth_nonce"), sdsnew(now_str));
add_parameter(params, sdsnew("oauth_signature_method"), sdsnew("HMAC-SHA1"));
add_parameter(params, sdsnew("oauth_timestamp"), sdsnew(now_str));
add_parameter(params, sdsnew("oauth_token"), t4c->accessToken);
add_parameter(params, sdsnew("oauth_version"), sdsnew("1.0"));
free(now_str);
}
void *
ys_load_properties(const char *name)
{
FILE *file;
parameters_t *p;
char buf[BUFSIZ];
p = (parameters_t*) calloc(1, sizeof(parameters_t));
if (p == 0) {
perror("calloc");
fprintf(stderr, "Failed to allocate memory\n");
return 0;
}
p->n = p->allocated = 0;
p->names = p->values = 0;
file = fopen(name, "r");
if (file == 0) {
perror("fopen");
fprintf(stderr, "Unable to open file %s\n", name);
return p;
}
if (Ys_debug) {
printf("opened parameter file %s\n", name);
}
while (fgets(buf, sizeof buf, file) != 0) {
char *n, *v;
if (*buf == '#')
continue;
n = strtok(buf, "=");
v = strtok(0, "\n");
if (n == 0 || v == 0)
continue;
add_parameter(p, n, v);
}
fclose(file);
return p;
}
_XShaderWaterParameterHandler::_XShaderWaterParameterHandler()
{
id = 0;
add_parameter(p_fStrength, "Noise strength", dtFloat);
add_parameter(p_bDisplace, "Toggle displacement", dtBool);
add_parameter(p_bSmooth, "Smooth heightmap", dtBool);
add_parameter(p_bReflRefrStrength,"Reflection/Refraction strength", dtFloat);
add_parameter(p_iOctaves, "Octaves", dtInt);
add_parameter(p_fScale, "Noise scale", dtFloat);
add_parameter(p_fFalloff, "Noise falloff", dtFloat);
add_parameter(p_fAnimspeed, "Animation speed", dtFloat);
add_parameter(p_fTimemulti, "Animation multi", dtFloat);
add_parameter(p_bPaused, "Pause animation", dtBool);
add_parameter(p_bDisplayTargets,"Display rendertargets(D)", dtBool);
add_parameter(p_fSunPosAlpha, "Sun location horizontal", dtFloat);
add_parameter(p_fSunPosTheta, "Sun location vertical", dtFloat);
add_parameter(p_fSunShininess, "Sun shininess", dtFloat);
add_parameter(p_fSunStrength, "Sun strength", dtFloat);
add_parameter(p_bAsPoints, "Render as points", dtBool);
add_parameter(p_fLODbias, "Mipmap LOD Bias", dtFloat);
add_parameter(p_fElevation, "Projector elevation", dtFloat);
add_parameter(p_fWaterColourR, "water colour Red", dtFloat);
add_parameter(p_fWaterColourG, "water colour Green", dtFloat);
add_parameter(p_fWaterColourB, "water colour Blue", dtFloat);
add_parameter(p_bDrawDuckie, "Render Duckie", dtBool);
add_parameter(p_bDrawIsland, "Render Island", dtBool);
add_parameter(p_bDiffuseRefl, "Diffuse sky reflection", dtBool);
}
/**
* Add a new unnamed constant to the parameter list.
* \param paramList - the parameter list
* \param values - four float values
* \return index of the new parameter.
*/
GLint
_mesa_add_named_constant(struct program_parameter_list *paramList,
const char *name, const GLfloat values[4])
{
return add_parameter(paramList, name, values, CONSTANT);
}
/**
* Add a new named program parameter (Ex: NV_fragment_program DEFINE statement)
* \return index of the new entry in the parameter list
*/
GLint
_mesa_add_named_parameter(struct program_parameter_list *paramList,
const char *name, const GLfloat values[4])
{
return add_parameter(paramList, name, values, NAMED_PARAMETER);
}
sds request(T4C* t4c, METHOD method, sds endPoint, Parameters* paramsArgument) {
sds result;
Parameters* oauthParams = new_parameters();
genOAuthParams(t4c, oauthParams);
Parameters* params = new_parameters();
buildParams(params, oauthParams, paramsArgument);
sds url = sdscatprintf(sdsempty(), "%s%s", baseUrl, endPoint);
sds oauthSignature = signature(t4c->consumerSecret, t4c->accessTokenSecret, method, url, params);
sds encodedSignature = url_encode(oauthSignature);
add_parameter(oauthParams, sdsnew("oauth_signature"), encodedSignature);
add_parameter(params, sdsnew("oauth_signature"), encodedSignature);
sds authorizeChild = join_parameters(oauthParams, ",");
sds authorize = sdscatprintf(sdsempty(), "Authorization: OAuth %s", authorizeChild);
sds path = join_parameters(params, "&");
if (DEBUG) {
printf("----------------------------\n");
printf("URL: %s\n", url);
printf("endPoint: %s\n", endPoint);
printf("path: %s\n", path);
printf("authorize: %s\n", authorize);
printf("----------------------------\n");
}
CURL* curl;
curl = curl_easy_init();
sds reqURL;
if (method == GET) {
reqURL = sdscatprintf(sdsempty(), "%s?%s", url, path);
curl_easy_setopt(curl, CURLOPT_URL, reqURL);
} else if (method == POST) {
curl_easy_setopt(curl, CURLOPT_POST, 1);
curl_easy_setopt(curl, CURLOPT_POSTFIELDS, path);
curl_easy_setopt(curl, CURLOPT_POSTFIELDSIZE, sdslen(path));
curl_easy_setopt(curl, CURLOPT_URL, url);
}
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, authorize);
curl_easy_setopt(curl, CURLOPT_HEADER, headers);
curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, curl_result_stringlize_callback);
curl_easy_setopt(curl, CURLOPT_WRITEDATA, (void*)&result);
curl_easy_perform(curl);
curl_easy_cleanup(curl);
sdsfree(oauthSignature);
sdsfree(encodedSignature);
sdsfree(reqURL);
sdsfree(url);
sdsfree(path);
sdsfree(authorize);
sdsfree(authorizeChild);
free_parameters(oauthParams);
return result;
}
