elektron_multi_wf_V2.pyscript

"""Notes corresponding frequencies."""

from enveditor import Editor, EditorSample, Utils, MEEditor, ScriptDialog, Sample


def notes_dict_factory():
    """This function generates a list of notes and their corresponding frequencies."""

    def calculate_frequency(t, n):
        return t * (2 ** (n / 12.0))

    def calculate_nr_of_samples(note_frequency, sample_rate, cycles):

        sample_rate = sample_rate * cycles

        if note_frequency > 0:
            samples_per_cycle = (sample_rate) / note_frequency
        else:
            samples_per_cycle = float("inf")
        return samples_per_cycle

    # Settings
    tuning_note_index = 33
    tuning = 440.0
    sample_rate = 48000
    nr_of_octaves = 11
    nr_of_notes_in_one_octave = 12
    samples_per_cycle_cycles_list = [2**i for i in range(0, 33)]

    # Names of the notes
    note_names = [
        "C",
        "C#",
        "D",
        "D#",
        "E",
        "F",
        "F#",
        "G",
        "G#",
        "A",
        "A#",
        "B",
    ]

    notes_dict = {}

    for note_index in range(0, nr_of_octaves * nr_of_notes_in_one_octave):
        current_octave = note_index // nr_of_notes_in_one_octave
        note = note_index % nr_of_notes_in_one_octave
        note_name = note_names[note] + str(current_octave)
        note_frequency = calculate_frequency(tuning, note_index - tuning_note_index)

        samples_per_cycles = []
        for cycles in samples_per_cycle_cycles_list:
            samples_per_cycles.append(
                calculate_nr_of_samples(note_frequency, sample_rate, cycles)
            )

        preferred_samples_per_cycle = 0
        preferred_samples_per_cycle_x2 = 0
        preferred_samples_per_cycle_x4 = 0

        for samples_per_cycle in samples_per_cycles:
            if (
                samples_per_cycle > 512
                and preferred_samples_per_cycle > 0
                and samples_per_cycle > samples_per_cycles[0]
            ):
                preferred_samples_per_cycle_x2 = samples_per_cycle
                preferred_samples_per_cycle_x4 = samples_per_cycle * 2
                break
            if (
                samples_per_cycle > 512
                and preferred_samples_per_cycle <= 0
                and samples_per_cycle > samples_per_cycles[0]
            ):
                preferred_samples_per_cycle = samples_per_cycle

        notes_dict[note_name] = {
            "name": note_name,
            "index": note_index,
            "frequency": note_frequency,
            "samples_per_cycles": samples_per_cycles,
            "preferred_samples_per_cycle": preferred_samples_per_cycle,
            "preferred_samples_per_cycle_x2": preferred_samples_per_cycle_x2,
            "preferred_samples_per_cycle_x4": preferred_samples_per_cycle_x4,
        }

    return notes_dict


def get_note_name():
    """Get note name."""
    region_count = EditorSample.RegionCount
    region_count_name = "error"
    if region_count == 0:
        return region_count_name

    for i in range(region_count - 1, -1, -1):
        region_count_name = EditorSample.GetRegion(i).Name
        EditorSample.DeleteRegion(i)

    return region_count_name


def find_peaks(sample_start_point, search_area):
    """Find largest and smallest peaks and their positions."""
    largest_peak = float("-inf")
    smallest_peak = float("inf")
    largest_peak_position = None
    smallest_peak_position = None

    for i in range(sample_start_point, sample_start_point + search_area):
        sample_value = EditorSample.GetSampleAt(i, 0)
        abs_sample_value = abs(sample_value)
        if abs_sample_value > largest_peak:
            largest_peak = abs_sample_value
            largest_peak_position = i
        if abs_sample_value < smallest_peak:
            smallest_peak = abs_sample_value
            smallest_peak_position = i

    return largest_peak, smallest_peak, largest_peak_position, smallest_peak_position


def find_previous_zero_crossing(sample_start_point, search_area):
    """Find the previous zero crossing."""
    for i in range(sample_start_point, search_area, -1):
        if EditorSample.GetSampleAt(i, 0) < 0:
            return i
    return None


def fix_sample():
    """Main function."""
    notes_dict = notes_dict_factory()
    region_count_name = get_note_name()
    current_note = notes_dict[region_count_name]

    if region_count_name == "error":
        Utils.ShowMessage("No region found.")
        return

    largest_peak, smallest_peak, largest_peak_position, smallest_peak_position = (
        find_peaks(
            int(EditorSample.Length / 2), int(current_note["samples_per_cycles"][4])
        )
    )

    zero_crossing = find_previous_zero_crossing(
        largest_peak_position, int(current_note["samples_per_cycles"][4])
    )

    if zero_crossing is not None:
        # EditorSample.DeleteFromTo(0, zero_crossing)
        EditorSample.AddRegion("Loop", zero_crossing)

        region_count = EditorSample.RegionCount

        for i in range(region_count - 1, -1, -1):
            EditorSample.GetRegion(i).SampleStart = zero_crossing + 1
            EditorSample.GetRegion(i).SampleEnd = (
                zero_crossing + 1 + int(current_note["preferred_samples_per_cycle_x4"])
            )
    else:
        Utils.ShowMessage("No zero crossing found.")


def lets_go(project_name):
    """Main function."""
    EditorSample.LoadFromFile(
        f"C:\\github\\elektron\\src\\akmwf_projects\\{project_name}\\Output\\{project_name} - A#0.wav"
    )

    # Save the processed file
    output_path = f"C:\\github\\elektron\\src\\akmwf_projects\\{project_name}\\Output\\{project_name} - A#0_processed.wav"

    # Option 1:
    # Editor.SaveToFile(output_path)

    # Option 2 (if Option 1 doesn't work):
    # Editor.SaveAs(output_path)

    # Option 3 (if Options 1 and 2 don't work):
    # MEEditor.SaveToFile(output_path)

    # Option 4 (if all above fail):
    # EditorSample.Save(output_path)

    fix_sample()


def main():
    """Main function"""
    lets_go("all-in-saw_akmwf")


if __name__ == "__main__":
    main()