void PhotonLTEIntegrator::ShootPhotons(size_t i_photons, bool i_low_thread_priority)
{
mp_photon_maps.reset(new PhotonMaps());
const LightSources &lights = mp_scene->GetLightSources();
if (lights.m_delta_light_sources.size() + lights.m_area_light_sources.size() + lights.m_infinite_light_sources.size() == 0 || i_photons == 0)
return;
std::vector<double> lights_CDF;
_GetLightsPowerCDF(lights, lights_CDF);
PhotonsInputFilter input_filter(mp_photon_maps, i_photons, m_params.m_max_caustic_photons, m_params.m_max_direct_photons, m_params.m_max_indirect_photons, MAX_PIPELINE_TOKENS_NUM, 4096);
PhotonsShootingFilter shooting_filter(this, mp_scene, lights_CDF, i_low_thread_priority);
PhotonsMergingFilter merging_filter(mp_photon_maps);
tbb::pipeline pipeline;
pipeline.add_filter(input_filter);
pipeline.add_filter(shooting_filter);
pipeline.add_filter(merging_filter);
pipeline.run(MAX_PIPELINE_TOKENS_NUM);
pipeline.clear();
// Construct the KD trees. We explicitly do this now while we are still in a single thread to avoid concurrency issues later.
tbb::parallel_invoke([&]{mp_photon_maps->GetCausticMap(); },
[&]{mp_photon_maps->GetDirectMap(); },
[&]{mp_photon_maps->GetIndirectMap(); });
_ConstructIrradiancePhotonMap();
}
void PolyPhonicChannel::ProcessChannel(VstInt32 sampleFrames)
{
double* out1 = _processBuffer[0];
double* out2 = _processBuffer[1];
while (--sampleFrames >= 0)
{
double value = 0.0;
_waveTable->ProcessSample(&value);
if(value != value)
{
std::cout << "Wavetable IS NAN" << std::endl;
}
t_out input_filter(value, value);
t_out filter_processed = _filter->ProcessStereo(input_filter);
double env = _env->Process();
// if(env != env)
// {
// std::cout << "ENV IS NAN" << std::endl;
// }
if(filter_processed.l != filter_processed.l)
{
std::cout << "FILTER IS NAN" << std::endl;
}
*out1++ = filter_processed.l * env;
*out2++ = filter_processed.r * env;
}
}
int
record_resend(int kind, const unsigned char *prefix, unsigned char plen,
const unsigned char *src_prefix, unsigned char src_plen,
unsigned short seqno, const unsigned char *id,
struct interface *ifp, int delay)
{
struct resend *resend;
unsigned int ifindex = ifp ? ifp->ifindex : 0;
if((kind == RESEND_REQUEST &&
input_filter(NULL, prefix, plen, src_prefix, src_plen, NULL,
ifindex) >=
INFINITY) ||
(kind == RESEND_UPDATE &&
output_filter(NULL, prefix, plen, src_prefix, src_plen, ifindex) >=
INFINITY))
return 0;
if(delay >= 0xFFFF)
delay = 0xFFFF;
resend = find_resend(kind, prefix, plen, src_prefix, src_plen, NULL);
if(resend) {
if(resend->delay && delay)
resend->delay = MIN(resend->delay, delay);
else if(delay)
resend->delay = delay;
resend->time = now;
resend->max = RESEND_MAX;
if(id && memcmp(resend->id, id, 8) == 0 &&
seqno_compare(resend->seqno, seqno) > 0) {
return 0;
}
if(id)
memcpy(resend->id, id, 8);
else
memset(resend->id, 0, 8);
resend->seqno = seqno;
if(resend->ifp != ifp)
resend->ifp = NULL;
} else {
resend = calloc(1, sizeof(struct resend));
if(resend == NULL)
return -1;
resend->kind = kind;
resend->max = RESEND_MAX;
resend->delay = delay;
memcpy(resend->prefix, prefix, 16);
resend->plen = plen;
memcpy(resend->src_prefix, src_prefix, 16);
resend->src_plen = src_plen;
resend->seqno = seqno;
if(id)
memcpy(resend->id, id, 8);
resend->ifp = ifp;
resend->time = now;
resend->next = to_resend;
to_resend = resend;
}
if(resend->delay) {
struct timeval timeout;
timeval_add_msec(&timeout, &resend->time, resend->delay);
timeval_min(&resend_time, &timeout);
}
return 1;
}
int input_pcm ( char* pdata, int datasize, int rate, int channelnum)
{
if (channelnum == 0 || pdata == NULL)
{
return -1;
}
double k = (double) rate / 8000; //下变换因子
int i = 0;
int samplenum = datasize / 2 / channelnum;
for (i = 0; i < samplenum; i++)
{
pgetter->input_sample_num++;
int64_t temp = pgetter->input_sample_num / k;
if (temp > pgetter->sample_8k_num) //下采样
{
pgetter->sample_8k_num = temp;
int n;
double valsum = 0;
short *pval = pdata + i * 2 * channelnum;
for (n = 0; n < channelnum; n++)
{
valsum += *pval;
}
valsum = valsum / channelnum / 32768; //声道采样混合,-1~1归一化
//过5组滤波器
for (n = 0; n < FILTER_NUM; n++)
{
double y = input_filter(&pgetter->filter[n], valsum);
pgetter->feat_win[n][pgetter->feat_win_pos] = y;
}
if (pgetter->feat_win_pos + 1 == WIN_SIZE)
{
for (n = 0; n < FILTER_NUM; n++)
{
int num = 0;
double sum = 0;
for (num = 0; num < WIN_SIZE; num++)
{
if (pgetter->feat_win[n][num] < 0)
{
sum = sum - pgetter->feat_win[n][num];
}
else
{
sum = sum + pgetter->feat_win[n][num];
}
}
//psample->pfeat_obj->val[n][pos] = sum;
if (n == 0)
{
//printf("hererere %f\n", sum);
//fprintf(pfilet,"%f\n",sum);
//fflush(pfilet);
}
//sum = sum * loudpara[n];
pgetter->diffval[n] = sum - pgetter->currval[n];
pgetter->currval[n] = sum;
memmove(pgetter->feat_win[n], pgetter->feat_win[n] + WIN_STEP, sizeof (double)*(WIN_SIZE - WIN_STEP));
}
//printf("hererere %f %f %f %f %f \n",pgetter->diffval[0],pgetter->diffval[1],pgetter->diffval[2],pgetter->diffval[3],pgetter->diffval[4]);
input_feature(pgetter);
pgetter->feat_win_pos = WIN_SIZE - WIN_STEP; //窗内数据满后计算意思，然后步进
}
else
{
pgetter->feat_win_pos++;
}
}
}
//fflush(pfile);
return 0;
}
void
subkey (struct input_cmds_t *ins, struct select_t *sel, unsigned char key)
{
char *tmp;
struct cmdNode_t *cmd;
size_t x;
/* test control symbols */
if (key == 127)
{
/* its <DEL> */
if (ins->failch)
{
ins->failch = '\0';
}
else
if (ins->strlen > ins->offset)
{
ins->strlen--;
}
else
if (ins->c)
{
/* TODO: raise from args last line before remove call ptr */
/* remove current call pointer */
ins->c->argn = 0;
ins->c->cmd = NULL;
ins->type = FINPUT_TSTRING;
ins->strlen = 0;
ins->offset = 0;
/* TODO: call split */
}
return;
}
else
/* remove all data in input */
if (key == 8)
{
ins->strlen = ins->offset;
ins->failch = '\0';
return;
}
/* ignore ',' in start of line and over characters */
if ((!ins->strlen && key == ',') ||
(key != ',' && input_filter (ins->type, key)))
{
ins->failch = key;
return;
}
/* test struct input_cmds_t */
if (!ins->c)
{
if (!ins->i)
{
ins->i = calloc (1, sizeof (struct input_node_t));
if (!ins->i)
return;
ins->c = ins->i;
}
else
{
ins->c = calloc (1, sizeof (struct input_node_t));
if (!ins->c)
return;
if (ins->i->prev)
ins->i->prev->next = ins->c;
ins->c->prev = ins->i->prev;
ins->i->prev = ins->c;
}
}
/* alloc input string */
if (!ins->input)
{
ins->input = calloc (INPUT_SZ, sizeof (char));
if (!ins->input)
return;
ins->strlen = 0;
}
else
/* resize string */
if ((ins->strlen + 2) % INPUT_SZ < ins->strlen % INPUT_SZ)
{
tmp = calloc (ins->strlen + INPUT_SZ, sizeof (char));
if (!tmp)
return;
memcpy (tmp, (const void*)ins->input, ins->strlen);
free (ins->input);
ins->input = tmp;
}
/* add new char */
ins->input[ins->strlen] = key;
ins->strlen++;
ins->input[ins->strlen] = '\0';
/* free error */
ins->failch = '\0';
/** current command not set **/
if (!(cmd = ins->c->cmd))
{
/* try find in layer space */
if ((cmd = sel->sel[sel->cursel].cmds))
{
do
{
/* skip smallest or biggest tags */
if (cmd->taglen != ins->strlen)
continue;
/* set current tag to find :3 */
if (!strncmp (cmd->tag, ins->input, ins->strlen))
break;
}
while ((++cmd)->tag);
}
/* try find in global space */
if (cmd && !(cmd->tag) && (cmd = sel->cmds))
{
do
{
if (cmd->taglen != ins->strlen)
continue;
if (!strncmp (cmd->tag, ins->input, ins->strlen))
break;
}
while ((++cmd)->tag);
}
/* continues input */
if (cmd && cmd->tag)
{
if (!cmd->call)
cmd->call = msel_func_NULL;
else
{
if (!cmd->call->merge)
cmd->call->merge = msel_func_NULL->merge;
if (!cmd->call->split)
cmd->call->split = msel_func_NULL->split;
if (!cmd->call->wargk)
cmd->call->wargk = msel_func_NULL->wargk;
}
ins->input[ins->strlen] = '\0';
ins->offset = ++ins->strlen;
ins->c->cmd = cmd;
ins->c->argn = 0;
}
}
/* test current command */
if (ins->c->cmd)
{
if (ins->input[ins->strlen - 1] == ',')
{
ins->offset = ins->strlen;
ins->input[ins->strlen - 1] = '\0';
ins->c->argn++;
}
/* test for call */
if (ins->c->cmd->call->wargk[ins->c->argn] == FINPUT_TVOID)
{
/* alloc:
* len of input string
* + nums of arguments
*/
ins->c->argv = calloc (1,
sizeof (char) * ins->strlen +
sizeof (char*) * (ins->c->argn + 1));
if (!ins->c->argv)
{
ins->c = NULL;
return;
}
/* copy tag to argv */
ins->c->argv[0] = (char*)(ins->c->argv + ins->c->argn + 1);
memcpy (ins->c->argv[0], ins->input, ins->strlen);
/* ptr to over data */
if (ins->c->argn)
{
ins->c->argv[1] = ins->c->argv[0] + ins->c->cmd->taglen + 1;
x = ins->c->argn;
/* fix offset (remove last 2zero) */
ins->offset--;
/* update links */
do
{
/* find last \0 */
while (--ins->offset && ins->c->argv[0][ins->offset - 1]);
/* set arg point */
ins->c->argv[x] = &(ins->c->argv[0][ins->offset]);
}
while (--x);
}
ins->c->cmd->call->merge (sel->cursel, sel,
ins->c->argn + 1, ins->c->argv);
ins->c = NULL;
ins->strlen = 0;
ins->offset = 0;
ins->type = FINPUT_TSTRING;
}
else
{
/* set input type */
ins->type = ins->c->cmd->call->wargk[ins->c->argn];
}
}
}
