void DimensionSelector::transform (ITransformer::info info,
ssi_stream_t &stream_in,
ssi_stream_t &stream_out,
ssi_size_t xtra_stream_in_num,
ssi_stream_t xtra_stream_in[]) {
ssi_byte_t *inptr = ssi_pcast (ssi_byte_t , stream_in.ptr);
ssi_byte_t *outptr = ssi_pcast (ssi_byte_t, stream_out.ptr);
for (ssi_size_t i = 0; i < stream_in.num; i++) {
ssi_size_t cur_selected = 0;
for (ssi_size_t a = 0; a < _max_selected; a++) {
if(_selector[a])
{
memcpy(outptr, inptr, sizeof(_bytes));
outptr += _bytes;
++cur_selected;
//stop searching if we found all needed values
if(cur_selected >= _n_selected)
break;
}
//go to next input
inptr += _bytes;
}
}
}
void QRSDetection::sendEvent_h(ITransformer::info &info, ssi_time_t sample_rate, ssi_size_t frame_count, ssi_size_t sample_number){
ssi_size_t samples_per_frame = info.frame_num;
ssi_size_t frame_time = ssi_sec2ms (info.time);
ssi_real_t time_per_sample = 1000.0f / (ssi_real_t) sample_rate;
ssi_size_t current_sample = frame_count * samples_per_frame + sample_number;
ssi_size_t current_sample_time = ssi_cast (ssi_size_t, current_sample * time_per_sample + 0.5);
if (_listener) {
_r_event.time = current_sample_time;
_r_event.dur = ssi_cast (ssi_size_t, time_per_sample + 0.5);
if(_send_etuple) {
ssi_event_map_t *ptr = ssi_pcast (ssi_event_map_t, _r_event.ptr);
ptr[0].value = ssi_real_t (current_sample_time - _last_R);
} else {
ssi_real_t *ptr = ssi_pcast (ssi_real_t, _r_event.ptr);
ptr[0] = ssi_real_t(current_sample_time - _last_R);
}
_listener->update (_r_event);
} else {
ssi_print("\nR-spike detected in \n\tframe number %u with starting time %u ms", frame_count, frame_time);
ssi_print("\n\tat sample number %u at time %u ms", current_sample, current_sample_time);
}
_last_R = current_sample_time;
}
void PreEmphasis::transform (ITransformer::info info,
ssi_stream_t &stream_in,
ssi_stream_t &stream_out,
ssi_size_t xtra_stream_in_num,
ssi_stream_t xtra_stream_in[]) {
ssi_size_t num = stream_in.num;
ssi_real_t *x = ssi_pcast (ssi_real_t, stream_in.ptr);
ssi_real_t *y = ssi_pcast (ssi_real_t, stream_out.ptr);
if (first_call) {
hist = *x;
first_call = false;
}
if (de) {
for (ssi_size_t n = 0; n < num; n++) {
*(y++) = *(x) + k * hist;
hist = *x++;
}
} else {
for (ssi_size_t n = 0; n < num; n++) {
*(y++) = *(x) - k * hist;
hist = *x++;
}
}
}
void AudioConvert::transform (ITransformer::info info,
ssi_stream_t &stream_in,
ssi_stream_t &stream_out,
ssi_size_t xtra_stream_in_num,
ssi_stream_t xtra_stream_in[]) {
if (_short_to_float) {
int16_t *srcptr = ssi_pcast (int16_t, stream_in.ptr);
ssi_real_t *dstptr = ssi_pcast (ssi_real_t, stream_out.ptr);
ssi_size_t N = stream_in.num * stream_in.dim;
for (ssi_size_t i = 0; i < N; i++) {
*dstptr++ = ssi_cast (ssi_real_t, *srcptr++) / 32768.0f;
}
} else {
ssi_real_t *srcptr = ssi_pcast (ssi_real_t, stream_in.ptr);
int16_t *dstptr = ssi_pcast (int16_t, stream_out.ptr);
ssi_size_t N = stream_in.num * stream_in.dim;
for (ssi_size_t i = 0; i < N; i++) {
*dstptr++ = ssi_cast (int16_t, *srcptr++ * 32768.0f);
}
}
}
void SignalPainter::consume (IConsumer::info consume_info,
ssi_size_t stream_in_num,
ssi_stream_t stream_in[]) {
for (ssi_size_t i = 0; i < _n_windows; i++) {
if (_options.type == PaintSignalType::BAR || _options.type == PaintSignalType::BAR_POS) {
if (_options.barNames[0] != '\0') {
ssi_size_t n = ssi_split_string_count(_options.barNames, ',');
ssi_char_t **tokens = new ssi_char_t *[n];
ssi_split_string(n, tokens, _options.barNames, ',');
ssi_pcast(PaintBars, _client[i])->setExternalAxisCaptions(n, tokens);
for (ssi_size_t j = 0; j < n; j++) {
delete[] tokens[j];
}
delete[] tokens;
}
if (_options.reset) {
ssi_pcast(PaintBars, _client[i])->reset();
}
ssi_pcast(PaintBars, _client[i])->setData(stream_in[i]);
} else {
if (_options.reset) {
ssi_pcast(PaintSignal, _client[i])->resetLimits();
}
ssi_pcast(PaintSignal, _client[i])->setData(stream_in[i], consume_info.time);
}
_canvas[i]->update();
}
}
void QRSDetection::transform_enter (ssi_stream_t &stream_in,
ssi_stream_t &stream_out,
ssi_size_t xtra_stream_in_num,
ssi_stream_t xtra_stream_in[]) {
//bandpass
Butfilt *bandpass = ssi_pcast (Butfilt, Factory::Create (Butfilt::GetCreateName (), 0, false));
bandpass->getOptions()->type = Butfilt::BAND;
bandpass->getOptions()->norm = false;
bandpass->getOptions()->high = 15;
bandpass->getOptions()->low = 5;
bandpass->getOptions()->order = 13;
_bandpass = bandpass;
ssi_stream_init (_bandpass_stream, 0, _bandpass->getSampleDimensionOut (stream_in.dim), _bandpass->getSampleBytesOut (stream_in.byte), _bandpass->getSampleTypeOut (stream_in.type), stream_in.sr);
_bandpass->transform_enter (stream_in, _bandpass_stream);
//diff
Derivative *diff = ssi_pcast(Derivative, Factory::Create (Derivative::GetCreateName (), 0, false));
ssi_strcpy (diff->getOptions()->names, "1st");
_diff = diff;
ssi_stream_init (_diff_stream, 0, _diff->getSampleDimensionOut (_bandpass_stream.dim), _diff->getSampleBytesOut (_bandpass_stream.byte), _diff->getSampleTypeOut (_bandpass_stream.type), _bandpass_stream.sr);
_diff->transform_enter (_bandpass_stream, _diff_stream);
//qrs-pre-process
QRSPreProcess *pre = ssi_pcast(QRSPreProcess, Factory::Create (QRSPreProcess::GetCreateName (), 0, false));
_pre = pre;
ssi_stream_init (_pre_stream, 0, _pre->getSampleDimensionOut (_diff_stream.dim), _pre->getSampleBytesOut (_diff_stream.byte), _pre->getSampleTypeOut (_diff_stream.type), _diff_stream.sr);
_pre->transform_enter(_diff_stream, _pre_stream);
Butfilt *pre_low = ssi_create (Butfilt, 0, false);
pre_low->getOptions()->zero = true;
pre_low->getOptions()->norm = false;
pre_low->getOptions ()->low = 6.4;
pre_low->getOptions ()->order = 3;
pre_low->getOptions ()->type = Butfilt::LOW;
_pre_low = pre_low;
ssi_stream_init (_pre_low_stream, 0, _pre_low->getSampleDimensionOut (_pre_stream.dim), _pre_low->getSampleBytesOut (_pre_stream.byte), _pre_low->getSampleTypeOut (_pre_stream.type), _pre_stream.sr);
_pre_low->transform_enter(_pre_stream, _pre_low_stream);
//qrs-detect
ssi_size_t sample_dimension = _pre_low_stream.dim;
_pulsed = false;
_n_R = 0;
_samples_since_last_R = 0;
_sum_RR = 0;
_average_RR = 0.0f;
_history_RR = new ssi_size_t[_options.depthRR];
_last_R = 0;
for (ssi_size_t k = 0; k < _options.depthRR; k++) {
_history_RR[k] = 0;
}
_first_call = true;
}
bool ISNorm::Norm(ssi_stream_t &stream, Params params) {
if (stream.dim != params.n_features) {
ssi_wrn("wrong stream dimension '%u' != '%u'", stream.dim, params.n_features);
return false;
}
if (params.method == METHOD::NONE) {
return true;
}
switch (params.method) {
case METHOD::SCALE: {
ssi_real_t *ptr = ssi_pcast(ssi_real_t, stream.ptr);
ssi_real_t *aptr = params.mins;
ssi_real_t *bptr = params.maxs;
for (ssi_size_t j = 0; j < params.n_features; j++) {
*ptr -= *aptr++;
*ptr++ /= *bptr++;
}
if (params.limits[0] != 0.0f || params.limits[1] != 1.0f) {
ptr = ssi_pcast(ssi_real_t, stream.ptr);
ssi_real_t a = params.limits[1] - params.limits[0];
ssi_real_t b = params.limits[0];
for (ssi_size_t j = 0; j < params.n_features; j++) {
*ptr *= a;
*ptr++ += b;
}
}
break;
}
case METHOD::ZSCORE: {
ssi_real_t *ptr = ssi_pcast(ssi_real_t, stream.ptr);
ssi_real_t *aptr = params.mean;
ssi_real_t *bptr = params.stdv;
for (ssi_size_t j = 0; j < params.n_features; j++) {
*ptr -= *aptr++;
*ptr++ /= *bptr++;
}
break;
}
}
return true;
}
void MyEventSender::consume(IConsumer::info consume_info,
ssi_size_t stream_in_num,
ssi_stream_t stream_in[]) {
ssi_real_t *in = ssi_pcast(ssi_real_t, stream_in[0].ptr);
ssi_real_t *out = ssi_pcast(ssi_real_t, _event.ptr);
ssi_mean(stream_in[0].num, stream_in[0].dim, in, out);
_event.time = ssi_cast(ssi_size_t, consume_info.time * 1000);
_event.dur = ssi_cast(ssi_size_t, consume_info.dur * 1000);
_elistener->update(_event);
}
void StreamTransformer::transform(ITransformer::info info,
ssi_stream_t &stream_in,
ssi_stream_t &stream_out,
ssi_size_t xtra_stream_in_num,
ssi_stream_t xtra_stream_in[]) {
ssi_size_t dim = stream_in.dim;
ssi_size_t num = info.frame_num;
ssi_real_t *srcptr = ssi_pcast(ssi_real_t, stream_in.ptr);
ssi_real_t *dstptr = ssi_pcast(ssi_real_t, stream_out.ptr);
transformThreshold(dim, num, srcptr, dstptr);
}
void TupleEventSender::consume (IConsumer::info consume_info,
ssi_size_t stream_in_num,
ssi_stream_t stream_in[]) {
ssi_size_t dim = stream_in[0].dim;
ssi_size_t num = stream_in[0].num;
ssi_real_t *src = ssi_pcast(ssi_real_t, stream_in[0].ptr);
ssi_event_tuple_t *dst = ssi_pcast(ssi_event_tuple_t, _event.ptr);
_event.time = ssi_cast (ssi_size_t, 1000 * consume_info.time + 0.5);
_event.dur = ssi_cast (ssi_size_t, 1000 * consume_info.dur + 0.5);
_event.state = consume_info.status == IConsumer::COMPLETED ? SSI_ESTATE_COMPLETED : SSI_ESTATE_CONTINUED;
if (_options.mean) {
ssi_real_t *mean = new ssi_real_t[dim];
ssi_mean(num, dim, src, mean);
for (ssi_size_t i = 0; i < dim; i++) {
dst++->value = mean[i];
}
}
if (_options.var) {
ssi_real_t *var = new ssi_real_t[dim];
ssi_var(num, dim, src, var);
for (ssi_size_t i = 0; i < dim; i++) {
dst++->value = var[i];
}
}
if (_options.minval || _options.maxval) {
ssi_real_t *minval = new ssi_real_t[dim];
ssi_size_t *minpos = new ssi_size_t[dim];
ssi_real_t *maxval = new ssi_real_t[dim];
ssi_size_t *maxpos = new ssi_size_t[dim];
ssi_minmax(num, dim, src, minval, minpos, maxval, maxpos);
if (_options.minval) {
for (ssi_size_t i = 0; i < dim; i++) {
dst++->value = minval[i];
}
}
if (_options.maxval) {
for (ssi_size_t i = 0; i < dim; i++) {
dst++->value = maxval[i];
}
}
}
_listener->update(_event);
}
void SignalTools::Series (ssi_stream_t &series,
ssi_time_t duration,
ssi_real_t offset) {
/* matlab code:
t = 0:1/sr:dur-1/sr;
*/
ssi_real_t delta = ssi_cast (ssi_real_t, 1.0 / series.sr);
ssi_size_t number = ssi_cast (ssi_size_t, duration / delta);
SSI_ASSERT (number > 0);
ssi_stream_adjust (series, number);
ssi_real_t *out = ssi_pcast (ssi_real_t, series.ptr);
ssi_real_t *outptr_new = out;
ssi_real_t *outptr_old = out;
for (ssi_size_t i = 0; i < series.dim; ++i) {
*outptr_new++ = offset;
}
for (ssi_size_t i = series.dim; i < series.dim * series.num; ++i) {
*outptr_new++ = *outptr_old++ + delta;
}
}
void MyFilter2::transform(ITransformer::info info,
ssi_stream_t &stream_in,
ssi_stream_t &stream_out,
ssi_size_t xtra_stream_in_num,
ssi_stream_t xtra_stream_in[]) {
ssi_real_t *ptr_in = ssi_pcast(ssi_real_t, stream_in.ptr);
char *ptr_out = ssi_pcast(char, stream_out.ptr);
if (!_hist) {
_hist = new ssi_real_t[stream_in.dim];
for (ssi_size_t i = 0; i < stream_in.dim; i++) {
_hist[i] = ptr_in[i];
}
}
for (ssi_size_t i = 0; i < stream_in.num; i++) {
bool result = false;
for (ssi_size_t j = 0; j < stream_in.dim; j++) {
result = result || (abs(_hist[j] - *ptr_in) > _options.speed);
_hist[j] = *ptr_in++;
}
*ptr_out++ = result ? 1 : 0;
}
}
void SignalTools::Cosine (ssi_stream_t &series,
ssi_time_t *frequency,
ssi_real_t *amplitude) {
/* matlab code:
t = 0:1/sr:dur-1/sr;
signal = A' * sin (2*pi*f*t);
*/
ssi_real_t *ptr = ssi_pcast (ssi_real_t, series.ptr);
ssi_real_t *pipif = new ssi_real_t[series.dim];
for (ssi_size_t j = 0; j < series.dim; ++j) {
pipif[j] = static_cast<ssi_real_t> (2.0 * PI * frequency[j]);
}
for (ssi_size_t i = 0; i < series.num; ++i) {
for (ssi_size_t j = 0; j < series.dim; ++j) {
*ptr = amplitude[j] * cos (pipif[j] * *ptr);
++ptr;
}
}
delete[] pipif;
}
void SignalTools::Random(ssi_stream_t &stream) {
ssi_real_t *ptr = ssi_pcast(ssi_real_t, stream.ptr);
for (ssi_size_t i = 0; i < stream.dim * stream.num; i++) {
*ptr++ = ssi_cast (ssi_real_t, ssi_random());
}
}
bool MyEventListener::update(IEvents &events,
ssi_size_t n_new_events,
ssi_size_t time_ms) {
EventAddress ea;
ssi_event_t *e = 0;
for (ssi_size_t i = 0; i < n_new_events; i++) {
e = events.next();
ea.clear();
ea.setSender(Factory::GetString(e->sender_id));
ea.setEvents(Factory::GetString(e->event_id));
ssi_print("received event %s of type %s at %ums for %ums\n", ea.getAddress(), SSI_ETYPE_NAMES[e->type], e->time, e->dur);
if (e->type == SSI_ETYPE_FLOATS) {
ssi_real_t *ptr = ssi_pcast(ssi_real_t, e->ptr);
ssi_size_t n = e->tot / sizeof(ssi_real_t);
for (ssi_size_t j = 0; j < n; j++) {
ssi_print("%.2f ", *ptr++);
}
ssi_print("\n");
}
}
return true;
}
bool QRSDetection::setEventListener (IEventListener *listener) {
_listener = listener;
_send_etuple = _options.tuple;
if(_send_etuple) {
ssi_event_init (_r_event, SSI_ETYPE_MAP);
ssi_event_adjust (_r_event, 1 * sizeof (ssi_event_map_t));
ssi_event_map_t *ptr = ssi_pcast (ssi_event_map_t, _r_event.ptr);
ptr[0].id = Factory::AddString ("delta");
} else {
ssi_event_init (_r_event, SSI_ETYPE_TUPLE);
ssi_event_adjust (_r_event, 1 * sizeof (ssi_real_t));
}
_r_event.sender_id = Factory::AddString (_options.sname);
if (_r_event.sender_id == SSI_FACTORY_STRINGS_INVALID_ID) {
return false;
}
_r_event.event_id = Factory::AddString (_options.ename);
if (_r_event.event_id == SSI_FACTORY_STRINGS_INVALID_ID) {
return false;
}
_event_address.setSender (_options.sname);
_event_address.setEvents (_options.ename);
return true;
}
void Energy::transform (ITransformer::info info,
ssi_stream_t &stream_in,
ssi_stream_t &stream_out,
ssi_size_t xtra_stream_in_num,
ssi_stream_t xtra_stream_in[]) {
ssi_size_t sample_dimension = stream_in.dim;
ssi_size_t sample_number = stream_in.num;
ssi_real_t *srcptr = ssi_pcast (ssi_real_t, stream_in.ptr);
ssi_real_t *dstptr = ssi_pcast (ssi_real_t, stream_out.ptr);
if (_options.global) {
ssi_real_t sum = 0;
ssi_size_t elems = sample_number * sample_dimension;
ssi_real_t value;
for (ssi_size_t i = 0; i < elems; i++) {
value = *srcptr++;
sum += value * value;
}
*dstptr = sqrt (sum / elems);
} else {
ssi_real_t *dstptr_tmp = dstptr;
ssi_real_t value;
for (ssi_size_t i = 0; i < sample_dimension; i++) {
value = *srcptr++;
*dstptr++ = value * value;
}
for (ssi_size_t i = 1; i < sample_number; i++) {
dstptr = dstptr_tmp;
for (ssi_size_t j = 0; j < sample_dimension; j++) {
value = *srcptr++;
*dstptr++ += value * value;
}
}
dstptr = dstptr_tmp;
for (ssi_size_t i = 0; i < sample_dimension; i++) {
value = *dstptr;
*dstptr++ = sqrt (value / sample_number);
}
}
}
void SignalTools::Sum (ssi_stream_t &series) {
ssi_real_t *old_ptr = ssi_pcast (ssi_real_t, series.ptr);
ssi_real_t *new_ptr = new ssi_real_t[series.num];
ssi_real_t *srcptr = old_ptr;
ssi_real_t *dstptr = new_ptr;
for (ssi_size_t i = 0; i < series.num; i++) {
*dstptr = 0;
for (ssi_size_t j = 0; j < series.dim; j++) {
*dstptr += *srcptr++;
}
dstptr++;
}
series.ptr = ssi_pcast (ssi_byte_t, new_ptr);
series.dim = 1;
delete[] old_ptr;
}
void AudioActivity::transform_enter (ssi_stream_t &stream_in,
ssi_stream_t &stream_out,
ssi_size_t xtra_stream_in_num,
ssi_stream_t xtra_stream_in[]) {
switch (_options.method) {
case AudioActivity::INTENSITY: {
AudioIntensity *intensity = ssi_pcast (AudioIntensity, Factory::Create (AudioIntensity::GetCreateName (), 0, false));
intensity->getOptions ()->intensity = true;
intensity->getOptions ()->loudness = false;
_feature = intensity;
break;
}
case AudioActivity::LOUDNESS: {
AudioIntensity *loudness = ssi_pcast (AudioIntensity, Factory::Create (AudioIntensity::GetCreateName (), 0, false));
loudness->getOptions ()->intensity = false;
loudness->getOptions ()->loudness = true;
_feature = loudness;
break;
}
case AudioActivity::SNRATIO: {
SNRatio *snratio = ssi_pcast (SNRatio, Factory::Create (SNRatio::GetCreateName (), 0, false));
snratio->getOptions ()->thresh = 0;
_feature = snratio;
break;
}
}
ssi_stream_init (_stream_feat, 1, 1, sizeof (ssi_real_t), SSI_REAL, stream_out.sr);
_convert_input = stream_in.type == SSI_SHORT;
if (_convert_input) {
_convert = ssi_pcast (AudioConvert, Factory::Create (AudioConvert::GetCreateName (), 0, false));
ssi_stream_init (_stream_convert, 0, stream_in.dim, sizeof (ssi_real_t), SSI_REAL, stream_in.sr);
_convert->transform_enter (stream_in, _stream_convert);
_feature->transform_enter (_stream_convert, _stream_feat);
} else {
_feature->transform_enter (stream_in, _stream_feat);
}
}
void MFCC::transform (ITransformer::info info,
ssi_stream_t &stream_in,
ssi_stream_t &stream_out,
ssi_size_t xtra_stream_in_num,
ssi_stream_t xtra_stream_in[]) {
ssi_size_t sample_dimension = stream_in.dim;
ssi_size_t sample_number = stream_in.num;
ssi_real_t *srcptr = ssi_pcast (ssi_real_t, stream_in.ptr);
ssi_real_t *dstptr = ssi_pcast (ssi_real_t, stream_out.ptr);
Matrix<ssi_real_t> matrix_in (sample_number, sample_dimension, srcptr);
Matrix<ssi_real_t> matrix_out (1, _options.n_last - _options.n_first, dstptr);
transform (&matrix_in, &matrix_out);
matrix_in.data = 0;
matrix_out.data = 0;
}
Sensor::Sensor (ISensor *sensor)
: _sensor (sensor),
_connected (false) {
_frame = ssi_pcast (TheFramework, Factory::GetFramework ());
// add consumer to framework
if (_frame->IsAutoRun ()) {
_frame->AddRunnable (this);
}
}
void MvgConDiv::transform_enter (ssi_stream_t &stream_in,
ssi_stream_t &stream_out,
ssi_size_t xtra_stream_in_num,
ssi_stream_t xtra_stream_in[]) {
MvgAvgVar *mvgs = ssi_pcast (MvgAvgVar, MvgAvgVar::Create (0));
mvgs->getOptions ()->format = MvgAvgVar::AVG;
mvgs->getOptions ()->method = _options.method == MOVING ? MvgAvgVar::MOVING : MvgAvgVar::SLIDING;
mvgs->getOptions ()->win = _options.wins;
_mvgs = mvgs;
ssi_stream_init (_mvgs_tmp, 0, _mvgs->getSampleDimensionOut (stream_in.dim), stream_in.byte, stream_in.type, stream_in.sr);
_mvgs->transform_enter (stream_in, _mvgs_tmp);
MvgAvgVar *mvgl = ssi_pcast (MvgAvgVar, MvgAvgVar::Create (0));
mvgl->getOptions ()->format = MvgAvgVar::AVG;
mvgl->getOptions ()->method = _options.method == MOVING ? MvgAvgVar::MOVING : MvgAvgVar::SLIDING;
mvgl->getOptions ()->win = _options.winl;
_mvgl = mvgl;
ssi_stream_init (_mvgl_tmp, 0, _mvgl->getSampleDimensionOut (stream_in.dim), stream_in.byte, stream_in.type, stream_in.sr);
_mvgl->transform_enter (stream_in, _mvgl_tmp);
}
void Statistics::transform(ITransformer::info info, ssi_stream_t &stream_in, ssi_stream_t &stream_out, ssi_size_t xtra_stream_in_num /*= 0*/, ssi_stream_t xtra_stream_in[] /*= 0*/)
{
provide_temp_array(stream_in.num_real);
calculate(stream_in);
ssi_real_t * out_ptr = ssi_pcast(ssi_real_t, stream_out.ptr);
for (ssi_size_t i = 0; i < _dim * _options.getSelection().size(); i++)
{
out_ptr[i] = _res[i];
}
}
void Butfilt::transform (ITransformer::info info,
ssi_stream_t &stream_in,
ssi_stream_t &stream_out,
ssi_size_t xtra_stream_in_num,
ssi_stream_t xtra_stream_in[]) {
if (_first_call) {
if (_options.zero) {
_first_sample = new ssi_real_t[stream_in.dim];
memcpy (_first_sample, stream_in.ptr, stream_in.dim * stream_in.byte);
}
_first_call = false;
}
if (_first_sample) {
ssi_real_t *ptr = ssi_pcast (ssi_real_t, stream_in.ptr);
ssi_real_t *sub = _first_sample;
for (ssi_size_t i = 0; i < info.frame_num; i++) {
for (ssi_size_t j = 0; j < stream_in.dim; j++) {
*ptr++ -= *sub++;
}
sub = _first_sample;
}
}
_iir->transform (info, stream_in, stream_out, xtra_stream_in_num, xtra_stream_in);
if (_first_sample) {
ssi_real_t *ptr = ssi_pcast (ssi_real_t, stream_out.ptr);
ssi_real_t *sub = _first_sample;
for (ssi_size_t i = 0; i < info.frame_num; i++) {
for (ssi_size_t j = 0; j < stream_in.dim; j++) {
*ptr++ += *sub++;
}
sub = _first_sample;
}
}
}
void Butfilt::transform_enter (ssi_stream_t &stream_in,
ssi_stream_t &stream_out,
ssi_size_t xtra_stream_in_num,
ssi_stream_t xtra_stream_in[]) {
getCoefs (stream_in.sr);
_iir = ssi_pcast (IIR, IIR::Create (0));
_iir->setCoefs (_coefs);
_iir->transform_enter (stream_in, stream_out, xtra_stream_in_num, xtra_stream_in);
_first_call = true;
}
void AudioActivity::transform (ITransformer::info info,
ssi_stream_t &stream_in,
ssi_stream_t &stream_out,
ssi_size_t xtra_stream_in_num,
ssi_stream_t xtra_stream_in[]) {
ssi_size_t sample_dimension = stream_in.dim;
ssi_size_t sample_number = stream_in.num;
ssi_real_t threshold = _options.threshold;
if (_convert_input) {
ssi_stream_adjust (_stream_convert, stream_in.num);
_convert->transform (info, stream_in, _stream_convert);
_feature->transform (info, _stream_convert, _stream_feat);
} else {
_feature->transform (info, stream_in, _stream_feat);
}
ssi_real_t *srcptr = ssi_pcast (ssi_real_t, _stream_feat.ptr);
ssi_real_t *dstptr = ssi_pcast (ssi_real_t, stream_out.ptr);
*dstptr = *srcptr > _options.threshold ? *srcptr : 0.0f;
}
bool ISTrigger::setTriggerStream (ssi_size_t index, ssi_stream_t &trigger, ssi_real_t thres) {
if (trigger.type != SSI_REAL) {
ssi_wrn ("ISTrigger::setTriggerStream () -> stream.type != SSI_REAL");
return false;
}
if (trigger.dim != 1) {
ssi_wrn ("ISTrigger::setTriggerStream () -> stream.dim != 1");
return false;
}
_samples.reset ();
ssi_sample_t *sample;
ssi_size_t count = 0;
ssi_real_t *ptr = 0;
ssi_real_t sum = 0;
ssi_size_t from, to;
while (sample = _samples.next ()) {
if (sample->streams[index] == 0) {
_trigger[index][count] = false;
++count;
continue;
}
from = ssi_cast (ssi_size_t, sample->time * trigger.sr + 0.5);
to = from + ssi_cast (ssi_size_t, sample->streams[index]->num / sample->streams[index]->sr * trigger.sr + 0.5) - 1;
if (to >= trigger.num) {
ssi_wrn ("sample#%u exceeds trigger stream, setting remaining samples to false", count);
for (; count < _samples.getSize (); count++) {
_trigger[index][count] = false;
}
break;
}
sum = 0;
ptr = ssi_pcast (ssi_real_t, trigger.ptr) + from;
for (ssi_size_t i = from; i <= to; i++) {
sum += *ptr++;
}
_trigger[index][count] = sum / (to - from + 1) > thres;
++count;
}
return true;
}
void MapEventSender::consume (IConsumer::info consume_info,
ssi_size_t stream_in_num,
ssi_stream_t stream_in[]) {
ssi_size_t dim = stream_in[0].dim;
ssi_size_t num = stream_in[0].num;
_event.time = ssi_cast (ssi_size_t, 1000 * consume_info.time + 0.5);
_event.dur = ssi_cast (ssi_size_t, 1000 * consume_info.dur + 0.5);
_event.state = consume_info.status == IConsumer::COMPLETED ? SSI_ESTATE_COMPLETED : SSI_ESTATE_CONTINUED;
if (_options.mean) {
ssi_real_t *src = ssi_pcast(ssi_real_t, stream_in[0].ptr);
ssi_event_map_t *dst = ssi_pcast(ssi_event_map_t, _event.ptr);
ssi_real_t *mean = new ssi_real_t[dim];
ssi_mean(num, dim, src, mean);
for (ssi_size_t i = 0; i < dim; i++) {
dst++->value = mean[i];
}
if (_listener) {
_listener->update(_event);
}
delete[] mean;
} else {
ssi_real_t *src = ssi_pcast(ssi_real_t, stream_in[0].ptr);
ssi_event_map_t *dst = ssi_pcast(ssi_event_map_t, _event.ptr);
for (ssi_size_t i = 0; i < num; i++) {
for (ssi_size_t j = 0; j < dim; j++) {
dst++->value = *src++;
}
if (_listener) {
_listener->update(_event);
}
}
}
}
void MvgConDiv::transform (ITransformer::info info,
ssi_stream_t &stream_in,
ssi_stream_t &stream_out,
ssi_size_t xtra_stream_in_num,
ssi_stream_t xtra_stream_in[]) {
/* Matlab code:
[avg, vrc, hist] = avgfun (signal, sr, [N_short, N_long], hist);
macd = avg(:,1:2:dim*2) - avg(:,2:2:dim*2);
*/
ssi_size_t sample_dimension = stream_in.dim;
ssi_size_t sample_number = stream_in.num;
ssi_stream_adjust (_mvgs_tmp, sample_number);
ssi_stream_adjust (_mvgl_tmp, sample_number);
_mvgs->transform (info, stream_in, _mvgs_tmp);
_mvgl->transform (info, stream_in, _mvgl_tmp);
ssi_real_t *srcptr = ssi_pcast (ssi_real_t, stream_in.ptr);
ssi_real_t *dstptr = ssi_pcast (ssi_real_t, stream_out.ptr);
ssi_real_t *mvgsptr = ssi_pcast (ssi_real_t, _mvgs_tmp.ptr);
ssi_real_t *mvglptr = ssi_pcast (ssi_real_t, _mvgl_tmp.ptr);
ssi_real_t short_value, long_value;
for (ssi_size_t i = 0; i < sample_number; ++i) {
for (ssi_size_t j = 0; j < sample_dimension; ++j) {
short_value = *mvgsptr++;
long_value = *mvglptr++;
*dstptr++ = short_value - long_value;
}
}
}
bool Chain::parseFeature (TiXmlElement *element) {
int n_features = 0;
element->QueryIntAttribute ("size", &n_features);
ssi_msg (SSI_LOG_LEVEL_DETAIL, "found %u feature", n_features);
if (n_features > 0) {
_n_features = n_features;
_features = new IFeature *[_n_features];
for (ssi_size_t i = 0; i < _n_features; i++) {
_features[i] = 0;
}
TiXmlElement *item = 0;
for (ssi_size_t i = 0; i < _n_features; i++) {
if (i == 0) {
item = element->FirstChildElement ("item");
} else {
item = item->NextSiblingElement ("item");
}
if (!item) {
ssi_wrn ("feature: failed parsing '%u'th <item> tag", i);
return false;
}
IObject *object = _xmlpipe->parseObject (item, false);
if (!object) {
ssi_wrn ("filter: class not found");
return false;
}
if (object->getType () != SSI_FEATURE) {
ssi_wrn ("feature: class is not a feature");
return false;
}
IFeature *feature = ssi_pcast (IFeature, object);
if (!feature) {
ssi_wrn ("feature: failed loading feature object");
return false;
}
ssi_msg (SSI_LOG_LEVEL_DETAIL, "load %u. feature '%s'", i+1, object->getName ());
_features[i] = feature;
}
}
return true;
}
