Onde ele já vai além do JUCE

Confira

automation_lands_on_its_exact_frame_and_updates_the_parameter agenda mudanças nos frames 100, 101 e 250 e confere a saída amostra por amostra. automation_lands_on_its_frame_when_processing_in_place faz o mesmo pela interface C do CLAP, e um teste de mesmo nome faz pelo VST 3, em que o host envia uma fila de pontos por parâmetro e todos os pontos são entregues. (O wrapper VST3 do JUCE aplica o último ponto de cada fila: processParameterChanges em juce_audio_plugin_client_VST3.cpp.)

O VST 3 tem uma armadilha própria. O host informa cada mudança duas vezes: ao processador, com o número do frame, e ao controlador, na thread principal, para que um editor possa acompanhar. Se a cópia do controlador for gravada no parâmetro, o plugin salta para um valor um pouco adiantado ou atrasado até o ponto seguinte corrigir. Enquanto os blocos estão rodando, o wrapper do Manguebyte guarda a cópia do controlador só para exibição; what_the_controller_is_told_does_not_disturb_running_automation confere isso.

• pluginautomation_lands_on_its_exact_frame_and_updates_the_parameterok
• clapautomation_lands_on_its_frame_when_processing_in_placeok
• vst3automation_lands_on_its_frame_when_processing_in_placeok
• vst3what_the_controller_is_told_does_not_disturb_running_automationok

#[test]
fn automation_lands_on_its_exact_frame_and_updates_the_parameter() {
    let mut harness = Harness::<Level>::new(48_000.0, 64);
    harness.automate(100, "level", 2.0);
    harness.automate(101, "level", 3.0);
    harness.automate(250, "level", 0.5);

    let output = harness.process(&ones(2, 300));
    let left = output.channel(0);
    assert_eq!(&left[..100], &[1.0; 100]);
    assert_eq!(left[100], 2.0);
    assert_eq!(&left[101..250], &[3.0; 149]);
    assert_eq!(&left[250..], &[0.5; 50]);
    assert_eq!(output.channel(1), left);

    // Anything polling the parameter sees where automation left it.
    assert_eq!(harness.params().level.value(), 0.5);
    assert_eq!(harness.position(), 300);
}

Confira

the_song_is_the_same_whatever_the_block_size renderiza uma música polifônica, com efeitos e automação, de seis maneiras: 64, 256, 997 e 1024 frames, um padrão irregular de 1, 511, 7, 300, 64, 2, 129 e blocos maiores que o máximo do próprio instrumento. Os resultados têm de ser iguais bit a bit. Os dois plugins de exemplo têm o mesmo teste: o instrumento e o efeito.

Na primeira vez em que rodou, o teste falhou. Uma voz que terminava no meio de um bloco continuava avançando até o fim dele, de modo que a nota seguinte partia de um estado que dependia do tamanho do bloco. O teste existe para achar exatamente isso, e a correção faz parte do contrato de Voice.

• manguebytethe_song_is_the_same_whatever_the_block_sizeok
• plucksounds_the_same_whatever_the_block_sizeok
• ducksounds_the_same_whatever_the_block_sizeok

#[test]
fn the_song_is_the_same_whatever_the_block_size() {
    let reference = render(256, &[256]);
    assert!(reference.peak() > 0.1, "the reference render is silent");

    for (max_block_size, pattern) in [
        (64, &[64][..]),
        (1024, &[1024]),
        // Odd lengths that never line up with a note boundary.
        (997, &[997]),
        // A host that changes its mind on every call.
        (512, &[1, 511, 7, 300, 64, 2, 129]),
        // Blocks larger than the player's own, which it must split itself.
        (48, &[5_000]),
    ] {
        let other = render(max_block_size, pattern);
        assert!(
            other == reference,
            "blocks of {pattern:?} (max {max_block_size}) changed the output"
        );
    }
}

Confira

changes_made_outside_the_host_reach_the_plugin_as_events usa um plugin de teste que nunca lê o seu parâmetro, só os eventos. Ele passa para uma escrita direta, para um estado restaurado e para automação do host no mesmo frame, que tem precedência.

• pluginchanges_made_outside_the_host_reach_the_plugin_as_eventsok

Confira

processors_do_not_use_the_heap e os testes vizinhos cobrem todos os processadores, a FFT, um sintetizador recebendo mais notas do que tem vozes e mudanças de parâmetro feitas durante a execução. Um teste da própria guarda garante que ela perceberia. Pela interface do CLAP, heap_calls tem de ser zero para automação, notas, mudanças informadas ao host e o bloco seguinte a uma restauração de estado.

A guarda já se pagou. No macOS ela acusou uma chamada ao heap dentro de process: um plugin de teste gravava um valor por meio de um mutex padrão, que nessa plataforma aloca na primeira vez em que é travado.

• dspprocessors_do_not_use_the_heapok
• dspa_synth_handles_a_flood_of_events_without_using_the_heapok
• dspthe_guard_itself_catches_an_allocationok
• clapheap_calls == 0 through the CLAP interfaceok
• ciCI job: Miriok

/// Runs `work` and panics if it used the heap in any way.
fn assert_no_heap_use(what: &str, work: impl FnOnce()) {
    HEAP_CALLS.with(|calls| calls.set(0));
    WATCHING.with(|watching| watching.set(true));
    work();
    WATCHING.with(|watching| watching.set(false));
    let calls = HEAP_CALLS.with(Cell::get);
    assert_eq!(
        calls, 0,
        "{what} used the heap {calls} time(s) while processing"
    );
}

/// Prepares a processor, then runs it over blocks of several sizes with the
/// allocator watched.
fn check<P: Processor<f32>>(what: &str, mut processor: P) {
    processor.prepare(&SPEC);
    let mut buffer = AudioBuffer::<f32>::new(SPEC.num_channels, SPEC.max_block_size);
    assert_no_heap_use(what, || {
        for frames in [256, 1, 64, 255, 256] {
            buffer.set_num_frames(frames);
            for channel in buffer.iter_channels_mut() {
                channel.fill(0.25);
            }
            processor.process(&mut buffer);
        }
        processor.reset();
        buffer.set_num_frames(256);
        processor.process(&mut buffer);
    });
}

Confira

expression_and_modulation_reach_one_note_and_parameters_reach_all e notes_with_identifiers_overlap_on_one_key_and_end_separately no sintetizador; an_instrument_takes_notes_expression_modulation_and_a_sidechain faz o mesmo pelo CLAP.

• dspexpression_and_modulation_reach_one_note_and_parameters_reach_allok
• dspnotes_with_identifiers_overlap_on_one_key_and_end_separatelyok
• clapan_instrument_takes_notes_expression_modulation_and_a_sidechainok

Confira

O job de CI compila os dois plugins de exemplo e roda neles o clap-validator, do próprio projeto CLAP, e falha diante de qualquer teste reprovado. No commit em que este site foi escrito, o validador rodou 44 testes em cada um: o instrumento passou em 35 e pulou 9, o efeito passou em 33 e pulou 11, e nenhum dos dois falhou em algum. Os testes pulados são de coisas que os plugins ainda não têm: descoberta de presets (3 testes), áudio em 64 bits (2) e as extensões que deixam o host reconfigurar as portas de áudio (3). O instrumento também pula um teste que lhe envia áudio, porque não tem entrada de áudio, e o efeito pula os três testes de notas, porque não recebe notas.

cargo mangue bundle grava o .clap ao lado do .vst3, no layout de cada sistema, e cargo mangue validate roda nele o validador do projeto CLAP e, no .vst3, o da Steinberg; um job de CI roda a ferramenta de ponta a ponta em Windows, Linux e macOS. O juce_add_plugin do JUCE não aceita o formato CLAP.

• ciCI job: CLAP validationok
• duckplugins/duck/src/lib.rsok
• ciCI job: command-line tool end to endok

Confira

Os testes do instrumento de exemplo conferem que ele fica em silêncio até ser tocado, que toca a altura pedida (por FFT), que a automação e a modulação por nota mudam o som, que o estado vai e volta, e que a saída não depende do tamanho do bloco. Os testes do efeito de exemplo alimentam o sidechain do mesmo jeito.

• pluckplays_the_pitch_it_is_asked_forok
• duckautomation_lands_on_its_frame_with_audio_running_throughok
• plucksounds_the_same_whatever_the_block_sizeok

#[test]
fn plays_the_pitch_it_is_asked_for() {
    use manguebyte::dsp::fft::{Complex, RealFft};

    let mut harness = Harness::<Pluck>::new(RATE, 512);
    harness.params().reverb.set(0.0);
    // No resonant peak, so the fundamental is the loudest partial.
    harness.params().resonance.set(0.7);
    harness.note(0, 40_000, 69, 1.0); // A4, 440 Hz
    let sound = harness.render(32_768);

    let mut fft = RealFft::<f32>::new(32_768);
    let mut spectrum = vec![Complex::ZERO; fft.spectrum_len()];
    fft.forward(sound.channel(0), &mut spectrum);
    let loudest = (1..spectrum.len())
        .max_by(|&a, &b| spectrum[a].norm_sqr().total_cmp(&spectrum[b].norm_sqr()))
        .unwrap();
    let hertz = loudest as f64 * RATE / 32_768.0;
    assert!((hertz - 440.0).abs() < 2.0, "loudest partial at {hertz} Hz");
}

Confira

state_from_another_version_loads_as_far_as_it_can e params_are_shareable_across_threads, no crate de parâmetros.

• paramsstate_from_another_version_loads_as_far_as_it_canok
• paramsparams_are_shareable_across_threadsok

Confira

Os dois textos de licença no repositório: MIT e Apache-2.0.

• fileLICENSE-MITok
• fileLICENSE-APACHEok

Confira

Um teste nos dois wrappers (CLAP, VST 3) faz um plugin informar, de dentro de process, o que o processador faz com um número subnormal, e depois confere que a thread do host voltou à configuração dela, inclusive depois de o plugin entrar em pânico. Medido no efeito de exemplo, 4.000 blocos de entrada subnormal levaram 442 ms sem a guarda e 31 ms com ela.

• clapnumbers_too_small_to_hear_are_zero_while_the_plugin_runs_and_only_thenok
• vst3numbers_too_small_to_hear_are_zero_while_the_plugin_runs_and_only_thenok
• corecrates/manguebyte-core/src/denormal.rsok

Confira

Doc-tests que precisam falhar na compilação, em ClapPlugin e Vst3Plugin, mostram que a metade da thread principal não pode ser enviada a outra thread. the_hosted_plugin_sounds_exactly_as_the_plugin_does_alone, para CLAP e para VST 3, carrega o instrumento de exemplo pelo seu ponto de entrada real e exige que a saída seja idêntica bit a bit à do mesmo plugin rodando dentro do processo pelo Harness, em quatro arranjos de blocos, com automação de cinco parâmetros, notas com ids, expressão e pitch bend; tirar qualquer um dos tipos de evento muda a saída, então a identidade não é a de dois caminhos surdos concordando. automation_lands_on_its_frame_through_the_host envia 59 pontos de VST 3 espaçados de 61 frames.

• hostthe_hosted_plugin_sounds_exactly_as_the_plugin_does_aloneok
• hostthe_hosted_plugin_sounds_exactly_as_the_plugin_does_aloneok
• hostautomation_lands_on_its_frame_through_the_hostok
• hostprocessing_never_uses_the_heapok
• ciCI job: Miri (plugin host)ok

Confira

ebu_tech_3341.rs sintetiza os sinais de teste da EBU Tech 3341 e exige os casos 1 a 6 e 9 a 14 dentro de 0,1 LU, e os casos de true peak 15 a 23 dentro de +0,2/−0,4 dB; ebu_tech_3342.rs faz o mesmo para a faixa de loudness, casos 1 a 4. O ponteiro do VU chega a 99% em 300 ms ±3 ms, com 1,0 a 1,5% de sobressinal, de 44,1 a 192 kHz. As leituras são idênticas até o bit em qualquer tamanho de bloco, e medir não faz nenhuma chamada ao heap.

• analysiscases_1_and_2_a_steady_tone_reads_its_level_on_all_three_scalesok
• analysiscases_15_to_19_a_sine_is_read_at_its_crest_wherever_the_samples_fallok
• analysiscase_1_two_tones_ten_decibels_apartok

Confira

a_time_tag_lands_on_its_exact_frame, every_frame_of_a_block_can_be_hit e where_an_event_lands_does_not_depend_on_the_block_size (400 eventos, sete padrões de bloco, frames idênticos); ler na thread de áudio não faz nenhuma chamada ao heap. codec.rs codifica os exemplos da especificação byte a byte e faz ida e volta com todos os tipos.

• osca_time_tag_lands_on_its_exact_frameok
• oscevery_frame_of_a_block_can_be_hitok
• oscwhere_an_event_lands_does_not_depend_on_the_block_sizeok
• oscthe_examples_in_the_specification_encode_byte_for_byteok

Confira

pitch.rs: senoides, dentes de serra, ondas quadradas, tons sem a fundamental e tons com um segundo harmônico forte, de 55 Hz a 2 kHz, são lidos dentro de 2 cents a 44,1 e 48 kHz, sem erros de oitava. spectrum.rs: uma senoide em escala cheia lê 0 dB na sua banda, com margem de 0,01 dB, e as bandas de terço de oitava de ruído branco e rosa somam certo dentro de 0,05 dB.

• analysisevery_test_tone_is_found_within_a_centok
• analysisa_full_scale_sine_reads_0_db_in_its_bandok
• analysisbands_of_white_and_pink_noise_read_the_power_that_lies_in_themok

Confira

the_keyboard_state_does_not_use_the_heap (20.000 mensagens aleatórias, com leituras intercaladas), e a_key_that_goes_on_sounding_is_never_read_as_silent e an_interface_can_read_while_another_thread_writes.

• midithe_keyboard_state_does_not_use_the_heapok
• midia_key_that_goes_on_sounding_is_never_read_as_silentok
• midian_interface_can_read_while_another_thread_writesok