Parameter updates get lost between controller and processor using performEdit

Hi,

While developing a VST3 instrument plugin, I’m stuck with a major issue:

When notifying the host from the controller side using performEdit, some messages get lost in the forwarding and don’t reach the processor.
I checked that all parameter changes occur on the controller side. Calls for performEdit are correctly performed every time.
However, on the Processor side, sometimes parameter updates don’t appear in the process() method when parsing data.inputParameterChanges.
This happens in different DAWs, with different VST3 SDK versions.

Do you have any recommendation on how properly debug this, or maybe a simple example ?

I have never experienced this problem. Are you sure you call:

beginEdit(id);

then 

performEdit(id);
performEdit(id);
performEdit(id);
...

then

endEdit(id);

I have encapsulated this sequence in a Editor concept, so that I don’t really have to think about it (beginEdit is done in constructor and endEdit in destructor).


Although now that I look at the code, it seems I also call setParamNormalized (see setValue method) in addition to performEdit.

Yan

Here is the code called from the Controller when setting a parameter from any of my UI widgets (slider, button, …):

// Notify a parameter changed -----
        
if(setParamNormalized(tag, value) != Steinberg::kResultOk) {
    printf("Fail to call set param normalized in Controller::SetParameter\n");
    return false;
}

// Transmit value to host -----

EditController::beginEdit(tag);
Steinberg::tresult result = EditController::performEdit(tag, getParamNormalized(tag));
EditController::endEdit(tag);

if(result != Steinberg::kResultOk) {
    printf("Perform Edit failed, param: %d, value: %f\n", paramId, value);
    return false;
}

From the Processor process() method:

Steinberg::int32 num_params_changed = data.inputParameterChanges->getParameterCount();
            
// Process each param
for(Steinberg::int32 index = 0; index < num_params_changed; ++index) {
    
    Steinberg::Vst::IParamValueQueue* paramQueue = data.inputParameterChanges->getParameterData(index);
    
    if(!paramQueue) {
        continue;
    }
    
    uint32_t param_id = paramQueue->getParameterId();
    Steinberg::int32 num_points = paramQueue->getPointCount();
    
    // Process each param value change
    for(Steinberg::int32 point=0; point < num_points; ++point) {
        
        Steinberg::Vst::ParamValue value = 0.f;
        Steinberg::int32 sampleOffset = 0;
        
        if(paramQueue->getPoint(point, sampleOffset, value) == Steinberg::kResultTrue) {
            if(param_id >= mParamIdToEngineParamIndexTable.size()) {
                printf("ERROR: out of range param id: %d\n", param_id);
                continue;
            }
            
            uint32_t engine_param_idx = mParamIdToEngineParamIndexTable[param_id];
            mAudioEngine->SetParameter(engine_param_idx, static_cast<float>(value));
        }
    }
}

These are directly inspired from the samples included in the VST3 SDK public.sdk section.
Am i doing something wrong here ?

Sorry to dig up this topic, but I’m still facing this issue.

It’s quite random and when I detect that the parameter update has not been forwarded, it’s already too late. Do you have any idea on how I can debug this properly ?

Is there a proper documentation on this topic somewhere ?

Thanks.

Ok, so I spent some time trying to narrow down the issue. The problem seems to be located in my processor’s process() method (see code in a previous comment).

I replaced my audio engine processing code with a basic sine wave generator. With this simple code, everything runs well, all parameter updates (sent from performEdit) seem to arrive properly in the inputParameterChanges queue.

Now, if I make a sleep() call for 5ms after the sinewave generation, the problem occurs very frequently.

Could the inputParameterChanges queue feeding be blocked when the process() method is doing too much work ?

Any idea on what could be the issue otherwise ?