From 9eddd5f649457b13e0fe9dd1181b2187961fe277 Mon Sep 17 00:00:00 2001 From: Paul Ferrand Date: Wed, 12 Feb 2020 00:12:25 +0100 Subject: [PATCH] Corrected a bug where files wouldn't auto-reload The changing_state check is probably redundant if there is a single worker thread, but just in case... --- lv2/sfizz.c | 104 ++++++++++++++++++++++++++++++++++------------------ 1 file changed, 68 insertions(+), 36 deletions(-) diff --git a/lv2/sfizz.c b/lv2/sfizz.c index 40b16bb5..dd274abc 100644 --- a/lv2/sfizz.c +++ b/lv2/sfizz.c @@ -458,14 +458,6 @@ sfizz_lv2_handle_atom_object(sfizz_plugin_t *self, const LV2_Atom_Object *obj) if (key == self->sfizz_sfz_file_uri) { - if (self->changing_state) - { - // We're changing the state already; try to advertise to the host that we - // did not change the path file and return - sfizz_lv2_send_file_path(self); - return; - } - const uint32_t original_atom_size = lv2_atom_total_size((const LV2_Atom *)atom); const uint32_t null_terminated_atom_size = original_atom_size + 1; char atom_buffer[MAX_PATH_SIZE]; @@ -473,10 +465,6 @@ sfizz_lv2_handle_atom_object(sfizz_plugin_t *self, const LV2_Atom_Object *obj) atom_buffer[original_atom_size] = 0; // Null terminate the string for safety LV2_Atom *sfz_file_path = (LV2_Atom *)&atom_buffer; sfz_file_path->type = self->sfizz_sfz_file_uri; - - // If the parameter is different from the current one we send it through - // TODO: this check could happen on the worker side - self->changing_state = true; self->worker->schedule_work(self->worker->handle, null_terminated_atom_size, sfz_file_path); } else @@ -541,7 +529,7 @@ static void sfizz_lv2_check_oversampling(sfizz_plugin_t* self) { sfizz_oversampling_factor_t oversampling = (sfizz_oversampling_factor_t)*self->oversampling_port; - if (oversampling != self->oversampling && !self->changing_state) + if (oversampling != self->oversampling) { LV2_Atom_Int atom; atom.atom.type = self->sfizz_oversampling_uri; @@ -549,9 +537,9 @@ sfizz_lv2_check_oversampling(sfizz_plugin_t* self) atom.body = oversampling; if (self->worker->schedule_work(self->worker->handle, lv2_atom_total_size((LV2_Atom *)&atom), - &atom) == LV2_WORKER_SUCCESS) + &atom) != LV2_WORKER_SUCCESS) { - self->changing_state = true; + lv2_log_error(&self->logger, "[sfizz] There was an issue changing the oversampling factor\n"); } } } @@ -560,7 +548,7 @@ static void sfizz_lv2_check_preload_size(sfizz_plugin_t* self) { unsigned int preload_size = (int)*self->preload_port; - if (preload_size != self->preload_size && !self->changing_state) + if (preload_size != self->preload_size) { LV2_Atom_Int atom; atom.atom.type = self->sfizz_preload_size_uri; @@ -568,9 +556,9 @@ sfizz_lv2_check_preload_size(sfizz_plugin_t* self) atom.body = preload_size; if (self->worker->schedule_work(self->worker->handle, lv2_atom_total_size((LV2_Atom *)&atom), - &atom) == LV2_WORKER_SUCCESS) + &atom) != LV2_WORKER_SUCCESS) { - self->changing_state = true; + lv2_log_error(&self->logger, "[sfizz] There was an issue changing the preload size\n"); } } } @@ -579,7 +567,7 @@ static void sfizz_lv2_check_num_voices(sfizz_plugin_t* self) { int num_voices = (int)*self->polyphony_port; - if (num_voices != self->num_voices && !self->changing_state) + if (num_voices != self->num_voices) { LV2_Atom_Int num_voices_atom; num_voices_atom.atom.type = self->sfizz_num_voices_uri; @@ -589,7 +577,7 @@ sfizz_lv2_check_num_voices(sfizz_plugin_t* self) lv2_atom_total_size((LV2_Atom *)&num_voices_atom), &num_voices_atom) == LV2_WORKER_SUCCESS) { - self->changing_state = true; + lv2_log_error(&self->logger, "[sfizz] There was an issue changing the number of voices\n"); } } } @@ -673,17 +661,8 @@ run(LV2_Handle instance, uint32_t sample_count) self->sample_counter += (int)sample_count; if (self->sample_counter > LOG_SAMPLE_COUNT) { - self->changing_state = true; // We potentially change LV2_Atom atom; atom.size = 0; - atom.type = self->sfizz_check_modification_uri; - if (!(self->worker->schedule_work(self->worker->handle, - lv2_atom_total_size((LV2_Atom *)&atom), - &atom) == LV2_WORKER_SUCCESS)) - { - self->changing_state = false; - lv2_log_error(&self->logger, "[sfizz] There was an issue sending a notice to check the modification of the SFZ file to the background worker\n"); - } #ifndef NDEBUG atom.type = self->sfizz_log_status_uri; if (!(self->worker->schedule_work(self->worker->handle, @@ -693,6 +672,13 @@ run(LV2_Handle instance, uint32_t sample_count) lv2_log_error(&self->logger, "[sfizz] There was an issue sending a logging message to the background worker\n"); } #endif + atom.type = self->sfizz_check_modification_uri; + if (!(self->worker->schedule_work(self->worker->handle, + lv2_atom_total_size((LV2_Atom *)&atom), + &atom) == LV2_WORKER_SUCCESS)) + { + lv2_log_error(&self->logger, "[sfizz] There was an issue sending a notice to check the modification of the SFZ file to the background worker\n"); + } self->sample_counter -= LOG_SAMPLE_COUNT; } @@ -913,7 +899,13 @@ work(LV2_Handle instance, const LV2_Atom *atom = (const LV2_Atom *)data; if (atom->type == self->sfizz_sfz_file_uri) { + if (self->changing_state) { + respond(handle, size, data); // send back so that we reschedule the check + return LV2_WORKER_SUCCESS; + } + const char *sfz_file_path = LV2_ATOM_BODY_CONST(atom); + self->changing_state = true; if (sfizz_load_file(self->synth, sfz_file_path)) { sfizz_lv2_update_file_info(self, sfz_file_path); @@ -922,27 +914,47 @@ work(LV2_Handle instance, { lv2_log_error(&self->logger, "[sfizz] Error with %s; no file should be loaded\n", sfz_file_path); } + self->changing_state = false; } else if (atom->type == self->sfizz_num_voices_uri) { + if (self->changing_state) { + respond(handle, size, data); // send back so that we reschedule the check + return LV2_WORKER_SUCCESS; + } + + self->changing_state = true; const int num_voices = *(const int *)LV2_ATOM_BODY_CONST(atom); sfizz_set_num_voices(self->synth, num_voices); if (sfizz_get_num_voices(self->synth) == num_voices) { self->num_voices = num_voices; lv2_log_note(&self->logger, "[sfizz] Number of voices changed to: %d\n", num_voices); } + self->changing_state = false; } else if (atom->type == self->sfizz_preload_size_uri) { + if (self->changing_state) { + respond(handle, size, data); // send back so that we reschedule the check + return LV2_WORKER_SUCCESS; + } + + self->changing_state = true; const unsigned int preload_size = *(const unsigned int *)LV2_ATOM_BODY_CONST(atom); sfizz_set_preload_size(self->synth, preload_size); if (sfizz_get_preload_size(self->synth) == preload_size) { self->preload_size = preload_size; lv2_log_note(&self->logger, "[sfizz] Preload size changed to: %d\n", preload_size); } + self->changing_state = false; } else if (atom->type == self->sfizz_oversampling_uri) { + if (self->changing_state) { + respond(handle, size, data); // send back so that we reschedule the check + return LV2_WORKER_SUCCESS; + } + self->changing_state = true; const sfizz_oversampling_factor_t oversampling = *(const sfizz_oversampling_factor_t *)LV2_ATOM_BODY_CONST(atom); sfizz_set_oversampling_factor(self->synth, oversampling); @@ -950,6 +962,7 @@ work(LV2_Handle instance, self->oversampling = oversampling; lv2_log_note(&self->logger, "[sfizz] Oversampling changed to: %d\n", oversampling); } + self->changing_state = false; } else if (atom->type == self->sfizz_log_status_uri) { @@ -957,8 +970,12 @@ work(LV2_Handle instance, } else if (atom->type == self->sfizz_check_modification_uri) { - if (!self->changing_state && sfizz_should_reload_file(self->synth)) + if (sfizz_should_reload_file(self->synth)) { + // We'll check later + if (self->changing_state) + return LV2_WORKER_SUCCESS; + lv2_log_note(&self->logger, "[sfizz] File %s seems to have been updated, reloading\n", self->sfz_file_path); if (sfizz_load_file(self->synth, self->sfz_file_path)) { @@ -980,7 +997,6 @@ work(LV2_Handle instance, return LV2_WORKER_ERR_UNKNOWN; } - respond(handle, size, data); return LV2_WORKER_SUCCESS; } @@ -999,19 +1015,35 @@ work_response(LV2_Handle instance, const LV2_Atom *atom = (const LV2_Atom *)data; if (atom->type == self->sfizz_sfz_file_uri) { - self->changing_state = false; + // If we're here we need to reschedule + lv2_log_note(&self->logger, "[sfizz] Got a pingback from the worker on a file\n"); + self->worker->schedule_work(self->worker->handle, + lv2_atom_total_size((const LV2_Atom *)data), + (const LV2_Atom *)data); } else if (atom->type == self->sfizz_num_voices_uri) { - self->changing_state = false; + // If we're here we need to reschedule + lv2_log_note(&self->logger, "[sfizz] Got a pingback from the worker on the number of voices\n"); + self->worker->schedule_work(self->worker->handle, + lv2_atom_total_size((const LV2_Atom *)data), + (const LV2_Atom *)data); } else if (atom->type == self->sfizz_preload_size_uri) { - self->changing_state = false; + // If we're here we need to reschedule + lv2_log_note(&self->logger, "[sfizz] Got a pingback from the worker on the preload size\n"); + self->worker->schedule_work(self->worker->handle, + lv2_atom_total_size((const LV2_Atom *)data), + (const LV2_Atom *)data); } else if (atom->type == self->sfizz_oversampling_uri) { - self->changing_state = false; + // If we're here we need to reschedule + lv2_log_note(&self->logger, "[sfizz] Got a pingback from the worker on the oversampling factor\n"); + self->worker->schedule_work(self->worker->handle, + lv2_atom_total_size((const LV2_Atom *)data), + (const LV2_Atom *)data); } else if (atom->type == self->sfizz_log_status_uri) { @@ -1019,7 +1051,7 @@ work_response(LV2_Handle instance, } else if (atom->type == self->sfizz_check_modification_uri) { - self->changing_state = false; + // Nothing to do, it'll get rechecked soon enough } else {