static LV2_Atom_Forge_Ref
_trans_event(prog_t *prog, LV2_Atom_Forge *forge, int rolling, jack_position_t *pos)
{
LV2_Atom_Forge_Frame frame;
LV2_Atom_Forge_Ref ref = lv2_atom_forge_frame_time(forge, 0);
if(ref)
ref = lv2_atom_forge_object(forge, &frame, 0, prog->time_position);
{
if(ref)
ref = lv2_atom_forge_key(forge, prog->time_frame);
if(ref)
ref = lv2_atom_forge_long(forge, pos->frame);
if(ref)
ref = lv2_atom_forge_key(forge, prog->time_speed);
if(ref)
ref = lv2_atom_forge_float(forge, rolling ? 1.0 : 0.0);
if(pos->valid & JackPositionBBT)
{
float bar_beat = pos->beat - 1 + (pos->tick / pos->ticks_per_beat);
float bar = pos->bar - 1;
if(ref)
ref = lv2_atom_forge_key(forge, prog->time_barBeat);
if(ref)
ref = lv2_atom_forge_float(forge, bar_beat);
if(ref)
ref = lv2_atom_forge_key(forge, prog->time_bar);
if(ref)
ref = lv2_atom_forge_long(forge, bar);
if(ref)
ref = lv2_atom_forge_key(forge, prog->time_beatUnit);
if(ref)
ref = lv2_atom_forge_int(forge, pos->beat_type);
if(ref)
ref = lv2_atom_forge_key(forge, prog->time_beatsPerBar);
if(ref)
ref = lv2_atom_forge_float(forge, pos->beats_per_bar);
if(ref)
ref = lv2_atom_forge_key(forge, prog->time_beatsPerMinute);
if(ref)
ref = lv2_atom_forge_float(forge, pos->beats_per_minute);
}
}
if(ref)
lv2_atom_forge_pop(forge, &frame);
return ref;
}
/** Forge a long integer value */
inline ForgeRef write_long (const int64_t val) { return lv2_atom_forge_long (this, val); }
static void
bim_run(LV2_Handle instance, uint32_t n_samples)
{
LV2meter* self = (LV2meter*)instance;
const uint32_t capacity = self->notify->atom.size;
assert(capacity > 920);
lv2_atom_forge_set_buffer(&self->forge, (uint8_t*)self->notify, capacity);
lv2_atom_forge_sequence_head(&self->forge, &self->frame, 0);
if (self->send_state_to_ui && self->ui_active) {
self->send_state_to_ui = false;
forge_kvcontrolmessage(&self->forge, &self->uris, self->uris.mtr_control, CTL_SAMPLERATE, self->rate);
}
/* Process incoming events from GUI */
if (self->control) {
LV2_Atom_Event* ev = lv2_atom_sequence_begin(&(self->control)->body);
while(!lv2_atom_sequence_is_end(&(self->control)->body, (self->control)->atom.size, ev)) {
if (ev->body.type == self->uris.atom_Blank || ev->body.type == self->uris.atom_Object) {
const LV2_Atom_Object* obj = (LV2_Atom_Object*)&ev->body;
if (obj->body.otype == self->uris.mtr_meters_on) {
self->ui_active = true;
self->send_state_to_ui = true;
}
else if (obj->body.otype == self->uris.mtr_meters_off) {
self->ui_active = false;
}
else if (obj->body.otype == self->uris.mtr_meters_cfg) {
int k; float v;
get_cc_key_value(&self->uris, obj, &k, &v);
switch (k) {
case CTL_START:
self->ebu_integrating = true;
break;
case CTL_PAUSE:
self->ebu_integrating = false;
break;
case CTL_RESET:
bim_reset(self);
self->send_state_to_ui = true;
break;
case CTL_AVERAGE:
self->bim_average = true;
break;
case CTL_WINDOWED:
self->bim_average = false;
break;
default:
break;
}
}
}
ev = lv2_atom_sequence_next(ev);
}
}
#if 0
static uint32_t max_post = 0;
if (self->notify->atom.size > max_post) {
max_post = self->notify->atom.size;
printf("new post parse: %d\n", max_post);
}
#endif
/* process */
if (self->ebu_integrating && self->integration_time < 2147483647) {
/* currently 'self->histS' is int32,
* the max peak that can be recorded is 2^31,
* for now we simply limit data-acquisition to at
* most 2^31 points.
*/
if (self->integration_time > 2147483647 - n_samples) {
self->integration_time = 2147483647;
} else {
for (uint32_t s = 0; s < n_samples; ++s) {
float_stats(self, self->input[0] + s);
}
self->integration_time += n_samples;
}
}
const int fps_limit = n_samples * ceil(self->rate / (5.f * n_samples)); // ~ 5fps
self->radar_resync += n_samples;
if (self->radar_resync >= fps_limit || self->send_state_to_ui) {
self->radar_resync = self->radar_resync % fps_limit;
if (self->ui_active && (self->ebu_integrating || self->send_state_to_ui)) {
LV2_Atom_Forge_Frame frame;
lv2_atom_forge_frame_time(&self->forge, 0);
x_forge_object(&self->forge, &frame, 1, self->uris.bim_stats);
lv2_atom_forge_property_head(&self->forge, self->uris.ebu_integr_time, 0);
lv2_atom_forge_long(&self->forge, self->integration_time);
lv2_atom_forge_property_head(&self->forge, self->uris.bim_zero, 0);
lv2_atom_forge_int(&self->forge, self->bim_zero);
lv2_atom_forge_property_head(&self->forge, self->uris.bim_pos, 0);
lv2_atom_forge_int(&self->forge, self->bim_pos);
lv2_atom_forge_property_head(&self->forge, self->uris.bim_max, 0);
lv2_atom_forge_double(&self->forge, self->bim_max);
lv2_atom_forge_property_head(&self->forge, self->uris.bim_min, 0);
lv2_atom_forge_double(&self->forge, self->bim_min);
lv2_atom_forge_property_head(&self->forge, self->uris.bim_nan, 0);
lv2_atom_forge_int(&self->forge, self->bim_nan);
lv2_atom_forge_property_head(&self->forge, self->uris.bim_inf, 0);
lv2_atom_forge_int(&self->forge, self->bim_inf);
lv2_atom_forge_property_head(&self->forge, self->uris.bim_den, 0);
lv2_atom_forge_int(&self->forge, self->bim_den);
lv2_atom_forge_property_head(&self->forge, self->uris.bim_data, 0);
lv2_atom_forge_vector(&self->forge, sizeof(int32_t), self->uris.atom_Int, BIM_LAST, self->histS);
lv2_atom_forge_pop(&self->forge, &frame);
}
if (self->ui_active) {
LV2_Atom_Forge_Frame frame;
lv2_atom_forge_frame_time(&self->forge, 0);
x_forge_object(&self->forge, &frame, 1, self->uris.bim_information);
lv2_atom_forge_property_head(&self->forge, self->uris.ebu_integrating, 0);
lv2_atom_forge_bool(&self->forge, self->ebu_integrating);
lv2_atom_forge_property_head(&self->forge, self->uris.bim_averaging, 0);
lv2_atom_forge_bool(&self->forge, self->bim_average);
lv2_atom_forge_pop(&self->forge, &frame);
}
if (!self->bim_average) {
bim_clear (self);
}
}
/* foward audio-data */
if (self->input[0] != self->output[0]) {
memcpy(self->output[0], self->input[0], sizeof(float) * n_samples);
}
#if 0
//printf("forged %d bytes\n", self->notify->atom.size);
static uint32_t max_cap = 0;
if (self->notify->atom.size > max_cap) {
max_cap = self->notify->atom.size;
printf("new max: %d (of %d avail)\n", max_cap, capacity);
}
#endif
}
