lint with official devs clang format

README.md

@@ -3,4 +3,4 @@
 
 CURRENT STATE: pre-alpha. All main features ready, fixing small bugs, waiting for others to try it in current state to be sure it works for everybody. Slowly making a demo module (it's cover of a nice song).
 
-[Telegram channel](https://t.me/flizzer_tracker)
+[Telegram channel](https://t.me/flizzer_tracker)

audio_modes.c

@@ -1,7 +1,7 @@
 #include <stdbool.h>
 #include <stdint.h>
 
-char *audio_modes_text[2] = {
+char* audio_modes_text[2] = {
     "Internal",
     "External",
 };

diskop.c

@@ -2,116 +2,119 @@
 
 #define CFG_FILENAME "settings.cfg"
 
-void save_instrument_inner(Stream *stream, Instrument *inst)
-{
-    size_t rwops = stream_write(stream, (uint8_t *)inst->name, sizeof(inst->name));
-    rwops = stream_write(stream, (uint8_t *)&inst->waveform, sizeof(inst->waveform));
-    rwops = stream_write(stream, (uint8_t *)&inst->flags, sizeof(inst->flags));
-    rwops = stream_write(stream, (uint8_t *)&inst->sound_engine_flags, sizeof(inst->sound_engine_flags));
+void save_instrument_inner(Stream* stream, Instrument* inst) {
+    size_t rwops = stream_write(stream, (uint8_t*)inst->name, sizeof(inst->name));
+    rwops = stream_write(stream, (uint8_t*)&inst->waveform, sizeof(inst->waveform));
+    rwops = stream_write(stream, (uint8_t*)&inst->flags, sizeof(inst->flags));
+    rwops = stream_write(
+        stream, (uint8_t*)&inst->sound_engine_flags, sizeof(inst->sound_engine_flags));
 
-    rwops = stream_write(stream, (uint8_t *)&inst->base_note, sizeof(inst->base_note));
-    rwops = stream_write(stream, (uint8_t *)&inst->finetune, sizeof(inst->finetune));
+    rwops = stream_write(stream, (uint8_t*)&inst->base_note, sizeof(inst->base_note));
+    rwops = stream_write(stream, (uint8_t*)&inst->finetune, sizeof(inst->finetune));
 
-    rwops = stream_write(stream, (uint8_t *)&inst->slide_speed, sizeof(inst->slide_speed));
+    rwops = stream_write(stream, (uint8_t*)&inst->slide_speed, sizeof(inst->slide_speed));
 
-    rwops = stream_write(stream, (uint8_t *)&inst->adsr, sizeof(inst->adsr));
-    rwops = stream_write(stream, (uint8_t *)&inst->pw, sizeof(inst->pw));
+    rwops = stream_write(stream, (uint8_t*)&inst->adsr, sizeof(inst->adsr));
+    rwops = stream_write(stream, (uint8_t*)&inst->pw, sizeof(inst->pw));
 
-    if (inst->sound_engine_flags & SE_ENABLE_RING_MOD)
-    {
-        rwops = stream_write(stream, (uint8_t *)&inst->ring_mod, sizeof(inst->ring_mod));
+    if(inst->sound_engine_flags & SE_ENABLE_RING_MOD) {
+        rwops = stream_write(stream, (uint8_t*)&inst->ring_mod, sizeof(inst->ring_mod));
     }
 
-    if (inst->sound_engine_flags & SE_ENABLE_HARD_SYNC)
-    {
-        rwops = stream_write(stream, (uint8_t *)&inst->hard_sync, sizeof(inst->hard_sync));
+    if(inst->sound_engine_flags & SE_ENABLE_HARD_SYNC) {
+        rwops = stream_write(stream, (uint8_t*)&inst->hard_sync, sizeof(inst->hard_sync));
     }
 
     uint8_t progsteps = 0;
 
-    for (uint8_t i = 0; i < INST_PROG_LEN; i++)
-    {
-        if ((inst->program[i] & 0x7fff) != TE_PROGRAM_NOP)
-        {
+    for(uint8_t i = 0; i < INST_PROG_LEN; i++) {
+        if((inst->program[i] & 0x7fff) != TE_PROGRAM_NOP) {
             progsteps = i + 1;
         }
     }
 
-    rwops = stream_write(stream, (uint8_t *)&progsteps, sizeof(progsteps));
+    rwops = stream_write(stream, (uint8_t*)&progsteps, sizeof(progsteps));
 
-    if (progsteps > 0)
-    {
-        rwops = stream_write(stream, (uint8_t *)inst->program, progsteps * sizeof(inst->program[0]));
+    if(progsteps > 0) {
+        rwops =
+            stream_write(stream, (uint8_t*)inst->program, progsteps * sizeof(inst->program[0]));
     }
 
-    rwops = stream_write(stream, (uint8_t *)&inst->program_period, sizeof(inst->program_period));
+    rwops = stream_write(stream, (uint8_t*)&inst->program_period, sizeof(inst->program_period));
 
-    if (inst->flags & TE_ENABLE_VIBRATO)
-    {
-        rwops = stream_write(stream, (uint8_t *)&inst->vibrato_speed, sizeof(inst->vibrato_speed));
-        rwops = stream_write(stream, (uint8_t *)&inst->vibrato_depth, sizeof(inst->vibrato_depth));
-        rwops = stream_write(stream, (uint8_t *)&inst->vibrato_delay, sizeof(inst->vibrato_delay));
+    if(inst->flags & TE_ENABLE_VIBRATO) {
+        rwops = stream_write(stream, (uint8_t*)&inst->vibrato_speed, sizeof(inst->vibrato_speed));
+        rwops = stream_write(stream, (uint8_t*)&inst->vibrato_depth, sizeof(inst->vibrato_depth));
+        rwops = stream_write(stream, (uint8_t*)&inst->vibrato_delay, sizeof(inst->vibrato_delay));
     }
 
-    if (inst->flags & TE_ENABLE_PWM)
-    {
-        rwops = stream_write(stream, (uint8_t *)&inst->pwm_speed, sizeof(inst->pwm_speed));
-        rwops = stream_write(stream, (uint8_t *)&inst->pwm_depth, sizeof(inst->pwm_depth));
-        rwops = stream_write(stream, (uint8_t *)&inst->pwm_delay, sizeof(inst->pwm_delay));
+    if(inst->flags & TE_ENABLE_PWM) {
+        rwops = stream_write(stream, (uint8_t*)&inst->pwm_speed, sizeof(inst->pwm_speed));
+        rwops = stream_write(stream, (uint8_t*)&inst->pwm_depth, sizeof(inst->pwm_depth));
+        rwops = stream_write(stream, (uint8_t*)&inst->pwm_delay, sizeof(inst->pwm_delay));
     }
 
-    if (inst->sound_engine_flags & SE_ENABLE_FILTER)
-    {
-        rwops = stream_write(stream, (uint8_t *)&inst->filter_cutoff, sizeof(inst->filter_cutoff));
-        rwops = stream_write(stream, (uint8_t *)&inst->filter_resonance, sizeof(inst->filter_resonance));
-        rwops = stream_write(stream, (uint8_t *)&inst->filter_type, sizeof(inst->filter_type));
+    if(inst->sound_engine_flags & SE_ENABLE_FILTER) {
+        rwops = stream_write(stream, (uint8_t*)&inst->filter_cutoff, sizeof(inst->filter_cutoff));
+        rwops = stream_write(
+            stream, (uint8_t*)&inst->filter_resonance, sizeof(inst->filter_resonance));
+        rwops = stream_write(stream, (uint8_t*)&inst->filter_type, sizeof(inst->filter_type));
     }
 
     UNUSED(rwops);
 }
 
-bool save_song(FlizzerTrackerApp *tracker, FuriString *filepath)
-{
-    bool file_removed = storage_simply_remove(tracker->storage, furi_string_get_cstr(filepath)); // just in case
-    bool open_file = file_stream_open(tracker->stream, furi_string_get_cstr(filepath), FSAM_WRITE, FSOM_OPEN_ALWAYS);
+bool save_song(FlizzerTrackerApp* tracker, FuriString* filepath) {
+    bool file_removed =
+        storage_simply_remove(tracker->storage, furi_string_get_cstr(filepath)); // just in case
+    bool open_file = file_stream_open(
+        tracker->stream, furi_string_get_cstr(filepath), FSAM_WRITE, FSOM_OPEN_ALWAYS);
 
     uint8_t version = TRACKER_ENGINE_VERSION;
-    size_t rwops = stream_write(tracker->stream, (uint8_t *)SONG_FILE_SIG, sizeof(SONG_FILE_SIG) - 1);
-    rwops = stream_write(tracker->stream, (uint8_t *)&version, sizeof(uint8_t));
+    size_t rwops =
+        stream_write(tracker->stream, (uint8_t*)SONG_FILE_SIG, sizeof(SONG_FILE_SIG) - 1);
+    rwops = stream_write(tracker->stream, (uint8_t*)&version, sizeof(uint8_t));
 
-    TrackerSong *song = &tracker->song;
+    TrackerSong* song = &tracker->song;
 
     /*for(uint32_t i = 0; i < 23444; i++)
     {
         rwops = stream_write(tracker->stream, (uint8_t*)&song->loop_end, sizeof(uint8_t));
     }*/
 
-    rwops = stream_write(tracker->stream, (uint8_t *)song->song_name, sizeof(song->song_name));
-    rwops = stream_write(tracker->stream, (uint8_t *)&song->loop_start, sizeof(song->loop_start));
-    rwops = stream_write(tracker->stream, (uint8_t *)&song->loop_end, sizeof(song->loop_end));
-    rwops = stream_write(tracker->stream, (uint8_t *)&song->pattern_length, sizeof(song->pattern_length));
+    rwops = stream_write(tracker->stream, (uint8_t*)song->song_name, sizeof(song->song_name));
+    rwops = stream_write(tracker->stream, (uint8_t*)&song->loop_start, sizeof(song->loop_start));
+    rwops = stream_write(tracker->stream, (uint8_t*)&song->loop_end, sizeof(song->loop_end));
+    rwops = stream_write(
+        tracker->stream, (uint8_t*)&song->pattern_length, sizeof(song->pattern_length));
 
-    rwops = stream_write(tracker->stream, (uint8_t *)&song->speed, sizeof(song->speed));
-    rwops = stream_write(tracker->stream, (uint8_t *)&song->rate, sizeof(song->rate));
+    rwops = stream_write(tracker->stream, (uint8_t*)&song->speed, sizeof(song->speed));
+    rwops = stream_write(tracker->stream, (uint8_t*)&song->rate, sizeof(song->rate));
 
-    rwops = stream_write(tracker->stream, (uint8_t *)&song->num_sequence_steps, sizeof(song->num_sequence_steps));
+    rwops = stream_write(
+        tracker->stream, (uint8_t*)&song->num_sequence_steps, sizeof(song->num_sequence_steps));
 
-    for (uint16_t i = 0; i < song->num_sequence_steps; i++)
-    {
-        rwops = stream_write(tracker->stream, (uint8_t *)&song->sequence.sequence_step[i], sizeof(song->sequence.sequence_step[0]));
+    for(uint16_t i = 0; i < song->num_sequence_steps; i++) {
+        rwops = stream_write(
+            tracker->stream,
+            (uint8_t*)&song->sequence.sequence_step[i],
+            sizeof(song->sequence.sequence_step[0]));
     }
 
-    rwops = stream_write(tracker->stream, (uint8_t *)&song->num_patterns, sizeof(song->num_patterns));
+    rwops =
+        stream_write(tracker->stream, (uint8_t*)&song->num_patterns, sizeof(song->num_patterns));
 
-    for (uint16_t i = 0; i < song->num_patterns; i++)
-    {
-        rwops = stream_write(tracker->stream, (uint8_t *)song->pattern[i].step, sizeof(TrackerSongPatternStep) * (song->pattern_length));
+    for(uint16_t i = 0; i < song->num_patterns; i++) {
+        rwops = stream_write(
+            tracker->stream,
+            (uint8_t*)song->pattern[i].step,
+            sizeof(TrackerSongPatternStep) * (song->pattern_length));
     }
 
-    rwops = stream_write(tracker->stream, (uint8_t *)&song->num_instruments, sizeof(song->num_instruments));
+    rwops = stream_write(
+        tracker->stream, (uint8_t*)&song->num_instruments, sizeof(song->num_instruments));
 
-    for (uint16_t i = 0; i < song->num_instruments; i++)
-    {
+    for(uint16_t i = 0; i < song->num_instruments; i++) {
         save_instrument_inner(tracker->stream, song->instrument[i]);
     }
 
@@ -125,9 +128,9 @@ bool save_song(FlizzerTrackerApp *tracker, FuriString *filepath)
     return false;
 }
 
-bool load_song_util(FlizzerTrackerApp *tracker, FuriString *filepath)
-{
-    bool open_file = file_stream_open(tracker->stream, furi_string_get_cstr(filepath), FSAM_READ, FSOM_OPEN_ALWAYS);
+bool load_song_util(FlizzerTrackerApp* tracker, FuriString* filepath) {
+    bool open_file = file_stream_open(
+        tracker->stream, furi_string_get_cstr(filepath), FSAM_READ, FSOM_OPEN_ALWAYS);
 
     bool result = load_song(&tracker->song, tracker->stream);
 
@@ -138,17 +141,18 @@ bool load_song_util(FlizzerTrackerApp *tracker, FuriString *filepath)
     return result;
 }
 
-void save_config(FlizzerTrackerApp *tracker)
-{
+void save_config(FlizzerTrackerApp* tracker) {
     // stream_read_line
-    FuriString *filepath = furi_string_alloc();
-    FuriString *config_line = furi_string_alloc();
+    FuriString* filepath = furi_string_alloc();
+    FuriString* config_line = furi_string_alloc();
     furi_string_cat_printf(filepath, "%s/%s", FLIZZER_TRACKER_FOLDER, CFG_FILENAME);
 
-    bool open_file = file_stream_open(tracker->stream, furi_string_get_cstr(filepath), FSAM_WRITE, FSOM_OPEN_ALWAYS);
+    bool open_file = file_stream_open(
+        tracker->stream, furi_string_get_cstr(filepath), FSAM_WRITE, FSOM_OPEN_ALWAYS);
     UNUSED(open_file);
 
-    furi_string_cat_printf(config_line, "%s = %s\n", "external_audio", tracker->external_audio ? "true" : "false");
+    furi_string_cat_printf(
+        config_line, "%s = %s\n", "external_audio", tracker->external_audio ? "true" : "false");
     stream_write_string(tracker->stream, config_line);
 
     file_stream_close(tracker->stream);
@@ -156,34 +160,36 @@ void save_config(FlizzerTrackerApp *tracker)
     furi_string_free(config_line);
 }
 
-void load_config(FlizzerTrackerApp *tracker)
-{
-    FuriString *filepath = furi_string_alloc();
-    FuriString *config_line = furi_string_alloc();
+void load_config(FlizzerTrackerApp* tracker) {
+    FuriString* filepath = furi_string_alloc();
+    FuriString* config_line = furi_string_alloc();
     furi_string_cat_printf(filepath, "%s/%s", FLIZZER_TRACKER_FOLDER, CFG_FILENAME);
 
-    bool open_file = file_stream_open(tracker->stream, furi_string_get_cstr(filepath), FSAM_READ, FSOM_OPEN_ALWAYS);
+    bool open_file = file_stream_open(
+        tracker->stream, furi_string_get_cstr(filepath), FSAM_READ, FSOM_OPEN_ALWAYS);
     UNUSED(open_file);
 
     stream_read_line(tracker->stream, config_line);
 
-    sscanf(furi_string_get_cstr(config_line), "%s%s%s", tracker->param, tracker->eq, tracker->value);
+    sscanf(
+        furi_string_get_cstr(config_line), "%s%s%s", tracker->param, tracker->eq, tracker->value);
 
-    if (strcmp(tracker->param, "external_audio") == 0)
-    {
-        if (strcmp(tracker->value, "false") == 0)
-        {
+    if(strcmp(tracker->param, "external_audio") == 0) {
+        if(strcmp(tracker->value, "false") == 0) {
             tracker->external_audio = false;
             // strcpy(tracker->value, "false_");
         }
 
-        if (strcmp(tracker->value, "true") == 0)
-        {
+        if(strcmp(tracker->value, "true") == 0) {
             tracker->external_audio = true;
             // strcpy(tracker->value, "true_");
         }
 
-        sound_engine_init(&tracker->sound_engine, tracker->sound_engine.sample_rate, tracker->external_audio, tracker->sound_engine.audio_buffer_size);
+        sound_engine_init(
+            &tracker->sound_engine,
+            tracker->sound_engine.sample_rate,
+            tracker->external_audio,
+            tracker->sound_engine.audio_buffer_size);
         // sound_engine_set_audio_output(tracker->external_audio);
     }
 

diskop.h

@@ -5,9 +5,9 @@
 
 #define INST_FILE_SIG "FZT!INST"
 
-bool save_song(FlizzerTrackerApp *tracker, FuriString *filepath);
+bool save_song(FlizzerTrackerApp* tracker, FuriString* filepath);
 
-bool load_song_util(FlizzerTrackerApp *tracker, FuriString *filepath);
+bool load_song_util(FlizzerTrackerApp* tracker, FuriString* filepath);
 
-void save_config(FlizzerTrackerApp *tracker);
-void load_config(FlizzerTrackerApp *tracker);
+void save_config(FlizzerTrackerApp* tracker);
+void load_config(FlizzerTrackerApp* tracker);

flizzer_tracker.c

@@ -9,21 +9,18 @@
 #include "font.h"
 #include <flizzer_tracker_icons.h>
 
-void draw_callback(Canvas *canvas, void *ctx)
-{
-    TrackerViewModel *model = (TrackerViewModel *)ctx;
-    FlizzerTrackerApp *tracker = (FlizzerTrackerApp *)(model->tracker);
+void draw_callback(Canvas* canvas, void* ctx) {
+    TrackerViewModel* model = (TrackerViewModel*)ctx;
+    FlizzerTrackerApp* tracker = (FlizzerTrackerApp*)(model->tracker);
 
     canvas_set_color(canvas, ColorXOR);
 
-    if (tracker->is_loading)
-    {
+    if(tracker->is_loading) {
         canvas_draw_str(canvas, 10, 10, "Loading...");
         return;
     }
 
-    if (tracker->is_saving)
-    {
+    if(tracker->is_saving) {
         canvas_draw_str(canvas, 10, 10, "Saving...");
         return;
     }
@@ -37,63 +34,56 @@ void draw_callback(Canvas *canvas, void *ctx)
     snprintf(buffer, sizeof(buffer), "%ld", (tracker->tracker_engine.counter & 8191));
     canvas_draw_str(canvas, 18, 29, buffer);*/
 
-    switch (tracker->mode)
-    {
-        case PATTERN_VIEW:
-        {
-            if (tracker->tracker_engine.song == NULL)
-            {
-                stop();
-                tracker_engine_set_song(&tracker->tracker_engine, &tracker->song);
-            }
-
-            draw_songinfo_view(canvas, tracker);
-            draw_sequence_view(canvas, tracker);
-            draw_pattern_view(canvas, tracker);
-            break;
+    switch(tracker->mode) {
+    case PATTERN_VIEW: {
+        if(tracker->tracker_engine.song == NULL) {
+            stop();
+            tracker_engine_set_song(&tracker->tracker_engine, &tracker->song);
         }
 
-        case INST_EDITOR_VIEW:
-        {
-            draw_instrument_view(canvas, tracker);
-            draw_instrument_program_view(canvas, tracker);
-            break;
-        }
+        draw_songinfo_view(canvas, tracker);
+        draw_sequence_view(canvas, tracker);
+        draw_pattern_view(canvas, tracker);
+        break;
+    }
+
+    case INST_EDITOR_VIEW: {
+        draw_instrument_view(canvas, tracker);
+        draw_instrument_program_view(canvas, tracker);
+        break;
+    }
 
-        default:
-            break;
+    default:
+        break;
     }
 }
 
-bool input_callback(InputEvent *input_event, void *ctx)
-{
+bool input_callback(InputEvent* input_event, void* ctx) {
     // Проверяем, что контекст не нулевой
     furi_assert(ctx);
-    TrackerView *tracker_view = (TrackerView *)ctx;
-    FlizzerTrackerApp *tracker = (FlizzerTrackerApp *)(tracker_view->context);
+    TrackerView* tracker_view = (TrackerView*)ctx;
+    FlizzerTrackerApp* tracker = (FlizzerTrackerApp*)(tracker_view->context);
 
     bool consumed = false;
 
-    if (input_event->key == InputKeyBack && input_event->type == InputTypeShort)
-    {
+    if(input_event->key == InputKeyBack && input_event->type == InputTypeShort) {
         tracker->period = furi_get_tick() - tracker->current_time;
         tracker->current_time = furi_get_tick();
 
         tracker->was_it_back_keypress = true;
     }
 
-    else if (input_event->type == InputTypeShort || input_event->type == InputTypeLong)
-    {
+    else if(input_event->type == InputTypeShort || input_event->type == InputTypeLong) {
         tracker->was_it_back_keypress = false;
         tracker->period = 0;
     }
 
     uint32_t final_period = (tracker->was_it_back_keypress ? tracker->period : 0);
 
-    FlizzerTrackerEvent event = {.type = EventTypeInput, .input = *input_event, .period = final_period};
+    FlizzerTrackerEvent event = {
+        .type = EventTypeInput, .input = *input_event, .period = final_period};
 
-    if (!(tracker->is_loading) && !(tracker->is_saving))
-    {
+    if(!(tracker->is_loading) && !(tracker->is_saving)) {
         furi_message_queue_put(tracker->event_queue, &event, FuriWaitForever);
     }
 
@@ -101,17 +91,16 @@ bool input_callback(InputEvent *input_event, void *ctx)
     return consumed;
 }
 
-int32_t flizzer_tracker_app(void *p)
-{
+int32_t flizzer_tracker_app(void* p) {
     UNUSED(p);
 
-    Storage *storage = furi_record_open(RECORD_STORAGE);
+    Storage* storage = furi_record_open(RECORD_STORAGE);
     bool st = storage_simply_mkdir(storage, APPSDATA_FOLDER);
     st = storage_simply_mkdir(storage, FLIZZER_TRACKER_FOLDER);
     UNUSED(st);
     furi_record_close(RECORD_STORAGE);
 
-    FlizzerTrackerApp *tracker = init_tracker(44100, 50, true, 1024);
+    FlizzerTrackerApp* tracker = init_tracker(44100, 50, true, 1024);
 
     // Текущее событие типа кастомного типа FlizzerTrackerEvent
     FlizzerTrackerEvent event;
@@ -119,38 +108,37 @@ int32_t flizzer_tracker_app(void *p)
     view_dispatcher_switch_to_view(tracker->view_dispatcher, VIEW_TRACKER);
 
     // Бесконечный цикл обработки очереди событий
-    while (!(tracker->quit))
-    {
+    while(!(tracker->quit)) {
         // Выбираем событие из очереди в переменную event (ждём бесконечно долго, если очередь пуста)
         // и проверяем, что у нас получилось это сделать
-        furi_check(furi_message_queue_get(tracker->event_queue, &event, FuriWaitForever) == FuriStatusOk);
+        furi_check(
+            furi_message_queue_get(tracker->event_queue, &event, FuriWaitForever) == FuriStatusOk);
 
         // Наше событие — это нажатие кнопки
-        if (event.type == EventTypeInput)
-        {
+        if(event.type == EventTypeInput) {
             process_input_event(tracker, &event);
         }
 
-        if (event.type == EventTypeSaveSong)
-        {
+        if(event.type == EventTypeSaveSong) {
             save_song(tracker, tracker->filepath);
         }
 
-        if (event.type == EventTypeLoadSong)
-        {
+        if(event.type == EventTypeLoadSong) {
             stop_song(tracker);
 
-            tracker->tracker_engine.sequence_position = tracker->tracker_engine.pattern_position = tracker->current_instrument = 0;
+            tracker->tracker_engine.sequence_position = tracker->tracker_engine.pattern_position =
+                tracker->current_instrument = 0;
 
             tracker->dialogs = furi_record_open(RECORD_DIALOGS);
             tracker->is_loading = true;
 
-            FuriString *path;
+            FuriString* path;
             path = furi_string_alloc();
             furi_string_set(path, FLIZZER_TRACKER_FOLDER);
 
             DialogsFileBrowserOptions browser_options;
-            dialog_file_browser_set_basic_options(&browser_options, SONG_FILE_EXT, &I_flizzer_tracker_module);
+            dialog_file_browser_set_basic_options(
+                &browser_options, SONG_FILE_EXT, &I_flizzer_tracker_module);
             browser_options.base_path = FLIZZER_TRACKER_FOLDER;
             browser_options.hide_ext = false;
 
@@ -158,23 +146,20 @@ int32_t flizzer_tracker_app(void *p)
 
             furi_record_close(RECORD_DIALOGS);
 
-            const char *cpath = furi_string_get_cstr(path);
+            const char* cpath = furi_string_get_cstr(path);
 
-            if (ret && strcmp(&cpath[strlen(cpath) - 4], SONG_FILE_EXT) == 0)
-            {
+            if(ret && strcmp(&cpath[strlen(cpath) - 4], SONG_FILE_EXT) == 0) {
                 bool result = load_song_util(tracker, path);
                 UNUSED(result);
             }
 
-            else
-            {
+            else {
                 furi_string_free(path);
                 tracker->is_loading = false;
             }
         }
 
-        if (event.type == EventTypeSetAudioMode)
-        {
+        if(event.type == EventTypeSetAudioMode) {
             sound_engine_PWM_timer_init(tracker->external_audio);
 
             tracker->sound_engine.external_audio_output = tracker->external_audio;

flizzer_tracker.h

@@ -26,30 +26,26 @@
 #define FLIZZER_TRACKER_FOLDER "/ext/apps_data/flizzer_tracker"
 #define FILE_NAME_LEN 64
 
-typedef enum
-{
+typedef enum {
     EventTypeInput,
     EventTypeSaveSong,
     EventTypeLoadSong,
     EventTypeSetAudioMode,
 } EventType;
 
-typedef struct
-{
+typedef struct {
     EventType type;
     InputEvent input;
     uint32_t period;
 } FlizzerTrackerEvent;
 
-typedef enum
-{
+typedef enum {
     PATTERN_VIEW,
     INST_EDITOR_VIEW,
     EXPORT_WAV_VIEW,
 } TrackerMode;
 
-typedef enum
-{
+typedef enum {
     EDIT_PATTERN,
     EDIT_SEQUENCE,
     EDIT_SONGINFO,
@@ -57,8 +53,7 @@ typedef enum
     EDIT_PROGRAM,
 } TrackerFocus;
 
-typedef enum
-{
+typedef enum {
     SI_PATTERNPOS,
     SI_SEQUENCEPOS,
     SI_SONGSPEED,
@@ -72,8 +67,7 @@ typedef enum
     SI_PARAMS,
 } SongInfoParam;
 
-typedef enum
-{
+typedef enum {
     INST_CURRENTINSTRUMENT,
     INST_INSTRUMENTNAME,
 
@@ -127,14 +121,12 @@ typedef enum
     INST_PARAMS,
 } InstrumentParam;
 
-typedef struct
-{
-    View *view;
-    void *context;
+typedef struct {
+    View* view;
+    void* context;
 } TrackerView;
 
-typedef enum
-{
+typedef enum {
     VIEW_TRACKER,
     VIEW_KEYBOARD,
     VIEW_SUBMENU_PATTERN,
@@ -143,35 +135,32 @@ typedef enum
     VIEW_SETTINGS,
 } FlizzerTrackerViews;
 
-typedef enum
-{
+typedef enum {
     SUBMENU_PATTERN_LOAD_SONG,
     SUBMENU_PATTERN_SAVE_SONG,
     SUBMENU_PATTERN_SETTINGS,
     SUBMENU_PATTERN_EXIT,
 } PatternSubmenuParams;
 
-typedef enum
-{
+typedef enum {
     SUBMENU_INSTRUMENT_EXIT,
 } InstrumentSubmenuParams;
 
-typedef struct
-{
-    NotificationApp *notification;
-    FuriMessageQueue *event_queue;
-    Gui *gui;
-    TrackerView *tracker_view;
-    ViewDispatcher *view_dispatcher;
-    TextInput *text_input;
-    Storage *storage;
-    Stream *stream;
-    FuriString *filepath;
-    DialogsApp *dialogs;
-    Submenu *pattern_submenu;
-    Submenu *instrument_submenu;
-    VariableItemList *settings_list;
-    Widget *overwrite_file_widget;
+typedef struct {
+    NotificationApp* notification;
+    FuriMessageQueue* event_queue;
+    Gui* gui;
+    TrackerView* tracker_view;
+    ViewDispatcher* view_dispatcher;
+    TextInput* text_input;
+    Storage* storage;
+    Stream* stream;
+    FuriString* filepath;
+    DialogsApp* dialogs;
+    Submenu* pattern_submenu;
+    Submenu* instrument_submenu;
+    VariableItemList* settings_list;
+    Widget* overwrite_file_widget;
     char filename[FILE_NAME_LEN + 1];
     bool was_it_back_keypress;
     uint32_t current_time;
@@ -187,7 +176,8 @@ typedef struct
     uint8_t selected_param;
 
     uint8_t mode, focus;
-    uint8_t patternx, current_channel, current_digit, program_position, current_program_step, current_instrument, current_note, current_volume;
+    uint8_t patternx, current_channel, current_digit, program_position, current_program_step,
+        current_instrument, current_note, current_volume;
 
     uint8_t inst_editor_shift;
 
@@ -204,10 +194,9 @@ typedef struct
     char value[10];
 } FlizzerTrackerApp;
 
-typedef struct
-{
-    FlizzerTrackerApp *tracker;
+typedef struct {
+    FlizzerTrackerApp* tracker;
 } TrackerViewModel;
 
-void draw_callback(Canvas *canvas, void *ctx);
-bool input_callback(InputEvent *input_event, void *ctx);
+void draw_callback(Canvas* canvas, void* ctx);
+bool input_callback(InputEvent* input_event, void* ctx);

flizzer_tracker_hal.c

@@ -1,40 +1,37 @@
 #include "flizzer_tracker_hal.h"
 #include "flizzer_tracker.h"
 
-void sound_engine_dma_isr(void *ctx)
-{
-    SoundEngine *sound_engine = (SoundEngine *)ctx;
+void sound_engine_dma_isr(void* ctx) {
+    SoundEngine* sound_engine = (SoundEngine*)ctx;
 
     // sound_engine->counter++;
 
     // half of transfer
-    if (LL_DMA_IsActiveFlag_HT1(DMA1))
-    {
+    if(LL_DMA_IsActiveFlag_HT1(DMA1)) {
         LL_DMA_ClearFlag_HT1(DMA1);
         // fill first half of buffer
-        uint16_t *audio_buffer = sound_engine->audio_buffer;
+        uint16_t* audio_buffer = sound_engine->audio_buffer;
         uint32_t audio_buffer_length = sound_engine->audio_buffer_size / 2;
         sound_engine_fill_buffer(sound_engine, audio_buffer, audio_buffer_length);
     }
 
     // transfer complete
-    if (LL_DMA_IsActiveFlag_TC1(DMA1))
-    {
+    if(LL_DMA_IsActiveFlag_TC1(DMA1)) {
         LL_DMA_ClearFlag_TC1(DMA1);
         // fill second half of buffer
         uint32_t audio_buffer_length = sound_engine->audio_buffer_size / 2;
-        uint16_t *audio_buffer = &sound_engine->audio_buffer[audio_buffer_length];
+        uint16_t* audio_buffer = &sound_engine->audio_buffer[audio_buffer_length];
         sound_engine_fill_buffer(sound_engine, audio_buffer, audio_buffer_length);
     }
 }
 
-void tracker_engine_timer_isr(void *ctx) // the tracker engine interrupt is of higher priority than sound engine one so it can run at the middle of filling the buffer, thus allowing sample-accurate tight effect timing
+void tracker_engine_timer_isr(
+    void* ctx) // the tracker engine interrupt is of higher priority than sound engine one so it can run at the middle of filling the buffer, thus allowing sample-accurate tight effect timing
 {
-    TrackerEngine *tracker_engine = (TrackerEngine *)ctx;
+    TrackerEngine* tracker_engine = (TrackerEngine*)ctx;
     // tracker_engine->counter++;
 
-    if (LL_TIM_IsActiveFlag_UPDATE(TRACKER_ENGINE_TIMER))
-    {
+    if(LL_TIM_IsActiveFlag_UPDATE(TRACKER_ENGINE_TIMER)) {
         LL_TIM_ClearFlag_UPDATE(TRACKER_ENGINE_TIMER);
         tracker_engine_advance_tick(tracker_engine);
     }
@@ -58,20 +55,17 @@ void sound_engine_PWM_timer_init(bool external_audio_output) // external audio o
     TIM_OC_InitStruct.CompareValue = 0;
     LL_TIM_OC_Init(SPEAKER_PWM_TIMER, SPEAKER_PWM_TIMER_CHANNEL, &TIM_OC_InitStruct);
 
-    if (external_audio_output)
-    {
-        furi_hal_gpio_init_ex(&gpio_ext_pa6, GpioModeAltFunctionPushPull, GpioPullNo, GpioSpeedLow, GpioAltFn14TIM16);
+    if(external_audio_output) {
+        furi_hal_gpio_init_ex(
+            &gpio_ext_pa6, GpioModeAltFunctionPushPull, GpioPullNo, GpioSpeedLow, GpioAltFn14TIM16);
 
-        if (furi_hal_speaker_is_mine())
-        {
+        if(furi_hal_speaker_is_mine()) {
             furi_hal_speaker_release();
         }
     }
 
-    else
-    {
-        if (!(furi_hal_speaker_is_mine()))
-        {
+    else {
+        if(!(furi_hal_speaker_is_mine())) {
             bool unu = furi_hal_speaker_acquire(1000);
             UNUSED(unu);
         }
@@ -83,22 +77,18 @@ void sound_engine_PWM_timer_init(bool external_audio_output) // external audio o
     LL_TIM_EnableCounter(SPEAKER_PWM_TIMER);
 }
 
-void sound_engine_set_audio_output(bool external_audio_output)
-{
-    if (external_audio_output)
-    {
-        furi_hal_gpio_init_ex(&gpio_ext_pa6, GpioModeAltFunctionPushPull, GpioPullNo, GpioSpeedLow, GpioAltFn14TIM16);
+void sound_engine_set_audio_output(bool external_audio_output) {
+    if(external_audio_output) {
+        furi_hal_gpio_init_ex(
+            &gpio_ext_pa6, GpioModeAltFunctionPushPull, GpioPullNo, GpioSpeedLow, GpioAltFn14TIM16);
 
-        if (furi_hal_speaker_is_mine())
-        {
+        if(furi_hal_speaker_is_mine()) {
             furi_hal_speaker_release();
         }
     }
 
-    else
-    {
-        if (!(furi_hal_speaker_is_mine()))
-        {
+    else {
+        if(!(furi_hal_speaker_is_mine())) {
             bool unu = furi_hal_speaker_acquire(1000);
             UNUSED(unu);
         }
@@ -113,7 +103,8 @@ void sound_engine_timer_init(uint32_t sample_rate) // external audio on pin PA6
     LL_TIM_OC_InitTypeDef TIM_OC_InitStruct = {0};
 
     TIM_InitStruct.Prescaler = 0;
-    TIM_InitStruct.Autoreload = TIMER_BASE_CLOCK / sample_rate - 1; // to support various sample rates
+    TIM_InitStruct.Autoreload =
+        TIMER_BASE_CLOCK / sample_rate - 1; // to support various sample rates
     TIM_InitStruct.CounterMode = LL_TIM_COUNTERMODE_UP;
     LL_TIM_Init(SAMPLE_RATE_TIMER, &TIM_InitStruct);
 
@@ -129,8 +120,9 @@ void tracker_engine_timer_init(uint8_t rate) // 0-255 hz
     LL_TIM_InitTypeDef TIM_InitStruct = {0};
     LL_TIM_OC_InitTypeDef TIM_OC_InitStruct = {0};
 
-    TIM_InitStruct.Prescaler = 0;                                                // using 32-bit timer
-    TIM_InitStruct.Autoreload = (uint32_t)TIMER_BASE_CLOCK / (uint32_t)rate - 1; // to support various tracker engine rates
+    TIM_InitStruct.Prescaler = 0; // using 32-bit timer
+    TIM_InitStruct.Autoreload =
+        (uint32_t)TIMER_BASE_CLOCK / (uint32_t)rate - 1; // to support various tracker engine rates
     TIM_InitStruct.CounterMode = LL_TIM_COUNTERMODE_UP;
     LL_TIM_Init(TRACKER_ENGINE_TIMER, &TIM_InitStruct);
 
@@ -141,23 +133,21 @@ void tracker_engine_timer_init(uint8_t rate) // 0-255 hz
     LL_TIM_EnableIT_UPDATE(TRACKER_ENGINE_TIMER);
 }
 
-void tracker_engine_set_rate(uint8_t rate)
-{
+void tracker_engine_set_rate(uint8_t rate) {
     LL_TIM_InitTypeDef TIM_InitStruct = {0};
 
-    TIM_InitStruct.Prescaler = 0;                                                // using 32-bit timer
-    TIM_InitStruct.Autoreload = (uint32_t)TIMER_BASE_CLOCK / (uint32_t)rate - 1; // to support various tracker engine rates
+    TIM_InitStruct.Prescaler = 0; // using 32-bit timer
+    TIM_InitStruct.Autoreload =
+        (uint32_t)TIMER_BASE_CLOCK / (uint32_t)rate - 1; // to support various tracker engine rates
     TIM_InitStruct.CounterMode = LL_TIM_COUNTERMODE_UP;
     LL_TIM_Init(TRACKER_ENGINE_TIMER, &TIM_InitStruct);
 }
 
-void tracker_engine_init_hardware(uint8_t rate)
-{
+void tracker_engine_init_hardware(uint8_t rate) {
     tracker_engine_timer_init(rate);
 }
 
-void sound_engine_dma_init(uint32_t address, uint32_t size)
-{
+void sound_engine_dma_init(uint32_t address, uint32_t size) {
     uint32_t dma_dst = (uint32_t) & (SPEAKER_PWM_TIMER->CCR1);
 
     LL_DMA_ConfigAddresses(DMA_INSTANCE, address, dma_dst, LL_DMA_DIRECTION_MEMORY_TO_PERIPH);
@@ -176,67 +166,61 @@ void sound_engine_dma_init(uint32_t address, uint32_t size)
     LL_DMA_EnableIT_HT(DMA_INSTANCE);
 }
 
-void sound_engine_init_hardware(uint32_t sample_rate, bool external_audio_output, uint16_t *audio_buffer, uint32_t audio_buffer_size)
-{
+void sound_engine_init_hardware(
+    uint32_t sample_rate,
+    bool external_audio_output,
+    uint16_t* audio_buffer,
+    uint32_t audio_buffer_size) {
     sound_engine_dma_init((uint32_t)audio_buffer, audio_buffer_size);
     sound_engine_timer_init(sample_rate);
     sound_engine_PWM_timer_init(external_audio_output);
 }
 
-void sound_engine_dma_start()
-{
+void sound_engine_dma_start() {
     LL_DMA_EnableChannel(DMA_INSTANCE);
     LL_TIM_EnableDMAReq_UPDATE(SAMPLE_RATE_TIMER);
 }
 
-void sound_engine_dma_stop()
-{
+void sound_engine_dma_stop() {
     LL_DMA_DisableChannel(DMA_INSTANCE);
 }
 
-void sound_engine_start()
-{
+void sound_engine_start() {
     LL_TIM_EnableCounter(SAMPLE_RATE_TIMER);
 
     sound_engine_dma_start();
 }
 
-void sound_engine_stop()
-{
+void sound_engine_stop() {
     LL_TIM_DisableAllOutputs(SAMPLE_RATE_TIMER);
     LL_TIM_DisableCounter(SAMPLE_RATE_TIMER);
 
     sound_engine_dma_stop();
 }
 
-void sound_engine_deinit_timer()
-{
+void sound_engine_deinit_timer() {
     LL_TIM_DisableAllOutputs(SAMPLE_RATE_TIMER);
     LL_TIM_DisableAllOutputs(SPEAKER_PWM_TIMER);
 
     LL_TIM_DisableCounter(SPEAKER_PWM_TIMER);
 }
 
-void tracker_engine_start()
-{
+void tracker_engine_start() {
     LL_TIM_EnableAllOutputs(TRACKER_ENGINE_TIMER);
     LL_TIM_EnableCounter(TRACKER_ENGINE_TIMER);
 }
 
-void tracker_engine_stop()
-{
+void tracker_engine_stop() {
     LL_TIM_DisableAllOutputs(TRACKER_ENGINE_TIMER);
     LL_TIM_DisableCounter(TRACKER_ENGINE_TIMER);
 }
 
-void play()
-{
+void play() {
     tracker_engine_start();
     sound_engine_start();
 }
 
-void stop()
-{
+void stop() {
     sound_engine_stop();
     tracker_engine_stop();
 }

flizzer_tracker_hal.h

@@ -21,9 +21,13 @@
 
 #define DMA_INSTANCE DMA1, LL_DMA_CHANNEL_1
 
-void sound_engine_dma_isr(void *ctx);
-void tracker_engine_timer_isr(void *ctx);
-void sound_engine_init_hardware(uint32_t sample_rate, bool external_audio_output, uint16_t *audio_buffer, uint32_t audio_buffer_size);
+void sound_engine_dma_isr(void* ctx);
+void tracker_engine_timer_isr(void* ctx);
+void sound_engine_init_hardware(
+    uint32_t sample_rate,
+    bool external_audio_output,
+    uint16_t* audio_buffer,
+    uint32_t audio_buffer_size);
 void sound_engine_dma_init(uint32_t address, uint32_t size);
 void sound_engine_PWM_timer_init(bool external_audio_output);
 void sound_engine_set_audio_output(bool external_audio_output);

init_deinit.c

@@ -5,9 +5,8 @@
 
 #define AUDIO_MODES_COUNT 2
 
-TrackerView *tracker_view_alloc(FlizzerTrackerApp *tracker)
-{
-    TrackerView *tracker_view = malloc(sizeof(TrackerView));
+TrackerView* tracker_view_alloc(FlizzerTrackerApp* tracker) {
+    TrackerView* tracker_view = malloc(sizeof(TrackerView));
     tracker_view->view = view_alloc();
     tracker_view->context = tracker;
     view_set_context(tracker_view->view, tracker_view);
@@ -18,21 +17,22 @@ TrackerView *tracker_view_alloc(FlizzerTrackerApp *tracker)
     return tracker_view;
 }
 
-void tracker_view_free(TrackerView *tracker_view)
-{
+void tracker_view_free(TrackerView* tracker_view) {
     furi_assert(tracker_view);
     view_free(tracker_view->view);
     free(tracker_view);
 }
 
-uint8_t my_value_index_bool(const bool value, const bool values[], uint8_t values_count) // why the fuck it gives unresolved symbol if I include it from toolbox???!!!
+uint8_t my_value_index_bool(
+    const bool value,
+    const bool values[],
+    uint8_t
+        values_count) // why the fuck it gives unresolved symbol if I include it from toolbox???!!!
 {
     uint8_t index = 0;
 
-    for (uint8_t i = 0; i < values_count; i++)
-    {
-        if (value == values[i])
-        {
+    for(uint8_t i = 0; i < values_count; i++) {
+        if(value == values[i]) {
             index = i;
             break;
         }
@@ -41,14 +41,18 @@ uint8_t my_value_index_bool(const bool value, const bool values[], uint8_t value
     return index;
 }
 
-FlizzerTrackerApp *init_tracker(uint32_t sample_rate, uint8_t rate, bool external_audio_output, uint32_t audio_buffer_size)
-{
-    FlizzerTrackerApp *tracker = malloc(sizeof(FlizzerTrackerApp));
+FlizzerTrackerApp* init_tracker(
+    uint32_t sample_rate,
+    uint8_t rate,
+    bool external_audio_output,
+    uint32_t audio_buffer_size) {
+    FlizzerTrackerApp* tracker = malloc(sizeof(FlizzerTrackerApp));
     memset(tracker, 0, sizeof(FlizzerTrackerApp));
 
     tracker->external_audio = external_audio_output;
 
-    sound_engine_init(&tracker->sound_engine, sample_rate, external_audio_output, audio_buffer_size);
+    sound_engine_init(
+        &tracker->sound_engine, sample_rate, external_audio_output, audio_buffer_size);
     tracker_engine_init(&tracker->tracker_engine, rate, &tracker->sound_engine);
 
     tracker->tracker_engine.song = &tracker->song;
@@ -64,7 +68,8 @@ FlizzerTrackerApp *init_tracker(uint32_t sample_rate, uint8_t rate, bool externa
     tracker->tracker_view = tracker_view_alloc(tracker);
 
     view_dispatcher_add_view(tracker->view_dispatcher, VIEW_TRACKER, tracker->tracker_view->view);
-    view_dispatcher_attach_to_gui(tracker->view_dispatcher, tracker->gui, ViewDispatcherTypeFullscreen);
+    view_dispatcher_attach_to_gui(
+        tracker->view_dispatcher, tracker->gui, ViewDispatcherTypeFullscreen);
 
     with_view_model(
         tracker->tracker_view->view, TrackerViewModel * model, { model->tracker = tracker; }, true);
@@ -73,35 +78,62 @@ FlizzerTrackerApp *init_tracker(uint32_t sample_rate, uint8_t rate, bool externa
     tracker->stream = file_stream_alloc(tracker->storage);
 
     tracker->text_input = text_input_alloc();
-    view_dispatcher_add_view(tracker->view_dispatcher, VIEW_KEYBOARD, text_input_get_view(tracker->text_input));
+    view_dispatcher_add_view(
+        tracker->view_dispatcher, VIEW_KEYBOARD, text_input_get_view(tracker->text_input));
 
     tracker->pattern_submenu = submenu_alloc();
     tracker->instrument_submenu = submenu_alloc();
 
     view_set_previous_callback(submenu_get_view(tracker->pattern_submenu), submenu_exit_callback);
-    view_set_previous_callback(submenu_get_view(tracker->instrument_submenu), submenu_exit_callback);
-
-    submenu_add_item(tracker->pattern_submenu, "Load song", SUBMENU_PATTERN_LOAD_SONG, submenu_callback, tracker);
-    submenu_add_item(tracker->pattern_submenu, "Save song", SUBMENU_PATTERN_SAVE_SONG, submenu_callback, tracker);
-    submenu_add_item(tracker->pattern_submenu, "Settings", SUBMENU_PATTERN_SETTINGS, submenu_callback, tracker);
-    submenu_add_item(tracker->pattern_submenu, "Exit", SUBMENU_PATTERN_EXIT, submenu_callback, tracker);
-
-    submenu_add_item(tracker->instrument_submenu, "Exit", SUBMENU_INSTRUMENT_EXIT, submenu_callback, tracker);
-
-    view_dispatcher_add_view(tracker->view_dispatcher, VIEW_SUBMENU_PATTERN, submenu_get_view(tracker->pattern_submenu));
-    view_dispatcher_add_view(tracker->view_dispatcher, VIEW_SUBMENU_INSTRUMENT, submenu_get_view(tracker->instrument_submenu));
+    view_set_previous_callback(
+        submenu_get_view(tracker->instrument_submenu), submenu_exit_callback);
+
+    submenu_add_item(
+        tracker->pattern_submenu,
+        "Load song",
+        SUBMENU_PATTERN_LOAD_SONG,
+        submenu_callback,
+        tracker);
+    submenu_add_item(
+        tracker->pattern_submenu,
+        "Save song",
+        SUBMENU_PATTERN_SAVE_SONG,
+        submenu_callback,
+        tracker);
+    submenu_add_item(
+        tracker->pattern_submenu, "Settings", SUBMENU_PATTERN_SETTINGS, submenu_callback, tracker);
+    submenu_add_item(
+        tracker->pattern_submenu, "Exit", SUBMENU_PATTERN_EXIT, submenu_callback, tracker);
+
+    submenu_add_item(
+        tracker->instrument_submenu, "Exit", SUBMENU_INSTRUMENT_EXIT, submenu_callback, tracker);
+
+    view_dispatcher_add_view(
+        tracker->view_dispatcher,
+        VIEW_SUBMENU_PATTERN,
+        submenu_get_view(tracker->pattern_submenu));
+    view_dispatcher_add_view(
+        tracker->view_dispatcher,
+        VIEW_SUBMENU_INSTRUMENT,
+        submenu_get_view(tracker->instrument_submenu));
 
     load_config(tracker);
 
     tracker->settings_list = variable_item_list_alloc();
-    View *view = variable_item_list_get_view(tracker->settings_list);
+    View* view = variable_item_list_get_view(tracker->settings_list);
     view_set_previous_callback(view, submenu_settings_exit_callback);
 
-    VariableItem *item;
+    VariableItem* item;
     uint8_t value_index;
 
-    item = variable_item_list_add(tracker->settings_list, "Audio output", AUDIO_MODES_COUNT, audio_output_changed_callback, tracker);
-    value_index = my_value_index_bool(tracker->external_audio, audio_modes_values, AUDIO_MODES_COUNT);
+    item = variable_item_list_add(
+        tracker->settings_list,
+        "Audio output",
+        AUDIO_MODES_COUNT,
+        audio_output_changed_callback,
+        tracker);
+    value_index =
+        my_value_index_bool(tracker->external_audio, audio_modes_values, AUDIO_MODES_COUNT);
     variable_item_set_current_value_index(item, value_index);
     variable_item_set_current_value_text(item, audio_modes_text[value_index]);
 
@@ -122,9 +154,18 @@ FlizzerTrackerApp *init_tracker(uint32_t sample_rate, uint8_t rate, bool externa
         (ButtonCallback)overwrite_file_widget_yes_input_callback,
         tracker);
 
-    widget_add_text_scroll_element(tracker->overwrite_file_widget, 0, 0, 128, 64, "This song file already exists,\n do you want to overwrite it?");
+    widget_add_text_scroll_element(
+        tracker->overwrite_file_widget,
+        0,
+        0,
+        128,
+        64,
+        "This song file already exists,\n do you want to overwrite it?");
 
-    view_dispatcher_add_view(tracker->view_dispatcher, VIEW_FILE_OVERWRITE, widget_get_view(tracker->overwrite_file_widget));
+    view_dispatcher_add_view(
+        tracker->view_dispatcher,
+        VIEW_FILE_OVERWRITE,
+        widget_get_view(tracker->overwrite_file_widget));
 
     tracker->notification = furi_record_open(RECORD_NOTIFICATION);
     notification_message(tracker->notification, &sequence_display_backlight_enforce_on);
@@ -134,8 +175,7 @@ FlizzerTrackerApp *init_tracker(uint32_t sample_rate, uint8_t rate, bool externa
     return tracker;
 }
 
-void deinit_tracker(FlizzerTrackerApp *tracker)
-{
+void deinit_tracker(FlizzerTrackerApp* tracker) {
     notification_message(tracker->notification, &sequence_display_backlight_enforce_auto);
     furi_record_close(RECORD_NOTIFICATION);
 
@@ -168,8 +208,7 @@ void deinit_tracker(FlizzerTrackerApp *tracker)
 
     sound_engine_deinit(&tracker->sound_engine);
 
-    if (tracker->tracker_engine.song == NULL)
-    {
+    if(tracker->tracker_engine.song == NULL) {
         tracker_engine_set_song(&tracker->tracker_engine, &tracker->song);
     }
 

init_deinit.h

@@ -4,7 +4,11 @@
 #include "flizzer_tracker_hal.h"
 
 extern bool audio_modes_values[];
-extern char *audio_modes_text[];
+extern char* audio_modes_text[];
 
-FlizzerTrackerApp *init_tracker(uint32_t sample_rate, uint8_t rate, bool external_audio_output, uint32_t audio_buffer_size);
-void deinit_tracker(FlizzerTrackerApp *tracker);
+FlizzerTrackerApp* init_tracker(
+    uint32_t sample_rate,
+    uint8_t rate,
+    bool external_audio_output,
+    uint32_t audio_buffer_size);
+void deinit_tracker(FlizzerTrackerApp* tracker);

input/instrument.c

@@ -1,610 +1,538 @@
 #include "instrument.h"
 #include "songinfo.h"
 
-void edit_instrument_param(FlizzerTrackerApp *tracker, uint8_t selected_param, int8_t delta)
-{
-    if (!(tracker->current_digit))
-    {
+void edit_instrument_param(FlizzerTrackerApp* tracker, uint8_t selected_param, int8_t delta) {
+    if(!(tracker->current_digit)) {
         delta *= 16;
     }
 
-    Instrument *inst = tracker->song.instrument[tracker->current_instrument];
+    Instrument* inst = tracker->song.instrument[tracker->current_instrument];
 
-    switch (selected_param)
-    {
-        case INST_CURRENTINSTRUMENT:
-        {
-            int16_t inst = tracker->current_instrument;
+    switch(selected_param) {
+    case INST_CURRENTINSTRUMENT: {
+        int16_t inst = tracker->current_instrument;
 
-            int8_t inst_delta = delta > 0 ? 1 : -1;
+        int8_t inst_delta = delta > 0 ? 1 : -1;
 
-            inst += inst_delta;
+        inst += inst_delta;
 
-            clamp(inst, 0, 0, tracker->song.num_instruments);
+        clamp(inst, 0, 0, tracker->song.num_instruments);
 
-            if (check_and_allocate_instrument(&tracker->song, (uint8_t)inst))
-            {
-                tracker->current_instrument = inst;
-            }
-
-            break;
+        if(check_and_allocate_instrument(&tracker->song, (uint8_t)inst)) {
+            tracker->current_instrument = inst;
         }
 
-        case INST_INSTRUMENTNAME:
-        {
-            text_input_set_header_text(tracker->text_input, "Instrument name:");
-            text_input_set_result_callback(tracker->text_input, return_from_keyboard_callback, tracker, (char *)&inst->name, MUS_INST_NAME_LEN + 1, false);
-
-            view_dispatcher_switch_to_view(tracker->view_dispatcher, VIEW_KEYBOARD);
-            break;
-        }
+        break;
+    }
 
-        case INST_CURRENT_NOTE:
-        {
-            int8_t note_delta = 0;
+    case INST_INSTRUMENTNAME: {
+        text_input_set_header_text(tracker->text_input, "Instrument name:");
+        text_input_set_result_callback(
+            tracker->text_input,
+            return_from_keyboard_callback,
+            tracker,
+            (char*)&inst->name,
+            MUS_INST_NAME_LEN + 1,
+            false);
+
+        view_dispatcher_switch_to_view(tracker->view_dispatcher, VIEW_KEYBOARD);
+        break;
+    }
 
-            if (delta < 0)
-            {
-                if (tracker->current_digit)
-                {
-                    note_delta = -12;
-                }
+    case INST_CURRENT_NOTE: {
+        int8_t note_delta = 0;
 
-                else
-                {
-                    note_delta = -1;
-                }
+        if(delta < 0) {
+            if(tracker->current_digit) {
+                note_delta = -12;
             }
 
-            if (delta > 0)
-            {
-                if (tracker->current_digit)
-                {
-                    note_delta = 12;
-                }
-
-                else
-                {
-                    note_delta = 1;
-                }
+            else {
+                note_delta = -1;
             }
+        }
 
-            clamp(inst->base_note, note_delta, 0, MAX_NOTE);
+        if(delta > 0) {
+            if(tracker->current_digit) {
+                note_delta = 12;
+            }
 
-            break;
+            else {
+                note_delta = 1;
+            }
         }
 
-        case INST_FINETUNE:
-        {
-            int8_t fine_delta = 0;
+        clamp(inst->base_note, note_delta, 0, MAX_NOTE);
 
-            if (delta < 0)
-            {
-                if (tracker->current_digit)
-                {
-                    fine_delta = -1;
-                }
-
-                else
-                {
-                    fine_delta = -10;
-                }
-            }
+        break;
+    }
 
-            if (delta > 0)
-            {
-                if (tracker->current_digit)
-                {
-                    fine_delta = 1;
-                }
+    case INST_FINETUNE: {
+        int8_t fine_delta = 0;
 
-                else
-                {
-                    fine_delta = 10;
-                }
+        if(delta < 0) {
+            if(tracker->current_digit) {
+                fine_delta = -1;
             }
 
-            inst->finetune += fine_delta;
-
-            break;
+            else {
+                fine_delta = -10;
+            }
         }
 
-        case INST_SLIDESPEED:
-        {
-            if ((int16_t)inst->slide_speed + (int16_t)delta >= 0 && (int16_t)inst->slide_speed + (int16_t)delta <= 0xff)
-            {
-                inst->slide_speed += delta;
+        if(delta > 0) {
+            if(tracker->current_digit) {
+                fine_delta = 1;
             }
 
-            break;
+            else {
+                fine_delta = 10;
+            }
         }
 
-        case INST_SETPW:
-        {
-            flipbit(inst->flags, TE_SET_PW);
-            break;
-        }
+        inst->finetune += fine_delta;
 
-        case INST_PW:
-        {
-            if ((int16_t)inst->pw + (int16_t)delta >= 0 && (int16_t)inst->pw + (int16_t)delta <= 0xff)
-            {
-                inst->pw += delta;
-            }
+        break;
+    }
 
-            break;
+    case INST_SLIDESPEED: {
+        if((int16_t)inst->slide_speed + (int16_t)delta >= 0 &&
+           (int16_t)inst->slide_speed + (int16_t)delta <= 0xff) {
+            inst->slide_speed += delta;
         }
 
-        case INST_SETCUTOFF:
-        {
-            flipbit(inst->flags, TE_SET_CUTOFF);
-            break;
-        }
+        break;
+    }
 
-        case INST_WAVE_NOISE:
-        {
-            flipbit(inst->waveform, SE_WAVEFORM_NOISE);
-            break;
-        }
+    case INST_SETPW: {
+        flipbit(inst->flags, TE_SET_PW);
+        break;
+    }
 
-        case INST_WAVE_PULSE:
-        {
-            flipbit(inst->waveform, SE_WAVEFORM_PULSE);
-            break;
+    case INST_PW: {
+        if((int16_t)inst->pw + (int16_t)delta >= 0 && (int16_t)inst->pw + (int16_t)delta <= 0xff) {
+            inst->pw += delta;
         }
 
-        case INST_WAVE_TRIANGLE:
-        {
-            flipbit(inst->waveform, SE_WAVEFORM_TRIANGLE);
-            break;
-        }
+        break;
+    }
 
-        case INST_WAVE_SAWTOOTH:
-        {
-            flipbit(inst->waveform, SE_WAVEFORM_SAW);
-            break;
-        }
+    case INST_SETCUTOFF: {
+        flipbit(inst->flags, TE_SET_CUTOFF);
+        break;
+    }
 
-        case INST_WAVE_NOISE_METAL:
-        {
-            flipbit(inst->waveform, SE_WAVEFORM_NOISE_METAL);
-            break;
-        }
+    case INST_WAVE_NOISE: {
+        flipbit(inst->waveform, SE_WAVEFORM_NOISE);
+        break;
+    }
 
-        case INST_WAVE_SINE:
-        {
-            flipbit(inst->waveform, SE_WAVEFORM_SINE);
-            break;
-        }
+    case INST_WAVE_PULSE: {
+        flipbit(inst->waveform, SE_WAVEFORM_PULSE);
+        break;
+    }
 
-        case INST_ATTACK:
-        {
-            if ((int16_t)inst->adsr.a + (int16_t)delta >= 0 && (int16_t)inst->adsr.a + (int16_t)delta <= 0xff)
-            {
-                inst->adsr.a += delta;
-            }
+    case INST_WAVE_TRIANGLE: {
+        flipbit(inst->waveform, SE_WAVEFORM_TRIANGLE);
+        break;
+    }
 
-            break;
-        }
+    case INST_WAVE_SAWTOOTH: {
+        flipbit(inst->waveform, SE_WAVEFORM_SAW);
+        break;
+    }
 
-        case INST_DECAY:
-        {
-            if ((int16_t)inst->adsr.d + (int16_t)delta >= 0 && (int16_t)inst->adsr.d + (int16_t)delta <= 0xff)
-            {
-                inst->adsr.d += delta;
-            }
+    case INST_WAVE_NOISE_METAL: {
+        flipbit(inst->waveform, SE_WAVEFORM_NOISE_METAL);
+        break;
+    }
 
-            break;
+    case INST_WAVE_SINE: {
+        flipbit(inst->waveform, SE_WAVEFORM_SINE);
+        break;
+    }
+
+    case INST_ATTACK: {
+        if((int16_t)inst->adsr.a + (int16_t)delta >= 0 &&
+           (int16_t)inst->adsr.a + (int16_t)delta <= 0xff) {
+            inst->adsr.a += delta;
         }
 
-        case INST_SUSTAIN:
-        {
-            if ((int16_t)inst->adsr.s + (int16_t)delta >= 0 && (int16_t)inst->adsr.s + (int16_t)delta <= 0xff)
-            {
-                inst->adsr.s += delta;
-            }
+        break;
+    }
 
-            break;
+    case INST_DECAY: {
+        if((int16_t)inst->adsr.d + (int16_t)delta >= 0 &&
+           (int16_t)inst->adsr.d + (int16_t)delta <= 0xff) {
+            inst->adsr.d += delta;
         }
 
-        case INST_RELEASE:
-        {
-            if ((int16_t)inst->adsr.r + (int16_t)delta >= 0 && (int16_t)inst->adsr.r + (int16_t)delta <= 0xff)
-            {
-                inst->adsr.r += delta;
-            }
+        break;
+    }
 
-            break;
+    case INST_SUSTAIN: {
+        if((int16_t)inst->adsr.s + (int16_t)delta >= 0 &&
+           (int16_t)inst->adsr.s + (int16_t)delta <= 0xff) {
+            inst->adsr.s += delta;
         }
 
-        case INST_VOLUME:
-        {
-            if ((int16_t)inst->adsr.volume + (int16_t)delta >= 0 && (int16_t)inst->adsr.volume + (int16_t)delta <= 0xff)
-            {
-                inst->adsr.volume += delta;
-            }
+        break;
+    }
 
-            break;
+    case INST_RELEASE: {
+        if((int16_t)inst->adsr.r + (int16_t)delta >= 0 &&
+           (int16_t)inst->adsr.r + (int16_t)delta <= 0xff) {
+            inst->adsr.r += delta;
         }
 
-        case INST_ENABLEFILTER:
-        {
-            flipbit(inst->sound_engine_flags, SE_ENABLE_FILTER);
-            break;
+        break;
+    }
+
+    case INST_VOLUME: {
+        if((int16_t)inst->adsr.volume + (int16_t)delta >= 0 &&
+           (int16_t)inst->adsr.volume + (int16_t)delta <= 0xff) {
+            inst->adsr.volume += delta;
         }
 
-        case INST_FILTERCUTOFF:
-        {
-            if ((int16_t)inst->filter_cutoff + (int16_t)delta >= 0 && (int16_t)inst->filter_cutoff + (int16_t)delta <= 0xff)
-            {
-                inst->filter_cutoff += delta;
-            }
+        break;
+    }
 
-            break;
+    case INST_ENABLEFILTER: {
+        flipbit(inst->sound_engine_flags, SE_ENABLE_FILTER);
+        break;
+    }
+
+    case INST_FILTERCUTOFF: {
+        if((int16_t)inst->filter_cutoff + (int16_t)delta >= 0 &&
+           (int16_t)inst->filter_cutoff + (int16_t)delta <= 0xff) {
+            inst->filter_cutoff += delta;
         }
 
-        case INST_FILTERRESONANCE:
-        {
-            if ((int16_t)inst->filter_resonance + (int16_t)delta >= 0 && (int16_t)inst->filter_resonance + (int16_t)delta <= 0xff)
-            {
-                inst->filter_resonance += delta;
-            }
+        break;
+    }
 
-            break;
+    case INST_FILTERRESONANCE: {
+        if((int16_t)inst->filter_resonance + (int16_t)delta >= 0 &&
+           (int16_t)inst->filter_resonance + (int16_t)delta <= 0xff) {
+            inst->filter_resonance += delta;
         }
 
-        case INST_FILTERTYPE:
-        {
-            int8_t flt_delta = (delta > 0 ? 1 : -1);
-
-            if ((int16_t)inst->filter_type + (int16_t)flt_delta >= 0 && (int16_t)inst->filter_type + (int16_t)flt_delta < FIL_MODES)
-            {
-                inst->filter_type += flt_delta;
-            }
+        break;
+    }
 
-            break;
-        }
+    case INST_FILTERTYPE: {
+        int8_t flt_delta = (delta > 0 ? 1 : -1);
 
-        case INST_ENABLERINGMOD:
-        {
-            flipbit(inst->sound_engine_flags, SE_ENABLE_RING_MOD);
-            break;
+        if((int16_t)inst->filter_type + (int16_t)flt_delta >= 0 &&
+           (int16_t)inst->filter_type + (int16_t)flt_delta < FIL_MODES) {
+            inst->filter_type += flt_delta;
         }
 
-        case INST_RINGMODSRC:
-        {
-            if ((int16_t)inst->ring_mod + (int16_t)delta >= 0 && (int16_t)inst->ring_mod + (int16_t)delta < SONG_MAX_CHANNELS)
-            {
-                inst->ring_mod += delta;
-            }
-
-            if ((int16_t)inst->ring_mod + (int16_t)delta < 0)
-            {
-                inst->ring_mod = 0xff; // 0xff = self
-            }
+        break;
+    }
 
-            if ((int16_t)inst->ring_mod == 0xff && (int16_t)delta > 0)
-            {
-                inst->ring_mod = 0;
-            }
+    case INST_ENABLERINGMOD: {
+        flipbit(inst->sound_engine_flags, SE_ENABLE_RING_MOD);
+        break;
+    }
 
-            break;
+    case INST_RINGMODSRC: {
+        if((int16_t)inst->ring_mod + (int16_t)delta >= 0 &&
+           (int16_t)inst->ring_mod + (int16_t)delta < SONG_MAX_CHANNELS) {
+            inst->ring_mod += delta;
         }
 
-        case INST_ENABLEHARDSYNC:
-        {
-            flipbit(inst->sound_engine_flags, SE_ENABLE_HARD_SYNC);
-            break;
+        if((int16_t)inst->ring_mod + (int16_t)delta < 0) {
+            inst->ring_mod = 0xff; // 0xff = self
         }
 
-        case INST_HARDSYNCSRC:
-        {
-            if ((int16_t)inst->hard_sync + (int16_t)delta >= 0 && (int16_t)inst->hard_sync + (int16_t)delta < SONG_MAX_CHANNELS)
-            {
-                inst->hard_sync += delta;
-            }
+        if((int16_t)inst->ring_mod == 0xff && (int16_t)delta > 0) {
+            inst->ring_mod = 0;
+        }
 
-            if ((int16_t)inst->hard_sync + (int16_t)delta < 0)
-            {
-                inst->hard_sync = 0xff; // 0xff = self
-            }
+        break;
+    }
 
-            if ((int16_t)inst->hard_sync == 0xff && (int16_t)delta > 0)
-            {
-                inst->hard_sync = 0;
-            }
+    case INST_ENABLEHARDSYNC: {
+        flipbit(inst->sound_engine_flags, SE_ENABLE_HARD_SYNC);
+        break;
+    }
 
-            break;
+    case INST_HARDSYNCSRC: {
+        if((int16_t)inst->hard_sync + (int16_t)delta >= 0 &&
+           (int16_t)inst->hard_sync + (int16_t)delta < SONG_MAX_CHANNELS) {
+            inst->hard_sync += delta;
         }
 
-        case INST_RETRIGGERONSLIDE:
-        {
-            flipbit(inst->flags, TE_RETRIGGER_ON_SLIDE);
-            break;
+        if((int16_t)inst->hard_sync + (int16_t)delta < 0) {
+            inst->hard_sync = 0xff; // 0xff = self
         }
 
-        case INST_ENABLEKEYSYNC:
-        {
-            flipbit(inst->sound_engine_flags, SE_ENABLE_KEYDOWN_SYNC);
-            break;
+        if((int16_t)inst->hard_sync == 0xff && (int16_t)delta > 0) {
+            inst->hard_sync = 0;
         }
 
-        case INST_ENABLEVIBRATO:
-        {
-            flipbit(inst->flags, TE_ENABLE_VIBRATO);
-            break;
-        }
+        break;
+    }
 
-        case INST_VIBRATOSPEED:
-        {
-            if ((int16_t)inst->vibrato_speed + (int16_t)delta >= 0 && (int16_t)inst->vibrato_speed + (int16_t)delta <= 0xff)
-            {
-                inst->vibrato_speed += delta;
-            }
+    case INST_RETRIGGERONSLIDE: {
+        flipbit(inst->flags, TE_RETRIGGER_ON_SLIDE);
+        break;
+    }
 
-            break;
-        }
+    case INST_ENABLEKEYSYNC: {
+        flipbit(inst->sound_engine_flags, SE_ENABLE_KEYDOWN_SYNC);
+        break;
+    }
 
-        case INST_VIBRATODEPTH:
-        {
-            if ((int16_t)inst->vibrato_depth + (int16_t)delta >= 0 && (int16_t)inst->vibrato_depth + (int16_t)delta <= 0xff)
-            {
-                inst->vibrato_depth += delta;
-            }
+    case INST_ENABLEVIBRATO: {
+        flipbit(inst->flags, TE_ENABLE_VIBRATO);
+        break;
+    }
 
-            break;
+    case INST_VIBRATOSPEED: {
+        if((int16_t)inst->vibrato_speed + (int16_t)delta >= 0 &&
+           (int16_t)inst->vibrato_speed + (int16_t)delta <= 0xff) {
+            inst->vibrato_speed += delta;
         }
 
-        case INST_VIBRATODELAY:
-        {
-            if ((int16_t)inst->vibrato_delay + (int16_t)delta >= 0 && (int16_t)inst->vibrato_delay + (int16_t)delta <= 0xff)
-            {
-                inst->vibrato_delay += delta;
-            }
+        break;
+    }
 
-            break;
+    case INST_VIBRATODEPTH: {
+        if((int16_t)inst->vibrato_depth + (int16_t)delta >= 0 &&
+           (int16_t)inst->vibrato_depth + (int16_t)delta <= 0xff) {
+            inst->vibrato_depth += delta;
         }
 
-        case INST_ENABLEPWM:
-        {
-            flipbit(inst->flags, TE_ENABLE_PWM);
-            break;
+        break;
+    }
+
+    case INST_VIBRATODELAY: {
+        if((int16_t)inst->vibrato_delay + (int16_t)delta >= 0 &&
+           (int16_t)inst->vibrato_delay + (int16_t)delta <= 0xff) {
+            inst->vibrato_delay += delta;
         }
 
-        case INST_PWMSPEED:
-        {
-            if ((int16_t)inst->pwm_speed + (int16_t)delta >= 0 && (int16_t)inst->pwm_speed + (int16_t)delta <= 0xff)
-            {
-                inst->pwm_speed += delta;
-            }
+        break;
+    }
 
-            break;
+    case INST_ENABLEPWM: {
+        flipbit(inst->flags, TE_ENABLE_PWM);
+        break;
+    }
+
+    case INST_PWMSPEED: {
+        if((int16_t)inst->pwm_speed + (int16_t)delta >= 0 &&
+           (int16_t)inst->pwm_speed + (int16_t)delta <= 0xff) {
+            inst->pwm_speed += delta;
         }
 
-        case INST_PWMDEPTH:
-        {
-            if ((int16_t)inst->pwm_depth + (int16_t)delta >= 0 && (int16_t)inst->pwm_depth + (int16_t)delta <= 0xff)
-            {
-                inst->pwm_depth += delta;
-            }
+        break;
+    }
 
-            break;
+    case INST_PWMDEPTH: {
+        if((int16_t)inst->pwm_depth + (int16_t)delta >= 0 &&
+           (int16_t)inst->pwm_depth + (int16_t)delta <= 0xff) {
+            inst->pwm_depth += delta;
         }
 
-        case INST_PWMDELAY:
-        {
-            if ((int16_t)inst->pwm_delay + (int16_t)delta >= 0 && (int16_t)inst->pwm_delay + (int16_t)delta <= 0xff)
-            {
-                inst->pwm_delay += delta;
-            }
+        break;
+    }
 
-            break;
+    case INST_PWMDELAY: {
+        if((int16_t)inst->pwm_delay + (int16_t)delta >= 0 &&
+           (int16_t)inst->pwm_delay + (int16_t)delta <= 0xff) {
+            inst->pwm_delay += delta;
         }
 
-        case INST_PROGRESTART:
-        {
-            flipbit(inst->flags, TE_PROG_NO_RESTART);
-            break;
-        }
+        break;
+    }
 
-        case INST_PROGRAMEPERIOD:
-        {
-            if ((int16_t)inst->program_period + (int16_t)delta >= 0 && (int16_t)inst->program_period + (int16_t)delta <= 0xff)
-            {
-                inst->program_period += delta;
-            }
+    case INST_PROGRESTART: {
+        flipbit(inst->flags, TE_PROG_NO_RESTART);
+        break;
+    }
 
-            break;
+    case INST_PROGRAMEPERIOD: {
+        if((int16_t)inst->program_period + (int16_t)delta >= 0 &&
+           (int16_t)inst->program_period + (int16_t)delta <= 0xff) {
+            inst->program_period += delta;
         }
+
+        break;
+    }
     }
 }
 
-void instrument_edit_event(FlizzerTrackerApp *tracker, FlizzerTrackerEvent *event)
-{
-    if (event->input.key == InputKeyOk && event->input.type == InputTypeShort && !tracker->tracker_engine.playing)
-    {
+void instrument_edit_event(FlizzerTrackerApp* tracker, FlizzerTrackerEvent* event) {
+    if(event->input.key == InputKeyOk && event->input.type == InputTypeShort &&
+       !tracker->tracker_engine.playing) {
         tracker->editing = !(tracker->editing);
         return;
     }
 
-    if (event->input.key == InputKeyOk && event->input.type == InputTypeLong && !tracker->editing)
-    {
+    if(event->input.key == InputKeyOk && event->input.type == InputTypeLong && !tracker->editing) {
         reset_buffer(&tracker->sound_engine);
         tracker_engine_set_song(&tracker->tracker_engine, NULL);
 
-        for (int i = 1; i < SONG_MAX_CHANNELS; i++)
-        {
+        for(int i = 1; i < SONG_MAX_CHANNELS; i++) {
             tracker->tracker_engine.channel[i].channel_flags &= TEC_PLAYING;
             tracker->tracker_engine.sound_engine->channel[i].frequency = 0;
             tracker->tracker_engine.sound_engine->channel[i].waveform = 0;
         }
 
-        Instrument *inst = tracker->song.instrument[tracker->current_instrument];
-        tracker_engine_trigger_instrument_internal(&tracker->tracker_engine, 0, inst, (MIDDLE_C << 8));
+        Instrument* inst = tracker->song.instrument[tracker->current_instrument];
+        tracker_engine_trigger_instrument_internal(
+            &tracker->tracker_engine, 0, inst, (MIDDLE_C << 8));
         tracker->tracker_engine.playing = true;
         play();
         return;
     }
 
-    if (event->input.key == InputKeyOk && event->input.type == InputTypeRelease && !tracker->editing)
-    {
-        SoundEngineChannel *se_channel = &tracker->sound_engine.channel[0];
+    if(event->input.key == InputKeyOk && event->input.type == InputTypeRelease &&
+       !tracker->editing) {
+        SoundEngineChannel* se_channel = &tracker->sound_engine.channel[0];
         sound_engine_enable_gate(&tracker->sound_engine, se_channel, false);
         return;
     }
 
-    if (event->input.key == InputKeyRight && event->input.type == InputTypeShort && tracker->editing)
-    {
-        switch (tracker->selected_param)
-        {
-            default:
-            {
-                tracker->current_digit++;
-
-                if (tracker->current_digit > 1)
-                {
-                    tracker->selected_param++;
-
-                    tracker->current_digit = 0;
-
-                    if (tracker->selected_param > INST_PARAMS - 1)
-                    {
-                        tracker->selected_param = 0;
-                    }
-                }
-
-                break;
-            }
+    if(event->input.key == InputKeyRight && event->input.type == InputTypeShort &&
+       tracker->editing) {
+        switch(tracker->selected_param) {
+        default: {
+            tracker->current_digit++;
 
-            case INST_CURRENTINSTRUMENT:
-            case INST_INSTRUMENTNAME:
-            case INST_SETPW:
-            case INST_SETCUTOFF:
-            case INST_WAVE_NOISE:
-            case INST_WAVE_PULSE:
-            case INST_WAVE_TRIANGLE:
-            case INST_WAVE_SAWTOOTH:
-            case INST_WAVE_NOISE_METAL:
-            case INST_WAVE_SINE:
-            case INST_ENABLEFILTER:
-            case INST_FILTERTYPE:
-            case INST_ENABLERINGMOD:
-            case INST_RINGMODSRC:
-            case INST_ENABLEHARDSYNC:
-            case INST_HARDSYNCSRC:
-            case INST_RETRIGGERONSLIDE:
-            case INST_ENABLEKEYSYNC:
-            case INST_ENABLEVIBRATO:
-            case INST_ENABLEPWM:
-            case INST_PROGRESTART:
-            {
+            if(tracker->current_digit > 1) {
                 tracker->selected_param++;
 
-                tracker->current_digit = 1;
+                tracker->current_digit = 0;
 
-                if (tracker->selected_param > INST_PARAMS - 1)
-                {
+                if(tracker->selected_param > INST_PARAMS - 1) {
                     tracker->selected_param = 0;
                 }
-
-                break;
             }
+
+            break;
         }
-    }
 
-    if (event->input.key == InputKeyLeft && event->input.type == InputTypeShort && tracker->editing)
-    {
-        switch (tracker->selected_param)
-        {
-            default:
-            {
-                tracker->current_digit--;
+        case INST_CURRENTINSTRUMENT:
+        case INST_INSTRUMENTNAME:
+        case INST_SETPW:
+        case INST_SETCUTOFF:
+        case INST_WAVE_NOISE:
+        case INST_WAVE_PULSE:
+        case INST_WAVE_TRIANGLE:
+        case INST_WAVE_SAWTOOTH:
+        case INST_WAVE_NOISE_METAL:
+        case INST_WAVE_SINE:
+        case INST_ENABLEFILTER:
+        case INST_FILTERTYPE:
+        case INST_ENABLERINGMOD:
+        case INST_RINGMODSRC:
+        case INST_ENABLEHARDSYNC:
+        case INST_HARDSYNCSRC:
+        case INST_RETRIGGERONSLIDE:
+        case INST_ENABLEKEYSYNC:
+        case INST_ENABLEVIBRATO:
+        case INST_ENABLEPWM:
+        case INST_PROGRESTART: {
+            tracker->selected_param++;
 
-                if (tracker->current_digit > 1) // unsigned int overflow
-                {
-                    tracker->selected_param--;
+            tracker->current_digit = 1;
 
-                    tracker->current_digit = 1;
+            if(tracker->selected_param > INST_PARAMS - 1) {
+                tracker->selected_param = 0;
+            }
 
-                    if (tracker->selected_param > INST_PARAMS - 1) // unsigned int overflow
-                    {
-                        tracker->selected_param = INST_PARAMS - 1;
-                    }
-                }
+            break;
+        }
+        }
+    }
 
-                break;
-            }
+    if(event->input.key == InputKeyLeft && event->input.type == InputTypeShort &&
+       tracker->editing) {
+        switch(tracker->selected_param) {
+        default: {
+            tracker->current_digit--;
 
-            case INST_CURRENTINSTRUMENT:
-            case INST_INSTRUMENTNAME:
-            case INST_SETPW:
-            case INST_SETCUTOFF:
-            case INST_WAVE_NOISE:
-            case INST_WAVE_PULSE:
-            case INST_WAVE_TRIANGLE:
-            case INST_WAVE_SAWTOOTH:
-            case INST_WAVE_NOISE_METAL:
-            case INST_WAVE_SINE:
-            case INST_ENABLEFILTER:
-            case INST_FILTERTYPE:
-            case INST_ENABLERINGMOD:
-            case INST_RINGMODSRC:
-            case INST_ENABLEHARDSYNC:
-            case INST_HARDSYNCSRC:
-            case INST_RETRIGGERONSLIDE:
-            case INST_ENABLEKEYSYNC:
-            case INST_ENABLEVIBRATO:
-            case INST_ENABLEPWM:
-            case INST_PROGRESTART:
+            if(tracker->current_digit > 1) // unsigned int overflow
             {
                 tracker->selected_param--;
 
                 tracker->current_digit = 1;
 
-                if (tracker->selected_param > INST_PARAMS - 1) // unsigned int overflow
+                if(tracker->selected_param > INST_PARAMS - 1) // unsigned int overflow
                 {
                     tracker->selected_param = INST_PARAMS - 1;
                 }
+            }
+
+            break;
+        }
+
+        case INST_CURRENTINSTRUMENT:
+        case INST_INSTRUMENTNAME:
+        case INST_SETPW:
+        case INST_SETCUTOFF:
+        case INST_WAVE_NOISE:
+        case INST_WAVE_PULSE:
+        case INST_WAVE_TRIANGLE:
+        case INST_WAVE_SAWTOOTH:
+        case INST_WAVE_NOISE_METAL:
+        case INST_WAVE_SINE:
+        case INST_ENABLEFILTER:
+        case INST_FILTERTYPE:
+        case INST_ENABLERINGMOD:
+        case INST_RINGMODSRC:
+        case INST_ENABLEHARDSYNC:
+        case INST_HARDSYNCSRC:
+        case INST_RETRIGGERONSLIDE:
+        case INST_ENABLEKEYSYNC:
+        case INST_ENABLEVIBRATO:
+        case INST_ENABLEPWM:
+        case INST_PROGRESTART: {
+            tracker->selected_param--;
+
+            tracker->current_digit = 1;
 
-                break;
+            if(tracker->selected_param > INST_PARAMS - 1) // unsigned int overflow
+            {
+                tracker->selected_param = INST_PARAMS - 1;
             }
+
+            break;
+        }
         }
 
         return;
     }
 
-    if (event->input.key == InputKeyDown && event->input.type == InputTypeShort)
-    {
-        if (tracker->editing)
-        {
+    if(event->input.key == InputKeyDown && event->input.type == InputTypeShort) {
+        if(tracker->editing) {
             edit_instrument_param(tracker, tracker->selected_param, -1);
         }
 
         return;
     }
 
-    if (event->input.key == InputKeyUp && event->input.type == InputTypeShort)
-    {
-        if (tracker->editing)
-        {
+    if(event->input.key == InputKeyUp && event->input.type == InputTypeShort) {
+        if(tracker->editing) {
             edit_instrument_param(tracker, tracker->selected_param, 1);
         }
 
         return;
     }
 
-    if (tracker->selected_param > INST_VIBRATODELAY)
-    {
+    if(tracker->selected_param > INST_VIBRATODELAY) {
         tracker->inst_editor_shift = 6;
     }
 
-    if (tracker->selected_param > INST_PWMDELAY)
-    {
+    if(tracker->selected_param > INST_PWMDELAY) {
         tracker->inst_editor_shift = 12;
     }
 
-    if (tracker->selected_param < INST_CURRENT_NOTE)
-    {
+    if(tracker->selected_param < INST_CURRENT_NOTE) {
         tracker->inst_editor_shift = 0;
     }
 }

input/instrument.h

@@ -9,4 +9,4 @@
 #include "../tracker_engine/tracker_engine_defs.h"
 #include "../util.h"
 
-void instrument_edit_event(FlizzerTrackerApp *tracker, FlizzerTrackerEvent *event);
+void instrument_edit_event(FlizzerTrackerApp* tracker, FlizzerTrackerEvent* event);

input/instrument_program.c

@@ -1,27 +1,27 @@
 #include "instrument_program.h"
 #include "../macros.h"
 
-void instrument_program_edit_event(FlizzerTrackerApp *tracker, FlizzerTrackerEvent *event)
-{
-    if (event->input.key == InputKeyOk && event->input.type == InputTypeShort)
-    {
+void instrument_program_edit_event(FlizzerTrackerApp* tracker, FlizzerTrackerEvent* event) {
+    if(event->input.key == InputKeyOk && event->input.type == InputTypeShort) {
         tracker->editing = !(tracker->editing);
         return;
     }
 
-    if (event->input.key == InputKeyRight && event->input.type == InputTypeShort && tracker->editing)
-    {
+    if(event->input.key == InputKeyRight && event->input.type == InputTypeShort &&
+       tracker->editing) {
         tracker->current_digit = my_min(2, tracker->current_digit + 1);
         return;
     }
 
-    if (event->input.key == InputKeyOk && event->input.type == InputTypeLong && tracker->editing)
-    {
-        Instrument *inst = tracker->song.instrument[tracker->current_instrument];
+    if(event->input.key == InputKeyOk && event->input.type == InputTypeLong && tracker->editing) {
+        Instrument* inst = tracker->song.instrument[tracker->current_instrument];
 
-        if (tracker->current_program_step < INST_PROG_LEN - 1)
-        {
-            if ((inst->program[tracker->current_program_step] & 0x7fff) < TE_PROGRAM_LOOP_BEGIN && ((inst->program[tracker->current_program_step + 1] & 0x7fff) < TE_PROGRAM_LOOP_BEGIN || (inst->program[tracker->current_program_step + 1] & 0x7f00) == TE_PROGRAM_LOOP_END)) // so we can unite with loop end as in klystrack
+        if(tracker->current_program_step < INST_PROG_LEN - 1) {
+            if((inst->program[tracker->current_program_step] & 0x7fff) < TE_PROGRAM_LOOP_BEGIN &&
+               ((inst->program[tracker->current_program_step + 1] & 0x7fff) <
+                    TE_PROGRAM_LOOP_BEGIN ||
+                (inst->program[tracker->current_program_step + 1] & 0x7f00) ==
+                    TE_PROGRAM_LOOP_END)) // so we can unite with loop end as in klystrack
             {
                 inst->program[tracker->current_program_step] ^= 0x8000; // flipping unite bit
             }
@@ -30,227 +30,207 @@ void instrument_program_edit_event(FlizzerTrackerApp *tracker, FlizzerTrackerEve
         return;
     }
 
-    if (event->input.key == InputKeyLeft && event->input.type == InputTypeShort && tracker->editing)
-    {
+    if(event->input.key == InputKeyLeft && event->input.type == InputTypeShort &&
+       tracker->editing) {
         tracker->current_digit = fmax(0, (int16_t)tracker->current_digit - 1);
         return;
     }
 
-    if (event->input.key == InputKeyBack && event->input.type == InputTypeShort && tracker->editing)
-    {
-        Instrument *inst = tracker->song.instrument[tracker->current_instrument];
+    if(event->input.key == InputKeyBack && event->input.type == InputTypeShort &&
+       tracker->editing) {
+        Instrument* inst = tracker->song.instrument[tracker->current_instrument];
         inst->program[tracker->current_program_step] = TE_PROGRAM_NOP;
     }
 
-    if (event->input.key == InputKeyUp && event->input.type == InputTypeShort)
-    {
-        if (!(tracker->editing))
-        {
-            if ((int16_t)tracker->current_program_step - 1 >= 0)
-            {
+    if(event->input.key == InputKeyUp && event->input.type == InputTypeShort) {
+        if(!(tracker->editing)) {
+            if((int16_t)tracker->current_program_step - 1 >= 0) {
                 tracker->current_program_step--;
 
-                if (tracker->program_position > tracker->current_program_step)
-                {
+                if(tracker->program_position > tracker->current_program_step) {
                     tracker->program_position = tracker->current_program_step;
                 }
             }
 
-            else
-            {
+            else {
                 tracker->current_program_step = INST_PROG_LEN - 1;
 
                 tracker->program_position = INST_PROG_LEN - 1 - 7;
             }
         }
 
-        if (tracker->editing)
-        {
-            Instrument *inst = tracker->song.instrument[tracker->current_instrument];
+        if(tracker->editing) {
+            Instrument* inst = tracker->song.instrument[tracker->current_instrument];
             uint16_t opcode = inst->program[tracker->current_program_step];
 
-            switch (tracker->current_digit)
+            switch(tracker->current_digit) {
+            case 0: // MSB
             {
-                case 0: // MSB
-                {
-                    uint8_t param = ((opcode & 0x7f00) >> 8);
-
-                    if (param < 0xff)
-                    {
-                        param++;
-                    }
-
-                    if ((inst->program[tracker->current_program_step] & 0x7fff) == TE_PROGRAM_NOP)
-                    {
-                        param = 0;
-                        inst->program[tracker->current_program_step] = 0;
-                    }
-
-                    param &= 0x7f;
+                uint8_t param = ((opcode & 0x7f00) >> 8);
 
-                    inst->program[tracker->current_program_step] &= 0x80ff;
-                    inst->program[tracker->current_program_step] |= ((uint16_t)param << 8);
+                if(param < 0xff) {
+                    param++;
+                }
 
-                    break;
+                if((inst->program[tracker->current_program_step] & 0x7fff) == TE_PROGRAM_NOP) {
+                    param = 0;
+                    inst->program[tracker->current_program_step] = 0;
                 }
 
-                case 1: // upper digit of param, e.g. eXx
-                {
-                    int8_t nibble = ((opcode & 0x00f0) >> 4);
+                param &= 0x7f;
 
-                    if (nibble + 1 <= 0xf)
-                    {
-                        nibble++;
-                    }
+                inst->program[tracker->current_program_step] &= 0x80ff;
+                inst->program[tracker->current_program_step] |= ((uint16_t)param << 8);
+
+                break;
+            }
 
-                    else
-                    {
-                        nibble = 0;
-                    }
+            case 1: // upper digit of param, e.g. eXx
+            {
+                int8_t nibble = ((opcode & 0x00f0) >> 4);
 
-                    inst->program[tracker->current_program_step] &= 0xff0f;
-                    inst->program[tracker->current_program_step] |= (nibble << 4);
+                if(nibble + 1 <= 0xf) {
+                    nibble++;
+                }
 
-                    break;
+                else {
+                    nibble = 0;
                 }
 
-                case 2: // lower digit of param, e.g. exX
-                {
-                    int8_t nibble = (opcode & 0x000f);
+                inst->program[tracker->current_program_step] &= 0xff0f;
+                inst->program[tracker->current_program_step] |= (nibble << 4);
 
-                    if (nibble + 1 <= 0xf)
-                    {
-                        nibble++;
-                    }
+                break;
+            }
 
-                    else
-                    {
-                        nibble = 0;
-                    }
+            case 2: // lower digit of param, e.g. exX
+            {
+                int8_t nibble = (opcode & 0x000f);
 
-                    inst->program[tracker->current_program_step] &= 0xfff0;
-                    inst->program[tracker->current_program_step] |= nibble;
+                if(nibble + 1 <= 0xf) {
+                    nibble++;
+                }
 
-                    break;
+                else {
+                    nibble = 0;
                 }
 
-                default:
-                    break;
+                inst->program[tracker->current_program_step] &= 0xfff0;
+                inst->program[tracker->current_program_step] |= nibble;
+
+                break;
+            }
+
+            default:
+                break;
             }
         }
 
         return;
     }
 
-    if (event->input.key == InputKeyDown && event->input.type == InputTypeShort)
-    {
-        if (!(tracker->editing))
-        {
-            if (tracker->current_program_step + 1 < INST_PROG_LEN)
-            {
+    if(event->input.key == InputKeyDown && event->input.type == InputTypeShort) {
+        if(!(tracker->editing)) {
+            if(tracker->current_program_step + 1 < INST_PROG_LEN) {
                 tracker->current_program_step++;
 
-                if (tracker->program_position < tracker->current_program_step - 7)
-                {
+                if(tracker->program_position < tracker->current_program_step - 7) {
                     tracker->program_position = tracker->current_program_step - 7;
                 }
             }
 
-            else
-            {
+            else {
                 tracker->current_program_step = 0;
 
                 tracker->program_position = 0;
             }
         }
 
-        if (tracker->editing)
-        {
-            Instrument *inst = tracker->song.instrument[tracker->current_instrument];
+        if(tracker->editing) {
+            Instrument* inst = tracker->song.instrument[tracker->current_instrument];
             uint16_t opcode = inst->program[tracker->current_program_step];
 
-            switch (tracker->current_digit)
+            switch(tracker->current_digit) {
+            case 0: // MSB
             {
-                case 0: // MSB
-                {
-                    uint8_t param = ((opcode & 0x7f00) >> 8);
-
-                    if (param < (TE_PROGRAM_JUMP >> 8) && param > 0)
-                    {
-                        param--;
-
-                        inst->program[tracker->current_program_step] &= 0x80ff;
-                        inst->program[tracker->current_program_step] |= ((uint16_t)param << 8);
-                    }
-
-                    if ((inst->program[tracker->current_program_step] & 0x7f00) == TE_PROGRAM_JUMP && (inst->program[tracker->current_program_step] & 0x7fff) != TE_PROGRAM_END && (inst->program[tracker->current_program_step] & 0x7fff) != TE_PROGRAM_NOP)
-                    {
-                        inst->program[tracker->current_program_step] = TE_PROGRAM_LOOP_END | (inst->program[tracker->current_program_step] & 0x8000);
-                    }
-
-                    if ((inst->program[tracker->current_program_step] & 0x7fff) == TE_PROGRAM_END)
-                    {
-                        // param = (TE_PROGRAM_JUMP >> 8);
-                        inst->program[tracker->current_program_step] = TE_PROGRAM_JUMP | (inst->program[tracker->current_program_step] & 0x8000);
-                    }
-
-                    if ((inst->program[tracker->current_program_step] & 0x7fff) == TE_PROGRAM_NOP)
-                    {
-                        // param = (TE_PROGRAM_END >> 8);
-                        inst->program[tracker->current_program_step] = TE_PROGRAM_END | (inst->program[tracker->current_program_step] & 0x8000);
-                    }
-
-                    if ((inst->program[tracker->current_program_step] & 0x7f00) == (TE_PROGRAM_LOOP_BEGIN - 0x100))
-                    {
-                        // param = (TE_PROGRAM_END >> 8);
-                        inst->program[tracker->current_program_step] = TE_EFFECT_TRIGGER_RELEASE | (inst->program[tracker->current_program_step] & 0x8000);
-                    }
-
-                    break;
+                uint8_t param = ((opcode & 0x7f00) >> 8);
+
+                if(param < (TE_PROGRAM_JUMP >> 8) && param > 0) {
+                    param--;
+
+                    inst->program[tracker->current_program_step] &= 0x80ff;
+                    inst->program[tracker->current_program_step] |= ((uint16_t)param << 8);
+                }
+
+                if((inst->program[tracker->current_program_step] & 0x7f00) == TE_PROGRAM_JUMP &&
+                   (inst->program[tracker->current_program_step] & 0x7fff) != TE_PROGRAM_END &&
+                   (inst->program[tracker->current_program_step] & 0x7fff) != TE_PROGRAM_NOP) {
+                    inst->program[tracker->current_program_step] =
+                        TE_PROGRAM_LOOP_END |
+                        (inst->program[tracker->current_program_step] & 0x8000);
+                }
+
+                if((inst->program[tracker->current_program_step] & 0x7fff) == TE_PROGRAM_END) {
+                    // param = (TE_PROGRAM_JUMP >> 8);
+                    inst->program[tracker->current_program_step] =
+                        TE_PROGRAM_JUMP | (inst->program[tracker->current_program_step] & 0x8000);
+                }
+
+                if((inst->program[tracker->current_program_step] & 0x7fff) == TE_PROGRAM_NOP) {
+                    // param = (TE_PROGRAM_END >> 8);
+                    inst->program[tracker->current_program_step] =
+                        TE_PROGRAM_END | (inst->program[tracker->current_program_step] & 0x8000);
                 }
 
-                case 1: // upper digit of param, e.g. eXx
-                {
-                    int8_t nibble = ((opcode & 0x00f0) >> 4);
+                if((inst->program[tracker->current_program_step] & 0x7f00) ==
+                   (TE_PROGRAM_LOOP_BEGIN - 0x100)) {
+                    // param = (TE_PROGRAM_END >> 8);
+                    inst->program[tracker->current_program_step] =
+                        TE_EFFECT_TRIGGER_RELEASE |
+                        (inst->program[tracker->current_program_step] & 0x8000);
+                }
 
-                    if (nibble - 1 >= 0)
-                    {
-                        nibble--;
-                    }
+                break;
+            }
 
-                    else
-                    {
-                        nibble = 0xf;
-                    }
+            case 1: // upper digit of param, e.g. eXx
+            {
+                int8_t nibble = ((opcode & 0x00f0) >> 4);
 
-                    inst->program[tracker->current_program_step] &= 0xff0f;
-                    inst->program[tracker->current_program_step] |= (nibble << 4);
+                if(nibble - 1 >= 0) {
+                    nibble--;
+                }
 
-                    break;
+                else {
+                    nibble = 0xf;
                 }
 
-                case 2: // lower digit of param, e.g. exX
-                {
-                    int8_t nibble = (opcode & 0x000f);
+                inst->program[tracker->current_program_step] &= 0xff0f;
+                inst->program[tracker->current_program_step] |= (nibble << 4);
 
-                    if (nibble - 1 >= 0)
-                    {
-                        nibble--;
-                    }
+                break;
+            }
 
-                    else
-                    {
-                        nibble = 0xf;
-                    }
+            case 2: // lower digit of param, e.g. exX
+            {
+                int8_t nibble = (opcode & 0x000f);
 
-                    inst->program[tracker->current_program_step] &= 0xfff0;
-                    inst->program[tracker->current_program_step] |= nibble;
+                if(nibble - 1 >= 0) {
+                    nibble--;
+                }
 
-                    break;
+                else {
+                    nibble = 0xf;
                 }
 
-                default:
-                    break;
+                inst->program[tracker->current_program_step] &= 0xfff0;
+                inst->program[tracker->current_program_step] |= nibble;
+
+                break;
+            }
+
+            default:
+                break;
             }
         }
 

input/instrument_program.h

@@ -9,4 +9,4 @@
 #include "../tracker_engine/tracker_engine_defs.h"
 #include "../util.h"
 
-void instrument_program_edit_event(FlizzerTrackerApp *tracker, FlizzerTrackerEvent *event);
+void instrument_program_edit_event(FlizzerTrackerApp* tracker, FlizzerTrackerEvent* event);

input/pattern.c

@@ -1,48 +1,42 @@
 #include "pattern.h"
 
-uint8_t get_field(uint8_t patternx)
-{
+uint8_t get_field(uint8_t patternx) {
     uint8_t field = 0;
 
-    if (patternx <= 1)
-        field = 0;
-    if (patternx == 2)
-        field = 1;
-    if (patternx == 3)
-        field = 2;
-    if (patternx > 3)
-        field = 3;
+    if(patternx <= 1) field = 0;
+    if(patternx == 2) field = 1;
+    if(patternx == 3) field = 2;
+    if(patternx > 3) field = 3;
 
     return field;
 }
 
-void edit_note(FlizzerTrackerApp *tracker, TrackerSongPatternStep *step, int8_t delta) // here we need data about last note if we place a new note
+void edit_note(
+    FlizzerTrackerApp* tracker,
+    TrackerSongPatternStep* step,
+    int8_t delta) // here we need data about last note if we place a new note
 {
     int16_t note = tracker_engine_get_note(step);
 
-    if (note == MUS_NOTE_RELEASE)
-    {
-        if (delta < 0)
-        {
+    if(note == MUS_NOTE_RELEASE) {
+        if(delta < 0) {
             set_note(step, MUS_NOTE_CUT);
         }
 
         return;
     }
 
-    if (note == MUS_NOTE_CUT)
-    {
-        if (delta > 0)
-        {
+    if(note == MUS_NOTE_CUT) {
+        if(delta > 0) {
             set_note(step, MUS_NOTE_RELEASE);
         }
 
         return;
     }
 
-    if (note == MUS_NOTE_NONE)
-    {
-        note = tracker->current_note; // remember which note we entered earlier and use it as reference
+    if(note == MUS_NOTE_NONE) {
+        note =
+            tracker->current_note; // remember which note we entered earlier and use it as reference
     }
 
     clamp(note, delta, 0, MAX_NOTE);
@@ -53,19 +47,15 @@ void edit_note(FlizzerTrackerApp *tracker, TrackerSongPatternStep *step, int8_t
     tracker->current_note = (uint8_t)note;
 }
 
-void edit_instrument(FlizzerTrackerApp *tracker, TrackerSongPatternStep *step, int8_t delta)
-{
+void edit_instrument(FlizzerTrackerApp* tracker, TrackerSongPatternStep* step, int8_t delta) {
     int16_t inst = tracker_engine_get_instrument(step);
 
-    if (inst == MUS_NOTE_INSTRUMENT_NONE)
-    {
-        if (delta > 0)
-        {
+    if(inst == MUS_NOTE_INSTRUMENT_NONE) {
+        if(delta > 0) {
             inst = tracker->current_instrument;
         }
 
-        else
-        {
+        else {
             inst = MUS_NOTE_INSTRUMENT_NONE - 1;
         }
     }
@@ -75,19 +65,16 @@ void edit_instrument(FlizzerTrackerApp *tracker, TrackerSongPatternStep *step, i
     set_instrument(step, (uint8_t)inst);
 }
 
-void edit_volume(FlizzerTrackerApp *tracker, TrackerSongPatternStep *step, int8_t delta)
-{
+void edit_volume(FlizzerTrackerApp* tracker, TrackerSongPatternStep* step, int8_t delta) {
     int16_t vol = tracker_engine_get_volume(step);
 
     vol = tracker->current_volume;
 
-    if (vol + delta < 0)
-    {
+    if(vol + delta < 0) {
         vol = MUS_NOTE_VOLUME_NONE - 1 - delta;
     }
 
-    if (vol + delta >= MUS_NOTE_VOLUME_NONE)
-    {
+    if(vol + delta >= MUS_NOTE_VOLUME_NONE) {
         vol = 0 - delta;
     }
 
@@ -98,345 +85,319 @@ void edit_volume(FlizzerTrackerApp *tracker, TrackerSongPatternStep *step, int8_
     tracker->current_volume = vol;
 }
 
-void edit_command(TrackerSongPatternStep *step, uint8_t digit, int8_t delta)
-{
+void edit_command(TrackerSongPatternStep* step, uint8_t digit, int8_t delta) {
     int32_t command = tracker_engine_get_command(step);
 
-    switch (digit)
+    switch(digit) {
+    case 0: // upper 7 bits
     {
-        case 0: // upper 7 bits
-        {
-            int16_t fx_name = ((command & 0x7f00) >> 8);
+        int16_t fx_name = ((command & 0x7f00) >> 8);
 
-            if (fx_name + delta > 35) // loop
-            {                         // 0-9 and then A-Z
-                fx_name = 0;
-            }
+        if(fx_name + delta > 35) // loop
+        { // 0-9 and then A-Z
+            fx_name = 0;
+        }
 
-            else if (fx_name + delta < 0)
-            {
-                fx_name = 35;
-            }
+        else if(fx_name + delta < 0) {
+            fx_name = 35;
+        }
 
-            else
-            {
-                fx_name += delta;
-            }
+        else {
+            fx_name += delta;
+        }
 
-            command &= 0x00ff;
+        command &= 0x00ff;
 
-            command |= (fx_name << 8);
+        command |= (fx_name << 8);
 
-            set_command(step, (uint16_t)command);
+        set_command(step, (uint16_t)command);
 
-            break;
-        }
+        break;
+    }
+
+    case 1: // upper digit of command param
+    {
+        int8_t upper_digit = ((command & 0x00f0) >> 4);
 
-        case 1: // upper digit of command param
+        if(upper_digit + delta > 0xf) // loop
         {
-            int8_t upper_digit = ((command & 0x00f0) >> 4);
+            upper_digit = 0;
+        }
 
-            if (upper_digit + delta > 0xf) // loop
-            {
-                upper_digit = 0;
-            }
+        else if(upper_digit + delta < 0) {
+            upper_digit = 0xf;
+        }
 
-            else if (upper_digit + delta < 0)
-            {
-                upper_digit = 0xf;
-            }
+        else {
+            upper_digit += delta;
+        }
 
-            else
-            {
-                upper_digit += delta;
-            }
+        command &= 0xff0f;
 
-            command &= 0xff0f;
+        command |= (upper_digit << 4);
 
-            command |= (upper_digit << 4);
+        set_command(step, (uint16_t)command);
 
-            set_command(step, (uint16_t)command);
+        break;
+    }
 
-            break;
-        }
+    case 2: // lower digit of command param
+    {
+        int8_t lower_digit = (command & 0x000f);
 
-        case 2: // lower digit of command param
+        if(lower_digit + delta > 0xf) // loop
         {
-            int8_t lower_digit = (command & 0x000f);
-
-            if (lower_digit + delta > 0xf) // loop
-            {
-                lower_digit = 0;
-            }
+            lower_digit = 0;
+        }
 
-            else if (lower_digit + delta < 0)
-            {
-                lower_digit = 0xf;
-            }
+        else if(lower_digit + delta < 0) {
+            lower_digit = 0xf;
+        }
 
-            else
-            {
-                lower_digit += delta;
-            }
+        else {
+            lower_digit += delta;
+        }
 
-            command &= 0xfff0;
+        command &= 0xfff0;
 
-            command |= lower_digit;
+        command |= lower_digit;
 
-            set_command(step, (uint16_t)command);
+        set_command(step, (uint16_t)command);
 
-            break;
-        }
+        break;
+    }
 
-        default:
-            break;
+    default:
+        break;
     }
 }
 
-void delete_field(TrackerSongPatternStep *step, uint8_t field)
-{
-    switch (field)
+void delete_field(TrackerSongPatternStep* step, uint8_t field) {
+    switch(field) {
+    case 0: // note
     {
-        case 0: // note
-        {
-            set_note(step, MUS_NOTE_NONE);
-            set_instrument(step, MUS_NOTE_INSTRUMENT_NONE); // also delete instrument
-            break;
-        }
+        set_note(step, MUS_NOTE_NONE);
+        set_instrument(step, MUS_NOTE_INSTRUMENT_NONE); // also delete instrument
+        break;
+    }
 
-        case 1: // instrument
-        {
-            set_instrument(step, MUS_NOTE_INSTRUMENT_NONE);
-            break;
-        }
+    case 1: // instrument
+    {
+        set_instrument(step, MUS_NOTE_INSTRUMENT_NONE);
+        break;
+    }
 
-        case 2: // volume
-        {
-            set_volume(step, MUS_NOTE_VOLUME_NONE);
-            break;
-        }
+    case 2: // volume
+    {
+        set_volume(step, MUS_NOTE_VOLUME_NONE);
+        break;
+    }
 
-        case 3: // command
-        {
-            set_command(step, 0);
-            break;
-        }
+    case 3: // command
+    {
+        set_command(step, 0);
+        break;
+    }
 
-        default:
-            break;
+    default:
+        break;
     }
 }
 
-void edit_pattern_step(FlizzerTrackerApp *tracker, TrackerSongPatternStep *step, int8_t delta)
-{
-    switch (get_field(tracker->patternx))
+void edit_pattern_step(FlizzerTrackerApp* tracker, TrackerSongPatternStep* step, int8_t delta) {
+    switch(get_field(tracker->patternx)) {
+    case 0: // note
     {
-        case 0: // note
+        if(tracker->patternx) // editing octave
         {
-            if (tracker->patternx) // editing octave
-            {
-                edit_note(tracker, step, 12 * delta);
-            }
-
-            else // editing note
-            {
-                edit_note(tracker, step, delta);
-            }
-
-            break;
+            edit_note(tracker, step, 12 * delta);
         }
 
-        case 1: // instrument
+        else // editing note
         {
-            edit_instrument(tracker, step, delta);
-            break;
+            edit_note(tracker, step, delta);
         }
 
-        case 2: // volume
-        {
-            edit_volume(tracker, step, delta);
-            break;
-        }
+        break;
+    }
 
-        case 3: // command
-        {
-            uint8_t digit = 0;
-            if (tracker->patternx == 4)
-                digit = 0;
-            if (tracker->patternx == 5)
-                digit = 1;
-            if (tracker->patternx == 6)
-                digit = 2;
-            edit_command(step, digit, delta);
-            break;
-        }
+    case 1: // instrument
+    {
+        edit_instrument(tracker, step, delta);
+        break;
+    }
 
-        default:
-            break;
+    case 2: // volume
+    {
+        edit_volume(tracker, step, delta);
+        break;
     }
-}
 
-void pattern_edit_event(FlizzerTrackerApp *tracker, FlizzerTrackerEvent *event)
-{
-    if (event->input.key == InputKeyDown && event->input.type == InputTypeLong && !(tracker->editing))
+    case 3: // command
     {
-        flipbit(tracker->tracker_engine.channel[tracker->current_channel].channel_flags, TEC_DISABLED);
+        uint8_t digit = 0;
+        if(tracker->patternx == 4) digit = 0;
+        if(tracker->patternx == 5) digit = 1;
+        if(tracker->patternx == 6) digit = 2;
+        edit_command(step, digit, delta);
+        break;
+    }
+
+    default:
+        break;
+    }
+}
+
+void pattern_edit_event(FlizzerTrackerApp* tracker, FlizzerTrackerEvent* event) {
+    if(event->input.key == InputKeyDown && event->input.type == InputTypeLong &&
+       !(tracker->editing)) {
+        flipbit(
+            tracker->tracker_engine.channel[tracker->current_channel].channel_flags, TEC_DISABLED);
         return;
     }
 
-    if (event->input.key == InputKeyUp && event->input.type == InputTypeLong && !(tracker->editing))
-    {
+    if(event->input.key == InputKeyUp && event->input.type == InputTypeLong &&
+       !(tracker->editing)) {
         tracker->tracker_engine.pattern_position = 0; // return to pattern 1st row
         return;
     }
 
     uint8_t sequence_position = tracker->tracker_engine.sequence_position;
-    uint8_t current_pattern = tracker->tracker_engine.song->sequence.sequence_step[sequence_position].pattern_indices[tracker->current_channel];
+    uint8_t current_pattern =
+        tracker->tracker_engine.song->sequence.sequence_step[sequence_position]
+            .pattern_indices[tracker->current_channel];
     uint16_t pattern_step = tracker->tracker_engine.pattern_position;
 
     uint16_t pattern_length = tracker->tracker_engine.song->pattern_length;
 
-    TrackerSongPattern *pattern = &tracker->tracker_engine.song->pattern[current_pattern];
+    TrackerSongPattern* pattern = &tracker->tracker_engine.song->pattern[current_pattern];
 
-    TrackerSongPatternStep *step = NULL;
+    TrackerSongPatternStep* step = NULL;
 
-    if (pattern_step < pattern_length)
-    {
+    if(pattern_step < pattern_length) {
         step = &pattern->step[pattern_step];
     }
 
-    if (!(step))
-        return;
+    if(!(step)) return;
 
-    if (event->input.key == InputKeyOk && event->input.type == InputTypeShort && !tracker->tracker_engine.playing)
-    {
+    if(event->input.key == InputKeyOk && event->input.type == InputTypeShort &&
+       !tracker->tracker_engine.playing) {
         tracker->editing = !tracker->editing;
 
-        if (tracker->editing)
-        {
+        if(tracker->editing) {
             // stop_song(tracker);
         }
     }
 
-    if (event->input.key == InputKeyOk && event->input.type == InputTypeLong)
-    {
-        if (!(tracker->editing))
-        {
-            if (tracker->tracker_engine.playing)
-            {
+    if(event->input.key == InputKeyOk && event->input.type == InputTypeLong) {
+        if(!(tracker->editing)) {
+            if(tracker->tracker_engine.playing) {
                 stop_song(tracker);
             }
 
-            else
-            {
-                if (tracker->tracker_engine.pattern_position == tracker->song.pattern_length - 1 && tracker->tracker_engine.sequence_position == tracker->song.num_sequence_steps - 1) // if we are at the very end of the song
+            else {
+                if(tracker->tracker_engine.pattern_position == tracker->song.pattern_length - 1 &&
+                   tracker->tracker_engine.sequence_position ==
+                       tracker->song.num_sequence_steps -
+                           1) // if we are at the very end of the song
                 {
                     stop_song(tracker);
                 }
 
-                else
-                {
+                else {
                     play_song(tracker, true);
                 }
             }
         }
 
-        else
-        {
-            if (get_field(tracker->patternx) == 0)
-            {
+        else {
+            if(get_field(tracker->patternx) == 0) {
                 set_note(step, MUS_NOTE_RELEASE);
             }
         }
     }
 
-    if (event->input.key == InputKeyRight && event->input.type == InputTypeShort && tracker->editing)
-    {
+    if(event->input.key == InputKeyRight && event->input.type == InputTypeShort &&
+       tracker->editing) {
         tracker->patternx++;
 
-        if (tracker->patternx > MAX_PATTERNX - 1)
-        {
+        if(tracker->patternx > MAX_PATTERNX - 1) {
             tracker->current_channel++;
 
             tracker->patternx = 0;
 
-            if (tracker->current_channel > SONG_MAX_CHANNELS - 1)
-            {
+            if(tracker->current_channel > SONG_MAX_CHANNELS - 1) {
                 tracker->current_channel = 0;
             }
         }
     }
 
-    if (event->input.key == InputKeyLeft && event->input.type == InputTypeShort && tracker->editing)
-    {
+    if(event->input.key == InputKeyLeft && event->input.type == InputTypeShort &&
+       tracker->editing) {
         tracker->patternx--;
 
-        if (tracker->patternx > MAX_PATTERNX - 1) // unsigned int overflow
+        if(tracker->patternx > MAX_PATTERNX - 1) // unsigned int overflow
         {
             tracker->current_channel--;
 
             tracker->patternx = MAX_PATTERNX - 1;
 
-            if (tracker->current_channel > SONG_MAX_CHANNELS - 1) // unsigned int overflow
+            if(tracker->current_channel > SONG_MAX_CHANNELS - 1) // unsigned int overflow
             {
                 tracker->current_channel = SONG_MAX_CHANNELS - 1;
             }
         }
     }
 
-    if (event->input.key == InputKeyDown && event->input.type == InputTypeShort)
-    {
-        if (!(tracker->editing))
-        {
+    if(event->input.key == InputKeyDown && event->input.type == InputTypeShort) {
+        if(!(tracker->editing)) {
             tracker->tracker_engine.pattern_position++;
 
-            if (tracker->tracker_engine.pattern_position > tracker->tracker_engine.song->pattern_length - 1 && tracker->tracker_engine.sequence_position < tracker->tracker_engine.song->num_sequence_steps - 1)
-            {
+            if(tracker->tracker_engine.pattern_position >
+                   tracker->tracker_engine.song->pattern_length - 1 &&
+               tracker->tracker_engine.sequence_position <
+                   tracker->tracker_engine.song->num_sequence_steps - 1) {
                 tracker->tracker_engine.pattern_position = 0;
                 tracker->tracker_engine.sequence_position++;
             }
 
-            else if (tracker->tracker_engine.pattern_position > tracker->tracker_engine.song->pattern_length - 1)
-            {
-                tracker->tracker_engine.pattern_position = tracker->tracker_engine.song->pattern_length - 1;
+            else if(
+                tracker->tracker_engine.pattern_position >
+                tracker->tracker_engine.song->pattern_length - 1) {
+                tracker->tracker_engine.pattern_position =
+                    tracker->tracker_engine.song->pattern_length - 1;
             }
         }
 
-        if (tracker->editing)
-        {
+        if(tracker->editing) {
             edit_pattern_step(tracker, step, -1);
         }
     }
 
-    if (event->input.key == InputKeyUp && event->input.type == InputTypeShort)
-    {
-        if (!(tracker->editing))
-        {
+    if(event->input.key == InputKeyUp && event->input.type == InputTypeShort) {
+        if(!(tracker->editing)) {
             int16_t temp_pattern_position = tracker->tracker_engine.pattern_position - 1;
 
-            if (temp_pattern_position < 0)
-            {
-                if (tracker->tracker_engine.sequence_position > 0)
-                {
+            if(temp_pattern_position < 0) {
+                if(tracker->tracker_engine.sequence_position > 0) {
                     tracker->tracker_engine.sequence_position--;
-                    tracker->tracker_engine.pattern_position = tracker->tracker_engine.song->pattern_length - 1;
+                    tracker->tracker_engine.pattern_position =
+                        tracker->tracker_engine.song->pattern_length - 1;
                 }
             }
 
-            else
-            {
+            else {
                 tracker->tracker_engine.pattern_position--;
             }
         }
 
-        if (tracker->editing)
-        {
+        if(tracker->editing) {
             edit_pattern_step(tracker, step, 1);
         }
     }
 
-    if (event->input.key == InputKeyBack && event->input.type == InputTypeShort && tracker->editing)
-    {
+    if(event->input.key == InputKeyBack && event->input.type == InputTypeShort &&
+       tracker->editing) {
         uint8_t field = get_field(tracker->patternx);
 
         delete_field(step, field);

input/pattern.h

@@ -11,4 +11,4 @@
 
 #define MAX_PATTERNX (2 + 1 + 1 + 3)
 
-void pattern_edit_event(FlizzerTrackerApp *tracker, FlizzerTrackerEvent *event);
+void pattern_edit_event(FlizzerTrackerApp* tracker, FlizzerTrackerEvent* event);

input/sequence.c

@@ -1,195 +1,177 @@
 #include "sequence.h"
 
-void delete_sequence_step(FlizzerTrackerApp *tracker)
-{
+void delete_sequence_step(FlizzerTrackerApp* tracker) {
     uint8_t sequence_position = tracker->tracker_engine.sequence_position;
-    uint8_t *pattern = &tracker->tracker_engine.song->sequence.sequence_step[sequence_position].pattern_indices[tracker->current_channel];
+    uint8_t* pattern = &tracker->tracker_engine.song->sequence.sequence_step[sequence_position]
+                            .pattern_indices[tracker->current_channel];
     *pattern = 0;
 }
 
-void edit_sequence_step(FlizzerTrackerApp *tracker, int8_t delta)
-{
+void edit_sequence_step(FlizzerTrackerApp* tracker, int8_t delta) {
     uint8_t digit = tracker->current_digit;
 
     uint8_t sequence_position = tracker->tracker_engine.sequence_position;
-    uint8_t pattern_index = tracker->tracker_engine.song->sequence.sequence_step[sequence_position].pattern_indices[tracker->current_channel];
+    uint8_t pattern_index = tracker->tracker_engine.song->sequence.sequence_step[sequence_position]
+                                .pattern_indices[tracker->current_channel];
 
-    uint8_t *pattern = &tracker->tracker_engine.song->sequence.sequence_step[sequence_position].pattern_indices[tracker->current_channel];
+    uint8_t* pattern = &tracker->tracker_engine.song->sequence.sequence_step[sequence_position]
+                            .pattern_indices[tracker->current_channel];
     uint8_t temp_pattern = *pattern;
 
-    switch (digit)
+    switch(digit) {
+    case 0: // upper nibble
     {
-        case 0: // upper nibble
-        {
-            int8_t nibble = ((pattern_index & 0xf0) >> 4);
-
-            if (nibble + delta < 0)
-            {
-                nibble = 0xf;
-            }
+        int8_t nibble = ((pattern_index & 0xf0) >> 4);
 
-            else if (nibble + delta > 0xf)
-            {
-                nibble = 0;
-            }
-
-            else
-            {
-                nibble += delta;
-            }
+        if(nibble + delta < 0) {
+            nibble = 0xf;
+        }
 
-            temp_pattern &= 0x0f;
-            temp_pattern |= (nibble << 4);
+        else if(nibble + delta > 0xf) {
+            nibble = 0;
+        }
 
-            break;
+        else {
+            nibble += delta;
         }
 
-        case 1: // lower nibble
-        {
-            int8_t nibble = (pattern_index & 0x0f);
+        temp_pattern &= 0x0f;
+        temp_pattern |= (nibble << 4);
 
-            if (nibble + delta < 0)
-            {
-                nibble = 0xf;
-            }
+        break;
+    }
 
-            else if (nibble + delta > 0xf)
-            {
-                nibble = 0;
-            }
+    case 1: // lower nibble
+    {
+        int8_t nibble = (pattern_index & 0x0f);
 
-            else
-            {
-                nibble += delta;
-            }
+        if(nibble + delta < 0) {
+            nibble = 0xf;
+        }
 
-            temp_pattern &= 0xf0;
-            temp_pattern |= nibble;
+        else if(nibble + delta > 0xf) {
+            nibble = 0;
+        }
 
-            break;
+        else {
+            nibble += delta;
         }
+
+        temp_pattern &= 0xf0;
+        temp_pattern |= nibble;
+
+        break;
+    }
     }
 
-    if (check_and_allocate_pattern(&tracker->song, temp_pattern))
-    {
+    if(check_and_allocate_pattern(&tracker->song, temp_pattern)) {
         *pattern = temp_pattern;
     }
 }
 
-void sequence_edit_event(FlizzerTrackerApp *tracker, FlizzerTrackerEvent *event)
-{
-    if (event->input.key == InputKeyOk && event->input.type == InputTypeShort && !tracker->tracker_engine.playing)
-    {
+void sequence_edit_event(FlizzerTrackerApp* tracker, FlizzerTrackerEvent* event) {
+    if(event->input.key == InputKeyOk && event->input.type == InputTypeShort &&
+       !tracker->tracker_engine.playing) {
         tracker->editing = !tracker->editing;
     }
 
-    if (event->input.key == InputKeyRight && event->input.type == InputTypeShort && tracker->editing)
-    {
+    if(event->input.key == InputKeyRight && event->input.type == InputTypeShort &&
+       tracker->editing) {
         tracker->current_digit++;
 
-        if (tracker->current_digit > 1)
-        {
+        if(tracker->current_digit > 1) {
             tracker->current_channel++;
 
             tracker->current_digit = 0;
 
-            if (tracker->current_channel > SONG_MAX_CHANNELS - 1)
-            {
+            if(tracker->current_channel > SONG_MAX_CHANNELS - 1) {
                 tracker->current_channel = 0;
             }
         }
     }
 
-    if (event->input.key == InputKeyLeft && event->input.type == InputTypeShort && tracker->editing)
-    {
+    if(event->input.key == InputKeyLeft && event->input.type == InputTypeShort &&
+       tracker->editing) {
         tracker->current_digit--;
 
-        if (tracker->current_digit > 1) // unsigned int overflow
+        if(tracker->current_digit > 1) // unsigned int overflow
         {
             tracker->current_channel--;
 
             tracker->current_digit = 1;
 
-            if (tracker->current_channel > SONG_MAX_CHANNELS - 1) // unsigned int overflow
+            if(tracker->current_channel > SONG_MAX_CHANNELS - 1) // unsigned int overflow
             {
                 tracker->current_channel = SONG_MAX_CHANNELS - 1;
             }
         }
     }
 
-    if (event->input.key == InputKeyDown && event->input.type == InputTypeShort)
-    {
-        if (!(tracker->editing))
-        {
+    if(event->input.key == InputKeyDown && event->input.type == InputTypeShort) {
+        if(!(tracker->editing)) {
             tracker->tracker_engine.sequence_position++;
 
-            if (tracker->tracker_engine.sequence_position >= tracker->tracker_engine.song->num_sequence_steps)
-            {
+            if(tracker->tracker_engine.sequence_position >=
+               tracker->tracker_engine.song->num_sequence_steps) {
                 tracker->tracker_engine.sequence_position = 0;
             }
         }
 
-        if (tracker->editing)
-        {
+        if(tracker->editing) {
             edit_sequence_step(tracker, -1);
         }
     }
 
-    if (event->input.key == InputKeyUp && event->input.type == InputTypeShort)
-    {
-        if (!(tracker->editing))
-        {
+    if(event->input.key == InputKeyUp && event->input.type == InputTypeShort) {
+        if(!(tracker->editing)) {
             int16_t temp_sequence_position = tracker->tracker_engine.sequence_position - 1;
 
-            if (temp_sequence_position < 0)
-            {
-                tracker->tracker_engine.sequence_position = tracker->tracker_engine.song->num_sequence_steps - 1;
+            if(temp_sequence_position < 0) {
+                tracker->tracker_engine.sequence_position =
+                    tracker->tracker_engine.song->num_sequence_steps - 1;
             }
 
-            else
-            {
+            else {
                 tracker->tracker_engine.sequence_position--;
             }
         }
 
-        if (tracker->editing)
-        {
+        if(tracker->editing) {
             edit_sequence_step(tracker, 1);
         }
     }
 
-    if (event->input.key == InputKeyUp && event->input.type == InputTypeLong && !(tracker->editing)) // set loop begin or loop end for the song
+    if(event->input.key == InputKeyUp && event->input.type == InputTypeLong &&
+       !(tracker->editing)) // set loop begin or loop end for the song
     {
-        TrackerSong *song = &tracker->song;
+        TrackerSong* song = &tracker->song;
 
-        if (song->loop_start == song->loop_end && song->loop_end == 0) // if both are 0
+        if(song->loop_start == song->loop_end && song->loop_end == 0) // if both are 0
         {
             song->loop_end = tracker->tracker_engine.sequence_position;
         }
 
-        else
-        {
-            if (tracker->tracker_engine.sequence_position < song->loop_end)
-            {
+        else {
+            if(tracker->tracker_engine.sequence_position < song->loop_end) {
                 song->loop_start = tracker->tracker_engine.sequence_position;
             }
 
-            if (tracker->tracker_engine.sequence_position > song->loop_start)
-            {
+            if(tracker->tracker_engine.sequence_position > song->loop_start) {
                 song->loop_end = tracker->tracker_engine.sequence_position;
             }
         }
     }
 
-    if (event->input.key == InputKeyDown && event->input.type == InputTypeLong && !(tracker->editing)) // erase loop begin and loop end points
+    if(event->input.key == InputKeyDown && event->input.type == InputTypeLong &&
+       !(tracker->editing)) // erase loop begin and loop end points
     {
-        TrackerSong *song = &tracker->song;
+        TrackerSong* song = &tracker->song;
 
         song->loop_start = song->loop_end = 0;
     }
 
-    if (event->input.key == InputKeyBack && event->input.type == InputTypeShort && tracker->editing)
-    {
+    if(event->input.key == InputKeyBack && event->input.type == InputTypeShort &&
+       tracker->editing) {
         delete_sequence_step(tracker);
     }
 }

input/sequence.h

@@ -9,4 +9,4 @@
 #include "../tracker_engine/tracker_engine_defs.h"
 #include "../util.h"
 
-void sequence_edit_event(FlizzerTrackerApp *tracker, FlizzerTrackerEvent *event);
+void sequence_edit_event(FlizzerTrackerApp* tracker, FlizzerTrackerEvent* event);

input/songinfo.c

@@ -2,217 +2,202 @@
 
 #include "../diskop.h"
 
-void edit_songinfo_param(FlizzerTrackerApp *tracker, uint8_t selected_param, int8_t delta)
-{
-    if (!(tracker->current_digit))
-    {
+void edit_songinfo_param(FlizzerTrackerApp* tracker, uint8_t selected_param, int8_t delta) {
+    if(!(tracker->current_digit)) {
         delta *= 16;
     }
 
-    switch (selected_param)
-    {
-        case SI_PATTERNPOS:
-        {
-            uint16_t new_length = tracker->song.pattern_length;
+    switch(selected_param) {
+    case SI_PATTERNPOS: {
+        uint16_t new_length = tracker->song.pattern_length;
 
-            if ((int16_t)new_length + (int16_t)delta > 0 && (int16_t)new_length + (int16_t)delta <= 0x100)
-            {
-                new_length += delta;
-                change_pattern_length(&tracker->song, new_length);
+        if((int16_t)new_length + (int16_t)delta > 0 &&
+           (int16_t)new_length + (int16_t)delta <= 0x100) {
+            new_length += delta;
+            change_pattern_length(&tracker->song, new_length);
 
-                if (tracker->tracker_engine.pattern_position >= new_length)
-                {
-                    tracker->tracker_engine.pattern_position = new_length - 1;
-                }
+            if(tracker->tracker_engine.pattern_position >= new_length) {
+                tracker->tracker_engine.pattern_position = new_length - 1;
             }
-
-            break;
         }
 
-        case SI_SEQUENCEPOS:
-        {
-            if ((int16_t)tracker->song.num_sequence_steps + (int16_t)delta > 0 && (int16_t)tracker->song.num_sequence_steps + (int16_t)delta <= 0x100)
-            {
-                tracker->song.num_sequence_steps += delta;
-
-                if (tracker->tracker_engine.sequence_position >= tracker->song.num_sequence_steps)
-                {
-                    tracker->tracker_engine.sequence_position = tracker->song.num_sequence_steps - 1;
-                }
-            }
+        break;
+    }
 
-            break;
-        }
+    case SI_SEQUENCEPOS: {
+        if((int16_t)tracker->song.num_sequence_steps + (int16_t)delta > 0 &&
+           (int16_t)tracker->song.num_sequence_steps + (int16_t)delta <= 0x100) {
+            tracker->song.num_sequence_steps += delta;
 
-        case SI_SONGSPEED:
-        {
-            if ((int16_t)tracker->song.speed + (int16_t)delta > 1 && (int16_t)tracker->song.speed + (int16_t)delta <= 0xff)
-            {
-                tracker->song.speed += delta;
+            if(tracker->tracker_engine.sequence_position >= tracker->song.num_sequence_steps) {
+                tracker->tracker_engine.sequence_position = tracker->song.num_sequence_steps - 1;
             }
-
-            break;
         }
 
-        case SI_SONGRATE:
-        {
-            if ((int16_t)tracker->song.rate + (int16_t)delta > 1 && (int16_t)tracker->song.rate + (int16_t)delta <= 0xff)
-            {
-                tracker->song.rate += delta;
-            }
+        break;
+    }
 
-            break;
+    case SI_SONGSPEED: {
+        if((int16_t)tracker->song.speed + (int16_t)delta > 1 &&
+           (int16_t)tracker->song.speed + (int16_t)delta <= 0xff) {
+            tracker->song.speed += delta;
         }
 
-        case SI_MASTERVOL:
-        {
-            if ((int16_t)tracker->tracker_engine.master_volume + (int16_t)delta > 0 && (int16_t)tracker->tracker_engine.master_volume + (int16_t)delta <= 0xff)
-            {
-                tracker->tracker_engine.master_volume += delta;
-            }
+        break;
+    }
 
-            break;
+    case SI_SONGRATE: {
+        if((int16_t)tracker->song.rate + (int16_t)delta > 1 &&
+           (int16_t)tracker->song.rate + (int16_t)delta <= 0xff) {
+            tracker->song.rate += delta;
         }
 
-        case SI_SONGNAME:
-        {
-            text_input_set_header_text(tracker->text_input, "Song name:");
-            text_input_set_result_callback(tracker->text_input, return_from_keyboard_callback, tracker, (char *)&tracker->song.song_name, MUS_SONG_NAME_LEN + 1, false);
+        break;
+    }
 
-            view_dispatcher_switch_to_view(tracker->view_dispatcher, VIEW_KEYBOARD);
-            break;
+    case SI_MASTERVOL: {
+        if((int16_t)tracker->tracker_engine.master_volume + (int16_t)delta > 0 &&
+           (int16_t)tracker->tracker_engine.master_volume + (int16_t)delta <= 0xff) {
+            tracker->tracker_engine.master_volume += delta;
         }
 
-        case SI_CURRENTINSTRUMENT:
-        {
-            int16_t inst = tracker->current_instrument;
+        break;
+    }
 
-            int8_t inst_delta = delta > 0 ? 1 : -1;
+    case SI_SONGNAME: {
+        text_input_set_header_text(tracker->text_input, "Song name:");
+        text_input_set_result_callback(
+            tracker->text_input,
+            return_from_keyboard_callback,
+            tracker,
+            (char*)&tracker->song.song_name,
+            MUS_SONG_NAME_LEN + 1,
+            false);
+
+        view_dispatcher_switch_to_view(tracker->view_dispatcher, VIEW_KEYBOARD);
+        break;
+    }
 
-            inst += inst_delta;
+    case SI_CURRENTINSTRUMENT: {
+        int16_t inst = tracker->current_instrument;
 
-            clamp(inst, 0, 0, tracker->song.num_instruments - 1);
+        int8_t inst_delta = delta > 0 ? 1 : -1;
 
-            tracker->current_instrument = inst;
+        inst += inst_delta;
 
-            break;
-        }
+        clamp(inst, 0, 0, tracker->song.num_instruments - 1);
 
-        case SI_INSTRUMENTNAME:
-        {
-            text_input_set_header_text(tracker->text_input, "Instrument name:");
-            text_input_set_result_callback(tracker->text_input, return_from_keyboard_callback, tracker, (char *)&tracker->song.instrument[tracker->current_instrument]->name, MUS_INST_NAME_LEN + 1, false);
+        tracker->current_instrument = inst;
 
-            view_dispatcher_switch_to_view(tracker->view_dispatcher, VIEW_KEYBOARD);
-            break;
-        }
+        break;
+    }
 
-        default:
-            break;
+    case SI_INSTRUMENTNAME: {
+        text_input_set_header_text(tracker->text_input, "Instrument name:");
+        text_input_set_result_callback(
+            tracker->text_input,
+            return_from_keyboard_callback,
+            tracker,
+            (char*)&tracker->song.instrument[tracker->current_instrument]->name,
+            MUS_INST_NAME_LEN + 1,
+            false);
+
+        view_dispatcher_switch_to_view(tracker->view_dispatcher, VIEW_KEYBOARD);
+        break;
+    }
+
+    default:
+        break;
     }
 }
 
-void songinfo_edit_event(FlizzerTrackerApp *tracker, FlizzerTrackerEvent *event)
-{
-    if (event->input.key == InputKeyOk && event->input.type == InputTypeShort && !tracker->tracker_engine.playing)
-    {
+void songinfo_edit_event(FlizzerTrackerApp* tracker, FlizzerTrackerEvent* event) {
+    if(event->input.key == InputKeyOk && event->input.type == InputTypeShort &&
+       !tracker->tracker_engine.playing) {
         tracker->editing = !tracker->editing;
     }
 
-    if (event->input.key == InputKeyRight && event->input.type == InputTypeShort && tracker->editing)
-    {
-        switch (tracker->selected_param)
-        {
-            default:
-            {
-                tracker->current_digit++;
-
-                if (tracker->current_digit > 1)
-                {
-                    tracker->selected_param++;
-
-                    tracker->current_digit = 0;
-
-                    if (tracker->selected_param > SI_PARAMS - 1)
-                    {
-                        tracker->selected_param = 0;
-                    }
-                }
-
-                break;
-            }
+    if(event->input.key == InputKeyRight && event->input.type == InputTypeShort &&
+       tracker->editing) {
+        switch(tracker->selected_param) {
+        default: {
+            tracker->current_digit++;
 
-            case SI_CURRENTINSTRUMENT:
-            case SI_SONGNAME:
-            case SI_INSTRUMENTNAME:
-            {
+            if(tracker->current_digit > 1) {
                 tracker->selected_param++;
 
                 tracker->current_digit = 0;
 
-                if (tracker->selected_param > SI_PARAMS - 1)
-                {
+                if(tracker->selected_param > SI_PARAMS - 1) {
                     tracker->selected_param = 0;
                 }
-
-                break;
             }
+
+            break;
         }
-    }
 
-    if (event->input.key == InputKeyLeft && event->input.type == InputTypeShort && tracker->editing)
-    {
-        switch (tracker->selected_param)
-        {
-            default:
-            {
-                tracker->current_digit--;
+        case SI_CURRENTINSTRUMENT:
+        case SI_SONGNAME:
+        case SI_INSTRUMENTNAME: {
+            tracker->selected_param++;
 
-                if (tracker->current_digit > 1) // unsigned int overflow
-                {
-                    tracker->selected_param--;
+            tracker->current_digit = 0;
 
-                    tracker->current_digit = 1;
+            if(tracker->selected_param > SI_PARAMS - 1) {
+                tracker->selected_param = 0;
+            }
 
-                    if (tracker->selected_param > SI_PARAMS - 1) // unsigned int overflow
-                    {
-                        tracker->selected_param = SI_PARAMS - 1;
-                    }
-                }
+            break;
+        }
+        }
+    }
 
-                break;
-            }
+    if(event->input.key == InputKeyLeft && event->input.type == InputTypeShort &&
+       tracker->editing) {
+        switch(tracker->selected_param) {
+        default: {
+            tracker->current_digit--;
 
-            case SI_CURRENTINSTRUMENT:
-            case SI_SONGNAME:
-            case SI_INSTRUMENTNAME:
+            if(tracker->current_digit > 1) // unsigned int overflow
             {
                 tracker->selected_param--;
 
-                tracker->current_digit = 0;
+                tracker->current_digit = 1;
 
-                if (tracker->selected_param > SI_PARAMS - 1) // unsigned int overflow
+                if(tracker->selected_param > SI_PARAMS - 1) // unsigned int overflow
                 {
                     tracker->selected_param = SI_PARAMS - 1;
                 }
+            }
 
-                break;
+            break;
+        }
+
+        case SI_CURRENTINSTRUMENT:
+        case SI_SONGNAME:
+        case SI_INSTRUMENTNAME: {
+            tracker->selected_param--;
+
+            tracker->current_digit = 0;
+
+            if(tracker->selected_param > SI_PARAMS - 1) // unsigned int overflow
+            {
+                tracker->selected_param = SI_PARAMS - 1;
             }
+
+            break;
+        }
         }
     }
 
-    if (event->input.key == InputKeyDown && event->input.type == InputTypeShort)
-    {
-        if (tracker->editing)
-        {
+    if(event->input.key == InputKeyDown && event->input.type == InputTypeShort) {
+        if(tracker->editing) {
             edit_songinfo_param(tracker, tracker->selected_param, -1);
         }
     }
 
-    if (event->input.key == InputKeyUp && event->input.type == InputTypeShort)
-    {
-        if (tracker->editing)
-        {
+    if(event->input.key == InputKeyUp && event->input.type == InputTypeShort) {
+        if(tracker->editing) {
             edit_songinfo_param(tracker, tracker->selected_param, 1);
         }
     }

input/songinfo.h

@@ -10,5 +10,5 @@
 #include "../tracker_engine/tracker_engine_defs.h"
 #include "../util.h"
 
-void songinfo_edit_event(FlizzerTrackerApp *tracker, FlizzerTrackerEvent *event);
-void return_from_keyboard_callback(void *ctx);
+void songinfo_edit_event(FlizzerTrackerApp* tracker, FlizzerTrackerEvent* event);
+void return_from_keyboard_callback(void* ctx);

input_event.c

@@ -4,52 +4,43 @@
 
 #define AUDIO_MODES_COUNT 2
 
-void return_from_keyboard_callback(void *ctx)
-{
-    FlizzerTrackerApp *tracker = (FlizzerTrackerApp *)ctx;
+void return_from_keyboard_callback(void* ctx) {
+    FlizzerTrackerApp* tracker = (FlizzerTrackerApp*)ctx;
 
-    if (!tracker->is_loading && !tracker->is_saving)
-    {
+    if(!tracker->is_loading && !tracker->is_saving) {
         uint8_t string_length = 0;
-        char *string = NULL;
+        char* string = NULL;
 
-        if (tracker->focus == EDIT_SONGINFO && tracker->mode == PATTERN_VIEW)
-        {
-            switch (tracker->selected_param)
-            {
-                case SI_SONGNAME:
-                {
-                    string_length = MUS_SONG_NAME_LEN;
-                    string = (char *)&tracker->song.song_name;
-                    break;
-                }
-
-                case SI_INSTRUMENTNAME:
-                {
-                    string_length = MUS_INST_NAME_LEN;
-                    string = (char *)&tracker->song.instrument[tracker->current_instrument]->name;
-                    break;
-                }
+        if(tracker->focus == EDIT_SONGINFO && tracker->mode == PATTERN_VIEW) {
+            switch(tracker->selected_param) {
+            case SI_SONGNAME: {
+                string_length = MUS_SONG_NAME_LEN;
+                string = (char*)&tracker->song.song_name;
+                break;
+            }
+
+            case SI_INSTRUMENTNAME: {
+                string_length = MUS_INST_NAME_LEN;
+                string = (char*)&tracker->song.instrument[tracker->current_instrument]->name;
+                break;
+            }
             }
         }
 
-        if (tracker->focus == EDIT_INSTRUMENT && tracker->mode == INST_EDITOR_VIEW)
-        {
-            switch (tracker->selected_param)
-            {
-                case INST_INSTRUMENTNAME:
-                {
-                    string_length = MUS_INST_NAME_LEN;
-                    string = (char *)&tracker->song.instrument[tracker->current_instrument]->name;
-                    break;
-                }
+        if(tracker->focus == EDIT_INSTRUMENT && tracker->mode == INST_EDITOR_VIEW) {
+            switch(tracker->selected_param) {
+            case INST_INSTRUMENTNAME: {
+                string_length = MUS_INST_NAME_LEN;
+                string = (char*)&tracker->song.instrument[tracker->current_instrument]->name;
+                break;
+            }
             }
         }
 
-        if (string == NULL || string_length == 0)
-            return;
+        if(string == NULL || string_length == 0) return;
 
-        for (uint8_t i = 0; i < string_length; i++) // I tinyfied the font by deleting lowercase chars, and I don't like the lowercase chars of any 3x5 pixels font
+        for(uint8_t i = 0; i < string_length;
+            i++) // I tinyfied the font by deleting lowercase chars, and I don't like the lowercase chars of any 3x5 pixels font
         {
             string[i] = toupper(string[i]);
         }
@@ -57,35 +48,31 @@ void return_from_keyboard_callback(void *ctx)
 
     view_dispatcher_switch_to_view(tracker->view_dispatcher, VIEW_TRACKER);
 
-    if (tracker->is_saving)
-    {
+    if(tracker->is_saving) {
         stop_song(tracker);
 
         tracker->filepath = furi_string_alloc();
-        furi_string_cat_printf(tracker->filepath, "%s/%s%s", FLIZZER_TRACKER_FOLDER, tracker->filename, SONG_FILE_EXT);
+        furi_string_cat_printf(
+            tracker->filepath, "%s/%s%s", FLIZZER_TRACKER_FOLDER, tracker->filename, SONG_FILE_EXT);
 
-        if (storage_file_exists(tracker->storage, furi_string_get_cstr(tracker->filepath)))
-        {
+        if(storage_file_exists(tracker->storage, furi_string_get_cstr(tracker->filepath))) {
             view_dispatcher_switch_to_view(tracker->view_dispatcher, VIEW_FILE_OVERWRITE);
             return;
         }
 
-        else
-        {
+        else {
             FlizzerTrackerEvent event = {.type = EventTypeSaveSong, .input = {0}, .period = 0};
             furi_message_queue_put(tracker->event_queue, &event, FuriWaitForever);
         }
     }
 }
 
-void overwrite_file_widget_yes_input_callback(GuiButtonType result, InputType type, void *ctx)
-{
+void overwrite_file_widget_yes_input_callback(GuiButtonType result, InputType type, void* ctx) {
     UNUSED(result);
 
-    FlizzerTrackerApp *tracker = (FlizzerTrackerApp *)ctx;
+    FlizzerTrackerApp* tracker = (FlizzerTrackerApp*)ctx;
 
-    if (type == InputTypeShort)
-    {
+    if(type == InputTypeShort) {
         tracker->is_saving = true;
         view_dispatcher_switch_to_view(tracker->view_dispatcher, VIEW_TRACKER);
         // save_song(tracker, tracker->filepath);
@@ -94,121 +81,118 @@ void overwrite_file_widget_yes_input_callback(GuiButtonType result, InputType ty
     }
 }
 
-void overwrite_file_widget_no_input_callback(GuiButtonType result, InputType type, void *ctx)
-{
+void overwrite_file_widget_no_input_callback(GuiButtonType result, InputType type, void* ctx) {
     UNUSED(result);
 
-    FlizzerTrackerApp *tracker = (FlizzerTrackerApp *)ctx;
+    FlizzerTrackerApp* tracker = (FlizzerTrackerApp*)ctx;
 
-    if (type == InputTypeShort)
-    {
+    if(type == InputTypeShort) {
         tracker->is_saving = false;
         furi_string_free(tracker->filepath);
         view_dispatcher_switch_to_view(tracker->view_dispatcher, VIEW_TRACKER);
     }
 }
 
-uint32_t submenu_settings_exit_callback(void *context)
-{
+uint32_t submenu_settings_exit_callback(void* context) {
     UNUSED(context);
     return VIEW_SUBMENU_PATTERN;
 }
 
-uint32_t submenu_exit_callback(void *context)
-{
+uint32_t submenu_exit_callback(void* context) {
     UNUSED(context);
     return VIEW_TRACKER;
 }
 
-void submenu_callback(void *context, uint32_t index)
-{
-    FlizzerTrackerApp *tracker = (FlizzerTrackerApp *)context;
+void submenu_callback(void* context, uint32_t index) {
+    FlizzerTrackerApp* tracker = (FlizzerTrackerApp*)context;
+
+    switch(tracker->mode) {
+    case PATTERN_VIEW: {
+        switch(index) {
+        case SUBMENU_PATTERN_EXIT: {
+            tracker->quit = true;
+
+            static InputEvent inevent = {.sequence = 0, .key = InputKeyLeft, .type = InputTypeMAX};
+            FlizzerTrackerEvent event = {
+                .type = EventTypeInput,
+                .input = inevent,
+                .period =
+                    0}; // making an event so tracker does not wait for next keypress and exits immediately
+            furi_message_queue_put(tracker->event_queue, &event, FuriWaitForever);
+            view_dispatcher_switch_to_view(tracker->view_dispatcher, VIEW_TRACKER);
+            break;
+        }
 
-    switch (tracker->mode)
-    {
-        case PATTERN_VIEW:
-        {
-            switch (index)
-            {
-                case SUBMENU_PATTERN_EXIT:
-                {
-                    tracker->quit = true;
-
-                    static InputEvent inevent = {.sequence = 0, .key = InputKeyLeft, .type = InputTypeMAX};
-                    FlizzerTrackerEvent event = {.type = EventTypeInput, .input = inevent, .period = 0}; // making an event so tracker does not wait for next keypress and exits immediately
-                    furi_message_queue_put(tracker->event_queue, &event, FuriWaitForever);
-                    view_dispatcher_switch_to_view(tracker->view_dispatcher, VIEW_TRACKER);
-                    break;
-                }
-
-                case SUBMENU_PATTERN_SAVE_SONG:
-                {
-                    text_input_set_header_text(tracker->text_input, "Song filename:");
-                    memset(&tracker->filename, 0, FILE_NAME_LEN);
-                    text_input_set_result_callback(tracker->text_input, return_from_keyboard_callback, tracker, (char *)&tracker->filename, FILE_NAME_LEN, true);
-
-                    tracker->is_saving = true;
-
-                    view_dispatcher_switch_to_view(tracker->view_dispatcher, VIEW_KEYBOARD);
-                    break;
-                }
-
-                case SUBMENU_PATTERN_LOAD_SONG:
-                {
-                    FlizzerTrackerEvent event = {.type = EventTypeLoadSong, .input = {0}, .period = 0};
-                    furi_message_queue_put(tracker->event_queue, &event, FuriWaitForever);
-                    view_dispatcher_switch_to_view(tracker->view_dispatcher, VIEW_TRACKER);
-                    break;
-                }
-
-                case SUBMENU_PATTERN_SETTINGS:
-                {
-                    view_dispatcher_switch_to_view(tracker->view_dispatcher, VIEW_SETTINGS);
-                    break;
-                }
-
-                default:
-                    break;
-            }
+        case SUBMENU_PATTERN_SAVE_SONG: {
+            text_input_set_header_text(tracker->text_input, "Song filename:");
+            memset(&tracker->filename, 0, FILE_NAME_LEN);
+            text_input_set_result_callback(
+                tracker->text_input,
+                return_from_keyboard_callback,
+                tracker,
+                (char*)&tracker->filename,
+                FILE_NAME_LEN,
+                true);
 
+            tracker->is_saving = true;
+
+            view_dispatcher_switch_to_view(tracker->view_dispatcher, VIEW_KEYBOARD);
             break;
         }
 
-        case INST_EDITOR_VIEW:
-        {
-            switch (index)
-            {
-                case SUBMENU_INSTRUMENT_EXIT:
-                {
-                    tracker->quit = true;
-
-                    static InputEvent inevent = {.sequence = 0, .key = InputKeyLeft, .type = InputTypeMAX};
-                    FlizzerTrackerEvent event = {.type = EventTypeInput, .input = inevent, .period = 0}; // making an event so tracker does not wait for next keypress and exits immediately
-                    furi_message_queue_put(tracker->event_queue, &event, FuriWaitForever);
-                    view_dispatcher_switch_to_view(tracker->view_dispatcher, VIEW_TRACKER);
-                    break;
-                }
-
-                default:
-                    break;
-            }
+        case SUBMENU_PATTERN_LOAD_SONG: {
+            FlizzerTrackerEvent event = {.type = EventTypeLoadSong, .input = {0}, .period = 0};
+            furi_message_queue_put(tracker->event_queue, &event, FuriWaitForever);
+            view_dispatcher_switch_to_view(tracker->view_dispatcher, VIEW_TRACKER);
+            break;
+        }
 
+        case SUBMENU_PATTERN_SETTINGS: {
+            view_dispatcher_switch_to_view(tracker->view_dispatcher, VIEW_SETTINGS);
             break;
         }
 
         default:
             break;
+        }
+
+        break;
+    }
+
+    case INST_EDITOR_VIEW: {
+        switch(index) {
+        case SUBMENU_INSTRUMENT_EXIT: {
+            tracker->quit = true;
+
+            static InputEvent inevent = {.sequence = 0, .key = InputKeyLeft, .type = InputTypeMAX};
+            FlizzerTrackerEvent event = {
+                .type = EventTypeInput,
+                .input = inevent,
+                .period =
+                    0}; // making an event so tracker does not wait for next keypress and exits immediately
+            furi_message_queue_put(tracker->event_queue, &event, FuriWaitForever);
+            view_dispatcher_switch_to_view(tracker->view_dispatcher, VIEW_TRACKER);
+            break;
+        }
+
+        default:
+            break;
+        }
+
+        break;
+    }
+
+    default:
+        break;
     }
 }
 
-void audio_output_changed_callback(VariableItem *item)
-{
-    FlizzerTrackerApp *tracker = (FlizzerTrackerApp *)variable_item_get_context(item);
+void audio_output_changed_callback(VariableItem* item) {
+    FlizzerTrackerApp* tracker = (FlizzerTrackerApp*)variable_item_get_context(item);
     uint8_t index = variable_item_get_current_value_index(item);
     variable_item_set_current_value_text(item, audio_modes_text[(index > 1 ? 1 : index)]);
 
-    if (tracker)
-    {
+    if(tracker) {
         tracker->external_audio = (bool)index;
 
         tracker->external_audio = audio_modes_values[(index > 1 ? 1 : index)];
@@ -223,48 +207,39 @@ void audio_output_changed_callback(VariableItem *item)
     }
 }
 
-void cycle_focus(FlizzerTrackerApp *tracker)
-{
-    switch (tracker->mode)
-    {
-        case PATTERN_VIEW:
-        {
-            tracker->focus++;
-
-            if (tracker->focus > EDIT_SONGINFO)
-            {
-                tracker->focus = EDIT_PATTERN;
-            }
+void cycle_focus(FlizzerTrackerApp* tracker) {
+    switch(tracker->mode) {
+    case PATTERN_VIEW: {
+        tracker->focus++;
 
-            break;
+        if(tracker->focus > EDIT_SONGINFO) {
+            tracker->focus = EDIT_PATTERN;
         }
 
-        case INST_EDITOR_VIEW:
-        {
-            tracker->focus++;
+        break;
+    }
 
-            if (tracker->focus > EDIT_PROGRAM)
-            {
-                tracker->focus = EDIT_INSTRUMENT;
+    case INST_EDITOR_VIEW: {
+        tracker->focus++;
 
-                if (tracker->current_digit > 1)
-                {
-                    tracker->current_digit = 1;
-                }
-            }
+        if(tracker->focus > EDIT_PROGRAM) {
+            tracker->focus = EDIT_INSTRUMENT;
 
-            break;
+            if(tracker->current_digit > 1) {
+                tracker->current_digit = 1;
+            }
         }
 
-        default:
-            break;
+        break;
+    }
+
+    default:
+        break;
     }
 }
 
-void cycle_view(FlizzerTrackerApp *tracker)
-{
-    if (tracker->mode == PATTERN_VIEW)
-    {
+void cycle_view(FlizzerTrackerApp* tracker) {
+    if(tracker->mode == PATTERN_VIEW) {
         tracker->mode = INST_EDITOR_VIEW;
         tracker->focus = EDIT_INSTRUMENT;
 
@@ -274,13 +249,11 @@ void cycle_view(FlizzerTrackerApp *tracker)
         return;
     }
 
-    if (tracker->mode == INST_EDITOR_VIEW)
-    {
+    if(tracker->mode == INST_EDITOR_VIEW) {
         tracker->mode = PATTERN_VIEW;
         tracker->focus = EDIT_PATTERN;
 
-        if (tracker->tracker_engine.song == NULL)
-        {
+        if(tracker->tracker_engine.song == NULL) {
             stop_song(tracker);
             tracker_engine_set_song(&tracker->tracker_engine, &tracker->song);
         }
@@ -292,80 +265,70 @@ void cycle_view(FlizzerTrackerApp *tracker)
     }
 }
 
-void process_input_event(FlizzerTrackerApp *tracker, FlizzerTrackerEvent *event)
-{
-    if (event->input.key == InputKeyBack && event->input.type == InputTypeShort && event->period > 0 && event->period < 300 && !(tracker->editing))
-    {
+void process_input_event(FlizzerTrackerApp* tracker, FlizzerTrackerEvent* event) {
+    if(event->input.key == InputKeyBack && event->input.type == InputTypeShort &&
+       event->period > 0 && event->period < 300 && !(tracker->editing)) {
         cycle_view(tracker);
         stop_song(tracker);
         return;
     }
 
-    else if (event->input.key == InputKeyBack && event->input.type == InputTypeShort && !(tracker->editing))
-    {
+    else if(
+        event->input.key == InputKeyBack && event->input.type == InputTypeShort &&
+        !(tracker->editing)) {
         cycle_focus(tracker);
         stop_song(tracker);
         return;
     }
 
-    if (event->input.key == InputKeyBack && event->input.type == InputTypeLong)
-    {
-        switch (tracker->mode)
-        {
-            case PATTERN_VIEW:
-            {
-                submenu_set_selected_item(tracker->pattern_submenu, SUBMENU_PATTERN_LOAD_SONG);
-                view_dispatcher_switch_to_view(tracker->view_dispatcher, VIEW_SUBMENU_PATTERN);
-                break;
-            }
+    if(event->input.key == InputKeyBack && event->input.type == InputTypeLong) {
+        switch(tracker->mode) {
+        case PATTERN_VIEW: {
+            submenu_set_selected_item(tracker->pattern_submenu, SUBMENU_PATTERN_LOAD_SONG);
+            view_dispatcher_switch_to_view(tracker->view_dispatcher, VIEW_SUBMENU_PATTERN);
+            break;
+        }
 
-            case INST_EDITOR_VIEW:
-            {
-                submenu_set_selected_item(tracker->instrument_submenu, SUBMENU_INSTRUMENT_EXIT);
-                view_dispatcher_switch_to_view(tracker->view_dispatcher, VIEW_SUBMENU_INSTRUMENT);
-                break;
-            }
+        case INST_EDITOR_VIEW: {
+            submenu_set_selected_item(tracker->instrument_submenu, SUBMENU_INSTRUMENT_EXIT);
+            view_dispatcher_switch_to_view(tracker->view_dispatcher, VIEW_SUBMENU_INSTRUMENT);
+            break;
+        }
 
-            default:
-                break;
+        default:
+            break;
         }
 
         return;
     }
 
-    switch (tracker->focus)
-    {
-        case EDIT_PATTERN:
-        {
-            pattern_edit_event(tracker, event);
-            break;
-        }
+    switch(tracker->focus) {
+    case EDIT_PATTERN: {
+        pattern_edit_event(tracker, event);
+        break;
+    }
 
-        case EDIT_SEQUENCE:
-        {
-            sequence_edit_event(tracker, event);
-            break;
-        }
+    case EDIT_SEQUENCE: {
+        sequence_edit_event(tracker, event);
+        break;
+    }
 
-        case EDIT_SONGINFO:
-        {
-            songinfo_edit_event(tracker, event);
-            break;
-        }
+    case EDIT_SONGINFO: {
+        songinfo_edit_event(tracker, event);
+        break;
+    }
 
-        case EDIT_INSTRUMENT:
-        {
-            instrument_edit_event(tracker, event);
-            break;
-        }
+    case EDIT_INSTRUMENT: {
+        instrument_edit_event(tracker, event);
+        break;
+    }
 
-        case EDIT_PROGRAM:
-        {
-            instrument_program_edit_event(tracker, event);
-            break;
-        }
+    case EDIT_PROGRAM: {
+        instrument_program_edit_event(tracker, event);
+        break;
+    }
 
-        default:
-            break;
+    default:
+        break;
     }
 }

input_event.h

@@ -16,15 +16,15 @@
 #include "input/songinfo.h"
 
 extern bool audio_modes_values[];
-extern char *audio_modes_text[];
+extern char* audio_modes_text[];
 
-void return_from_keyboard_callback(void *ctx);
+void return_from_keyboard_callback(void* ctx);
 
-void overwrite_file_widget_yes_input_callback(GuiButtonType result, InputType type, void *ctx);
-void overwrite_file_widget_no_input_callback(GuiButtonType result, InputType type, void *ctx);
+void overwrite_file_widget_yes_input_callback(GuiButtonType result, InputType type, void* ctx);
+void overwrite_file_widget_no_input_callback(GuiButtonType result, InputType type, void* ctx);
 
-uint32_t submenu_exit_callback(void *context);
-uint32_t submenu_settings_exit_callback(void *context);
-void submenu_callback(void *context, uint32_t index);
-void audio_output_changed_callback(VariableItem *item);
-void process_input_event(FlizzerTrackerApp *tracker, FlizzerTrackerEvent *event);
+uint32_t submenu_exit_callback(void* context);
+uint32_t submenu_settings_exit_callback(void* context);
+void submenu_callback(void* context, uint32_t index);
+void audio_output_changed_callback(VariableItem* item);
+void process_input_event(FlizzerTrackerApp* tracker, FlizzerTrackerEvent* event);

sound_engine/freqs.c

@@ -1,37 +1,35 @@
 #include "freqs.h"
 
-const uint32_t frequency_table[FREQ_TAB_SIZE] =
-    {
-        (uint32_t)(2093.00 * 1024), // 7th octave, the highest in this tracker
-        (uint32_t)(2217.46 * 1024), // frequency precision is 1 / 1024th of Hz
-        (uint32_t)(2349.32 * 1024),
-        (uint32_t)(2489.02 * 1024),
-        (uint32_t)(2637.02 * 1024),
-        (uint32_t)(2793.83 * 1024),
-        (uint32_t)(2959.96 * 1024),
-        (uint32_t)(3135.96 * 1024),
-        (uint32_t)(3322.44 * 1024),
-        (uint32_t)(3520.00 * 1024),
-        (uint32_t)(3729.31 * 1024),
-        (uint32_t)(3951.07 * 1024),
+const uint32_t frequency_table[FREQ_TAB_SIZE] = {
+    (uint32_t)(2093.00 * 1024), // 7th octave, the highest in this tracker
+    (uint32_t)(2217.46 * 1024), // frequency precision is 1 / 1024th of Hz
+    (uint32_t)(2349.32 * 1024),
+    (uint32_t)(2489.02 * 1024),
+    (uint32_t)(2637.02 * 1024),
+    (uint32_t)(2793.83 * 1024),
+    (uint32_t)(2959.96 * 1024),
+    (uint32_t)(3135.96 * 1024),
+    (uint32_t)(3322.44 * 1024),
+    (uint32_t)(3520.00 * 1024),
+    (uint32_t)(3729.31 * 1024),
+    (uint32_t)(3951.07 * 1024),
 };
 
-uint32_t get_freq(uint16_t note)
-{
-    if (note >= ((FREQ_TAB_SIZE * 8) << 8))
-    {
+uint32_t get_freq(uint16_t note) {
+    if(note >= ((FREQ_TAB_SIZE * 8) << 8)) {
         return frequency_table[FREQ_TAB_SIZE - 1];
     }
 
-    if ((note & 0xff) == 0)
-    {
-        return frequency_table[((note >> 8) % 12)] / (2 << (((NUM_OCTAVES) - ((note >> 8) / 12)) - 2)); // wrap to one octave
+    if((note & 0xff) == 0) {
+        return frequency_table[((note >> 8) % 12)] /
+               (2 << (((NUM_OCTAVES) - ((note >> 8) / 12)) - 2)); // wrap to one octave
     }
 
-    else
-    {
-        uint64_t f1 = frequency_table[((note >> 8) % 12)] / (uint64_t)(2 << (((NUM_OCTAVES) - ((note >> 8) / 12)) - 2));
-        uint64_t f2 = frequency_table[(((note >> 8) + 1) % 12)] / (uint64_t)(2 << (((NUM_OCTAVES) - (((note >> 8) + 1) / 12)) - 2));
+    else {
+        uint64_t f1 = frequency_table[((note >> 8) % 12)] /
+                      (uint64_t)(2 << (((NUM_OCTAVES) - ((note >> 8) / 12)) - 2));
+        uint64_t f2 = frequency_table[(((note >> 8) + 1) % 12)] /
+                      (uint64_t)(2 << (((NUM_OCTAVES) - (((note >> 8) + 1) / 12)) - 2));
 
         return f1 + (uint64_t)((f2 - f1) * (uint64_t)(note & 0xff)) / (uint64_t)256;
     }

sound_engine/freqs.h

@@ -4,7 +4,7 @@
 #include <stdio.h>
 
 #define FREQ_TAB_SIZE 12 /* one octave */
-#define NUM_OCTAVES 8    /* 0-7th octaves */
+#define NUM_OCTAVES 8 /* 0-7th octaves */
 
 extern const uint32_t frequency_table[FREQ_TAB_SIZE];
 

sound_engine/sound_engine.c

@@ -5,15 +5,16 @@
 
 #define PI 3.1415
 
-void sound_engine_init(SoundEngine *sound_engine, uint32_t sample_rate, bool external_audio_output, uint32_t audio_buffer_size)
-{
-    if (sound_engine->audio_buffer)
-    {
+void sound_engine_init(
+    SoundEngine* sound_engine,
+    uint32_t sample_rate,
+    bool external_audio_output,
+    uint32_t audio_buffer_size) {
+    if(sound_engine->audio_buffer) {
         free(sound_engine->audio_buffer);
     }
 
-    if (sound_engine->sine_lut)
-    {
+    if(sound_engine->sine_lut) {
         free(sound_engine->sine_lut);
     }
 
@@ -25,35 +26,31 @@ void sound_engine_init(SoundEngine *sound_engine, uint32_t sample_rate, bool ext
     sound_engine->sample_rate = sample_rate;
     sound_engine->external_audio_output = external_audio_output;
 
-    for (int i = 0; i < NUM_CHANNELS; ++i)
-    {
+    for(int i = 0; i < NUM_CHANNELS; ++i) {
         sound_engine->channel[i].lfsr = RANDOM_SEED;
     }
 
-    for (int i = 0; i < SINE_LUT_SIZE; ++i)
-    {
+    for(int i = 0; i < SINE_LUT_SIZE; ++i) {
         sound_engine->sine_lut[i] = (uint8_t)((sinf(i / 64.0 * PI) + 1.0) * 127.0);
     }
 
-    furi_hal_interrupt_set_isr_ex(FuriHalInterruptIdDma1Ch1, 15, sound_engine_dma_isr, sound_engine);
+    furi_hal_interrupt_set_isr_ex(
+        FuriHalInterruptIdDma1Ch1, 15, sound_engine_dma_isr, sound_engine);
 
-    sound_engine_init_hardware(sample_rate, external_audio_output, sound_engine->audio_buffer, audio_buffer_size);
+    sound_engine_init_hardware(
+        sample_rate, external_audio_output, sound_engine->audio_buffer, audio_buffer_size);
 }
 
-void sound_engine_deinit(SoundEngine *sound_engine)
-{
+void sound_engine_deinit(SoundEngine* sound_engine) {
     free(sound_engine->audio_buffer);
 
-    if (!(sound_engine->external_audio_output))
-    {
-        if (furi_hal_speaker_is_mine())
-        {
+    if(!(sound_engine->external_audio_output)) {
+        if(furi_hal_speaker_is_mine()) {
             furi_hal_speaker_release();
         }
     }
 
-    else
-    {
+    else {
         furi_hal_gpio_init(&gpio_ext_pa6, GpioModeAnalog, GpioPullNo, GpioSpeedLow);
     }
 
@@ -62,59 +59,55 @@ void sound_engine_deinit(SoundEngine *sound_engine)
     sound_engine_deinit_timer();
 }
 
-void sound_engine_set_channel_frequency(SoundEngine *sound_engine, SoundEngineChannel *channel, uint16_t note)
-{
+void sound_engine_set_channel_frequency(
+    SoundEngine* sound_engine,
+    SoundEngineChannel* channel,
+    uint16_t note) {
     uint32_t frequency = get_freq(note);
 
-    if (frequency != 0)
-    {
-        channel->frequency = (uint64_t)(ACC_LENGTH) / (uint64_t)1024 * (uint64_t)(frequency) / (uint64_t)sound_engine->sample_rate;
+    if(frequency != 0) {
+        channel->frequency = (uint64_t)(ACC_LENGTH) / (uint64_t)1024 * (uint64_t)(frequency) /
+                             (uint64_t)sound_engine->sample_rate;
     }
 
-    else
-    {
+    else {
         channel->frequency = 0;
     }
 }
 
-void sound_engine_enable_gate(SoundEngine *sound_engine, SoundEngineChannel *channel, bool enable)
-{
-    if (enable)
-    {
+void sound_engine_enable_gate(SoundEngine* sound_engine, SoundEngineChannel* channel, bool enable) {
+    if(enable) {
         channel->adsr.envelope = 0;
         channel->adsr.envelope_speed = envspd(sound_engine, channel->adsr.a);
         channel->adsr.envelope_state = ATTACK;
 
         channel->flags |= SE_ENABLE_GATE;
 
-        if (channel->flags & SE_ENABLE_KEYDOWN_SYNC)
-        {
+        if(channel->flags & SE_ENABLE_KEYDOWN_SYNC) {
             channel->accumulator = 0;
         }
     }
 
-    else
-    {
+    else {
         channel->adsr.envelope_state = RELEASE;
         channel->adsr.envelope_speed = envspd(sound_engine, channel->adsr.r);
     }
 }
 
-void sound_engine_fill_buffer(SoundEngine *sound_engine, uint16_t *audio_buffer, uint32_t audio_buffer_size)
-{
+void sound_engine_fill_buffer(
+    SoundEngine* sound_engine,
+    uint16_t* audio_buffer,
+    uint32_t audio_buffer_size) {
     int32_t channel_output[NUM_CHANNELS];
     int32_t channel_output_final[NUM_CHANNELS];
 
-    for (uint32_t i = 0; i < audio_buffer_size; ++i)
-    {
+    for(uint32_t i = 0; i < audio_buffer_size; ++i) {
         int32_t output = WAVE_AMP / 2 / 64;
 
-        for (uint32_t chan = 0; chan < NUM_CHANNELS; ++chan)
-        {
-            SoundEngineChannel *channel = &sound_engine->channel[chan];
+        for(uint32_t chan = 0; chan < NUM_CHANNELS; ++chan) {
+            SoundEngineChannel* channel = &sound_engine->channel[chan];
 
-            if (channel->frequency > 0)
-            {
+            if(channel->frequency > 0) {
                 uint32_t prev_acc = channel->accumulator;
 
                 channel->accumulator += channel->frequency;
@@ -123,80 +116,84 @@ void sound_engine_fill_buffer(SoundEngine *sound_engine, uint16_t *audio_buffer,
 
                 channel->accumulator &= ACC_LENGTH - 1;
 
-                if (channel->flags & SE_ENABLE_HARD_SYNC)
-                {
+                if(channel->flags & SE_ENABLE_HARD_SYNC) {
                     uint8_t hard_sync_src = channel->hard_sync == 0xff ? i : channel->hard_sync;
 
-                    if (sound_engine->channel[hard_sync_src].sync_bit)
-                    {
+                    if(sound_engine->channel[hard_sync_src].sync_bit) {
                         channel->accumulator = 0;
                     }
                 }
 
-                channel_output[chan] = sound_engine_osc(sound_engine, channel, prev_acc) - WAVE_AMP / 2;
+                channel_output[chan] =
+                    sound_engine_osc(sound_engine, channel, prev_acc) - WAVE_AMP / 2;
 
-                if (channel->flags & SE_ENABLE_RING_MOD)
-                {
+                if(channel->flags & SE_ENABLE_RING_MOD) {
                     uint8_t ring_mod_src = channel->ring_mod == 0xff ? i : channel->ring_mod;
-                    channel_output[chan] = channel_output[chan] * channel_output[ring_mod_src] / WAVE_AMP;
+                    channel_output[chan] =
+                        channel_output[chan] * channel_output[ring_mod_src] / WAVE_AMP;
                 }
 
-                channel_output_final[chan] = sound_engine_cycle_and_output_adsr(channel_output[chan], sound_engine, &channel->adsr, &channel->flags);
+                channel_output_final[chan] = sound_engine_cycle_and_output_adsr(
+                    channel_output[chan], sound_engine, &channel->adsr, &channel->flags);
 
-                if (channel->flags & SE_ENABLE_FILTER)
-                {
-                    if (channel->filter_mode != 0)
-                    {
+                if(channel->flags & SE_ENABLE_FILTER) {
+                    if(channel->filter_mode != 0) {
                         sound_engine_filter_cycle(&channel->filter, channel_output_final[chan]);
 
-                        switch (channel->filter_mode)
-                        {
-                            case FIL_OUTPUT_LOWPASS:
-                            {
-                                channel_output_final[chan] = sound_engine_output_lowpass(&channel->filter);
-                                break;
-                            }
-
-                            case FIL_OUTPUT_HIGHPASS:
-                            {
-                                channel_output_final[chan] = sound_engine_output_highpass(&channel->filter);
-                                break;
-                            }
-
-                            case FIL_OUTPUT_BANDPASS:
-                            {
-                                channel_output_final[chan] = sound_engine_output_bandpass(&channel->filter);
-                                break;
-                            }
-
-                            case FIL_OUTPUT_LOW_HIGH:
-                            {
-                                channel_output_final[chan] = sound_engine_output_lowpass(&channel->filter) + sound_engine_output_highpass(&channel->filter);
-                                break;
-                            }
-
-                            case FIL_OUTPUT_HIGH_BAND:
-                            {
-                                channel_output_final[chan] = sound_engine_output_highpass(&channel->filter) + sound_engine_output_bandpass(&channel->filter);
-                                break;
-                            }
-
-                            case FIL_OUTPUT_LOW_BAND:
-                            {
-                                channel_output_final[chan] = sound_engine_output_lowpass(&channel->filter) + sound_engine_output_bandpass(&channel->filter);
-                                break;
-                            }
-
-                            case FIL_OUTPUT_LOW_HIGH_BAND:
-                            {
-                                channel_output_final[chan] = sound_engine_output_lowpass(&channel->filter) + sound_engine_output_highpass(&channel->filter) + sound_engine_output_bandpass(&channel->filter);
-                                break;
-                            }
+                        switch(channel->filter_mode) {
+                        case FIL_OUTPUT_LOWPASS: {
+                            channel_output_final[chan] =
+                                sound_engine_output_lowpass(&channel->filter);
+                            break;
+                        }
+
+                        case FIL_OUTPUT_HIGHPASS: {
+                            channel_output_final[chan] =
+                                sound_engine_output_highpass(&channel->filter);
+                            break;
+                        }
+
+                        case FIL_OUTPUT_BANDPASS: {
+                            channel_output_final[chan] =
+                                sound_engine_output_bandpass(&channel->filter);
+                            break;
+                        }
+
+                        case FIL_OUTPUT_LOW_HIGH: {
+                            channel_output_final[chan] =
+                                sound_engine_output_lowpass(&channel->filter) +
+                                sound_engine_output_highpass(&channel->filter);
+                            break;
+                        }
+
+                        case FIL_OUTPUT_HIGH_BAND: {
+                            channel_output_final[chan] =
+                                sound_engine_output_highpass(&channel->filter) +
+                                sound_engine_output_bandpass(&channel->filter);
+                            break;
+                        }
+
+                        case FIL_OUTPUT_LOW_BAND: {
+                            channel_output_final[chan] =
+                                sound_engine_output_lowpass(&channel->filter) +
+                                sound_engine_output_bandpass(&channel->filter);
+                            break;
+                        }
+
+                        case FIL_OUTPUT_LOW_HIGH_BAND: {
+                            channel_output_final[chan] =
+                                sound_engine_output_lowpass(&channel->filter) +
+                                sound_engine_output_highpass(&channel->filter) +
+                                sound_engine_output_bandpass(&channel->filter);
+                            break;
+                        }
                         }
                     }
                 }
 
-                output += ((channel_output_final[chan]) / (int32_t)(64 * 4)); // 2 more bits so all channels fit
+                output +=
+                    ((channel_output_final[chan]) /
+                     (int32_t)(64 * 4)); // 2 more bits so all channels fit
             }
         }
 

sound_engine/sound_engine.h

@@ -6,8 +6,18 @@
 #include "sound_engine_filter.h"
 #include "sound_engine_osc.h"
 
-void sound_engine_init(SoundEngine *sound_engine, uint32_t sample_rate, bool external_audio_output, uint32_t audio_buffer_size);
-void sound_engine_deinit(SoundEngine *sound_engine);
-void sound_engine_set_channel_frequency(SoundEngine *sound_engine, SoundEngineChannel *channel, uint16_t note);
-void sound_engine_fill_buffer(SoundEngine *sound_engine, uint16_t *audio_buffer, uint32_t audio_buffer_size);
-void sound_engine_enable_gate(SoundEngine *sound_engine, SoundEngineChannel *channel, bool enable);
+void sound_engine_init(
+    SoundEngine* sound_engine,
+    uint32_t sample_rate,
+    bool external_audio_output,
+    uint32_t audio_buffer_size);
+void sound_engine_deinit(SoundEngine* sound_engine);
+void sound_engine_set_channel_frequency(
+    SoundEngine* sound_engine,
+    SoundEngineChannel* channel,
+    uint16_t note);
+void sound_engine_fill_buffer(
+    SoundEngine* sound_engine,
+    uint16_t* audio_buffer,
+    uint32_t audio_buffer_size);
+void sound_engine_enable_gate(SoundEngine* sound_engine, SoundEngineChannel* channel, bool enable);

sound_engine/sound_engine_adsr.c

@@ -1,64 +1,57 @@
 #include "sound_engine_adsr.h"
 
-int32_t sound_engine_cycle_and_output_adsr(int32_t input, SoundEngine *eng, SoundEngineADSR *adsr, uint16_t *flags)
-{
-    switch (adsr->envelope_state)
-    {
-        case ATTACK:
-        {
-            adsr->envelope += adsr->envelope_speed;
-
-            if (adsr->envelope >= MAX_ADSR)
-            {
-                adsr->envelope_state = DECAY;
-                adsr->envelope = MAX_ADSR;
-
-                adsr->envelope_speed = envspd(eng, adsr->d);
-            }
-
-            break;
+int32_t sound_engine_cycle_and_output_adsr(
+    int32_t input,
+    SoundEngine* eng,
+    SoundEngineADSR* adsr,
+    uint16_t* flags) {
+    switch(adsr->envelope_state) {
+    case ATTACK: {
+        adsr->envelope += adsr->envelope_speed;
+
+        if(adsr->envelope >= MAX_ADSR) {
+            adsr->envelope_state = DECAY;
+            adsr->envelope = MAX_ADSR;
+
+            adsr->envelope_speed = envspd(eng, adsr->d);
         }
 
-        case DECAY:
-        {
-            if (adsr->envelope > ((uint32_t)adsr->s << 17) + adsr->envelope_speed)
-            {
-                adsr->envelope -= adsr->envelope_speed;
-            }
+        break;
+    }
 
-            else
-            {
-                adsr->envelope = (uint32_t)adsr->s << 17;
-                adsr->envelope_state = (adsr->s == 0) ? RELEASE : SUSTAIN;
+    case DECAY: {
+        if(adsr->envelope > ((uint32_t)adsr->s << 17) + adsr->envelope_speed) {
+            adsr->envelope -= adsr->envelope_speed;
+        }
 
-                adsr->envelope_speed = envspd(eng, adsr->r);
-            }
+        else {
+            adsr->envelope = (uint32_t)adsr->s << 17;
+            adsr->envelope_state = (adsr->s == 0) ? RELEASE : SUSTAIN;
 
-            break;
+            adsr->envelope_speed = envspd(eng, adsr->r);
         }
 
-        case SUSTAIN:
-        case DONE:
-        {
-            break;
-        }
+        break;
+    }
 
-        case RELEASE:
-        {
-            if (adsr->envelope > adsr->envelope_speed)
-            {
-                adsr->envelope -= adsr->envelope_speed;
-            }
+    case SUSTAIN:
+    case DONE: {
+        break;
+    }
 
-            else
-            {
-                adsr->envelope_state = DONE;
-                *flags &= ~SE_ENABLE_GATE;
-                adsr->envelope = 0;
-            }
+    case RELEASE: {
+        if(adsr->envelope > adsr->envelope_speed) {
+            adsr->envelope -= adsr->envelope_speed;
+        }
 
-            break;
+        else {
+            adsr->envelope_state = DONE;
+            *flags &= ~SE_ENABLE_GATE;
+            adsr->envelope = 0;
         }
+
+        break;
+    }
     }
 
     return (int32_t)((int32_t)input * (int32_t)(adsr->envelope >> 10) / (int32_t)(MAX_ADSR >> 10) * (int32_t)adsr->volume / (int32_t)MAX_ADSR_VOLUME);

sound_engine/sound_engine_adsr.h

@@ -2,4 +2,8 @@
 
 #include "sound_engine_defs.h"
 
-int32_t sound_engine_cycle_and_output_adsr(int32_t input, SoundEngine *eng, SoundEngineADSR *adsr, uint16_t *flags);
+int32_t sound_engine_cycle_and_output_adsr(
+    int32_t input,
+    SoundEngine* eng,
+    SoundEngineADSR* adsr,
+    uint16_t* flags);

sound_engine/sound_engine_defs.h

@@ -20,10 +20,12 @@
 #define MAX_ADSR (0xff << 17)
 #define MAX_ADSR_VOLUME 0x80
 #define BASE_FREQ 22050
-#define envspd(eng, slope) ((slope) != 0 ? (((uint64_t)MAX_ADSR / ((slope) * (slope)*256 / 8)) * BASE_FREQ / eng->sample_rate) : ((uint64_t)MAX_ADSR * BASE_FREQ / eng->sample_rate))
+#define envspd(eng, slope)                                                                     \
+    ((slope) != 0 ?                                                                            \
+         (((uint64_t)MAX_ADSR / ((slope) * (slope)*256 / 8)) * BASE_FREQ / eng->sample_rate) : \
+         ((uint64_t)MAX_ADSR * BASE_FREQ / eng->sample_rate))
 
-typedef enum
-{
+typedef enum {
     SE_WAVEFORM_NONE = 0,
     SE_WAVEFORM_NOISE = 1,
     SE_WAVEFORM_PULSE = 2,
@@ -33,8 +35,7 @@ typedef enum
     SE_WAVEFORM_SINE = 32,
 } SoundEngineWaveformType;
 
-typedef enum
-{
+typedef enum {
     SE_ENABLE_FILTER = 1,
     SE_ENABLE_GATE = 2,
     SE_ENABLE_RING_MOD = 4,
@@ -42,8 +43,7 @@ typedef enum
     SE_ENABLE_KEYDOWN_SYNC = 16, // sync oscillators on keydown
 } SoundEngineFlags;
 
-typedef enum
-{
+typedef enum {
     FIL_OUTPUT_LOWPASS = 1,
     FIL_OUTPUT_HIGHPASS = 2,
     FIL_OUTPUT_BANDPASS = 3,
@@ -55,8 +55,7 @@ typedef enum
     FIL_MODES = 8,
 } SoundEngineFilterModes;
 
-typedef enum
-{
+typedef enum {
     ATTACK = 1,
     DECAY = 2,
     SUSTAIN = 3,
@@ -64,19 +63,16 @@ typedef enum
     DONE = 5,
 } SoundEngineEnvelopeStates;
 
-typedef struct
-{
+typedef struct {
     uint8_t a, d, s, r, volume, envelope_state;
     uint32_t envelope, envelope_speed;
 } SoundEngineADSR;
 
-typedef struct
-{
+typedef struct {
     int32_t cutoff, resonance, low, high, band;
 } SoundEngineFilter;
 
-typedef struct
-{
+typedef struct {
     uint32_t accumulator;
     uint32_t frequency;
     uint8_t waveform;
@@ -94,11 +90,10 @@ typedef struct
     SoundEngineFilter filter;
 } SoundEngineChannel;
 
-typedef struct
-{
+typedef struct {
     SoundEngineChannel channel[NUM_CHANNELS];
     uint32_t sample_rate;
-    uint16_t *audio_buffer;
+    uint16_t* audio_buffer;
     uint32_t audio_buffer_size;
     bool external_audio_output;
     uint8_t sine_lut[SINE_LUT_SIZE];

sound_engine/sound_engine_filter.c

@@ -1,12 +1,13 @@
 #include "sound_engine_filter.h"
 
-void sound_engine_filter_set_coeff(SoundEngineFilter *flt, uint32_t frequency, uint16_t resonance)
-{
+void sound_engine_filter_set_coeff(SoundEngineFilter* flt, uint32_t frequency, uint16_t resonance) {
     flt->cutoff = (frequency << 5);
     flt->resonance = ((int32_t)resonance * 11 / 6) - 200;
 }
 
-void sound_engine_filter_cycle(SoundEngineFilter *flt, int32_t input) // don't ask me how it works, stolen from Furnace tracker TSU synth
+void sound_engine_filter_cycle(
+    SoundEngineFilter* flt,
+    int32_t input) // don't ask me how it works, stolen from Furnace tracker TSU synth
 {
     input /= 8;
     flt->low = flt->low + ((flt->cutoff * flt->band) >> 16);
@@ -14,17 +15,14 @@ void sound_engine_filter_cycle(SoundEngineFilter *flt, int32_t input) // don't a
     flt->band = ((flt->cutoff * flt->high) >> 16) + flt->band;
 }
 
-int32_t sound_engine_output_lowpass(SoundEngineFilter *flt)
-{
+int32_t sound_engine_output_lowpass(SoundEngineFilter* flt) {
     return flt->low * 8;
 }
 
-int32_t sound_engine_output_highpass(SoundEngineFilter *flt)
-{
+int32_t sound_engine_output_highpass(SoundEngineFilter* flt) {
     return flt->high * 8;
 }
 
-int32_t sound_engine_output_bandpass(SoundEngineFilter *flt)
-{
+int32_t sound_engine_output_bandpass(SoundEngineFilter* flt) {
     return flt->band * 8;
 }

sound_engine/sound_engine_filter.h

@@ -2,8 +2,8 @@
 
 #include "sound_engine_defs.h"
 
-void sound_engine_filter_set_coeff(SoundEngineFilter *flt, uint32_t frequency, uint16_t resonance);
-void sound_engine_filter_cycle(SoundEngineFilter *flt, int32_t input);
-int32_t sound_engine_output_lowpass(SoundEngineFilter *flt);
-int32_t sound_engine_output_highpass(SoundEngineFilter *flt);
-int32_t sound_engine_output_bandpass(SoundEngineFilter *flt);
+void sound_engine_filter_set_coeff(SoundEngineFilter* flt, uint32_t frequency, uint16_t resonance);
+void sound_engine_filter_cycle(SoundEngineFilter* flt, int32_t input);
+int32_t sound_engine_output_lowpass(SoundEngineFilter* flt);
+int32_t sound_engine_output_highpass(SoundEngineFilter* flt);
+int32_t sound_engine_output_bandpass(SoundEngineFilter* flt);

sound_engine/sound_engine_osc.c

@@ -2,47 +2,45 @@
 
 static inline uint16_t sound_engine_pulse(uint32_t acc, uint32_t pw) // 0-FFF pulse width range
 {
-    return (((acc >> (((uint32_t)ACC_BITS - 17))) >= ((pw == 0xfff ? pw + 1 : pw) << 4) ? (WAVE_AMP - 1) : 0));
+    return (
+        ((acc >> (((uint32_t)ACC_BITS - 17))) >= ((pw == 0xfff ? pw + 1 : pw) << 4) ?
+             (WAVE_AMP - 1) :
+             0));
 }
 
-static inline uint16_t sound_engine_saw(uint32_t acc)
-{
+static inline uint16_t sound_engine_saw(uint32_t acc) {
     return (acc >> (ACC_BITS - OUTPUT_BITS - 1)) & (WAVE_AMP - 1);
 }
 
-uint16_t sound_engine_triangle(uint32_t acc)
-{
-    return ((((acc & (ACC_LENGTH / 2)) ? ~acc : acc) >> (ACC_BITS - OUTPUT_BITS - 2)) & (WAVE_AMP * 2 - 1));
+uint16_t sound_engine_triangle(uint32_t acc) {
+    return (
+        (((acc & (ACC_LENGTH / 2)) ? ~acc : acc) >> (ACC_BITS - OUTPUT_BITS - 2)) &
+        (WAVE_AMP * 2 - 1));
 }
 
-static inline uint16_t sound_engine_sine(uint32_t acc, SoundEngine *sound_engine)
-{
-    return ((uint16_t)sound_engine->sine_lut[(acc >> (ACC_BITS - SINE_LUT_BITDEPTH))] << (OUTPUT_BITS - SINE_LUT_BITDEPTH));
+static inline uint16_t sound_engine_sine(uint32_t acc, SoundEngine* sound_engine) {
+    return (
+        (uint16_t)sound_engine->sine_lut[(acc >> (ACC_BITS - SINE_LUT_BITDEPTH))]
+        << (OUTPUT_BITS - SINE_LUT_BITDEPTH));
 }
 
-inline static void shift_lfsr(uint32_t *v, uint32_t tap_0, uint32_t tap_1)
-{
+inline static void shift_lfsr(uint32_t* v, uint32_t tap_0, uint32_t tap_1) {
     typedef uint32_t T;
     const T zero = (T)(0);
     const T lsb = zero + (T)(1);
-    const T feedback = ((lsb << (tap_0)) ^
-                        (lsb << (tap_1)));
+    const T feedback = ((lsb << (tap_0)) ^ (lsb << (tap_1)));
 
     *v = (*v >> 1) ^ ((zero - (*v & lsb)) & feedback);
 }
 
-static inline uint16_t sound_engine_noise(SoundEngineChannel *channel, uint32_t prev_acc)
-{
-    if ((prev_acc & (ACC_LENGTH / 32)) != (channel->accumulator & (ACC_LENGTH / 32)))
-    {
-        if (channel->waveform & SE_WAVEFORM_NOISE_METAL)
-        {
+static inline uint16_t sound_engine_noise(SoundEngineChannel* channel, uint32_t prev_acc) {
+    if((prev_acc & (ACC_LENGTH / 32)) != (channel->accumulator & (ACC_LENGTH / 32))) {
+        if(channel->waveform & SE_WAVEFORM_NOISE_METAL) {
             shift_lfsr(&channel->lfsr, 14, 8);
             channel->lfsr &= (1 << (14 + 1)) - 1;
         }
 
-        else
-        {
+        else {
             shift_lfsr(&channel->lfsr, 22, 17);
             channel->lfsr &= (1 << (22 + 1)) - 1;
         }
@@ -51,204 +49,229 @@ static inline uint16_t sound_engine_noise(SoundEngineChannel *channel, uint32_t
     return (channel->lfsr) & (WAVE_AMP - 1);
 }
 
-uint16_t sound_engine_osc(SoundEngine *sound_engine, SoundEngineChannel *channel, uint32_t prev_acc)
-{
-    switch (channel->waveform)
-    {
-        case SE_WAVEFORM_NOISE:
-        case SE_WAVEFORM_NOISE_METAL:
-        case (SE_WAVEFORM_NOISE | SE_WAVEFORM_NOISE_METAL):
-        {
-            return sound_engine_noise(channel, prev_acc);
-            break;
-        }
+uint16_t
+    sound_engine_osc(SoundEngine* sound_engine, SoundEngineChannel* channel, uint32_t prev_acc) {
+    switch(channel->waveform) {
+    case SE_WAVEFORM_NOISE:
+    case SE_WAVEFORM_NOISE_METAL:
+    case(SE_WAVEFORM_NOISE | SE_WAVEFORM_NOISE_METAL): {
+        return sound_engine_noise(channel, prev_acc);
+        break;
+    }
 
-        case SE_WAVEFORM_PULSE:
-        {
-            return sound_engine_pulse(channel->accumulator, channel->pw);
-            break;
-        }
+    case SE_WAVEFORM_PULSE: {
+        return sound_engine_pulse(channel->accumulator, channel->pw);
+        break;
+    }
 
-        case SE_WAVEFORM_TRIANGLE:
-        {
-            return sound_engine_triangle(channel->accumulator);
-            break;
-        }
+    case SE_WAVEFORM_TRIANGLE: {
+        return sound_engine_triangle(channel->accumulator);
+        break;
+    }
 
-        case SE_WAVEFORM_SAW:
-        {
-            return sound_engine_saw(channel->accumulator);
-            break;
-        }
+    case SE_WAVEFORM_SAW: {
+        return sound_engine_saw(channel->accumulator);
+        break;
+    }
 
-        case SE_WAVEFORM_SINE:
-        {
-            return sound_engine_sine(channel->accumulator, sound_engine);
-            break;
-        }
+    case SE_WAVEFORM_SINE: {
+        return sound_engine_sine(channel->accumulator, sound_engine);
+        break;
+    }
 
-        case (SE_WAVEFORM_PULSE | SE_WAVEFORM_NOISE):
-        case (SE_WAVEFORM_PULSE | SE_WAVEFORM_NOISE_METAL):
-        case (SE_WAVEFORM_PULSE | SE_WAVEFORM_NOISE | SE_WAVEFORM_NOISE_METAL):
-        {
-            return sound_engine_pulse(channel->accumulator, channel->pw) & sound_engine_noise(channel, prev_acc);
-        }
+    case(SE_WAVEFORM_PULSE | SE_WAVEFORM_NOISE):
+    case(SE_WAVEFORM_PULSE | SE_WAVEFORM_NOISE_METAL):
+    case(SE_WAVEFORM_PULSE | SE_WAVEFORM_NOISE | SE_WAVEFORM_NOISE_METAL): {
+        return sound_engine_pulse(channel->accumulator, channel->pw) &
+               sound_engine_noise(channel, prev_acc);
+    }
 
-        case (SE_WAVEFORM_TRIANGLE | SE_WAVEFORM_NOISE):
-        case (SE_WAVEFORM_TRIANGLE | SE_WAVEFORM_NOISE_METAL):
-        case (SE_WAVEFORM_TRIANGLE | SE_WAVEFORM_NOISE | SE_WAVEFORM_NOISE_METAL):
-        {
-            return sound_engine_triangle(channel->accumulator) & sound_engine_noise(channel, prev_acc);
-        }
+    case(SE_WAVEFORM_TRIANGLE | SE_WAVEFORM_NOISE):
+    case(SE_WAVEFORM_TRIANGLE | SE_WAVEFORM_NOISE_METAL):
+    case(SE_WAVEFORM_TRIANGLE | SE_WAVEFORM_NOISE | SE_WAVEFORM_NOISE_METAL): {
+        return sound_engine_triangle(channel->accumulator) & sound_engine_noise(channel, prev_acc);
+    }
 
-        case (SE_WAVEFORM_PULSE | SE_WAVEFORM_TRIANGLE):
-        {
-            return sound_engine_pulse(channel->accumulator, channel->pw) & sound_engine_triangle(channel->accumulator);
-        }
+    case(SE_WAVEFORM_PULSE | SE_WAVEFORM_TRIANGLE): {
+        return sound_engine_pulse(channel->accumulator, channel->pw) &
+               sound_engine_triangle(channel->accumulator);
+    }
 
-        case (SE_WAVEFORM_TRIANGLE | SE_WAVEFORM_PULSE | SE_WAVEFORM_NOISE):
-        case (SE_WAVEFORM_TRIANGLE | SE_WAVEFORM_PULSE | SE_WAVEFORM_NOISE_METAL):
-        case (SE_WAVEFORM_TRIANGLE | SE_WAVEFORM_PULSE | SE_WAVEFORM_NOISE | SE_WAVEFORM_NOISE_METAL):
-        {
-            return sound_engine_pulse(channel->accumulator, channel->pw) & sound_engine_noise(channel, prev_acc) & sound_engine_triangle(channel->accumulator);
-        }
+    case(SE_WAVEFORM_TRIANGLE | SE_WAVEFORM_PULSE | SE_WAVEFORM_NOISE):
+    case(SE_WAVEFORM_TRIANGLE | SE_WAVEFORM_PULSE | SE_WAVEFORM_NOISE_METAL):
+    case(SE_WAVEFORM_TRIANGLE | SE_WAVEFORM_PULSE | SE_WAVEFORM_NOISE | SE_WAVEFORM_NOISE_METAL): {
+        return sound_engine_pulse(channel->accumulator, channel->pw) &
+               sound_engine_noise(channel, prev_acc) & sound_engine_triangle(channel->accumulator);
+    }
 
-        case (SE_WAVEFORM_SAW | SE_WAVEFORM_NOISE):
-        case (SE_WAVEFORM_SAW | SE_WAVEFORM_NOISE_METAL):
-        case (SE_WAVEFORM_SAW | SE_WAVEFORM_NOISE | SE_WAVEFORM_NOISE_METAL):
-        {
-            return sound_engine_saw(channel->accumulator) & sound_engine_noise(channel, prev_acc);
-        }
+    case(SE_WAVEFORM_SAW | SE_WAVEFORM_NOISE):
+    case(SE_WAVEFORM_SAW | SE_WAVEFORM_NOISE_METAL):
+    case(SE_WAVEFORM_SAW | SE_WAVEFORM_NOISE | SE_WAVEFORM_NOISE_METAL): {
+        return sound_engine_saw(channel->accumulator) & sound_engine_noise(channel, prev_acc);
+    }
 
-        case (SE_WAVEFORM_PULSE | SE_WAVEFORM_SAW):
-        {
-            return sound_engine_pulse(channel->accumulator, channel->pw) & sound_engine_saw(channel->accumulator);
-        }
+    case(SE_WAVEFORM_PULSE | SE_WAVEFORM_SAW): {
+        return sound_engine_pulse(channel->accumulator, channel->pw) &
+               sound_engine_saw(channel->accumulator);
+    }
 
-        case (SE_WAVEFORM_PULSE | SE_WAVEFORM_SAW | SE_WAVEFORM_NOISE):
-        case (SE_WAVEFORM_PULSE | SE_WAVEFORM_SAW | SE_WAVEFORM_NOISE_METAL):
-        case (SE_WAVEFORM_PULSE | SE_WAVEFORM_SAW | SE_WAVEFORM_NOISE | SE_WAVEFORM_NOISE_METAL):
-        {
-            return sound_engine_pulse(channel->accumulator, channel->pw) & sound_engine_saw(channel->accumulator) & sound_engine_noise(channel, prev_acc);
-        }
+    case(SE_WAVEFORM_PULSE | SE_WAVEFORM_SAW | SE_WAVEFORM_NOISE):
+    case(SE_WAVEFORM_PULSE | SE_WAVEFORM_SAW | SE_WAVEFORM_NOISE_METAL):
+    case(SE_WAVEFORM_PULSE | SE_WAVEFORM_SAW | SE_WAVEFORM_NOISE | SE_WAVEFORM_NOISE_METAL): {
+        return sound_engine_pulse(channel->accumulator, channel->pw) &
+               sound_engine_saw(channel->accumulator) & sound_engine_noise(channel, prev_acc);
+    }
 
-        case (SE_WAVEFORM_TRIANGLE | SE_WAVEFORM_SAW):
-        {
-            return sound_engine_triangle(channel->accumulator) & sound_engine_saw(channel->accumulator);
-        }
+    case(SE_WAVEFORM_TRIANGLE | SE_WAVEFORM_SAW): {
+        return sound_engine_triangle(channel->accumulator) &
+               sound_engine_saw(channel->accumulator);
+    }
 
-        case (SE_WAVEFORM_TRIANGLE | SE_WAVEFORM_SAW | SE_WAVEFORM_NOISE):
-        case (SE_WAVEFORM_TRIANGLE | SE_WAVEFORM_SAW | SE_WAVEFORM_NOISE_METAL):
-        case (SE_WAVEFORM_TRIANGLE | SE_WAVEFORM_SAW | SE_WAVEFORM_NOISE | SE_WAVEFORM_NOISE_METAL):
-        {
-            return sound_engine_triangle(channel->accumulator) & sound_engine_saw(channel->accumulator) & sound_engine_noise(channel, prev_acc);
-        }
+    case(SE_WAVEFORM_TRIANGLE | SE_WAVEFORM_SAW | SE_WAVEFORM_NOISE):
+    case(SE_WAVEFORM_TRIANGLE | SE_WAVEFORM_SAW | SE_WAVEFORM_NOISE_METAL):
+    case(SE_WAVEFORM_TRIANGLE | SE_WAVEFORM_SAW | SE_WAVEFORM_NOISE | SE_WAVEFORM_NOISE_METAL): {
+        return sound_engine_triangle(channel->accumulator) &
+               sound_engine_saw(channel->accumulator) & sound_engine_noise(channel, prev_acc);
+    }
 
-        case (SE_WAVEFORM_PULSE | SE_WAVEFORM_TRIANGLE | SE_WAVEFORM_SAW):
-        {
-            return sound_engine_pulse(channel->accumulator, channel->pw) & sound_engine_triangle(channel->accumulator) & sound_engine_saw(channel->accumulator);
-        }
+    case(SE_WAVEFORM_PULSE | SE_WAVEFORM_TRIANGLE | SE_WAVEFORM_SAW): {
+        return sound_engine_pulse(channel->accumulator, channel->pw) &
+               sound_engine_triangle(channel->accumulator) &
+               sound_engine_saw(channel->accumulator);
+    }
 
-        case (SE_WAVEFORM_PULSE | SE_WAVEFORM_TRIANGLE | SE_WAVEFORM_SAW | SE_WAVEFORM_NOISE):
-        case (SE_WAVEFORM_PULSE | SE_WAVEFORM_TRIANGLE | SE_WAVEFORM_SAW | SE_WAVEFORM_NOISE_METAL):
-        case (SE_WAVEFORM_PULSE | SE_WAVEFORM_TRIANGLE | SE_WAVEFORM_SAW | SE_WAVEFORM_NOISE | SE_WAVEFORM_NOISE_METAL):
-        {
-            return sound_engine_pulse(channel->accumulator, channel->pw) & sound_engine_triangle(channel->accumulator) & sound_engine_saw(channel->accumulator) & sound_engine_noise(channel, prev_acc);
-        }
+    case(SE_WAVEFORM_PULSE | SE_WAVEFORM_TRIANGLE | SE_WAVEFORM_SAW | SE_WAVEFORM_NOISE):
+    case(SE_WAVEFORM_PULSE | SE_WAVEFORM_TRIANGLE | SE_WAVEFORM_SAW | SE_WAVEFORM_NOISE_METAL):
+    case(
+        SE_WAVEFORM_PULSE | SE_WAVEFORM_TRIANGLE | SE_WAVEFORM_SAW | SE_WAVEFORM_NOISE |
+        SE_WAVEFORM_NOISE_METAL): {
+        return sound_engine_pulse(channel->accumulator, channel->pw) &
+               sound_engine_triangle(channel->accumulator) &
+               sound_engine_saw(channel->accumulator) & sound_engine_noise(channel, prev_acc);
+    }
 
-        case (SE_WAVEFORM_SINE | SE_WAVEFORM_NOISE):
-        case (SE_WAVEFORM_SINE | SE_WAVEFORM_NOISE_METAL):
-        case (SE_WAVEFORM_SINE | SE_WAVEFORM_NOISE | SE_WAVEFORM_NOISE_METAL):
-        {
-            return sound_engine_sine(channel->accumulator, sound_engine) & sound_engine_noise(channel, prev_acc);
-        }
+    case(SE_WAVEFORM_SINE | SE_WAVEFORM_NOISE):
+    case(SE_WAVEFORM_SINE | SE_WAVEFORM_NOISE_METAL):
+    case(SE_WAVEFORM_SINE | SE_WAVEFORM_NOISE | SE_WAVEFORM_NOISE_METAL): {
+        return sound_engine_sine(channel->accumulator, sound_engine) &
+               sound_engine_noise(channel, prev_acc);
+    }
 
-        case (SE_WAVEFORM_SINE | SE_WAVEFORM_PULSE):
-        {
-            return sound_engine_pulse(channel->accumulator, channel->pw) & sound_engine_sine(channel->accumulator, sound_engine);
-        }
+    case(SE_WAVEFORM_SINE | SE_WAVEFORM_PULSE): {
+        return sound_engine_pulse(channel->accumulator, channel->pw) &
+               sound_engine_sine(channel->accumulator, sound_engine);
+    }
 
-        case (SE_WAVEFORM_SINE | SE_WAVEFORM_PULSE | SE_WAVEFORM_NOISE):
-        case (SE_WAVEFORM_SINE | SE_WAVEFORM_PULSE | SE_WAVEFORM_NOISE_METAL):
-        case (SE_WAVEFORM_SINE | SE_WAVEFORM_PULSE | SE_WAVEFORM_NOISE | SE_WAVEFORM_NOISE_METAL):
-        {
-            return sound_engine_pulse(channel->accumulator, channel->pw) & sound_engine_sine(channel->accumulator, sound_engine) & sound_engine_noise(channel, prev_acc);
-        }
+    case(SE_WAVEFORM_SINE | SE_WAVEFORM_PULSE | SE_WAVEFORM_NOISE):
+    case(SE_WAVEFORM_SINE | SE_WAVEFORM_PULSE | SE_WAVEFORM_NOISE_METAL):
+    case(SE_WAVEFORM_SINE | SE_WAVEFORM_PULSE | SE_WAVEFORM_NOISE | SE_WAVEFORM_NOISE_METAL): {
+        return sound_engine_pulse(channel->accumulator, channel->pw) &
+               sound_engine_sine(channel->accumulator, sound_engine) &
+               sound_engine_noise(channel, prev_acc);
+    }
 
-        case (SE_WAVEFORM_SINE | SE_WAVEFORM_TRIANGLE):
-        {
-            return sound_engine_triangle(channel->accumulator) & sound_engine_sine(channel->accumulator, sound_engine);
-        }
+    case(SE_WAVEFORM_SINE | SE_WAVEFORM_TRIANGLE): {
+        return sound_engine_triangle(channel->accumulator) &
+               sound_engine_sine(channel->accumulator, sound_engine);
+    }
 
-        case (SE_WAVEFORM_SINE | SE_WAVEFORM_TRIANGLE | SE_WAVEFORM_NOISE):
-        case (SE_WAVEFORM_SINE | SE_WAVEFORM_TRIANGLE | SE_WAVEFORM_NOISE_METAL):
-        case (SE_WAVEFORM_SINE | SE_WAVEFORM_TRIANGLE | SE_WAVEFORM_NOISE | SE_WAVEFORM_NOISE_METAL):
-        {
-            return sound_engine_triangle(channel->accumulator) & sound_engine_sine(channel->accumulator, sound_engine) & sound_engine_noise(channel, prev_acc);
-        }
+    case(SE_WAVEFORM_SINE | SE_WAVEFORM_TRIANGLE | SE_WAVEFORM_NOISE):
+    case(SE_WAVEFORM_SINE | SE_WAVEFORM_TRIANGLE | SE_WAVEFORM_NOISE_METAL):
+    case(SE_WAVEFORM_SINE | SE_WAVEFORM_TRIANGLE | SE_WAVEFORM_NOISE | SE_WAVEFORM_NOISE_METAL): {
+        return sound_engine_triangle(channel->accumulator) &
+               sound_engine_sine(channel->accumulator, sound_engine) &
+               sound_engine_noise(channel, prev_acc);
+    }
 
-        case (SE_WAVEFORM_SINE | SE_WAVEFORM_TRIANGLE | SE_WAVEFORM_PULSE):
-        {
-            return sound_engine_pulse(channel->accumulator, channel->pw) & sound_engine_triangle(channel->accumulator) & sound_engine_sine(channel->accumulator, sound_engine);
-        }
+    case(SE_WAVEFORM_SINE | SE_WAVEFORM_TRIANGLE | SE_WAVEFORM_PULSE): {
+        return sound_engine_pulse(channel->accumulator, channel->pw) &
+               sound_engine_triangle(channel->accumulator) &
+               sound_engine_sine(channel->accumulator, sound_engine);
+    }
 
-        case (SE_WAVEFORM_SINE | SE_WAVEFORM_TRIANGLE | SE_WAVEFORM_PULSE | SE_WAVEFORM_NOISE):
-        case (SE_WAVEFORM_SINE | SE_WAVEFORM_TRIANGLE | SE_WAVEFORM_PULSE | SE_WAVEFORM_NOISE_METAL):
-        case (SE_WAVEFORM_SINE | SE_WAVEFORM_TRIANGLE | SE_WAVEFORM_PULSE | SE_WAVEFORM_NOISE | SE_WAVEFORM_NOISE_METAL):
-        {
-            return sound_engine_pulse(channel->accumulator, channel->pw) & sound_engine_triangle(channel->accumulator) & sound_engine_sine(channel->accumulator, sound_engine) & sound_engine_noise(channel, prev_acc);
-        }
+    case(SE_WAVEFORM_SINE | SE_WAVEFORM_TRIANGLE | SE_WAVEFORM_PULSE | SE_WAVEFORM_NOISE):
+    case(SE_WAVEFORM_SINE | SE_WAVEFORM_TRIANGLE | SE_WAVEFORM_PULSE | SE_WAVEFORM_NOISE_METAL):
+    case(
+        SE_WAVEFORM_SINE | SE_WAVEFORM_TRIANGLE | SE_WAVEFORM_PULSE | SE_WAVEFORM_NOISE |
+        SE_WAVEFORM_NOISE_METAL): {
+        return sound_engine_pulse(channel->accumulator, channel->pw) &
+               sound_engine_triangle(channel->accumulator) &
+               sound_engine_sine(channel->accumulator, sound_engine) &
+               sound_engine_noise(channel, prev_acc);
+    }
 
-        case (SE_WAVEFORM_SINE | SE_WAVEFORM_SAW):
-        {
-            return sound_engine_saw(channel->accumulator) & sound_engine_sine(channel->accumulator, sound_engine);
-        }
+    case(SE_WAVEFORM_SINE | SE_WAVEFORM_SAW): {
+        return sound_engine_saw(channel->accumulator) &
+               sound_engine_sine(channel->accumulator, sound_engine);
+    }
 
-        case (SE_WAVEFORM_SINE | SE_WAVEFORM_SAW | SE_WAVEFORM_NOISE):
-        case (SE_WAVEFORM_SINE | SE_WAVEFORM_SAW | SE_WAVEFORM_NOISE_METAL):
-        case (SE_WAVEFORM_SINE | SE_WAVEFORM_SAW | SE_WAVEFORM_NOISE | SE_WAVEFORM_NOISE_METAL):
-        {
-            return sound_engine_saw(channel->accumulator) & sound_engine_sine(channel->accumulator, sound_engine) & sound_engine_noise(channel, prev_acc);
-        }
+    case(SE_WAVEFORM_SINE | SE_WAVEFORM_SAW | SE_WAVEFORM_NOISE):
+    case(SE_WAVEFORM_SINE | SE_WAVEFORM_SAW | SE_WAVEFORM_NOISE_METAL):
+    case(SE_WAVEFORM_SINE | SE_WAVEFORM_SAW | SE_WAVEFORM_NOISE | SE_WAVEFORM_NOISE_METAL): {
+        return sound_engine_saw(channel->accumulator) &
+               sound_engine_sine(channel->accumulator, sound_engine) &
+               sound_engine_noise(channel, prev_acc);
+    }
 
-        case (SE_WAVEFORM_SINE | SE_WAVEFORM_PULSE | SE_WAVEFORM_SAW):
-        {
-            return sound_engine_pulse(channel->accumulator, channel->pw) & sound_engine_saw(channel->accumulator) & sound_engine_sine(channel->accumulator, sound_engine);
-        }
+    case(SE_WAVEFORM_SINE | SE_WAVEFORM_PULSE | SE_WAVEFORM_SAW): {
+        return sound_engine_pulse(channel->accumulator, channel->pw) &
+               sound_engine_saw(channel->accumulator) &
+               sound_engine_sine(channel->accumulator, sound_engine);
+    }
 
-        case (SE_WAVEFORM_SINE | SE_WAVEFORM_PULSE | SE_WAVEFORM_SAW | SE_WAVEFORM_NOISE):
-        case (SE_WAVEFORM_SINE | SE_WAVEFORM_PULSE | SE_WAVEFORM_SAW | SE_WAVEFORM_NOISE_METAL):
-        case (SE_WAVEFORM_SINE | SE_WAVEFORM_PULSE | SE_WAVEFORM_SAW | SE_WAVEFORM_NOISE | SE_WAVEFORM_NOISE_METAL):
-        {
-            return sound_engine_pulse(channel->accumulator, channel->pw) & sound_engine_saw(channel->accumulator) & sound_engine_sine(channel->accumulator, sound_engine) & sound_engine_noise(channel, prev_acc);
-        }
+    case(SE_WAVEFORM_SINE | SE_WAVEFORM_PULSE | SE_WAVEFORM_SAW | SE_WAVEFORM_NOISE):
+    case(SE_WAVEFORM_SINE | SE_WAVEFORM_PULSE | SE_WAVEFORM_SAW | SE_WAVEFORM_NOISE_METAL):
+    case(
+        SE_WAVEFORM_SINE | SE_WAVEFORM_PULSE | SE_WAVEFORM_SAW | SE_WAVEFORM_NOISE |
+        SE_WAVEFORM_NOISE_METAL): {
+        return sound_engine_pulse(channel->accumulator, channel->pw) &
+               sound_engine_saw(channel->accumulator) &
+               sound_engine_sine(channel->accumulator, sound_engine) &
+               sound_engine_noise(channel, prev_acc);
+    }
 
-        case (SE_WAVEFORM_SINE | SE_WAVEFORM_TRIANGLE | SE_WAVEFORM_SAW):
-        {
-            return sound_engine_saw(channel->accumulator) & sound_engine_triangle(channel->accumulator) & sound_engine_sine(channel->accumulator, sound_engine);
-        }
+    case(SE_WAVEFORM_SINE | SE_WAVEFORM_TRIANGLE | SE_WAVEFORM_SAW): {
+        return sound_engine_saw(channel->accumulator) &
+               sound_engine_triangle(channel->accumulator) &
+               sound_engine_sine(channel->accumulator, sound_engine);
+    }
 
-        case (SE_WAVEFORM_SINE | SE_WAVEFORM_TRIANGLE | SE_WAVEFORM_SAW | SE_WAVEFORM_NOISE):
-        case (SE_WAVEFORM_SINE | SE_WAVEFORM_TRIANGLE | SE_WAVEFORM_SAW | SE_WAVEFORM_NOISE_METAL):
-        case (SE_WAVEFORM_SINE | SE_WAVEFORM_TRIANGLE | SE_WAVEFORM_SAW | SE_WAVEFORM_NOISE | SE_WAVEFORM_NOISE_METAL):
-        {
-            return sound_engine_saw(channel->accumulator) & sound_engine_triangle(channel->accumulator) & sound_engine_sine(channel->accumulator, sound_engine) & sound_engine_noise(channel, prev_acc);
-        }
+    case(SE_WAVEFORM_SINE | SE_WAVEFORM_TRIANGLE | SE_WAVEFORM_SAW | SE_WAVEFORM_NOISE):
+    case(SE_WAVEFORM_SINE | SE_WAVEFORM_TRIANGLE | SE_WAVEFORM_SAW | SE_WAVEFORM_NOISE_METAL):
+    case(
+        SE_WAVEFORM_SINE | SE_WAVEFORM_TRIANGLE | SE_WAVEFORM_SAW | SE_WAVEFORM_NOISE |
+        SE_WAVEFORM_NOISE_METAL): {
+        return sound_engine_saw(channel->accumulator) &
+               sound_engine_triangle(channel->accumulator) &
+               sound_engine_sine(channel->accumulator, sound_engine) &
+               sound_engine_noise(channel, prev_acc);
+    }
 
-        case (SE_WAVEFORM_SINE | SE_WAVEFORM_PULSE | SE_WAVEFORM_TRIANGLE | SE_WAVEFORM_SAW):
-        {
-            return sound_engine_saw(channel->accumulator) & sound_engine_pulse(channel->accumulator, channel->pw) & sound_engine_triangle(channel->accumulator) & sound_engine_sine(channel->accumulator, sound_engine);
-        }
+    case(SE_WAVEFORM_SINE | SE_WAVEFORM_PULSE | SE_WAVEFORM_TRIANGLE | SE_WAVEFORM_SAW): {
+        return sound_engine_saw(channel->accumulator) &
+               sound_engine_pulse(channel->accumulator, channel->pw) &
+               sound_engine_triangle(channel->accumulator) &
+               sound_engine_sine(channel->accumulator, sound_engine);
+    }
 
-        case (SE_WAVEFORM_SINE | SE_WAVEFORM_PULSE | SE_WAVEFORM_TRIANGLE | SE_WAVEFORM_SAW | SE_WAVEFORM_NOISE):
-        case (SE_WAVEFORM_SINE | SE_WAVEFORM_PULSE | SE_WAVEFORM_TRIANGLE | SE_WAVEFORM_SAW | SE_WAVEFORM_NOISE_METAL):
-        case (SE_WAVEFORM_SINE | SE_WAVEFORM_PULSE | SE_WAVEFORM_TRIANGLE | SE_WAVEFORM_SAW | SE_WAVEFORM_NOISE | SE_WAVEFORM_NOISE_METAL):
-        {
-            return sound_engine_saw(channel->accumulator) & sound_engine_pulse(channel->accumulator, channel->pw) & sound_engine_triangle(channel->accumulator) & sound_engine_sine(channel->accumulator, sound_engine) & sound_engine_noise(channel, prev_acc);
-        }
+    case(
+        SE_WAVEFORM_SINE | SE_WAVEFORM_PULSE | SE_WAVEFORM_TRIANGLE | SE_WAVEFORM_SAW |
+        SE_WAVEFORM_NOISE):
+    case(
+        SE_WAVEFORM_SINE | SE_WAVEFORM_PULSE | SE_WAVEFORM_TRIANGLE | SE_WAVEFORM_SAW |
+        SE_WAVEFORM_NOISE_METAL):
+    case(
+        SE_WAVEFORM_SINE | SE_WAVEFORM_PULSE | SE_WAVEFORM_TRIANGLE | SE_WAVEFORM_SAW |
+        SE_WAVEFORM_NOISE | SE_WAVEFORM_NOISE_METAL): {
+        return sound_engine_saw(channel->accumulator) &
+               sound_engine_pulse(channel->accumulator, channel->pw) &
+               sound_engine_triangle(channel->accumulator) &
+               sound_engine_sine(channel->accumulator, sound_engine) &
+               sound_engine_noise(channel, prev_acc);
+    }
 
-        default:
-            break;
+    default:
+        break;
     }
 
     return WAVE_AMP / 2;

sound_engine/sound_engine_osc.h

@@ -4,4 +4,5 @@
 
 uint16_t sound_engine_triangle(uint32_t acc);
 
-uint16_t sound_engine_osc(SoundEngine *sound_engine, SoundEngineChannel *channel, uint32_t prev_acc);
+uint16_t
+    sound_engine_osc(SoundEngine* sound_engine, SoundEngineChannel* channel, uint32_t prev_acc);

tracker_engine/diskop.c

@@ -1,71 +1,66 @@
 #include "diskop.h"
 
-void load_instrument_inner(Stream *stream, Instrument *inst)
-{
-    size_t rwops = stream_read(stream, (uint8_t *)inst->name, sizeof(inst->name));
-    rwops = stream_read(stream, (uint8_t *)&inst->waveform, sizeof(inst->waveform));
-    rwops = stream_read(stream, (uint8_t *)&inst->flags, sizeof(inst->flags));
-    rwops = stream_read(stream, (uint8_t *)&inst->sound_engine_flags, sizeof(inst->sound_engine_flags));
+void load_instrument_inner(Stream* stream, Instrument* inst) {
+    size_t rwops = stream_read(stream, (uint8_t*)inst->name, sizeof(inst->name));
+    rwops = stream_read(stream, (uint8_t*)&inst->waveform, sizeof(inst->waveform));
+    rwops = stream_read(stream, (uint8_t*)&inst->flags, sizeof(inst->flags));
+    rwops =
+        stream_read(stream, (uint8_t*)&inst->sound_engine_flags, sizeof(inst->sound_engine_flags));
 
-    rwops = stream_read(stream, (uint8_t *)&inst->base_note, sizeof(inst->base_note));
-    rwops = stream_read(stream, (uint8_t *)&inst->finetune, sizeof(inst->finetune));
+    rwops = stream_read(stream, (uint8_t*)&inst->base_note, sizeof(inst->base_note));
+    rwops = stream_read(stream, (uint8_t*)&inst->finetune, sizeof(inst->finetune));
 
-    rwops = stream_read(stream, (uint8_t *)&inst->slide_speed, sizeof(inst->slide_speed));
+    rwops = stream_read(stream, (uint8_t*)&inst->slide_speed, sizeof(inst->slide_speed));
 
-    rwops = stream_read(stream, (uint8_t *)&inst->adsr, sizeof(inst->adsr));
-    rwops = stream_read(stream, (uint8_t *)&inst->pw, sizeof(inst->pw));
+    rwops = stream_read(stream, (uint8_t*)&inst->adsr, sizeof(inst->adsr));
+    rwops = stream_read(stream, (uint8_t*)&inst->pw, sizeof(inst->pw));
 
-    if (inst->sound_engine_flags & SE_ENABLE_RING_MOD)
-    {
-        rwops = stream_read(stream, (uint8_t *)&inst->ring_mod, sizeof(inst->ring_mod));
+    if(inst->sound_engine_flags & SE_ENABLE_RING_MOD) {
+        rwops = stream_read(stream, (uint8_t*)&inst->ring_mod, sizeof(inst->ring_mod));
     }
 
-    if (inst->sound_engine_flags & SE_ENABLE_HARD_SYNC)
-    {
-        rwops = stream_read(stream, (uint8_t *)&inst->hard_sync, sizeof(inst->hard_sync));
+    if(inst->sound_engine_flags & SE_ENABLE_HARD_SYNC) {
+        rwops = stream_read(stream, (uint8_t*)&inst->hard_sync, sizeof(inst->hard_sync));
     }
 
     uint8_t progsteps = 0;
 
-    rwops = stream_read(stream, (uint8_t *)&progsteps, sizeof(progsteps));
+    rwops = stream_read(stream, (uint8_t*)&progsteps, sizeof(progsteps));
 
-    if (progsteps > 0)
-    {
-        rwops = stream_read(stream, (uint8_t *)inst->program, progsteps * sizeof(inst->program[0]));
+    if(progsteps > 0) {
+        rwops = stream_read(stream, (uint8_t*)inst->program, progsteps * sizeof(inst->program[0]));
     }
 
-    rwops = stream_read(stream, (uint8_t *)&inst->program_period, sizeof(inst->program_period));
+    rwops = stream_read(stream, (uint8_t*)&inst->program_period, sizeof(inst->program_period));
 
-    if (inst->flags & TE_ENABLE_VIBRATO)
-    {
-        rwops = stream_read(stream, (uint8_t *)&inst->vibrato_speed, sizeof(inst->vibrato_speed));
-        rwops = stream_read(stream, (uint8_t *)&inst->vibrato_depth, sizeof(inst->vibrato_depth));
-        rwops = stream_read(stream, (uint8_t *)&inst->vibrato_delay, sizeof(inst->vibrato_delay));
+    if(inst->flags & TE_ENABLE_VIBRATO) {
+        rwops = stream_read(stream, (uint8_t*)&inst->vibrato_speed, sizeof(inst->vibrato_speed));
+        rwops = stream_read(stream, (uint8_t*)&inst->vibrato_depth, sizeof(inst->vibrato_depth));
+        rwops = stream_read(stream, (uint8_t*)&inst->vibrato_delay, sizeof(inst->vibrato_delay));
     }
 
-    if (inst->flags & TE_ENABLE_PWM)
-    {
-        rwops = stream_read(stream, (uint8_t *)&inst->pwm_speed, sizeof(inst->pwm_speed));
-        rwops = stream_read(stream, (uint8_t *)&inst->pwm_depth, sizeof(inst->pwm_depth));
-        rwops = stream_read(stream, (uint8_t *)&inst->pwm_delay, sizeof(inst->pwm_delay));
+    if(inst->flags & TE_ENABLE_PWM) {
+        rwops = stream_read(stream, (uint8_t*)&inst->pwm_speed, sizeof(inst->pwm_speed));
+        rwops = stream_read(stream, (uint8_t*)&inst->pwm_depth, sizeof(inst->pwm_depth));
+        rwops = stream_read(stream, (uint8_t*)&inst->pwm_delay, sizeof(inst->pwm_delay));
     }
 
-    if (inst->sound_engine_flags & SE_ENABLE_FILTER)
-    {
-        rwops = stream_read(stream, (uint8_t *)&inst->filter_cutoff, sizeof(inst->filter_cutoff));
-        rwops = stream_read(stream, (uint8_t *)&inst->filter_resonance, sizeof(inst->filter_resonance));
-        rwops = stream_read(stream, (uint8_t *)&inst->filter_type, sizeof(inst->filter_type));
+    if(inst->sound_engine_flags & SE_ENABLE_FILTER) {
+        rwops = stream_read(stream, (uint8_t*)&inst->filter_cutoff, sizeof(inst->filter_cutoff));
+        rwops =
+            stream_read(stream, (uint8_t*)&inst->filter_resonance, sizeof(inst->filter_resonance));
+        rwops = stream_read(stream, (uint8_t*)&inst->filter_type, sizeof(inst->filter_type));
     }
 
     UNUSED(rwops);
 }
 
-bool load_song_inner(TrackerSong *song, Stream *stream)
-{
+bool load_song_inner(TrackerSong* song, Stream* stream) {
     uint8_t version = 0;
-    size_t rwops = stream_read(stream, (uint8_t *)&version, sizeof(version));
+    size_t rwops = stream_read(stream, (uint8_t*)&version, sizeof(version));
 
-    if (version > TRACKER_ENGINE_VERSION) // if song is of newer version this version of tracker engine can't support
+    if(version >
+       TRACKER_ENGINE_VERSION) // if song is of newer version this version of tracker engine can't support
     {
         return false;
     }
@@ -73,35 +68,40 @@ bool load_song_inner(TrackerSong *song, Stream *stream)
     tracker_engine_deinit_song(song, false);
     memset(song, 0, sizeof(TrackerSong));
 
-    rwops = stream_read(stream, (uint8_t *)song->song_name, sizeof(song->song_name));
-    rwops = stream_read(stream, (uint8_t *)&song->loop_start, sizeof(song->loop_start));
-    rwops = stream_read(stream, (uint8_t *)&song->loop_end, sizeof(song->loop_end));
-    rwops = stream_read(stream, (uint8_t *)&song->pattern_length, sizeof(song->pattern_length));
+    rwops = stream_read(stream, (uint8_t*)song->song_name, sizeof(song->song_name));
+    rwops = stream_read(stream, (uint8_t*)&song->loop_start, sizeof(song->loop_start));
+    rwops = stream_read(stream, (uint8_t*)&song->loop_end, sizeof(song->loop_end));
+    rwops = stream_read(stream, (uint8_t*)&song->pattern_length, sizeof(song->pattern_length));
 
-    rwops = stream_read(stream, (uint8_t *)&song->speed, sizeof(song->speed));
-    rwops = stream_read(stream, (uint8_t *)&song->rate, sizeof(song->rate));
+    rwops = stream_read(stream, (uint8_t*)&song->speed, sizeof(song->speed));
+    rwops = stream_read(stream, (uint8_t*)&song->rate, sizeof(song->rate));
 
-    rwops = stream_read(stream, (uint8_t *)&song->num_sequence_steps, sizeof(song->num_sequence_steps));
+    rwops =
+        stream_read(stream, (uint8_t*)&song->num_sequence_steps, sizeof(song->num_sequence_steps));
 
-    for (uint16_t i = 0; i < song->num_sequence_steps; i++)
-    {
-        rwops = stream_read(stream, (uint8_t *)&song->sequence.sequence_step[i], sizeof(song->sequence.sequence_step[0]));
+    for(uint16_t i = 0; i < song->num_sequence_steps; i++) {
+        rwops = stream_read(
+            stream,
+            (uint8_t*)&song->sequence.sequence_step[i],
+            sizeof(song->sequence.sequence_step[0]));
     }
 
-    rwops = stream_read(stream, (uint8_t *)&song->num_patterns, sizeof(song->num_patterns));
+    rwops = stream_read(stream, (uint8_t*)&song->num_patterns, sizeof(song->num_patterns));
 
-    for (uint16_t i = 0; i < song->num_patterns; i++)
-    {
-        song->pattern[i].step = (TrackerSongPatternStep *)malloc(sizeof(TrackerSongPatternStep) * (song->pattern_length));
+    for(uint16_t i = 0; i < song->num_patterns; i++) {
+        song->pattern[i].step = (TrackerSongPatternStep*)malloc(
+            sizeof(TrackerSongPatternStep) * (song->pattern_length));
         set_empty_pattern(&song->pattern[i], song->pattern_length);
-        rwops = stream_read(stream, (uint8_t *)song->pattern[i].step, sizeof(TrackerSongPatternStep) * (song->pattern_length));
+        rwops = stream_read(
+            stream,
+            (uint8_t*)song->pattern[i].step,
+            sizeof(TrackerSongPatternStep) * (song->pattern_length));
     }
 
-    rwops = stream_read(stream, (uint8_t *)&song->num_instruments, sizeof(song->num_instruments));
+    rwops = stream_read(stream, (uint8_t*)&song->num_instruments, sizeof(song->num_instruments));
 
-    for (uint16_t i = 0; i < song->num_instruments; i++)
-    {
-        song->instrument[i] = (Instrument *)malloc(sizeof(Instrument));
+    for(uint16_t i = 0; i < song->num_instruments; i++) {
+        song->instrument[i] = (Instrument*)malloc(sizeof(Instrument));
         set_default_instrument(song->instrument[i]);
         load_instrument_inner(stream, song->instrument[i]);
     }
@@ -110,14 +110,12 @@ bool load_song_inner(TrackerSong *song, Stream *stream)
     return false;
 }
 
-bool load_song(TrackerSong *song, Stream *stream)
-{
+bool load_song(TrackerSong* song, Stream* stream) {
     char header[sizeof(SONG_FILE_SIG) + 2] = {0};
-    size_t rwops = stream_read(stream, (uint8_t *)&header, sizeof(SONG_FILE_SIG) - 1);
+    size_t rwops = stream_read(stream, (uint8_t*)&header, sizeof(SONG_FILE_SIG) - 1);
     header[sizeof(SONG_FILE_SIG)] = '\0';
 
-    if (strcmp(header, SONG_FILE_SIG) == 0)
-    {
+    if(strcmp(header, SONG_FILE_SIG) == 0) {
         bool result = load_song_inner(song, stream);
         UNUSED(result);
     }

tracker_engine/diskop.h

@@ -7,4 +7,4 @@
 #include <storage/storage.h>
 #include <toolbox/stream/file_stream.h>
 
-bool load_song(TrackerSong *song, Stream *stream);
+bool load_song(TrackerSong* song, Stream* stream);

tracker_engine/do_effects.c

@@ -5,541 +5,462 @@
 #include "../sound_engine/sound_engine_filter.h"
 #include "tracker_engine.h"
 
-void do_command(uint16_t opcode, TrackerEngine *tracker_engine, uint8_t channel, uint8_t tick, bool from_program)
-{
+void do_command(
+    uint16_t opcode,
+    TrackerEngine* tracker_engine,
+    uint8_t channel,
+    uint8_t tick,
+    bool from_program) {
     UNUSED(from_program);
 
-    TrackerEngineChannel *te_channel = &tracker_engine->channel[channel];
-    SoundEngineChannel *se_channel = &tracker_engine->sound_engine->channel[channel];
+    TrackerEngineChannel* te_channel = &tracker_engine->channel[channel];
+    SoundEngineChannel* se_channel = &tracker_engine->sound_engine->channel[channel];
 
-    switch (opcode & 0x7f00)
-    {
-        case TE_EFFECT_ARPEGGIO:
-        {
-            if (tick == 0)
-            {
-                if (te_channel->fixed_note != 0xffff)
-                {
-                    te_channel->note = te_channel->last_note;
-                    te_channel->fixed_note = 0xffff;
-                }
-
-                if ((opcode & 0xff) == 0xf0)
-                    te_channel->arpeggio_note = te_channel->extarp1;
-                else if ((opcode & 0xff) == 0xf1)
-                    te_channel->arpeggio_note = te_channel->extarp2;
-                else
-                    te_channel->arpeggio_note = (opcode & 0xff);
+    switch(opcode & 0x7f00) {
+    case TE_EFFECT_ARPEGGIO: {
+        if(tick == 0) {
+            if(te_channel->fixed_note != 0xffff) {
+                te_channel->note = te_channel->last_note;
+                te_channel->fixed_note = 0xffff;
             }
-            break;
+
+            if((opcode & 0xff) == 0xf0)
+                te_channel->arpeggio_note = te_channel->extarp1;
+            else if((opcode & 0xff) == 0xf1)
+                te_channel->arpeggio_note = te_channel->extarp2;
+            else
+                te_channel->arpeggio_note = (opcode & 0xff);
         }
+        break;
+    }
 
-        case TE_EFFECT_PORTAMENTO_UP:
-        {
-            uint32_t prev = te_channel->note;
+    case TE_EFFECT_PORTAMENTO_UP: {
+        uint32_t prev = te_channel->note;
 
-            te_channel->note += ((opcode & 0xff) << 2);
-            if (prev > te_channel->note)
-                te_channel->note = 0xffff;
+        te_channel->note += ((opcode & 0xff) << 2);
+        if(prev > te_channel->note) te_channel->note = 0xffff;
 
-            te_channel->target_note = te_channel->note;
-            break;
-        }
+        te_channel->target_note = te_channel->note;
+        break;
+    }
 
-        case TE_EFFECT_PORTAMENTO_DOWN:
-        {
-            int32_t prev = te_channel->note;
+    case TE_EFFECT_PORTAMENTO_DOWN: {
+        int32_t prev = te_channel->note;
 
-            te_channel->note -= ((opcode & 0xff) << 2);
-            if (prev < te_channel->note)
-                te_channel->note = 0;
+        te_channel->note -= ((opcode & 0xff) << 2);
+        if(prev < te_channel->note) te_channel->note = 0;
 
-            te_channel->target_note = te_channel->note;
-            break;
-        }
+        te_channel->target_note = te_channel->note;
+        break;
+    }
 
-        case TE_EFFECT_VIBRATO:
-        {
-            if (tick == 0)
-            {
-                if (opcode & 0xff)
-                {
-                    te_channel->flags |= TE_ENABLE_VIBRATO;
-
-                    te_channel->vibrato_speed = (opcode & 0xf0);
-                    te_channel->vibrato_depth = ((opcode & 0x0f) << 4);
-                }
+    case TE_EFFECT_VIBRATO: {
+        if(tick == 0) {
+            if(opcode & 0xff) {
+                te_channel->flags |= TE_ENABLE_VIBRATO;
 
-                else
-                {
-                    te_channel->flags &= ~(TE_ENABLE_VIBRATO);
-                }
+                te_channel->vibrato_speed = (opcode & 0xf0);
+                te_channel->vibrato_depth = ((opcode & 0x0f) << 4);
             }
 
-            break;
+            else {
+                te_channel->flags &= ~(TE_ENABLE_VIBRATO);
+            }
         }
 
-        case TE_EFFECT_PWM:
-        {
-            if (tick == 0)
-            {
-                if (opcode & 0xff)
-                {
-                    te_channel->flags |= TE_ENABLE_PWM;
-
-                    te_channel->pwm_speed = (opcode & 0xf0);
-                    te_channel->pwm_depth = ((opcode & 0x0f) << 4);
-                }
+        break;
+    }
 
-                else
-                {
-                    te_channel->flags &= ~(TE_ENABLE_PWM);
-                }
+    case TE_EFFECT_PWM: {
+        if(tick == 0) {
+            if(opcode & 0xff) {
+                te_channel->flags |= TE_ENABLE_PWM;
+
+                te_channel->pwm_speed = (opcode & 0xf0);
+                te_channel->pwm_depth = ((opcode & 0x0f) << 4);
             }
 
-            break;
+            else {
+                te_channel->flags &= ~(TE_ENABLE_PWM);
+            }
         }
 
-        case TE_EFFECT_SET_PW:
-        {
-            if (tick == 0)
-            {
-                te_channel->pw = ((opcode & 0xff) << 4);
-            }
+        break;
+    }
 
-            break;
+    case TE_EFFECT_SET_PW: {
+        if(tick == 0) {
+            te_channel->pw = ((opcode & 0xff) << 4);
         }
 
-        case TE_EFFECT_PW_UP:
-        {
-            int16_t temp_pw = te_channel->pw + (int16_t)(opcode & 0xff);
+        break;
+    }
 
-            if (temp_pw < 0)
-                temp_pw = 0;
-            if (temp_pw > 0xfff)
-                temp_pw = 0xfff;
+    case TE_EFFECT_PW_UP: {
+        int16_t temp_pw = te_channel->pw + (int16_t)(opcode & 0xff);
 
-            te_channel->pw = temp_pw;
+        if(temp_pw < 0) temp_pw = 0;
+        if(temp_pw > 0xfff) temp_pw = 0xfff;
 
-            break;
-        }
+        te_channel->pw = temp_pw;
 
-        case TE_EFFECT_PW_DOWN:
-        {
-            int16_t temp_pw = te_channel->pw - (int16_t)(opcode & 0xff);
+        break;
+    }
 
-            if (temp_pw < 0)
-                temp_pw = 0;
-            if (temp_pw > 0xfff)
-                temp_pw = 0xfff;
+    case TE_EFFECT_PW_DOWN: {
+        int16_t temp_pw = te_channel->pw - (int16_t)(opcode & 0xff);
 
-            te_channel->pw = temp_pw;
+        if(temp_pw < 0) temp_pw = 0;
+        if(temp_pw > 0xfff) temp_pw = 0xfff;
 
-            break;
-        }
+        te_channel->pw = temp_pw;
 
-        case TE_EFFECT_SET_CUTOFF:
-        {
-            if (tick == 0)
-            {
-                te_channel->filter_cutoff = ((opcode & 0xff) << 3);
-                sound_engine_filter_set_coeff(&se_channel->filter, te_channel->filter_cutoff, te_channel->filter_resonance);
-            }
+        break;
+    }
 
-            break;
+    case TE_EFFECT_SET_CUTOFF: {
+        if(tick == 0) {
+            te_channel->filter_cutoff = ((opcode & 0xff) << 3);
+            sound_engine_filter_set_coeff(
+                &se_channel->filter, te_channel->filter_cutoff, te_channel->filter_resonance);
         }
 
-        case TE_EFFECT_VOLUME_FADE:
-        {
-            if (!(te_channel->channel_flags & TEC_DISABLED))
-            {
-                te_channel->volume -= (opcode & 0xf);
-                if (te_channel->volume > MAX_ADSR_VOLUME)
-                    te_channel->volume = 0;
-                te_channel->volume += ((opcode >> 4) & 0xf);
-                if (te_channel->volume > MAX_ADSR_VOLUME)
-                    te_channel->volume = MAX_ADSR_VOLUME;
+        break;
+    }
 
-                se_channel->adsr.volume = (int32_t)te_channel->volume;
-                se_channel->adsr.volume = (int32_t)se_channel->adsr.volume * (int32_t)tracker_engine->master_volume / MAX_ADSR_VOLUME;
-            }
+    case TE_EFFECT_VOLUME_FADE: {
+        if(!(te_channel->channel_flags & TEC_DISABLED)) {
+            te_channel->volume -= (opcode & 0xf);
+            if(te_channel->volume > MAX_ADSR_VOLUME) te_channel->volume = 0;
+            te_channel->volume += ((opcode >> 4) & 0xf);
+            if(te_channel->volume > MAX_ADSR_VOLUME) te_channel->volume = MAX_ADSR_VOLUME;
 
-            break;
+            se_channel->adsr.volume = (int32_t)te_channel->volume;
+            se_channel->adsr.volume = (int32_t)se_channel->adsr.volume *
+                                      (int32_t)tracker_engine->master_volume / MAX_ADSR_VOLUME;
         }
 
-        case TE_EFFECT_SET_WAVEFORM:
-        {
-            if (tick == 0)
-            {
-                se_channel->waveform = (opcode & 0x3f);
-            }
+        break;
+    }
 
-            break;
+    case TE_EFFECT_SET_WAVEFORM: {
+        if(tick == 0) {
+            se_channel->waveform = (opcode & 0x3f);
         }
 
-        case TE_EFFECT_SET_VOLUME:
-        {
-            if (tick == 0)
-            {
-                if (!(te_channel->channel_flags & TEC_DISABLED))
-                {
-                    te_channel->volume = opcode & 0xff;
-
-                    se_channel->adsr.volume = (int32_t)te_channel->volume;
-                    se_channel->adsr.volume = (int32_t)se_channel->adsr.volume * (int32_t)tracker_engine->master_volume / MAX_ADSR_VOLUME;
-                }
-            }
+        break;
+    }
 
-            break;
+    case TE_EFFECT_SET_VOLUME: {
+        if(tick == 0) {
+            if(!(te_channel->channel_flags & TEC_DISABLED)) {
+                te_channel->volume = opcode & 0xff;
+
+                se_channel->adsr.volume = (int32_t)te_channel->volume;
+                se_channel->adsr.volume = (int32_t)se_channel->adsr.volume *
+                                          (int32_t)tracker_engine->master_volume / MAX_ADSR_VOLUME;
+            }
         }
 
-        case TE_EFFECT_EXT:
-        {
-            switch (opcode & 0x7ff0)
-            {
-                case TE_EFFECT_EXT_TOGGLE_FILTER:
-                {
-                    if (tick == 0)
-                    {
-                        if (opcode & 0xf)
-                        {
-                            se_channel->flags |= SE_ENABLE_FILTER;
-                        }
-
-                        else
-                        {
-                            se_channel->flags &= ~SE_ENABLE_FILTER;
-                        }
-                    }
-
-                    break;
+        break;
+    }
+
+    case TE_EFFECT_EXT: {
+        switch(opcode & 0x7ff0) {
+        case TE_EFFECT_EXT_TOGGLE_FILTER: {
+            if(tick == 0) {
+                if(opcode & 0xf) {
+                    se_channel->flags |= SE_ENABLE_FILTER;
                 }
 
-                case TE_EFFECT_EXT_PORTA_DN:
-                {
-                    if (tick == 0)
-                    {
-                        int32_t prev = te_channel->note;
+                else {
+                    se_channel->flags &= ~SE_ENABLE_FILTER;
+                }
+            }
 
-                        te_channel->note -= (opcode & 0xf);
-                        if (prev < te_channel->note)
-                            te_channel->note = 0;
+            break;
+        }
 
-                        te_channel->target_note = te_channel->note;
-                    }
+        case TE_EFFECT_EXT_PORTA_DN: {
+            if(tick == 0) {
+                int32_t prev = te_channel->note;
 
-                    break;
-                }
+                te_channel->note -= (opcode & 0xf);
+                if(prev < te_channel->note) te_channel->note = 0;
 
-                case TE_EFFECT_EXT_PORTA_UP:
-                {
-                    if (tick == 0)
-                    {
-                        uint32_t prev = te_channel->note;
+                te_channel->target_note = te_channel->note;
+            }
 
-                        te_channel->note += (opcode & 0xf);
-                        if (prev > te_channel->note)
-                            te_channel->note = 0xffff;
+            break;
+        }
 
-                        te_channel->target_note = te_channel->note;
-                    }
+        case TE_EFFECT_EXT_PORTA_UP: {
+            if(tick == 0) {
+                uint32_t prev = te_channel->note;
 
-                    break;
-                }
+                te_channel->note += (opcode & 0xf);
+                if(prev > te_channel->note) te_channel->note = 0xffff;
 
-                case TE_EFFECT_EXT_FILTER_MODE:
-                {
-                    if (tick == 0)
-                    {
-                        se_channel->filter_mode = (opcode & 0xf);
-                    }
+                te_channel->target_note = te_channel->note;
+            }
 
-                    break;
-                }
+            break;
+        }
 
-                case TE_EFFECT_EXT_RETRIGGER:
-                {
-                    if ((opcode & 0xf) > 0 && (tick % (opcode & 0xf)) == 0)
-                    {
-                        uint8_t prev_vol_tr = te_channel->volume;
-                        uint8_t prev_vol_cyd = se_channel->adsr.volume;
-                        tracker_engine_trigger_instrument_internal(tracker_engine, channel, te_channel->instrument, te_channel->last_note);
-                        te_channel->volume = prev_vol_tr;
-                        se_channel->adsr.volume = prev_vol_cyd;
-                    }
-
-                    break;
-                }
+        case TE_EFFECT_EXT_FILTER_MODE: {
+            if(tick == 0) {
+                se_channel->filter_mode = (opcode & 0xf);
+            }
 
-                case TE_EFFECT_EXT_FINE_VOLUME_DOWN:
-                {
-                    if (tick == 0)
-                    {
-                        te_channel->volume -= (opcode & 0xf);
+            break;
+        }
 
-                        if (te_channel->volume > MAX_ADSR_VOLUME)
-                            te_channel->volume = 0;
+        case TE_EFFECT_EXT_RETRIGGER: {
+            if((opcode & 0xf) > 0 && (tick % (opcode & 0xf)) == 0) {
+                uint8_t prev_vol_tr = te_channel->volume;
+                uint8_t prev_vol_cyd = se_channel->adsr.volume;
+                tracker_engine_trigger_instrument_internal(
+                    tracker_engine, channel, te_channel->instrument, te_channel->last_note);
+                te_channel->volume = prev_vol_tr;
+                se_channel->adsr.volume = prev_vol_cyd;
+            }
 
-                        se_channel->adsr.volume = (int32_t)te_channel->volume;
-                        se_channel->adsr.volume = (int32_t)se_channel->adsr.volume * (int32_t)tracker_engine->master_volume / MAX_ADSR_VOLUME;
-                    }
+            break;
+        }
 
-                    break;
-                }
+        case TE_EFFECT_EXT_FINE_VOLUME_DOWN: {
+            if(tick == 0) {
+                te_channel->volume -= (opcode & 0xf);
 
-                case TE_EFFECT_EXT_FINE_VOLUME_UP:
-                {
-                    if (tick == 0)
-                    {
-                        te_channel->volume += (opcode & 0xf);
+                if(te_channel->volume > MAX_ADSR_VOLUME) te_channel->volume = 0;
 
-                        if (te_channel->volume > MAX_ADSR_VOLUME)
-                            te_channel->volume = MAX_ADSR_VOLUME;
+                se_channel->adsr.volume = (int32_t)te_channel->volume;
+                se_channel->adsr.volume = (int32_t)se_channel->adsr.volume *
+                                          (int32_t)tracker_engine->master_volume / MAX_ADSR_VOLUME;
+            }
 
-                        se_channel->adsr.volume = (int32_t)te_channel->volume;
-                        se_channel->adsr.volume = (int32_t)se_channel->adsr.volume * (int32_t)tracker_engine->master_volume / MAX_ADSR_VOLUME;
-                    }
+            break;
+        }
 
-                    break;
-                }
+        case TE_EFFECT_EXT_FINE_VOLUME_UP: {
+            if(tick == 0) {
+                te_channel->volume += (opcode & 0xf);
 
-                case TE_EFFECT_EXT_NOTE_CUT:
-                {
-                    if ((opcode & 0xf) <= tick)
-                    {
-                        se_channel->adsr.volume = 0;
-                        te_channel->volume = 0;
-                    }
+                if(te_channel->volume > MAX_ADSR_VOLUME) te_channel->volume = MAX_ADSR_VOLUME;
 
-                    break;
-                }
+                se_channel->adsr.volume = (int32_t)te_channel->volume;
+                se_channel->adsr.volume = (int32_t)se_channel->adsr.volume *
+                                          (int32_t)tracker_engine->master_volume / MAX_ADSR_VOLUME;
+            }
 
-                case TE_EFFECT_EXT_PHASE_RESET:
-                {
-                    if (tick == (opcode & 0xf))
-                    {
-                        se_channel->accumulator = 0;
-                        se_channel->lfsr = RANDOM_SEED;
-                    }
+            break;
+        }
 
-                    break;
-                }
+        case TE_EFFECT_EXT_NOTE_CUT: {
+            if((opcode & 0xf) <= tick) {
+                se_channel->adsr.volume = 0;
+                te_channel->volume = 0;
             }
 
             break;
         }
 
-        case TE_EFFECT_SET_SPEED_PROG_PERIOD:
-        {
-            if (tick == 0)
-            {
-                if (from_program)
-                {
-                    te_channel->program_period = opcode & 0xff;
-                }
-
-                else
-                {
-                    tracker_engine->song->speed = opcode & 0xff;
-                }
+        case TE_EFFECT_EXT_PHASE_RESET: {
+            if(tick == (opcode & 0xf)) {
+                se_channel->accumulator = 0;
+                se_channel->lfsr = RANDOM_SEED;
             }
 
             break;
         }
+        }
 
-        case TE_EFFECT_CUTOFF_UP:
-        {
-            te_channel->filter_cutoff += (opcode & 0xff);
+        break;
+    }
+
+    case TE_EFFECT_SET_SPEED_PROG_PERIOD: {
+        if(tick == 0) {
+            if(from_program) {
+                te_channel->program_period = opcode & 0xff;
+            }
 
-            if (te_channel->filter_cutoff > 0x7ff)
-            {
-                te_channel->filter_cutoff = 0x7ff;
+            else {
+                tracker_engine->song->speed = opcode & 0xff;
             }
+        }
 
-            sound_engine_filter_set_coeff(&se_channel->filter, te_channel->filter_cutoff, te_channel->filter_resonance);
+        break;
+    }
 
-            break;
+    case TE_EFFECT_CUTOFF_UP: {
+        te_channel->filter_cutoff += (opcode & 0xff);
+
+        if(te_channel->filter_cutoff > 0x7ff) {
+            te_channel->filter_cutoff = 0x7ff;
         }
 
-        case TE_EFFECT_CUTOFF_DOWN:
-        {
-            te_channel->filter_cutoff -= (opcode & 0xff);
+        sound_engine_filter_set_coeff(
+            &se_channel->filter, te_channel->filter_cutoff, te_channel->filter_resonance);
 
-            if (te_channel->filter_cutoff > 0x7ff) // unsigned int overflow
-            {
-                te_channel->filter_cutoff = 0;
-            }
+        break;
+    }
 
-            sound_engine_filter_set_coeff(&se_channel->filter, te_channel->filter_cutoff, te_channel->filter_resonance);
+    case TE_EFFECT_CUTOFF_DOWN: {
+        te_channel->filter_cutoff -= (opcode & 0xff);
 
-            break;
+        if(te_channel->filter_cutoff > 0x7ff) // unsigned int overflow
+        {
+            te_channel->filter_cutoff = 0;
         }
 
-        case TE_EFFECT_SET_RESONANCE:
-        {
-            if (tick == 0)
-            {
-                te_channel->filter_resonance = (opcode & 0xff);
-                sound_engine_filter_set_coeff(&se_channel->filter, te_channel->filter_cutoff, te_channel->filter_resonance);
-            }
+        sound_engine_filter_set_coeff(
+            &se_channel->filter, te_channel->filter_cutoff, te_channel->filter_resonance);
 
-            break;
+        break;
+    }
+
+    case TE_EFFECT_SET_RESONANCE: {
+        if(tick == 0) {
+            te_channel->filter_resonance = (opcode & 0xff);
+            sound_engine_filter_set_coeff(
+                &se_channel->filter, te_channel->filter_cutoff, te_channel->filter_resonance);
         }
 
-        case TE_EFFECT_RESONANCE_UP:
-        {
-            te_channel->filter_resonance += (opcode & 0xff);
+        break;
+    }
 
-            if (te_channel->filter_resonance > 0xff)
-            {
-                te_channel->filter_resonance = 0xff;
-            }
+    case TE_EFFECT_RESONANCE_UP: {
+        te_channel->filter_resonance += (opcode & 0xff);
 
-            sound_engine_filter_set_coeff(&se_channel->filter, te_channel->filter_cutoff, te_channel->filter_resonance);
-            break;
+        if(te_channel->filter_resonance > 0xff) {
+            te_channel->filter_resonance = 0xff;
         }
 
-        case TE_EFFECT_RESONANCE_DOWN:
-        {
-            te_channel->filter_resonance -= (opcode & 0xff);
+        sound_engine_filter_set_coeff(
+            &se_channel->filter, te_channel->filter_cutoff, te_channel->filter_resonance);
+        break;
+    }
 
-            if (te_channel->filter_resonance > 0xff)
-            {
-                te_channel->filter_resonance = 0;
-            }
+    case TE_EFFECT_RESONANCE_DOWN: {
+        te_channel->filter_resonance -= (opcode & 0xff);
 
-            sound_engine_filter_set_coeff(&se_channel->filter, te_channel->filter_cutoff, te_channel->filter_resonance);
-            break;
+        if(te_channel->filter_resonance > 0xff) {
+            te_channel->filter_resonance = 0;
         }
 
-        case TE_EFFECT_SET_RING_MOD_SRC:
-        {
-            if (tick == 0)
-            {
-                se_channel->ring_mod = (opcode & 0xff);
-            }
+        sound_engine_filter_set_coeff(
+            &se_channel->filter, te_channel->filter_cutoff, te_channel->filter_resonance);
+        break;
+    }
 
-            break;
+    case TE_EFFECT_SET_RING_MOD_SRC: {
+        if(tick == 0) {
+            se_channel->ring_mod = (opcode & 0xff);
         }
 
-        case TE_EFFECT_SET_HARD_SYNC_SRC:
-        {
-            if (tick == 0)
-            {
-                se_channel->hard_sync = (opcode & 0xff);
-            }
+        break;
+    }
 
-            break;
+    case TE_EFFECT_SET_HARD_SYNC_SRC: {
+        if(tick == 0) {
+            se_channel->hard_sync = (opcode & 0xff);
         }
 
-        case TE_EFFECT_SET_ATTACK:
-        {
-            if (tick == 0)
-            {
-                se_channel->adsr.a = (opcode & 0xff);
+        break;
+    }
 
-                if (se_channel->adsr.envelope_state == ATTACK)
-                {
-                    se_channel->adsr.envelope_speed = envspd(tracker_engine->sound_engine, se_channel->adsr.a);
-                }
-            }
+    case TE_EFFECT_SET_ATTACK: {
+        if(tick == 0) {
+            se_channel->adsr.a = (opcode & 0xff);
 
-            break;
+            if(se_channel->adsr.envelope_state == ATTACK) {
+                se_channel->adsr.envelope_speed =
+                    envspd(tracker_engine->sound_engine, se_channel->adsr.a);
+            }
         }
 
-        case TE_EFFECT_SET_DECAY:
-        {
-            if (tick == 0)
-            {
-                se_channel->adsr.d = (opcode & 0xff);
+        break;
+    }
 
-                if (se_channel->adsr.envelope_state == DECAY)
-                {
-                    se_channel->adsr.envelope_speed = envspd(tracker_engine->sound_engine, se_channel->adsr.d);
-                }
-            }
+    case TE_EFFECT_SET_DECAY: {
+        if(tick == 0) {
+            se_channel->adsr.d = (opcode & 0xff);
 
-            break;
+            if(se_channel->adsr.envelope_state == DECAY) {
+                se_channel->adsr.envelope_speed =
+                    envspd(tracker_engine->sound_engine, se_channel->adsr.d);
+            }
         }
 
-        case TE_EFFECT_SET_SUSTAIN:
-        {
-            if (tick == 0)
-            {
-                se_channel->adsr.s = (opcode & 0xff);
-            }
+        break;
+    }
 
-            break;
+    case TE_EFFECT_SET_SUSTAIN: {
+        if(tick == 0) {
+            se_channel->adsr.s = (opcode & 0xff);
         }
 
-        case TE_EFFECT_SET_RELEASE:
-        {
-            if (tick == 0)
-            {
-                se_channel->adsr.r = (opcode & 0xff);
+        break;
+    }
 
-                if (se_channel->adsr.envelope_state == RELEASE)
-                {
-                    se_channel->adsr.envelope_speed = envspd(tracker_engine->sound_engine, se_channel->adsr.r);
-                }
-            }
+    case TE_EFFECT_SET_RELEASE: {
+        if(tick == 0) {
+            se_channel->adsr.r = (opcode & 0xff);
 
-            break;
+            if(se_channel->adsr.envelope_state == RELEASE) {
+                se_channel->adsr.envelope_speed =
+                    envspd(tracker_engine->sound_engine, se_channel->adsr.r);
+            }
         }
 
-        case TE_EFFECT_PROGRAM_RESTART:
-        {
-            if (tick == 0)
-            {
-                te_channel->program_counter = 0;
-                te_channel->program_loop = 0;
-                te_channel->program_period = 0;
-                te_channel->program_tick = 0;
-            }
+        break;
+    }
 
-            break;
+    case TE_EFFECT_PROGRAM_RESTART: {
+        if(tick == 0) {
+            te_channel->program_counter = 0;
+            te_channel->program_loop = 0;
+            te_channel->program_period = 0;
+            te_channel->program_tick = 0;
         }
 
-        case TE_EFFECT_PORTA_UP_SEMITONE:
-        {
-            uint32_t prev = te_channel->note;
+        break;
+    }
 
-            te_channel->note += ((opcode & 0xff) << 8);
-            if (prev > te_channel->note)
-                te_channel->note = 0xffff;
+    case TE_EFFECT_PORTA_UP_SEMITONE: {
+        uint32_t prev = te_channel->note;
 
-            te_channel->target_note = te_channel->note;
-            break;
-        }
+        te_channel->note += ((opcode & 0xff) << 8);
+        if(prev > te_channel->note) te_channel->note = 0xffff;
 
-        case TE_EFFECT_PORTA_DOWN_SEMITONE:
-        {
-            int32_t prev = te_channel->note;
+        te_channel->target_note = te_channel->note;
+        break;
+    }
 
-            te_channel->note -= ((opcode & 0xff) << 8);
-            if (prev < te_channel->note)
-                te_channel->note = 0;
+    case TE_EFFECT_PORTA_DOWN_SEMITONE: {
+        int32_t prev = te_channel->note;
 
-            te_channel->target_note = te_channel->note;
-            break;
-        }
+        te_channel->note -= ((opcode & 0xff) << 8);
+        if(prev < te_channel->note) te_channel->note = 0;
 
-        case TE_EFFECT_ARPEGGIO_ABS:
-        {
-            te_channel->arpeggio_note = 0;
-            te_channel->fixed_note = ((opcode & 0xff) << 8);
+        te_channel->target_note = te_channel->note;
+        break;
+    }
 
-            break;
-        }
+    case TE_EFFECT_ARPEGGIO_ABS: {
+        te_channel->arpeggio_note = 0;
+        te_channel->fixed_note = ((opcode & 0xff) << 8);
 
-        case TE_EFFECT_TRIGGER_RELEASE:
-        {
-            sound_engine_enable_gate(tracker_engine->sound_engine, se_channel, 0);
+        break;
+    }
 
-            break;
-        }
+    case TE_EFFECT_TRIGGER_RELEASE: {
+        sound_engine_enable_gate(tracker_engine->sound_engine, se_channel, 0);
 
-        default:
-            break;
+        break;
+    }
+
+    default:
+        break;
     }
 }

tracker_engine/do_effects.h

@@ -2,4 +2,9 @@
 #include <stdbool.h>
 #include <stdio.h>
 
-void do_command(uint16_t opcode, TrackerEngine *tracker_engine, uint8_t channel, uint8_t tick, bool from_program);
+void do_command(
+    uint16_t opcode,
+    TrackerEngine* tracker_engine,
+    uint8_t channel,
+    uint8_t tick,
+    bool from_program);

tracker_engine/tracker_engine.c

@@ -6,57 +6,48 @@
 #include "../sound_engine/sound_engine_osc.h"
 #include <furi_hal.h>
 
-void tracker_engine_init(TrackerEngine *tracker_engine, uint8_t rate, SoundEngine *sound_engine)
-{
+void tracker_engine_init(TrackerEngine* tracker_engine, uint8_t rate, SoundEngine* sound_engine) {
     memset(tracker_engine, 0, sizeof(TrackerEngine));
 
-    furi_hal_interrupt_set_isr_ex(FuriHalInterruptIdTIM2, 14, tracker_engine_timer_isr, (void *)tracker_engine);
+    furi_hal_interrupt_set_isr_ex(
+        FuriHalInterruptIdTIM2, 14, tracker_engine_timer_isr, (void*)tracker_engine);
     tracker_engine_init_hardware(rate);
 
     tracker_engine->sound_engine = sound_engine;
     tracker_engine->rate = rate;
 }
 
-void tracker_engine_deinit_song(TrackerSong *song, bool free_song)
-{
-    for (int i = 0; i < MAX_PATTERNS; i++)
-    {
-        if (song->pattern[i].step != NULL)
-        {
+void tracker_engine_deinit_song(TrackerSong* song, bool free_song) {
+    for(int i = 0; i < MAX_PATTERNS; i++) {
+        if(song->pattern[i].step != NULL) {
             free(song->pattern[i].step);
         }
     }
 
-    for (int i = 0; i < MAX_INSTRUMENTS; i++)
-    {
-        if (song->instrument[i] != NULL)
-        {
+    for(int i = 0; i < MAX_INSTRUMENTS; i++) {
+        if(song->instrument[i] != NULL) {
             free(song->instrument[i]);
         }
     }
 
-    if (free_song)
-    {
+    if(free_song) {
         free(song);
     }
 }
 
-void tracker_engine_deinit(TrackerEngine *tracker_engine, bool free_song)
-{
+void tracker_engine_deinit(TrackerEngine* tracker_engine, bool free_song) {
     tracker_engine_deinit_song(tracker_engine->song, free_song);
 
     furi_hal_interrupt_set_isr_ex(FuriHalInterruptIdTIM2, 13, NULL, NULL);
     tracker_engine_stop();
 }
 
-void set_note(TrackerSongPatternStep *step, uint8_t note)
-{
+void set_note(TrackerSongPatternStep* step, uint8_t note) {
     step->note &= 0x80;
     step->note |= (note & 0x7f);
 }
 
-void set_instrument(TrackerSongPatternStep *step, uint8_t inst)
-{
+void set_instrument(TrackerSongPatternStep* step, uint8_t inst) {
     step->note &= 0x7f;
     step->inst_vol &= 0x0f;
 
@@ -64,8 +55,7 @@ void set_instrument(TrackerSongPatternStep *step, uint8_t inst)
     step->inst_vol |= ((inst & 0xf) << 4);
 }
 
-void set_volume(TrackerSongPatternStep *step, uint8_t vol)
-{
+void set_volume(TrackerSongPatternStep* step, uint8_t vol) {
     step->command &= 0x7fff;
     step->inst_vol &= 0xf0;
 
@@ -73,14 +63,12 @@ void set_volume(TrackerSongPatternStep *step, uint8_t vol)
     step->inst_vol |= (vol & 0xf);
 }
 
-void set_command(TrackerSongPatternStep *step, uint16_t command)
-{
+void set_command(TrackerSongPatternStep* step, uint16_t command) {
     step->command &= 0x8000;
     step->command |= command & (0x7fff);
 }
 
-void set_default_instrument(Instrument *inst)
-{
+void set_default_instrument(Instrument* inst) {
     memset(inst, 0, sizeof(Instrument));
 
     inst->flags = TE_SET_CUTOFF | TE_SET_PW | TE_ENABLE_VIBRATO;
@@ -100,8 +88,7 @@ void set_default_instrument(Instrument *inst)
 
     inst->program_period = 1;
 
-    for (int i = 0; i < INST_PROG_LEN; i++)
-    {
+    for(int i = 0; i < INST_PROG_LEN; i++) {
         inst->program[i] = TE_PROGRAM_NOP;
     }
 
@@ -110,11 +97,9 @@ void set_default_instrument(Instrument *inst)
     inst->vibrato_delay = 0x20;
 }
 
-void set_empty_pattern(TrackerSongPattern *pattern, uint16_t pattern_length)
-{
-    for (uint16_t i = 0; i < pattern_length; i++)
-    {
-        TrackerSongPatternStep *step = &pattern->step[i];
+void set_empty_pattern(TrackerSongPattern* pattern, uint16_t pattern_length) {
+    for(uint16_t i = 0; i < pattern_length; i++) {
+        TrackerSongPatternStep* step = &pattern->step[i];
 
         set_note(step, MUS_NOTE_NONE);
         set_instrument(step, MUS_NOTE_INSTRUMENT_NONE);
@@ -123,50 +108,50 @@ void set_empty_pattern(TrackerSongPattern *pattern, uint16_t pattern_length)
     }
 }
 
-uint8_t tracker_engine_get_note(TrackerSongPatternStep *step)
-{
+uint8_t tracker_engine_get_note(TrackerSongPatternStep* step) {
     return (step->note & 0x7f);
 }
 
-uint8_t tracker_engine_get_instrument(TrackerSongPatternStep *step)
-{
+uint8_t tracker_engine_get_instrument(TrackerSongPatternStep* step) {
     return ((step->note & 0x80) >> 3) | ((step->inst_vol & 0xf0) >> 4);
 }
 
-uint8_t tracker_engine_get_volume(TrackerSongPatternStep *step)
-{
+uint8_t tracker_engine_get_volume(TrackerSongPatternStep* step) {
     return (step->inst_vol & 0xf) | ((step->command & 0x8000) >> 11);
 }
 
-uint16_t tracker_engine_get_command(TrackerSongPatternStep *step)
-{
+uint16_t tracker_engine_get_command(TrackerSongPatternStep* step) {
     return (step->command & 0x7fff);
 }
 
-void tracker_engine_set_note(TrackerEngine *tracker_engine, uint8_t chan, uint16_t note, bool update_note)
-{
-    if (update_note)
-        tracker_engine->channel[chan].note = note;
+void tracker_engine_set_note(
+    TrackerEngine* tracker_engine,
+    uint8_t chan,
+    uint16_t note,
+    bool update_note) {
+    if(update_note) tracker_engine->channel[chan].note = note;
 
-    sound_engine_set_channel_frequency(tracker_engine->sound_engine, &tracker_engine->sound_engine->channel[chan], note);
+    sound_engine_set_channel_frequency(
+        tracker_engine->sound_engine, &tracker_engine->sound_engine->channel[chan], note);
 }
 
-void tracker_engine_set_song(TrackerEngine *tracker_engine, TrackerSong *song)
-{
+void tracker_engine_set_song(TrackerEngine* tracker_engine, TrackerSong* song) {
     tracker_engine->song = song;
 }
 
-void tracker_engine_trigger_instrument_internal(TrackerEngine *tracker_engine, uint8_t chan, Instrument *pinst, uint16_t note)
-{
-    SoundEngineChannel *se_channel = &tracker_engine->sound_engine->channel[chan];
-    TrackerEngineChannel *te_channel = &tracker_engine->channel[chan];
+void tracker_engine_trigger_instrument_internal(
+    TrackerEngine* tracker_engine,
+    uint8_t chan,
+    Instrument* pinst,
+    uint16_t note) {
+    SoundEngineChannel* se_channel = &tracker_engine->sound_engine->channel[chan];
+    TrackerEngineChannel* te_channel = &tracker_engine->channel[chan];
 
     te_channel->channel_flags = TEC_PLAYING | (te_channel->channel_flags & TEC_DISABLED);
 
     te_channel->program_period = pinst->program_period;
 
-    if (!(pinst->flags & TE_PROG_NO_RESTART) && pinst->program_period > 0)
-    {
+    if(!(pinst->flags & TE_PROG_NO_RESTART) && pinst->program_period > 0) {
         te_channel->channel_flags |= TEC_PROGRAM_RUNNING;
 
         te_channel->program_counter = 0;
@@ -191,22 +176,19 @@ void tracker_engine_trigger_instrument_internal(TrackerEngine *tracker_engine, u
 
     te_channel->extarp1 = te_channel->extarp2 = 0;
 
-    if (pinst->flags & TE_ENABLE_VIBRATO)
-    {
+    if(pinst->flags & TE_ENABLE_VIBRATO) {
         te_channel->vibrato_speed = pinst->vibrato_speed;
         te_channel->vibrato_depth = pinst->vibrato_depth;
         te_channel->vibrato_delay = pinst->vibrato_delay;
     }
 
-    if (pinst->flags & TE_ENABLE_PWM)
-    {
+    if(pinst->flags & TE_ENABLE_PWM) {
         te_channel->pwm_speed = pinst->pwm_speed;
         te_channel->pwm_depth = pinst->pwm_depth;
         te_channel->pwm_delay = pinst->pwm_delay;
     }
 
-    if (pinst->sound_engine_flags & SE_ENABLE_KEYDOWN_SYNC)
-    {
+    if(pinst->sound_engine_flags & SE_ENABLE_KEYDOWN_SYNC) {
         te_channel->vibrato_position = ((ACC_LENGTH / 2 / 2) << 9);
         te_channel->pwm_position = ((ACC_LENGTH / 2 / 2) << 9);
 
@@ -214,8 +196,7 @@ void tracker_engine_trigger_instrument_internal(TrackerEngine *tracker_engine, u
         se_channel->lfsr = RANDOM_SEED;
     }
 
-    if (pinst->flags & TE_SET_CUTOFF)
-    {
+    if(pinst->flags & TE_SET_CUTOFF) {
         te_channel->filter_cutoff = ((uint16_t)pinst->filter_cutoff << 3);
         te_channel->filter_resonance = (uint16_t)pinst->filter_resonance;
 
@@ -223,17 +204,16 @@ void tracker_engine_trigger_instrument_internal(TrackerEngine *tracker_engine, u
         se_channel->filter.high = 0;
         se_channel->filter.band = 0;
 
-        sound_engine_filter_set_coeff(&se_channel->filter, te_channel->filter_cutoff, te_channel->filter_resonance);
+        sound_engine_filter_set_coeff(
+            &se_channel->filter, te_channel->filter_cutoff, te_channel->filter_resonance);
     }
 
-    if (pinst->sound_engine_flags & SE_ENABLE_FILTER)
-    {
+    if(pinst->sound_engine_flags & SE_ENABLE_FILTER) {
         te_channel->filter_type = pinst->filter_type;
         se_channel->filter_mode = te_channel->filter_type;
     }
 
-    if (pinst->flags & TE_SET_PW)
-    {
+    if(pinst->flags & TE_SET_PW) {
         te_channel->pw = (pinst->pw << 4);
         se_channel->pw = (pinst->pw << 4);
     }
@@ -248,16 +228,22 @@ void tracker_engine_trigger_instrument_internal(TrackerEngine *tracker_engine, u
     se_channel->adsr.s = pinst->adsr.s;
     se_channel->adsr.r = pinst->adsr.r;
     se_channel->adsr.volume = pinst->adsr.volume;
-    se_channel->adsr.volume = (int32_t)se_channel->adsr.volume * (int32_t)tracker_engine->master_volume / MAX_ADSR_VOLUME;
+    se_channel->adsr.volume = (int32_t)se_channel->adsr.volume *
+                              (int32_t)tracker_engine->master_volume / MAX_ADSR_VOLUME;
 
     te_channel->volume = pinst->adsr.volume;
-    te_channel->volume = (int32_t)te_channel->volume * (int32_t)tracker_engine->master_volume / MAX_ADSR_VOLUME;
+    te_channel->volume =
+        (int32_t)te_channel->volume * (int32_t)tracker_engine->master_volume / MAX_ADSR_VOLUME;
 
-    sound_engine_enable_gate(tracker_engine->sound_engine, &tracker_engine->sound_engine->channel[chan], true);
+    sound_engine_enable_gate(
+        tracker_engine->sound_engine, &tracker_engine->sound_engine->channel[chan], true);
 }
 
-void tracker_engine_execute_track_command(TrackerEngine *tracker_engine, uint8_t chan, TrackerSongPatternStep *step, bool first_tick)
-{
+void tracker_engine_execute_track_command(
+    TrackerEngine* tracker_engine,
+    uint8_t chan,
+    TrackerSongPatternStep* step,
+    bool first_tick) {
     UNUSED(first_tick);
     UNUSED(tracker_engine);
     UNUSED(chan);
@@ -265,35 +251,34 @@ void tracker_engine_execute_track_command(TrackerEngine *tracker_engine, uint8_t
     uint8_t vol = tracker_engine_get_volume(step);
     uint16_t opcode = tracker_engine_get_command(step);
 
-    if (vol != MUS_NOTE_VOLUME_NONE && !(tracker_engine->channel[chan].channel_flags & TEC_DISABLED))
-    {
-        tracker_engine->sound_engine->channel[chan].adsr.volume = (int32_t)tracker_engine->channel[chan].volume * (int32_t)vol / (MUS_NOTE_VOLUME_NONE);
+    if(vol != MUS_NOTE_VOLUME_NONE &&
+       !(tracker_engine->channel[chan].channel_flags & TEC_DISABLED)) {
+        tracker_engine->sound_engine->channel[chan].adsr.volume =
+            (int32_t)tracker_engine->channel[chan].volume * (int32_t)vol / (MUS_NOTE_VOLUME_NONE);
         // tracker_engine->sound_engine->channel[chan].adsr.volume = (int32_t)tracker_engine->sound_engine->channel[chan].adsr.volume * (int32_t)tracker_engine->channel[chan].instrument->adsr.volume / MAX_ADSR_VOLUME * (int32_t)tracker_engine->master_volume / MAX_ADSR_VOLUME;
     }
 
-    if (tracker_engine->channel[chan].instrument != NULL && opcode != 0)
-    {
-        if ((opcode & 0x7f00) == TE_EFFECT_ARPEGGIO)
-        {
+    if(tracker_engine->channel[chan].instrument != NULL && opcode != 0) {
+        if((opcode & 0x7f00) == TE_EFFECT_ARPEGGIO) {
             tracker_engine->channel[chan].extarp1 = ((opcode & 0xf0) >> 4);
             tracker_engine->channel[chan].extarp2 = (opcode & 0xf);
         }
 
-        else
-        {
+        else {
             do_command(opcode, tracker_engine, chan, tracker_engine->current_tick, false);
         }
     }
 
-    if (tracker_engine->channel[chan].channel_flags & TEC_DISABLED)
-    {
+    if(tracker_engine->channel[chan].channel_flags & TEC_DISABLED) {
         tracker_engine->sound_engine->channel[chan].adsr.volume = 0;
     }
 }
 
-void tracker_engine_execute_program_tick(TrackerEngine *tracker_engine, uint8_t chan, uint8_t advance)
-{
-    TrackerEngineChannel *te_channel = &tracker_engine->channel[chan];
+void tracker_engine_execute_program_tick(
+    TrackerEngine* tracker_engine,
+    uint8_t chan,
+    uint8_t advance) {
+    TrackerEngineChannel* te_channel = &tracker_engine->channel[chan];
     uint8_t tick = te_channel->program_tick;
     uint8_t visited[INST_PROG_LEN] = {0};
 
@@ -301,366 +286,337 @@ do_it_again:;
 
     const uint16_t inst = te_channel->instrument->program[tick];
 
-    if ((inst & 0x7fff) == TE_PROGRAM_END)
-    {
+    if((inst & 0x7fff) == TE_PROGRAM_END) {
         te_channel->channel_flags &= ~(TEC_PROGRAM_RUNNING);
         return;
     }
 
     uint8_t dont_reloop = 0;
 
-    if ((inst & 0x7fff) != TE_PROGRAM_NOP)
-    {
-        switch (inst & 0x7f00)
-        {
-            case TE_PROGRAM_JUMP:
-            {
-                if (!visited[tick])
-                {
-                    visited[tick] = 1;
-                    tick = inst & (INST_PROG_LEN - 1);
-                }
-
-                else
-                    return;
-
-                break;
+    if((inst & 0x7fff) != TE_PROGRAM_NOP) {
+        switch(inst & 0x7f00) {
+        case TE_PROGRAM_JUMP: {
+            if(!visited[tick]) {
+                visited[tick] = 1;
+                tick = inst & (INST_PROG_LEN - 1);
             }
 
-            case TE_PROGRAM_LOOP_BEGIN:
-                break;
+            else
+                return;
 
-            case TE_PROGRAM_LOOP_END:
-            {
-                if (te_channel->program_loop == (inst & 0xff))
-                {
-                    if (advance)
-                        te_channel->program_loop = 1;
-                }
+            break;
+        }
 
-                else
-                {
-                    if (advance)
-                        ++te_channel->program_loop;
+        case TE_PROGRAM_LOOP_BEGIN:
+            break;
 
-                    uint8_t l = 0;
+        case TE_PROGRAM_LOOP_END: {
+            if(te_channel->program_loop == (inst & 0xff)) {
+                if(advance) te_channel->program_loop = 1;
+            }
 
-                    while ((te_channel->instrument->program[tick] & 0x7f00) != TE_PROGRAM_LOOP_BEGIN && tick > 0)
-                    {
-                        --tick;
-                        if (!(te_channel->instrument->program[tick] & 0x8000))
-                            ++l;
-                    }
+            else {
+                if(advance) ++te_channel->program_loop;
 
-                    --tick;
+                uint8_t l = 0;
 
-                    dont_reloop = l <= 1;
+                while((te_channel->instrument->program[tick] & 0x7f00) != TE_PROGRAM_LOOP_BEGIN &&
+                      tick > 0) {
+                    --tick;
+                    if(!(te_channel->instrument->program[tick] & 0x8000)) ++l;
                 }
 
-                break;
-            }
+                --tick;
 
-            default:
-            {
-                do_command(inst, tracker_engine, chan, te_channel->program_counter, true);
-                break;
+                dont_reloop = l <= 1;
             }
+
+            break;
+        }
+
+        default: {
+            do_command(inst, tracker_engine, chan, te_channel->program_counter, true);
+            break;
+        }
         }
     }
 
-    if ((inst & 0x7fff) == TE_PROGRAM_NOP || (inst & 0x7f00) != TE_PROGRAM_JUMP)
-    {
+    if((inst & 0x7fff) == TE_PROGRAM_NOP || (inst & 0x7f00) != TE_PROGRAM_JUMP) {
         ++tick;
-        if (tick >= INST_PROG_LEN)
-        {
+        if(tick >= INST_PROG_LEN) {
             tick = 0;
         }
     }
 
     // skip to next on msb
 
-    if (((inst & 0x8000) || ((inst & 0x7f00) == TE_PROGRAM_LOOP_BEGIN) || ((inst & 0x7f00) == TE_PROGRAM_JUMP)) && (inst & 0x7fff) != TE_PROGRAM_NOP && !dont_reloop)
-    {
+    if(((inst & 0x8000) || ((inst & 0x7f00) == TE_PROGRAM_LOOP_BEGIN) ||
+        ((inst & 0x7f00) == TE_PROGRAM_JUMP)) &&
+       (inst & 0x7fff) != TE_PROGRAM_NOP && !dont_reloop) {
         goto do_it_again;
     }
 
-    if (advance)
-    {
+    if(advance) {
         te_channel->program_tick = tick;
     }
 }
 
-void tracker_engine_advance_channel(TrackerEngine *tracker_engine, uint8_t chan)
-{
-    SoundEngineChannel *se_channel = &tracker_engine->sound_engine->channel[chan];
-    TrackerEngineChannel *te_channel = &tracker_engine->channel[chan];
+void tracker_engine_advance_channel(TrackerEngine* tracker_engine, uint8_t chan) {
+    SoundEngineChannel* se_channel = &tracker_engine->sound_engine->channel[chan];
+    TrackerEngineChannel* te_channel = &tracker_engine->channel[chan];
 
-    if (te_channel->channel_flags & TEC_PLAYING)
-    {
-        if (!(se_channel->flags & SE_ENABLE_GATE))
-        {
+    if(te_channel->channel_flags & TEC_PLAYING) {
+        if(!(se_channel->flags & SE_ENABLE_GATE)) {
             te_channel->flags &= ~(TEC_PLAYING);
         }
 
-        if (te_channel->slide_speed != 0)
-        {
-            if (te_channel->target_note > te_channel->note)
-            {
-                te_channel->note += my_min(te_channel->slide_speed, te_channel->target_note - te_channel->note);
+        if(te_channel->slide_speed != 0) {
+            if(te_channel->target_note > te_channel->note) {
+                te_channel->note +=
+                    my_min(te_channel->slide_speed, te_channel->target_note - te_channel->note);
             }
 
-            else if (te_channel->target_note < te_channel->note)
-            {
-                te_channel->note -= my_min(te_channel->slide_speed, te_channel->note - te_channel->target_note);
+            else if(te_channel->target_note < te_channel->note) {
+                te_channel->note -=
+                    my_min(te_channel->slide_speed, te_channel->note - te_channel->target_note);
             }
         }
 
-        if (te_channel->channel_flags & TEC_PROGRAM_RUNNING)
-        {
+        if(te_channel->channel_flags & TEC_PROGRAM_RUNNING) {
             uint8_t u = (te_channel->program_counter + 1) >= te_channel->program_period;
             tracker_engine_execute_program_tick(tracker_engine, chan, u);
             ++te_channel->program_counter;
 
-            if (u)
-                te_channel->program_counter = 0;
+            if(u) te_channel->program_counter = 0;
         }
 
         int16_t vib = 0;
         int32_t pwm = 0;
 
-        if (te_channel->flags & TE_ENABLE_VIBRATO)
-        {
-            if (te_channel->vibrato_delay > 0)
-            {
+        if(te_channel->flags & TE_ENABLE_VIBRATO) {
+            if(te_channel->vibrato_delay > 0) {
                 te_channel->vibrato_delay--;
             }
 
-            else
-            {
+            else {
                 te_channel->vibrato_position += ((uint32_t)te_channel->vibrato_speed << 21);
-                vib = (int32_t)(sound_engine_triangle(te_channel->vibrato_position >> 9) - WAVE_AMP / 2) * (int32_t)te_channel->vibrato_depth / (256 * 128);
+                vib =
+                    (int32_t)(sound_engine_triangle(te_channel->vibrato_position >> 9) - WAVE_AMP / 2) *
+                    (int32_t)te_channel->vibrato_depth / (256 * 128);
             }
         }
 
-        if (te_channel->flags & TE_ENABLE_PWM)
-        {
-            if (te_channel->pwm_delay > 0)
-            {
+        if(te_channel->flags & TE_ENABLE_PWM) {
+            if(te_channel->pwm_delay > 0) {
                 te_channel->pwm_delay--;
             }
 
-            else
-            {
-                te_channel->pwm_position += ((uint32_t)te_channel->pwm_speed << 20); // so minimum PWM speed is even lower than minimum vibrato speed
-                pwm = ((int32_t)sound_engine_triangle((te_channel->pwm_position) >> 9) - WAVE_AMP / 2) * (int32_t)te_channel->pwm_depth / (256 * 16);
+            else {
+                te_channel->pwm_position +=
+                    ((uint32_t)te_channel->pwm_speed
+                     << 20); // so minimum PWM speed is even lower than minimum vibrato speed
+                pwm = ((int32_t)sound_engine_triangle((te_channel->pwm_position) >> 9) -
+                       WAVE_AMP / 2) *
+                      (int32_t)te_channel->pwm_depth / (256 * 16);
             }
 
             int16_t final_pwm = (int16_t)tracker_engine->channel[chan].pw + pwm;
 
-            if (final_pwm < 0)
-            {
+            if(final_pwm < 0) {
                 final_pwm = 0;
             }
 
-            if (final_pwm > 0xfff)
-            {
+            if(final_pwm > 0xfff) {
                 final_pwm = 0xfff;
             }
 
             tracker_engine->sound_engine->channel[chan].pw = final_pwm;
         }
 
-        else
-        {
+        else {
             tracker_engine->sound_engine->channel[chan].pw = tracker_engine->channel[chan].pw;
         }
 
-        int32_t chn_note = (int16_t)(te_channel->fixed_note != 0xffff ? te_channel->fixed_note : te_channel->note) + vib + ((int16_t)te_channel->arpeggio_note << 8);
+        int32_t chn_note =
+            (int16_t)(te_channel->fixed_note != 0xffff ? te_channel->fixed_note : te_channel->note) +
+            vib + ((int16_t)te_channel->arpeggio_note << 8);
 
-        if (chn_note < 0)
-        {
+        if(chn_note < 0) {
             chn_note = 0;
         }
 
-        if (chn_note > ((12 * 7 + 11) << 8))
-        {
+        if(chn_note > ((12 * 7 + 11) << 8)) {
             chn_note = ((12 * 7 + 11) << 8); // highest note is B-7
         }
 
         tracker_engine_set_note(tracker_engine, chan, (uint16_t)chn_note, false);
     }
 
-    if (tracker_engine->channel[chan].channel_flags & TEC_DISABLED) // so we can't set some non-zero volme from inst program too
+    if(tracker_engine->channel[chan].channel_flags &
+       TEC_DISABLED) // so we can't set some non-zero volme from inst program too
     {
         tracker_engine->sound_engine->channel[chan].adsr.volume = 0;
     }
 }
 
-void tracker_engine_advance_tick(TrackerEngine *tracker_engine)
-{
-    if (!(tracker_engine->playing))
-        return;
+void tracker_engine_advance_tick(TrackerEngine* tracker_engine) {
+    if(!(tracker_engine->playing)) return;
 
-    if (!(tracker_engine->sound_engine))
-        return;
+    if(!(tracker_engine->sound_engine)) return;
 
-    TrackerSong *song = tracker_engine->song;
+    TrackerSong* song = tracker_engine->song;
 
     uint16_t opcode = 0;
 
-    for (int chan = 0; chan < SONG_MAX_CHANNELS; ++chan)
-    {
-        SoundEngineChannel *se_channel = &tracker_engine->sound_engine->channel[chan];
-        TrackerEngineChannel *te_channel = &tracker_engine->channel[chan];
+    for(int chan = 0; chan < SONG_MAX_CHANNELS; ++chan) {
+        SoundEngineChannel* se_channel = &tracker_engine->sound_engine->channel[chan];
+        TrackerEngineChannel* te_channel = &tracker_engine->channel[chan];
 
-        if (tracker_engine->song)
-        {
+        if(tracker_engine->song) {
             uint16_t sequence_position = tracker_engine->sequence_position;
-            uint8_t current_pattern = song->sequence.sequence_step[sequence_position].pattern_indices[chan];
+            uint8_t current_pattern =
+                song->sequence.sequence_step[sequence_position].pattern_indices[chan];
             uint8_t pattern_step = tracker_engine->pattern_position;
 
-            TrackerSongPattern *pattern = &song->pattern[current_pattern];
+            TrackerSongPattern* pattern = &song->pattern[current_pattern];
 
             uint8_t note_delay = 0;
 
             opcode = tracker_engine_get_command(&pattern->step[pattern_step]);
 
-            if ((opcode & 0x7ff0) == TE_EFFECT_EXT_NOTE_DELAY)
-            {
+            if((opcode & 0x7ff0) == TE_EFFECT_EXT_NOTE_DELAY) {
                 note_delay = (opcode & 0xf);
             }
 
-            if (tracker_engine->current_tick == note_delay)
-            {
+            if(tracker_engine->current_tick == note_delay) {
                 uint8_t note = tracker_engine_get_note(&pattern->step[pattern_step]);
                 uint8_t inst = tracker_engine_get_instrument(&pattern->step[pattern_step]);
 
-                Instrument *pinst = NULL;
+                Instrument* pinst = NULL;
 
-                if (inst == MUS_NOTE_INSTRUMENT_NONE)
-                {
+                if(inst == MUS_NOTE_INSTRUMENT_NONE) {
                     pinst = te_channel->instrument;
                 }
 
-                else
-                {
-                    if (inst < song->num_instruments)
-                    {
+                else {
+                    if(inst < song->num_instruments) {
                         pinst = song->instrument[inst];
                         te_channel->instrument = pinst;
                     }
                 }
 
-                if (note == MUS_NOTE_CUT)
-                {
+                if(note == MUS_NOTE_CUT) {
                     sound_engine_enable_gate(tracker_engine->sound_engine, se_channel, 0);
                     se_channel->adsr.volume = 0;
                     te_channel->volume = 0;
                 }
 
-                if (note == MUS_NOTE_RELEASE)
-                {
+                if(note == MUS_NOTE_RELEASE) {
                     sound_engine_enable_gate(tracker_engine->sound_engine, se_channel, 0);
                 }
 
-                else if (pinst && note != MUS_NOTE_RELEASE && note != MUS_NOTE_CUT && note != MUS_NOTE_NONE)
-                {
+                else if(
+                    pinst && note != MUS_NOTE_RELEASE && note != MUS_NOTE_CUT &&
+                    note != MUS_NOTE_NONE) {
                     // te_channel->slide_speed = 0;
 
                     uint8_t prev_adsr_volume = se_channel->adsr.volume;
 
-                    if ((opcode & 0x7f00) == TE_EFFECT_SLIDE)
-                    {
-                        if (pinst->flags & TE_RETRIGGER_ON_SLIDE)
-                        {
+                    if((opcode & 0x7f00) == TE_EFFECT_SLIDE) {
+                        if(pinst->flags & TE_RETRIGGER_ON_SLIDE) {
                             uint16_t temp_note = te_channel->note;
-                            tracker_engine_trigger_instrument_internal(tracker_engine, chan, pinst, note << 8);
+                            tracker_engine_trigger_instrument_internal(
+                                tracker_engine, chan, pinst, note << 8);
                             te_channel->note = temp_note;
                         }
 
-                        te_channel->target_note = ((note + pinst->base_note - MIDDLE_C) << 8) + pinst->finetune;
+                        te_channel->target_note =
+                            ((note + pinst->base_note - MIDDLE_C) << 8) + pinst->finetune;
                         te_channel->slide_speed = (opcode & 0xff);
                     }
 
-                    else if ((opcode & 0x7f00) == TE_EFFECT_LEGATO)
-                    {
-                        te_channel->note = te_channel->target_note = te_channel->last_note = ((note + pinst->base_note - MIDDLE_C) << 8) + pinst->finetune;
+                    else if((opcode & 0x7f00) == TE_EFFECT_LEGATO) {
+                        te_channel->note = te_channel->target_note = te_channel->last_note =
+                            ((note + pinst->base_note - MIDDLE_C) << 8) + pinst->finetune;
                     }
 
-                    else
-                    {
-                        tracker_engine_trigger_instrument_internal(tracker_engine, chan, pinst, note << 8);
-                        te_channel->note = ((note + pinst->base_note - MIDDLE_C) << 8) + pinst->finetune;
+                    else {
+                        tracker_engine_trigger_instrument_internal(
+                            tracker_engine, chan, pinst, note << 8);
+                        te_channel->note =
+                            ((note + pinst->base_note - MIDDLE_C) << 8) + pinst->finetune;
 
-                        te_channel->target_note = ((note + pinst->base_note - MIDDLE_C) << 8) + pinst->finetune;
+                        te_channel->target_note =
+                            ((note + pinst->base_note - MIDDLE_C) << 8) + pinst->finetune;
                     }
 
-                    if (inst == MUS_NOTE_INSTRUMENT_NONE)
-                    {
+                    if(inst == MUS_NOTE_INSTRUMENT_NONE) {
                         se_channel->adsr.volume = prev_adsr_volume;
                     }
                 }
             }
 
-            tracker_engine_execute_track_command(tracker_engine, chan, &pattern->step[pattern_step], tracker_engine->current_tick == note_delay);
+            tracker_engine_execute_track_command(
+                tracker_engine,
+                chan,
+                &pattern->step[pattern_step],
+                tracker_engine->current_tick == note_delay);
         }
 
-        tracker_engine_advance_channel(tracker_engine, chan); // this will be executed even if the song pointer is NULL; handy for live instrument playback from inst editor ("jams")
+        tracker_engine_advance_channel(
+            tracker_engine,
+            chan); // this will be executed even if the song pointer is NULL; handy for live instrument playback from inst editor ("jams")
     }
 
-    if (tracker_engine->song)
-    {
+    if(tracker_engine->song) {
         tracker_engine->current_tick++;
 
-        if (tracker_engine->current_tick >= song->speed)
-        {
+        if(tracker_engine->current_tick >= song->speed) {
             bool flag = true;
 
-            for (int chan = 0; chan < SONG_MAX_CHANNELS; ++chan)
-            {
+            for(int chan = 0; chan < SONG_MAX_CHANNELS; ++chan) {
                 uint16_t sequence_position = tracker_engine->sequence_position;
-                uint8_t current_pattern = song->sequence.sequence_step[sequence_position].pattern_indices[chan];
+                uint8_t current_pattern =
+                    song->sequence.sequence_step[sequence_position].pattern_indices[chan];
                 uint8_t pattern_step = tracker_engine->pattern_position;
 
-                TrackerSongPattern *pattern = &song->pattern[current_pattern];
+                TrackerSongPattern* pattern = &song->pattern[current_pattern];
 
                 opcode = tracker_engine_get_command(&pattern->step[pattern_step]);
 
-                if ((opcode & 0x7ff0) == TE_EFFECT_EXT_PATTERN_LOOP)
-                {
-                    if (opcode & 0xf) // loop end
+                if((opcode & 0x7ff0) == TE_EFFECT_EXT_PATTERN_LOOP) {
+                    if(opcode & 0xf) // loop end
                     {
-                        if (!(tracker_engine->in_loop))
-                        {
+                        if(!(tracker_engine->in_loop)) {
                             tracker_engine->loops_left = (opcode & 0xf);
                             tracker_engine->in_loop = true;
 
-                            for (int j = tracker_engine->pattern_position; j >= 0; j--)
-                            {
-                                if (tracker_engine_get_command(&pattern->step[j]) == TE_EFFECT_EXT_PATTERN_LOOP) // search for loop start
+                            for(int j = tracker_engine->pattern_position; j >= 0; j--) {
+                                if(tracker_engine_get_command(&pattern->step[j]) ==
+                                   TE_EFFECT_EXT_PATTERN_LOOP) // search for loop start
                                 {
-                                    tracker_engine->pattern_position = fmax((int16_t)j - 1, 0); // jump to loop start
+                                    tracker_engine->pattern_position =
+                                        fmax((int16_t)j - 1, 0); // jump to loop start
 
                                     goto out;
                                 }
                             }
                         }
 
-                        else
-                        {
+                        else {
                             tracker_engine->loops_left--;
 
-                            if (tracker_engine->loops_left == 0)
-                            {
+                            if(tracker_engine->loops_left == 0) {
                                 tracker_engine->in_loop = false;
                                 goto out;
                             }
 
-                            for (int j = tracker_engine->pattern_position; j >= 0; j--)
-                            {
-                                if (tracker_engine_get_command(&pattern->step[j]) == TE_EFFECT_EXT_PATTERN_LOOP) // search for loop start
+                            for(int j = tracker_engine->pattern_position; j >= 0; j--) {
+                                if(tracker_engine_get_command(&pattern->step[j]) ==
+                                   TE_EFFECT_EXT_PATTERN_LOOP) // search for loop start
                                 {
-                                    tracker_engine->pattern_position = fmax((int16_t)j - 1, 0); // jump to loop start
+                                    tracker_engine->pattern_position =
+                                        fmax((int16_t)j - 1, 0); // jump to loop start
 
                                     goto out;
                                 }
@@ -675,22 +631,22 @@ void tracker_engine_advance_tick(TrackerEngine *tracker_engine)
                 out:;
                 }
 
-                if ((opcode & 0x7f00) == TE_EFFECT_SKIP_PATTERN)
-                {
+                if((opcode & 0x7f00) == TE_EFFECT_SKIP_PATTERN) {
                     tracker_engine->sequence_position++;
                     tracker_engine->pattern_position = 0;
 
                     flag = false;
 
-                    if (tracker_engine->sequence_position >= song->num_sequence_steps)
-                    {
+                    if(tracker_engine->sequence_position >= song->num_sequence_steps) {
                         tracker_engine->playing = false;
                         tracker_engine->sequence_position--;
                         tracker_engine->pattern_position = song->pattern_length - 1;
 
-                        for (int i = 0; i < SONG_MAX_CHANNELS; i++)
-                        {
-                            sound_engine_enable_gate(tracker_engine->sound_engine, &tracker_engine->sound_engine->channel[i], false);
+                        for(int i = 0; i < SONG_MAX_CHANNELS; i++) {
+                            sound_engine_enable_gate(
+                                tracker_engine->sound_engine,
+                                &tracker_engine->sound_engine->channel[i],
+                                false);
                         }
 
                         goto end_process;
@@ -698,44 +654,40 @@ void tracker_engine_advance_tick(TrackerEngine *tracker_engine)
                 }
             }
 
-            if (flag)
-            {
+            if(flag) {
                 tracker_engine->pattern_position++;
             }
 
             tracker_engine->current_tick = 0;
 
-            if (tracker_engine->pattern_position >= song->pattern_length)
-            {
+            if(tracker_engine->pattern_position >= song->pattern_length) {
                 tracker_engine->pattern_position = 0;
 
-                if (song->loop_start != 0 || song->loop_end != 0)
-                {
-                    if (tracker_engine->sequence_position == song->loop_end)
-                    {
-                        tracker_engine->sequence_position = song->loop_start; // infinite loop between loop start and loop end
+                if(song->loop_start != 0 || song->loop_end != 0) {
+                    if(tracker_engine->sequence_position == song->loop_end) {
+                        tracker_engine->sequence_position =
+                            song->loop_start; // infinite loop between loop start and loop end
                     }
 
-                    else
-                    {
+                    else {
                         tracker_engine->sequence_position++;
                     }
                 }
 
-                else
-                {
+                else {
                     tracker_engine->sequence_position++;
                 }
 
-                if (tracker_engine->sequence_position >= song->num_sequence_steps)
-                {
+                if(tracker_engine->sequence_position >= song->num_sequence_steps) {
                     tracker_engine->playing = false;
                     tracker_engine->sequence_position--;
                     tracker_engine->pattern_position = song->pattern_length - 1;
 
-                    for (int i = 0; i < SONG_MAX_CHANNELS; i++)
-                    {
-                        sound_engine_enable_gate(tracker_engine->sound_engine, &tracker_engine->sound_engine->channel[i], false);
+                    for(int i = 0; i < SONG_MAX_CHANNELS; i++) {
+                        sound_engine_enable_gate(
+                            tracker_engine->sound_engine,
+                            &tracker_engine->sound_engine->channel[i],
+                            false);
                     }
                 }
             }

tracker_engine/tracker_engine.h

@@ -3,22 +3,26 @@
 #include "do_effects.h"
 #include "tracker_engine_defs.h"
 
-void tracker_engine_init(TrackerEngine *tracker_engine, uint8_t rate, SoundEngine *sound_engine);
-void tracker_engine_deinit(TrackerEngine *tracker_engine, bool free_song);
-void tracker_engine_advance_tick(TrackerEngine *tracker_engine);
-void tracker_engine_set_song(TrackerEngine *tracker_engine, TrackerSong *song);
-void tracker_engine_deinit_song(TrackerSong *song, bool free_song);
-void tracker_engine_trigger_instrument_internal(TrackerEngine *tracker_engine, uint8_t chan, Instrument *pinst, uint16_t note);
+void tracker_engine_init(TrackerEngine* tracker_engine, uint8_t rate, SoundEngine* sound_engine);
+void tracker_engine_deinit(TrackerEngine* tracker_engine, bool free_song);
+void tracker_engine_advance_tick(TrackerEngine* tracker_engine);
+void tracker_engine_set_song(TrackerEngine* tracker_engine, TrackerSong* song);
+void tracker_engine_deinit_song(TrackerSong* song, bool free_song);
+void tracker_engine_trigger_instrument_internal(
+    TrackerEngine* tracker_engine,
+    uint8_t chan,
+    Instrument* pinst,
+    uint16_t note);
 
-uint8_t tracker_engine_get_note(TrackerSongPatternStep *step);
-uint8_t tracker_engine_get_instrument(TrackerSongPatternStep *step);
-uint8_t tracker_engine_get_volume(TrackerSongPatternStep *step);
-uint16_t tracker_engine_get_command(TrackerSongPatternStep *step);
+uint8_t tracker_engine_get_note(TrackerSongPatternStep* step);
+uint8_t tracker_engine_get_instrument(TrackerSongPatternStep* step);
+uint8_t tracker_engine_get_volume(TrackerSongPatternStep* step);
+uint16_t tracker_engine_get_command(TrackerSongPatternStep* step);
 
-void set_note(TrackerSongPatternStep *step, uint8_t note);
-void set_instrument(TrackerSongPatternStep *step, uint8_t inst);
-void set_volume(TrackerSongPatternStep *step, uint8_t vol);
-void set_command(TrackerSongPatternStep *step, uint16_t command);
+void set_note(TrackerSongPatternStep* step, uint8_t note);
+void set_instrument(TrackerSongPatternStep* step, uint8_t inst);
+void set_volume(TrackerSongPatternStep* step, uint8_t vol);
+void set_command(TrackerSongPatternStep* step, uint16_t command);
 
-void set_default_instrument(Instrument *inst);
-void set_empty_pattern(TrackerSongPattern *pattern, uint16_t pattern_length);
+void set_default_instrument(Instrument* inst);
+void set_empty_pattern(TrackerSongPattern* pattern, uint16_t pattern_length);

tracker_engine/tracker_engine_defs.h

@@ -31,8 +31,7 @@
 #define MIDDLE_C (12 * 4)
 #define MAX_NOTE (12 * 7 + 11)
 
-typedef enum
-{
+typedef enum {
     TE_ENABLE_VIBRATO = 1,
     TE_ENABLE_PWM = 2,
     TE_PROG_NO_RESTART = 4,
@@ -41,15 +40,13 @@ typedef enum
     TE_RETRIGGER_ON_SLIDE = 32, // call trigger instrument function even if slide command is there
 } TrackerEngineFlags;
 
-typedef enum
-{
+typedef enum {
     TEC_PLAYING = 1,
     TEC_PROGRAM_RUNNING = 2,
     TEC_DISABLED = 4,
 } TrackerEngineChannelFlags;
 
-typedef enum
-{
+typedef enum {
     TE_EFFECT_ARPEGGIO = 0x0000,
     TE_EFFECT_PORTAMENTO_UP = 0x0100,
     TE_EFFECT_PORTAMENTO_DOWN = 0x0200,
@@ -70,7 +67,8 @@ typedef enum
     TE_EFFECT_EXT_PORTA_UP = 0x0e10,
     TE_EFFECT_EXT_PORTA_DN = 0x0e20,
     TE_EFFECT_EXT_FILTER_MODE = 0x0e30,
-    TE_EFFECT_EXT_PATTERN_LOOP = 0x0e60, // e60 = start, e61-e6f = end and indication how many loops you want
+    TE_EFFECT_EXT_PATTERN_LOOP =
+        0x0e60, // e60 = start, e61-e6f = end and indication how many loops you want
     TE_EFFECT_EXT_RETRIGGER = 0x0e90,
     TE_EFFECT_EXT_FINE_VOLUME_DOWN = 0x0ea0,
     TE_EFFECT_EXT_FINE_VOLUME_UP = 0x0eb0,
@@ -79,33 +77,33 @@ typedef enum
     TE_EFFECT_EXT_PHASE_RESET = 0x0ef0,
 
     TE_EFFECT_SET_SPEED_PROG_PERIOD = 0x0f00,
-    TE_EFFECT_CUTOFF_UP = 0x1000,      // Gxx
-    TE_EFFECT_CUTOFF_DOWN = 0x1100,    // Hxx
-    TE_EFFECT_SET_RESONANCE = 0x1200,  // Ixx
-    TE_EFFECT_RESONANCE_UP = 0x1300,   // Jxx
+    TE_EFFECT_CUTOFF_UP = 0x1000, // Gxx
+    TE_EFFECT_CUTOFF_DOWN = 0x1100, // Hxx
+    TE_EFFECT_SET_RESONANCE = 0x1200, // Ixx
+    TE_EFFECT_RESONANCE_UP = 0x1300, // Jxx
     TE_EFFECT_RESONANCE_DOWN = 0x1400, // Kxx
 
-    TE_EFFECT_SET_ATTACK = 0x1500,      // Lxx
-    TE_EFFECT_SET_DECAY = 0x1600,       // Mxx
-    TE_EFFECT_SET_SUSTAIN = 0x1700,     // Nxx
-    TE_EFFECT_SET_RELEASE = 0x1800,     // Oxx
+    TE_EFFECT_SET_ATTACK = 0x1500, // Lxx
+    TE_EFFECT_SET_DECAY = 0x1600, // Mxx
+    TE_EFFECT_SET_SUSTAIN = 0x1700, // Nxx
+    TE_EFFECT_SET_RELEASE = 0x1800, // Oxx
     TE_EFFECT_PROGRAM_RESTART = 0x1900, // Pxx
     /*
     TE_EFFECT_ = 0x1a00, //Qxx
     */
 
-    TE_EFFECT_SET_RING_MOD_SRC = 0x1b00,  // Rxx
+    TE_EFFECT_SET_RING_MOD_SRC = 0x1b00, // Rxx
     TE_EFFECT_SET_HARD_SYNC_SRC = 0x1c00, // Sxx
 
-    TE_EFFECT_PORTA_UP_SEMITONE = 0x1d00,   // Txx
+    TE_EFFECT_PORTA_UP_SEMITONE = 0x1d00, // Txx
     TE_EFFECT_PORTA_DOWN_SEMITONE = 0x1e00, // Uxx
     /*
     TE_EFFECT_ = 0x1f00, //Vxx
     TE_EFFECT_ = 0x2000, //Wxx
     */
 
-    TE_EFFECT_LEGATO = 0x2100,          // Xxx
-    TE_EFFECT_ARPEGGIO_ABS = 0x2200,    // Yxx
+    TE_EFFECT_LEGATO = 0x2100, // Xxx
+    TE_EFFECT_ARPEGGIO_ABS = 0x2200, // Yxx
     TE_EFFECT_TRIGGER_RELEASE = 0x2300, // Zxx
 
     /* These effects work only in instrument program */
@@ -116,13 +114,11 @@ typedef enum
     TE_PROGRAM_END = 0x7fff,
 } EffectCommandsOpcodes;
 
-typedef struct
-{
+typedef struct {
     uint8_t a, d, s, r, volume;
 } InstrumentAdsr;
 
-typedef struct
-{
+typedef struct {
     char name[MUS_INST_NAME_LEN + 1];
 
     uint8_t waveform;
@@ -137,7 +133,8 @@ typedef struct
 
     uint8_t pw; // store only one byte since we don't have the luxury of virtually unlimited memory!
 
-    uint16_t program[INST_PROG_LEN]; // MSB is unite bit (indicates this and next command must be executed at once)
+    uint16_t program
+        [INST_PROG_LEN]; // MSB is unite bit (indicates this and next command must be executed at once)
     uint8_t program_period;
 
     uint8_t vibrato_speed, vibrato_depth, vibrato_delay;
@@ -149,9 +146,8 @@ typedef struct
     int8_t finetune;
 } Instrument;
 
-typedef struct
-{
-    Instrument *instrument;
+typedef struct {
+    Instrument* instrument;
 
     uint16_t flags;
 
@@ -179,31 +175,26 @@ typedef struct
     uint8_t slide_speed;
 } TrackerEngineChannel;
 
-typedef struct
-{
-    uint8_t note;     // MSB is used for instrument number MSB
+typedef struct {
+    uint8_t note; // MSB is used for instrument number MSB
     uint8_t inst_vol; // high nibble + MSB from note = instrument, low nibble = 4 volume LSBs
     uint16_t command; // MSB used as volume MSB
 } TrackerSongPatternStep;
 
-typedef struct
-{
-    TrackerSongPatternStep *step;
+typedef struct {
+    TrackerSongPatternStep* step;
 } TrackerSongPattern;
 
-typedef struct
-{
+typedef struct {
     uint8_t pattern_indices[SONG_MAX_CHANNELS];
 } TrackerSongSequenceStep;
 
-typedef struct
-{
+typedef struct {
     TrackerSongSequenceStep sequence_step[MAX_SEQUENCE_LENGTH];
 } TrackerSongSequence;
 
-typedef struct
-{
-    Instrument *instrument[MAX_INSTRUMENTS];
+typedef struct {
+    Instrument* instrument[MAX_INSTRUMENTS];
     TrackerSongPattern pattern[MAX_PATTERNS];
     TrackerSongSequence sequence;
 
@@ -217,12 +208,11 @@ typedef struct
     uint8_t loop_start, loop_end;
 } TrackerSong;
 
-typedef struct
-{
+typedef struct {
     TrackerEngineChannel channel[SONG_MAX_CHANNELS];
 
-    TrackerSong *song;
-    SoundEngine *sound_engine;
+    TrackerSong* song;
+    SoundEngine* sound_engine;
 
     uint16_t pattern_position, sequence_position, current_tick;
     uint16_t absolute_position; // sequence_position * pattern_length + pattern_position

util.c

@@ -1,26 +1,23 @@
 #include "util.h"
 #include "macros.h"
 
-void reset_buffer(SoundEngine *sound_engine)
-{
-    for (uint16_t i = 0; i < sound_engine->audio_buffer_size; i++)
-    {
+void reset_buffer(SoundEngine* sound_engine) {
+    for(uint16_t i = 0; i < sound_engine->audio_buffer_size; i++) {
         sound_engine->audio_buffer[i] = 512;
     }
 }
 
-void play_song(FlizzerTrackerApp *tracker, bool from_cursor)
-{
+void play_song(FlizzerTrackerApp* tracker, bool from_cursor) {
     reset_buffer(&tracker->sound_engine);
 
-    sound_engine_dma_init((uint32_t)tracker->sound_engine.audio_buffer, tracker->sound_engine.audio_buffer_size);
+    sound_engine_dma_init(
+        (uint32_t)tracker->sound_engine.audio_buffer, tracker->sound_engine.audio_buffer_size);
 
     tracker->tracker_engine.playing = true;
     tracker->was_editing = tracker->editing;
     tracker->editing = false;
 
-    if (!(from_cursor))
-    {
+    if(!(from_cursor)) {
         tracker->tracker_engine.pattern_position = 0;
     }
 
@@ -32,32 +29,27 @@ void play_song(FlizzerTrackerApp *tracker, bool from_cursor)
     play();
 }
 
-void stop_song(FlizzerTrackerApp *tracker)
-{
+void stop_song(FlizzerTrackerApp* tracker) {
     tracker->tracker_engine.playing = false;
     tracker->editing = tracker->was_editing;
 
-    for (int i = 0; i < SONG_MAX_CHANNELS; i++)
-    {
+    for(int i = 0; i < SONG_MAX_CHANNELS; i++) {
         tracker->sound_engine.channel[i].adsr.volume = 0;
     }
 
     stop();
 }
 
-bool is_pattern_empty(TrackerSong *song, uint8_t pattern)
-{
+bool is_pattern_empty(TrackerSong* song, uint8_t pattern) {
     TrackerSongPattern song_pattern = song->pattern[pattern];
 
-    for (int i = 0; i < song->pattern_length; i++)
-    {
-        TrackerSongPatternStep *step = &song_pattern.step[i];
+    for(int i = 0; i < song->pattern_length; i++) {
+        TrackerSongPatternStep* step = &song_pattern.step[i];
 
-        if (tracker_engine_get_note(step) != MUS_NOTE_NONE ||
-            tracker_engine_get_instrument(step) != MUS_NOTE_INSTRUMENT_NONE ||
-            tracker_engine_get_volume(step) != MUS_NOTE_VOLUME_NONE ||
-            tracker_engine_get_command(step) != 0)
-        {
+        if(tracker_engine_get_note(step) != MUS_NOTE_NONE ||
+           tracker_engine_get_instrument(step) != MUS_NOTE_INSTRUMENT_NONE ||
+           tracker_engine_get_volume(step) != MUS_NOTE_VOLUME_NONE ||
+           tracker_engine_get_command(step) != 0) {
             return false;
         }
     }
@@ -65,51 +57,47 @@ bool is_pattern_empty(TrackerSong *song, uint8_t pattern)
     return true;
 }
 
-bool check_and_allocate_pattern(TrackerSong *song, uint8_t pattern)
-{
-    if (pattern < song->num_patterns) // we can set this pattern since it already exists
+bool check_and_allocate_pattern(TrackerSong* song, uint8_t pattern) {
+    if(pattern < song->num_patterns) // we can set this pattern since it already exists
     {
         return true;
     }
 
-    else
-    {
-        if (song->pattern[pattern - 1].step == NULL)
+    else {
+        if(song->pattern[pattern - 1].step == NULL)
             return false; // if we hop through several patterns (e.g. editing upper digit)
 
-        if (!(is_pattern_empty(song, pattern - 1))) // don't let the user flood the song with empty patterns
+        if(!(is_pattern_empty(
+               song, pattern - 1))) // don't let the user flood the song with empty patterns
         {
-            song->pattern[pattern].step = malloc(sizeof(TrackerSongPatternStep) * song->pattern_length);
+            song->pattern[pattern].step =
+                malloc(sizeof(TrackerSongPatternStep) * song->pattern_length);
             set_empty_pattern(&song->pattern[pattern], song->pattern_length);
             song->num_patterns++;
             return true;
         }
 
-        else
-        {
+        else {
             return false;
         }
     }
 }
 
-void resize_pattern(TrackerSongPattern *pattern, uint16_t old_length, uint16_t new_length)
-{
+void resize_pattern(TrackerSongPattern* pattern, uint16_t old_length, uint16_t new_length) {
     TrackerSongPattern temp;
     temp.step = malloc((new_length) * sizeof(TrackerSongPatternStep));
 
     set_empty_pattern(&temp, new_length);
-    memcpy(temp.step, pattern->step, my_min(old_length, new_length) * sizeof(TrackerSongPatternStep));
+    memcpy(
+        temp.step, pattern->step, my_min(old_length, new_length) * sizeof(TrackerSongPatternStep));
 
     free(pattern->step);
     pattern->step = temp.step;
 }
 
-void change_pattern_length(TrackerSong *song, uint16_t new_length)
-{
-    for (int i = 0; i < MAX_PATTERNS; i++)
-    {
-        if (song->pattern[i].step)
-        {
+void change_pattern_length(TrackerSong* song, uint16_t new_length) {
+    for(int i = 0; i < MAX_PATTERNS; i++) {
+        if(song->pattern[i].step) {
             resize_pattern(&song->pattern[i], song->pattern_length, new_length);
         }
     }
@@ -117,28 +105,26 @@ void change_pattern_length(TrackerSong *song, uint16_t new_length)
     song->pattern_length = new_length;
 }
 
-bool is_default_instrument(Instrument *inst)
-{
-    Instrument *ref = malloc(sizeof(Instrument));
+bool is_default_instrument(Instrument* inst) {
+    Instrument* ref = malloc(sizeof(Instrument));
     set_default_instrument(ref);
     bool is_default = memcmp(ref, inst, sizeof(Instrument)) != 0 ? false : true;
     free(ref);
     return is_default;
 }
 
-bool check_and_allocate_instrument(TrackerSong *song, uint8_t inst)
-{
-    if (inst < song->num_instruments) // we can go to this instrument since it already exists
+bool check_and_allocate_instrument(TrackerSong* song, uint8_t inst) {
+    if(inst < song->num_instruments) // we can go to this instrument since it already exists
     {
         return true;
     }
 
-    else
-    {
-        if (inst >= MAX_INSTRUMENTS)
-            return false;
+    else {
+        if(inst >= MAX_INSTRUMENTS) return false;
 
-        if (!(is_default_instrument(song->instrument[inst - 1]))) // don't let the user flood the song with default instrument
+        if(!(is_default_instrument(
+               song->instrument
+                   [inst - 1]))) // don't let the user flood the song with default instrument
         {
             song->instrument[inst] = malloc(sizeof(Instrument));
             set_default_instrument(song->instrument[inst]);
@@ -146,15 +132,13 @@ bool check_and_allocate_instrument(TrackerSong *song, uint8_t inst)
             return true;
         }
 
-        else
-        {
+        else {
             return false;
         }
     }
 }
 
-void set_default_song(FlizzerTrackerApp *tracker)
-{
+void set_default_song(FlizzerTrackerApp* tracker) {
     tracker->tracker_engine.master_volume = 0x80;
 
     tracker->song.speed = 6;
@@ -169,16 +153,13 @@ void set_default_song(FlizzerTrackerApp *tracker)
     tracker->song.sequence.sequence_step[0].pattern_indices[2] = 3;
     tracker->song.sequence.sequence_step[0].pattern_indices[3] = 4;
 
-    for (int i = 0; i < 5; i++)
-    {
+    for(int i = 0; i < 5; i++) {
         tracker->song.pattern[i].step = malloc(64 * sizeof(TrackerSongPatternStep));
         memset(tracker->song.pattern[i].step, 0, 64 * sizeof(TrackerSongPatternStep));
     }
 
-    for (int i = 0; i < 64; ++i)
-    {
-        for (int j = 0; j < 5; j++)
-        {
+    for(int i = 0; i < 64; ++i) {
+        for(int j = 0; j < 5; j++) {
             set_note(&tracker->song.pattern[j].step[i], MUS_NOTE_NONE);
 
             set_instrument(&tracker->song.pattern[j].step[i], MUS_NOTE_INSTRUMENT_NONE);

util.h

@@ -12,17 +12,15 @@
 
 #define clamp(val, add, _min, _max) val = my_min(_max, my_max(_min, (int32_t)val + add))
 #define flipbit(val, bit) \
-    {                     \
-        val ^= bit;       \
-    };
+    { val ^= bit; };
 
-void reset_buffer(SoundEngine *sound_engine);
-void play_song(FlizzerTrackerApp *tracker, bool from_cursor);
-void stop_song(FlizzerTrackerApp *tracker);
+void reset_buffer(SoundEngine* sound_engine);
+void play_song(FlizzerTrackerApp* tracker, bool from_cursor);
+void stop_song(FlizzerTrackerApp* tracker);
 
-bool is_pattern_empty(TrackerSong *song, uint8_t pattern);
-bool check_and_allocate_pattern(TrackerSong *song, uint8_t pattern);
-void change_pattern_length(TrackerSong *song, uint16_t new_length);
+bool is_pattern_empty(TrackerSong* song, uint8_t pattern);
+bool check_and_allocate_pattern(TrackerSong* song, uint8_t pattern);
+void change_pattern_length(TrackerSong* song, uint16_t new_length);
 
-bool check_and_allocate_instrument(TrackerSong *song, uint8_t inst);
-void set_default_song(FlizzerTrackerApp *tracker);
+bool check_and_allocate_instrument(TrackerSong* song, uint8_t inst);
+void set_default_song(FlizzerTrackerApp* tracker);

view/char_array.c

@@ -1,39 +1,4 @@
-const char to_char_array[] =
-    {
-        '0',
-        '1',
-        '2',
-        '3',
-        '4',
-        '5',
-        '6',
-        '7',
-        '8',
-        '9',
-        'A',
-        'B',
-        'C',
-        'D',
-        'E',
-        'F',
-        'G',
-        'H',
-        'I',
-        'J',
-        'K',
-        'L',
-        'M',
-        'N',
-        'O',
-        'P',
-        'Q',
-        'R',
-        'S',
-        'T',
-        'U',
-        'V',
-        'W',
-        'X',
-        'Y',
-        'Z',
+const char to_char_array[] = {
+    '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H',
+    'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z',
 };

view/instrument_editor.c

@@ -6,142 +6,160 @@
 
 #include <flizzer_tracker_icons.h>
 
-void draw_inst_flag(FlizzerTrackerApp *tracker, Canvas *canvas, uint8_t focus, uint8_t param, const char *text, uint8_t x, uint8_t y, uint16_t flags, uint16_t mask)
-{
+void draw_inst_flag(
+    FlizzerTrackerApp* tracker,
+    Canvas* canvas,
+    uint8_t focus,
+    uint8_t param,
+    const char* text,
+    uint8_t x,
+    uint8_t y,
+    uint16_t flags,
+    uint16_t mask) {
     canvas_draw_icon(canvas, x, y - 5, ((flags & mask) ? &I_checkbox_checked : &I_checkbox_empty));
     canvas_draw_str(canvas, x + 6, y, text);
 
-    if (tracker->focus == focus && tracker->selected_param == param && tracker->editing)
-    {
-        if (text[strlen(text) - 1] == ':')
-        {
+    if(tracker->focus == focus && tracker->selected_param == param && tracker->editing) {
+        if(text[strlen(text) - 1] == ':') {
             canvas_draw_box(canvas, x + 5, y - 6, strlen(text) * 4 - 1, 7);
         }
 
-        else
-        {
+        else {
             canvas_draw_box(canvas, x + 5, y - 6, strlen(text) * 4 + 1, 7);
         }
     }
 }
 
-void draw_inst_text_one_digit(FlizzerTrackerApp *tracker, Canvas *canvas, uint8_t focus, uint8_t param, const char *text, uint8_t x, uint8_t y, uint8_t value) // text MUST end with semicolon
+void draw_inst_text_one_digit(
+    FlizzerTrackerApp* tracker,
+    Canvas* canvas,
+    uint8_t focus,
+    uint8_t param,
+    const char* text,
+    uint8_t x,
+    uint8_t y,
+    uint8_t value) // text MUST end with semicolon
 {
     canvas_draw_str(canvas, x, y, text);
     char buffer[4];
     snprintf(buffer, sizeof(buffer), "%01X", (value & 0xF));
     canvas_draw_str(canvas, x + strlen(text) * 4 - 2, y, buffer);
 
-    if (tracker->focus == focus && tracker->selected_param == param && tracker->editing)
-    {
+    if(tracker->focus == focus && tracker->selected_param == param && tracker->editing) {
         canvas_draw_box(canvas, x + strlen(text) * 4 - 3, y - 6, 5, 7);
     }
 }
 
-void draw_inst_text_two_digits(FlizzerTrackerApp *tracker, Canvas *canvas, uint8_t focus, uint8_t param, const char *text, uint8_t x, uint8_t y, uint8_t value) // text MUST end with semicolon
+void draw_inst_text_two_digits(
+    FlizzerTrackerApp* tracker,
+    Canvas* canvas,
+    uint8_t focus,
+    uint8_t param,
+    const char* text,
+    uint8_t x,
+    uint8_t y,
+    uint8_t value) // text MUST end with semicolon
 {
     canvas_draw_str(canvas, x, y, text);
     char buffer[4];
     snprintf(buffer, sizeof(buffer), "%02X", value);
     canvas_draw_str(canvas, x + strlen(text) * 4 - 2, y, buffer);
 
-    if (tracker->focus == focus && tracker->selected_param == param && tracker->editing)
-    {
-        canvas_draw_box(canvas, x + strlen(text) * 4 + 4 * tracker->current_digit - 3, y - 6, 5, 7);
+    if(tracker->focus == focus && tracker->selected_param == param && tracker->editing) {
+        canvas_draw_box(
+            canvas, x + strlen(text) * 4 + 4 * tracker->current_digit - 3, y - 6, 5, 7);
     }
 }
 
-static const char *filter_types[] =
-    {
-        "NONE",
-        "LOW",
-        "HIGH",
-        "BAND",
-        "LOHI",
-        "HIBD",
-        "LOBD",
-        "ALL",
+static const char* filter_types[] = {
+    "NONE",
+    "LOW",
+    "HIGH",
+    "BAND",
+    "LOHI",
+    "HIBD",
+    "LOBD",
+    "ALL",
 };
 
-static const char *instrument_editor_params_description[] =
-    {
-        "CURRENT INSTRUMENT",
-        "CURRENT INSTRUMENT NAME",
-        "INSTRUMENT BASE NOTE",
-        "INSTRUMENT FINETUNE",
-        "SLIDE SPEED",
-        "SET PULSE WIDTH ON KEYDOWN",
-        "PULSE WIDTH",
-        "SET FILTER PARAMETERS ON KEYDOWN",
-        "NOISE WAVEFORM",
-        "PULSE WAVEFORM",
-        "TRIANGLE WAVEFORM",
-        "SAWTOOTH WAVEFORM",
-        "METALLIC NOISE WAVEFORM",
-        "SINE WAVEFORM",
-        "ENVELOPE ATTACK",
-        "ENVELOPE DECAY",
-        "ENVELOPE SUSTAIN",
-        "ENVELOPE RELEASE",
-        "ENVELOPE VOLUME",
-        "ENABLE FILTER",
-        "FILTER CUTOFF FREQUENCY",
-        "FILTER RESONANCE",
-        "FILTER TYPE (NONE=OFF)",
-        "ENABLE RING MODULATION",
-        "RINGMOD SOURCE CHANNEL (F=SELF)",
-        "ENABLE HARD SYNC",
-        "HARDSYNC SOURCE CHANNEL (F=SELF)",
-        "RETRIGGER INSTRUMENT ON SLIDE",
-        "SYNC OSCILLATORS ON KEYDOWN",
-        "ENABLE VIBRATO",
-        "VIBRATO SPEED",
-        "VIBRATO DEPTH",
-        "VIBRATO DELAY (IN TICKS)",
-        "ENABLE PWM",
-        "PWM SPEED",
-        "PWM DEPTH",
-        "PWM DELAY (IN TICKS)",
-        "DON'T RESTART PROGRAM ON KEYDOWN",
-        "PROG.PERIOD (00 = PROGRAM OFF)",
+static const char* instrument_editor_params_description[] = {
+    "CURRENT INSTRUMENT",
+    "CURRENT INSTRUMENT NAME",
+    "INSTRUMENT BASE NOTE",
+    "INSTRUMENT FINETUNE",
+    "SLIDE SPEED",
+    "SET PULSE WIDTH ON KEYDOWN",
+    "PULSE WIDTH",
+    "SET FILTER PARAMETERS ON KEYDOWN",
+    "NOISE WAVEFORM",
+    "PULSE WAVEFORM",
+    "TRIANGLE WAVEFORM",
+    "SAWTOOTH WAVEFORM",
+    "METALLIC NOISE WAVEFORM",
+    "SINE WAVEFORM",
+    "ENVELOPE ATTACK",
+    "ENVELOPE DECAY",
+    "ENVELOPE SUSTAIN",
+    "ENVELOPE RELEASE",
+    "ENVELOPE VOLUME",
+    "ENABLE FILTER",
+    "FILTER CUTOFF FREQUENCY",
+    "FILTER RESONANCE",
+    "FILTER TYPE (NONE=OFF)",
+    "ENABLE RING MODULATION",
+    "RINGMOD SOURCE CHANNEL (F=SELF)",
+    "ENABLE HARD SYNC",
+    "HARDSYNC SOURCE CHANNEL (F=SELF)",
+    "RETRIGGER INSTRUMENT ON SLIDE",
+    "SYNC OSCILLATORS ON KEYDOWN",
+    "ENABLE VIBRATO",
+    "VIBRATO SPEED",
+    "VIBRATO DEPTH",
+    "VIBRATO DELAY (IN TICKS)",
+    "ENABLE PWM",
+    "PWM SPEED",
+    "PWM DEPTH",
+    "PWM DELAY (IN TICKS)",
+    "DON'T RESTART PROGRAM ON KEYDOWN",
+    "PROG.PERIOD (00 = PROGRAM OFF)",
 };
 
-void draw_instrument_view(Canvas *canvas, FlizzerTrackerApp *tracker)
-{
-    SoundEngineChannel *se_channel = &tracker->sound_engine.channel[0];
-    if (!(se_channel->flags & SE_ENABLE_GATE) && tracker->tracker_engine.song == NULL)
-    {
+void draw_instrument_view(Canvas* canvas, FlizzerTrackerApp* tracker) {
+    SoundEngineChannel* se_channel = &tracker->sound_engine.channel[0];
+    if(!(se_channel->flags & SE_ENABLE_GATE) && tracker->tracker_engine.song == NULL) {
         stop();
         tracker->tracker_engine.playing = false;
         tracker_engine_set_song(&tracker->tracker_engine, &tracker->song);
     }
 
     char buffer[30];
-    Instrument *inst = tracker->song.instrument[tracker->current_instrument];
+    Instrument* inst = tracker->song.instrument[tracker->current_instrument];
     uint8_t shift = tracker->inst_editor_shift;
 
-    if (shift < 6)
-    {
+    if(shift < 6) {
         snprintf(buffer, sizeof(buffer), "INST:%c", to_char(tracker->current_instrument));
-        draw_generic_n_digit_field(tracker, canvas, EDIT_INSTRUMENT, INST_CURRENTINSTRUMENT, buffer, 0, 5 - shift, 1);
-        snprintf(buffer, sizeof(buffer), "%s", tracker->song.instrument[tracker->current_instrument]->name);
-        draw_generic_n_digit_field(tracker, canvas, EDIT_INSTRUMENT, INST_INSTRUMENTNAME, buffer, 4 * 7 - 1, 5 - shift, 1);
+        draw_generic_n_digit_field(
+            tracker, canvas, EDIT_INSTRUMENT, INST_CURRENTINSTRUMENT, buffer, 0, 5 - shift, 1);
+        snprintf(
+            buffer,
+            sizeof(buffer),
+            "%s",
+            tracker->song.instrument[tracker->current_instrument]->name);
+        draw_generic_n_digit_field(
+            tracker, canvas, EDIT_INSTRUMENT, INST_INSTRUMENTNAME, buffer, 4 * 7 - 1, 5 - shift, 1);
     }
 
-    if (shift < 12)
-    {
+    if(shift < 12) {
         snprintf(buffer, sizeof(buffer), "NOTE:%s", notename(inst->base_note));
         canvas_draw_str(canvas, 0, 11 - shift, buffer);
 
-        if (tracker->editing && tracker->focus == EDIT_INSTRUMENT && tracker->selected_param == INST_CURRENT_NOTE)
-        {
-            if (tracker->current_digit)
-            {
+        if(tracker->editing && tracker->focus == EDIT_INSTRUMENT &&
+           tracker->selected_param == INST_CURRENT_NOTE) {
+            if(tracker->current_digit) {
                 canvas_draw_box(canvas, 19 + 2 * 4, 5 - shift, 5, 7);
             }
 
-            else
-            {
+            else {
                 canvas_draw_box(canvas, 19, 5 - shift, 5 + 4, 7);
             }
         }
@@ -149,206 +167,426 @@ void draw_instrument_view(Canvas *canvas, FlizzerTrackerApp *tracker)
         snprintf(buffer, sizeof(buffer), "FINE:%+02d", inst->finetune);
         canvas_draw_str(canvas, 37, 11 - shift, buffer);
 
-        if (tracker->editing && tracker->focus == EDIT_INSTRUMENT && tracker->selected_param == INST_FINETUNE)
-        {
-            if (tracker->current_digit)
-            {
+        if(tracker->editing && tracker->focus == EDIT_INSTRUMENT &&
+           tracker->selected_param == INST_FINETUNE) {
+            if(tracker->current_digit) {
                 canvas_draw_box(canvas, 60 + 4, 5 - shift, 5, 7);
             }
 
-            else
-            {
+            else {
                 canvas_draw_box(canvas, 60, 5 - shift, 5, 7);
             }
         }
     }
 
-    draw_inst_text_two_digits(tracker, canvas, EDIT_INSTRUMENT, INST_SLIDESPEED, "SL.SPD:", 0, 17 - shift, inst->slide_speed);
-
-    draw_inst_flag(tracker, canvas, EDIT_INSTRUMENT, INST_SETPW, "PW:", 36, 17 - shift, inst->flags, TE_SET_PW);
-    draw_inst_text_two_digits(tracker, canvas, EDIT_INSTRUMENT, INST_PW, "", 54, 17 - shift, inst->pw);
-    draw_inst_flag(tracker, canvas, EDIT_INSTRUMENT, INST_SETCUTOFF, "CUT", 61, 17 - shift, inst->flags, TE_SET_CUTOFF);
-
-    draw_inst_flag(tracker, canvas, EDIT_INSTRUMENT, INST_WAVE_NOISE, "N", 0, 23 - shift, inst->waveform, SE_WAVEFORM_NOISE);
-    draw_inst_flag(tracker, canvas, EDIT_INSTRUMENT, INST_WAVE_PULSE, "P", 10, 23 - shift, inst->waveform, SE_WAVEFORM_PULSE);
-    draw_inst_flag(tracker, canvas, EDIT_INSTRUMENT, INST_WAVE_TRIANGLE, "T", 20, 23 - shift, inst->waveform, SE_WAVEFORM_TRIANGLE);
-    draw_inst_flag(tracker, canvas, EDIT_INSTRUMENT, INST_WAVE_SAWTOOTH, "S", 30, 23 - shift, inst->waveform, SE_WAVEFORM_SAW);
-    draw_inst_flag(tracker, canvas, EDIT_INSTRUMENT, INST_WAVE_NOISE_METAL, "M", 40, 23 - shift, inst->waveform, SE_WAVEFORM_NOISE_METAL);
-    draw_inst_flag(tracker, canvas, EDIT_INSTRUMENT, INST_WAVE_SINE, "SINE", 50, 23 - shift, inst->waveform, SE_WAVEFORM_SINE);
-
-    draw_inst_text_two_digits(tracker, canvas, EDIT_INSTRUMENT, INST_ATTACK, "A:", 0, 29 - shift, inst->adsr.a);
-    draw_inst_text_two_digits(tracker, canvas, EDIT_INSTRUMENT, INST_DECAY, "D:", 16, 29 - shift, inst->adsr.d);
-    draw_inst_text_two_digits(tracker, canvas, EDIT_INSTRUMENT, INST_SUSTAIN, "S:", 32, 29 - shift, inst->adsr.s);
-    draw_inst_text_two_digits(tracker, canvas, EDIT_INSTRUMENT, INST_RELEASE, "R:", 48, 29 - shift, inst->adsr.r);
-    draw_inst_text_two_digits(tracker, canvas, EDIT_INSTRUMENT, INST_VOLUME, "V:", 64, 29 - shift, inst->adsr.volume);
-
-    draw_inst_flag(tracker, canvas, EDIT_INSTRUMENT, INST_ENABLEFILTER, "FIL", 0, 35 - shift, inst->sound_engine_flags, SE_ENABLE_FILTER);
-    draw_inst_text_two_digits(tracker, canvas, EDIT_INSTRUMENT, INST_FILTERCUTOFF, "CUT:", 20, 35 - shift, inst->filter_cutoff);
-    draw_inst_text_two_digits(tracker, canvas, EDIT_INSTRUMENT, INST_FILTERRESONANCE, "RES:", 44, 35 - shift, inst->filter_resonance);
+    draw_inst_text_two_digits(
+        tracker,
+        canvas,
+        EDIT_INSTRUMENT,
+        INST_SLIDESPEED,
+        "SL.SPD:",
+        0,
+        17 - shift,
+        inst->slide_speed);
+
+    draw_inst_flag(
+        tracker, canvas, EDIT_INSTRUMENT, INST_SETPW, "PW:", 36, 17 - shift, inst->flags, TE_SET_PW);
+    draw_inst_text_two_digits(
+        tracker, canvas, EDIT_INSTRUMENT, INST_PW, "", 54, 17 - shift, inst->pw);
+    draw_inst_flag(
+        tracker,
+        canvas,
+        EDIT_INSTRUMENT,
+        INST_SETCUTOFF,
+        "CUT",
+        61,
+        17 - shift,
+        inst->flags,
+        TE_SET_CUTOFF);
+
+    draw_inst_flag(
+        tracker,
+        canvas,
+        EDIT_INSTRUMENT,
+        INST_WAVE_NOISE,
+        "N",
+        0,
+        23 - shift,
+        inst->waveform,
+        SE_WAVEFORM_NOISE);
+    draw_inst_flag(
+        tracker,
+        canvas,
+        EDIT_INSTRUMENT,
+        INST_WAVE_PULSE,
+        "P",
+        10,
+        23 - shift,
+        inst->waveform,
+        SE_WAVEFORM_PULSE);
+    draw_inst_flag(
+        tracker,
+        canvas,
+        EDIT_INSTRUMENT,
+        INST_WAVE_TRIANGLE,
+        "T",
+        20,
+        23 - shift,
+        inst->waveform,
+        SE_WAVEFORM_TRIANGLE);
+    draw_inst_flag(
+        tracker,
+        canvas,
+        EDIT_INSTRUMENT,
+        INST_WAVE_SAWTOOTH,
+        "S",
+        30,
+        23 - shift,
+        inst->waveform,
+        SE_WAVEFORM_SAW);
+    draw_inst_flag(
+        tracker,
+        canvas,
+        EDIT_INSTRUMENT,
+        INST_WAVE_NOISE_METAL,
+        "M",
+        40,
+        23 - shift,
+        inst->waveform,
+        SE_WAVEFORM_NOISE_METAL);
+    draw_inst_flag(
+        tracker,
+        canvas,
+        EDIT_INSTRUMENT,
+        INST_WAVE_SINE,
+        "SINE",
+        50,
+        23 - shift,
+        inst->waveform,
+        SE_WAVEFORM_SINE);
+
+    draw_inst_text_two_digits(
+        tracker, canvas, EDIT_INSTRUMENT, INST_ATTACK, "A:", 0, 29 - shift, inst->adsr.a);
+    draw_inst_text_two_digits(
+        tracker, canvas, EDIT_INSTRUMENT, INST_DECAY, "D:", 16, 29 - shift, inst->adsr.d);
+    draw_inst_text_two_digits(
+        tracker, canvas, EDIT_INSTRUMENT, INST_SUSTAIN, "S:", 32, 29 - shift, inst->adsr.s);
+    draw_inst_text_two_digits(
+        tracker, canvas, EDIT_INSTRUMENT, INST_RELEASE, "R:", 48, 29 - shift, inst->adsr.r);
+    draw_inst_text_two_digits(
+        tracker, canvas, EDIT_INSTRUMENT, INST_VOLUME, "V:", 64, 29 - shift, inst->adsr.volume);
+
+    draw_inst_flag(
+        tracker,
+        canvas,
+        EDIT_INSTRUMENT,
+        INST_ENABLEFILTER,
+        "FIL",
+        0,
+        35 - shift,
+        inst->sound_engine_flags,
+        SE_ENABLE_FILTER);
+    draw_inst_text_two_digits(
+        tracker,
+        canvas,
+        EDIT_INSTRUMENT,
+        INST_FILTERCUTOFF,
+        "CUT:",
+        20,
+        35 - shift,
+        inst->filter_cutoff);
+    draw_inst_text_two_digits(
+        tracker,
+        canvas,
+        EDIT_INSTRUMENT,
+        INST_FILTERRESONANCE,
+        "RES:",
+        44,
+        35 - shift,
+        inst->filter_resonance);
 
     snprintf(buffer, sizeof(buffer), "TYPE:%s", filter_types[inst->filter_type]);
     canvas_draw_str(canvas, 0, 41 - shift, buffer);
 
-    if (tracker->editing && tracker->focus == EDIT_INSTRUMENT && tracker->selected_param == INST_FILTERTYPE)
-    {
-        canvas_draw_box(canvas, 19, 35 - shift, strlen(filter_types[inst->filter_type]) * 4 + 1, 7);
+    if(tracker->editing && tracker->focus == EDIT_INSTRUMENT &&
+       tracker->selected_param == INST_FILTERTYPE) {
+        canvas_draw_box(
+            canvas, 19, 35 - shift, strlen(filter_types[inst->filter_type]) * 4 + 1, 7);
     }
 
-    draw_inst_flag(tracker, canvas, EDIT_INSTRUMENT, INST_ENABLERINGMOD, "R:", 38, 41 - shift, inst->sound_engine_flags, SE_ENABLE_RING_MOD);
-    draw_inst_text_one_digit(tracker, canvas, EDIT_INSTRUMENT, INST_RINGMODSRC, "", 52, 41 - shift, inst->ring_mod);
-    draw_inst_flag(tracker, canvas, EDIT_INSTRUMENT, INST_ENABLEHARDSYNC, "H:", 56, 41 - shift, inst->sound_engine_flags, SE_ENABLE_HARD_SYNC);
-    draw_inst_text_one_digit(tracker, canvas, EDIT_INSTRUMENT, INST_HARDSYNCSRC, "", 70, 41 - shift, inst->hard_sync);
-
-    draw_inst_flag(tracker, canvas, EDIT_INSTRUMENT, INST_RETRIGGERONSLIDE, "SL.RETRIG", 0, 47 - shift, inst->flags, TE_RETRIGGER_ON_SLIDE);
-    draw_inst_flag(tracker, canvas, EDIT_INSTRUMENT, INST_ENABLEKEYSYNC, "KSYNC", 44, 47 - shift, inst->sound_engine_flags, SE_ENABLE_KEYDOWN_SYNC);
-
-    draw_inst_flag(tracker, canvas, EDIT_INSTRUMENT, INST_ENABLEVIBRATO, "VIB", 0, 53 - shift, inst->flags, TE_ENABLE_VIBRATO);
-    draw_inst_text_two_digits(tracker, canvas, EDIT_INSTRUMENT, INST_VIBRATOSPEED, "S:", 20, 53 - shift, inst->vibrato_speed);
-    draw_inst_text_two_digits(tracker, canvas, EDIT_INSTRUMENT, INST_VIBRATODEPTH, "D:", 36, 53 - shift, inst->vibrato_depth);
-    draw_inst_text_two_digits(tracker, canvas, EDIT_INSTRUMENT, INST_VIBRATODELAY, "DEL:", 52, 53 - shift, inst->vibrato_delay);
-
-    if (shift >= 6)
-    {
-        draw_inst_flag(tracker, canvas, EDIT_INSTRUMENT, INST_ENABLEPWM, "PWM", 0, 59 - shift, inst->flags, TE_ENABLE_PWM);
-        draw_inst_text_two_digits(tracker, canvas, EDIT_INSTRUMENT, INST_PWMSPEED, "S:", 20, 59 - shift, inst->pwm_speed);
-        draw_inst_text_two_digits(tracker, canvas, EDIT_INSTRUMENT, INST_PWMDEPTH, "D:", 36, 59 - shift, inst->pwm_depth);
-        draw_inst_text_two_digits(tracker, canvas, EDIT_INSTRUMENT, INST_PWMDELAY, "DEL:", 52, 59 - shift, inst->pwm_delay);
+    draw_inst_flag(
+        tracker,
+        canvas,
+        EDIT_INSTRUMENT,
+        INST_ENABLERINGMOD,
+        "R:",
+        38,
+        41 - shift,
+        inst->sound_engine_flags,
+        SE_ENABLE_RING_MOD);
+    draw_inst_text_one_digit(
+        tracker, canvas, EDIT_INSTRUMENT, INST_RINGMODSRC, "", 52, 41 - shift, inst->ring_mod);
+    draw_inst_flag(
+        tracker,
+        canvas,
+        EDIT_INSTRUMENT,
+        INST_ENABLEHARDSYNC,
+        "H:",
+        56,
+        41 - shift,
+        inst->sound_engine_flags,
+        SE_ENABLE_HARD_SYNC);
+    draw_inst_text_one_digit(
+        tracker, canvas, EDIT_INSTRUMENT, INST_HARDSYNCSRC, "", 70, 41 - shift, inst->hard_sync);
+
+    draw_inst_flag(
+        tracker,
+        canvas,
+        EDIT_INSTRUMENT,
+        INST_RETRIGGERONSLIDE,
+        "SL.RETRIG",
+        0,
+        47 - shift,
+        inst->flags,
+        TE_RETRIGGER_ON_SLIDE);
+    draw_inst_flag(
+        tracker,
+        canvas,
+        EDIT_INSTRUMENT,
+        INST_ENABLEKEYSYNC,
+        "KSYNC",
+        44,
+        47 - shift,
+        inst->sound_engine_flags,
+        SE_ENABLE_KEYDOWN_SYNC);
+
+    draw_inst_flag(
+        tracker,
+        canvas,
+        EDIT_INSTRUMENT,
+        INST_ENABLEVIBRATO,
+        "VIB",
+        0,
+        53 - shift,
+        inst->flags,
+        TE_ENABLE_VIBRATO);
+    draw_inst_text_two_digits(
+        tracker,
+        canvas,
+        EDIT_INSTRUMENT,
+        INST_VIBRATOSPEED,
+        "S:",
+        20,
+        53 - shift,
+        inst->vibrato_speed);
+    draw_inst_text_two_digits(
+        tracker,
+        canvas,
+        EDIT_INSTRUMENT,
+        INST_VIBRATODEPTH,
+        "D:",
+        36,
+        53 - shift,
+        inst->vibrato_depth);
+    draw_inst_text_two_digits(
+        tracker,
+        canvas,
+        EDIT_INSTRUMENT,
+        INST_VIBRATODELAY,
+        "DEL:",
+        52,
+        53 - shift,
+        inst->vibrato_delay);
+
+    if(shift >= 6) {
+        draw_inst_flag(
+            tracker,
+            canvas,
+            EDIT_INSTRUMENT,
+            INST_ENABLEPWM,
+            "PWM",
+            0,
+            59 - shift,
+            inst->flags,
+            TE_ENABLE_PWM);
+        draw_inst_text_two_digits(
+            tracker, canvas, EDIT_INSTRUMENT, INST_PWMSPEED, "S:", 20, 59 - shift, inst->pwm_speed);
+        draw_inst_text_two_digits(
+            tracker, canvas, EDIT_INSTRUMENT, INST_PWMDEPTH, "D:", 36, 59 - shift, inst->pwm_depth);
+        draw_inst_text_two_digits(
+            tracker,
+            canvas,
+            EDIT_INSTRUMENT,
+            INST_PWMDELAY,
+            "DEL:",
+            52,
+            59 - shift,
+            inst->pwm_delay);
     }
 
-    if (shift >= 12)
-    {
-        draw_inst_flag(tracker, canvas, EDIT_INSTRUMENT, INST_PROGRESTART, "NO PROG.RESTART", 0, 65 - shift, inst->flags, TE_PROG_NO_RESTART);
+    if(shift >= 12) {
+        draw_inst_flag(
+            tracker,
+            canvas,
+            EDIT_INSTRUMENT,
+            INST_PROGRESTART,
+            "NO PROG.RESTART",
+            0,
+            65 - shift,
+            inst->flags,
+            TE_PROG_NO_RESTART);
     }
 
-    draw_inst_text_two_digits(tracker, canvas, EDIT_INSTRUMENT, INST_PROGRAMEPERIOD, "P.PERIOD:", 81, 56, inst->program_period);
+    draw_inst_text_two_digits(
+        tracker,
+        canvas,
+        EDIT_INSTRUMENT,
+        INST_PROGRAMEPERIOD,
+        "P.PERIOD:",
+        81,
+        56,
+        inst->program_period);
 
     canvas_draw_line(canvas, 0, 57, 127, 57);
     canvas_draw_line(canvas, 79, 0, 79, 56);
     canvas_draw_line(canvas, 80, 49, 127, 49);
 
-    if (tracker->focus == EDIT_INSTRUMENT)
-    {
-        canvas_draw_str(canvas, 0, 64, instrument_editor_params_description[tracker->selected_param]);
+    if(tracker->focus == EDIT_INSTRUMENT) {
+        canvas_draw_str(
+            canvas, 0, 64, instrument_editor_params_description[tracker->selected_param]);
     }
 }
 
-char command_get_char(uint16_t command)
-{
-    if ((command >> 8) < 36)
-    {
+char command_get_char(uint16_t command) {
+    if((command >> 8) < 36) {
         return to_char_array[(command >> 8)];
     }
 
-    if (command == TE_PROGRAM_END)
-    {
+    if(command == TE_PROGRAM_END) {
         return ':';
     }
 
-    if ((command & 0xff00) == TE_PROGRAM_JUMP)
-    {
+    if((command & 0xff00) == TE_PROGRAM_JUMP) {
         return '^';
     }
 
-    if ((command & 0xff00) == TE_PROGRAM_LOOP_END)
-    {
+    if((command & 0xff00) == TE_PROGRAM_LOOP_END) {
         return '>';
     }
 
-    if ((command & 0xff00) == TE_PROGRAM_LOOP_BEGIN)
-    {
+    if((command & 0xff00) == TE_PROGRAM_LOOP_BEGIN) {
         return '<';
     }
 
     return '?';
 }
 
-void draw_program_step(Canvas *canvas, uint8_t y, FlizzerTrackerApp *tracker, uint8_t index)
-{
+void draw_program_step(Canvas* canvas, uint8_t y, FlizzerTrackerApp* tracker, uint8_t index) {
     char buffer[15];
 
-    Instrument *inst = tracker->song.instrument[tracker->current_instrument];
+    Instrument* inst = tracker->song.instrument[tracker->current_instrument];
     uint16_t opcode = inst->program[index];
 
-    if (opcode != TE_PROGRAM_NOP)
-    {
-        if ((opcode & 0x7f00) == TE_EFFECT_ARPEGGIO)
-        {
-            if ((opcode & 0xff) != 0xf0 && (opcode & 0xff) != 0xf1)
-            {
-                snprintf(buffer, sizeof(buffer), "%01X %c%02X %s", index, command_get_char(opcode & 0x7fff), (opcode & 0xff), notename(my_min(12 * 7 + 11, (opcode & 0xff) + tracker->song.instrument[tracker->current_instrument]->base_note)));
+    if(opcode != TE_PROGRAM_NOP) {
+        if((opcode & 0x7f00) == TE_EFFECT_ARPEGGIO) {
+            if((opcode & 0xff) != 0xf0 && (opcode & 0xff) != 0xf1) {
+                snprintf(
+                    buffer,
+                    sizeof(buffer),
+                    "%01X %c%02X %s",
+                    index,
+                    command_get_char(opcode & 0x7fff),
+                    (opcode & 0xff),
+                    notename(my_min(
+                        12 * 7 + 11,
+                        (opcode & 0xff) +
+                            tracker->song.instrument[tracker->current_instrument]->base_note)));
             }
 
-            else
-            {
-                snprintf(buffer, sizeof(buffer), "%01X %c%02X %s", index, command_get_char(opcode & 0x7fff), (opcode & 0xff), notename((opcode & 0xff)));
+            else {
+                snprintf(
+                    buffer,
+                    sizeof(buffer),
+                    "%01X %c%02X %s",
+                    index,
+                    command_get_char(opcode & 0x7fff),
+                    (opcode & 0xff),
+                    notename((opcode & 0xff)));
             }
         }
 
-        else if ((opcode & 0x7f00) == TE_EFFECT_ARPEGGIO_ABS)
-        {
-            snprintf(buffer, sizeof(buffer), "%01X %c%02X F.%s", index, command_get_char(opcode & 0x7fff), (opcode & 0xff), notename(opcode & 0xff));
+        else if((opcode & 0x7f00) == TE_EFFECT_ARPEGGIO_ABS) {
+            snprintf(
+                buffer,
+                sizeof(buffer),
+                "%01X %c%02X F.%s",
+                index,
+                command_get_char(opcode & 0x7fff),
+                (opcode & 0xff),
+                notename(opcode & 0xff));
         }
 
-        else
-        {
-            snprintf(buffer, sizeof(buffer), "%01X %c%02X %s", index, command_get_char(opcode & 0x7fff), (opcode & 0xff), get_opcode_description(opcode, true) ? get_opcode_description(opcode, true) : "");
+        else {
+            snprintf(
+                buffer,
+                sizeof(buffer),
+                "%01X %c%02X %s",
+                index,
+                command_get_char(opcode & 0x7fff),
+                (opcode & 0xff),
+                get_opcode_description(opcode, true) ? get_opcode_description(opcode, true) : "");
         }
 
-        if (opcode & 0x8000)
-        {
-            if (index == 0)
-            {
+        if(opcode & 0x8000) {
+            if(index == 0) {
                 canvas_draw_line(canvas, 84 + 4 * 4 + 2, y, 84 + 4 * 4 + 2, y - 3);
                 canvas_draw_dot(canvas, 84 + 4 * 4 + 1, y - 4);
             }
 
-            if (index > 0 && !(inst->program[index - 1] & 0x8000))
-            {
+            if(index > 0 && !(inst->program[index - 1] & 0x8000)) {
                 canvas_draw_line(canvas, 84 + 4 * 4 + 2, y, 84 + 4 * 4 + 2, y - 3);
                 canvas_draw_dot(canvas, 84 + 4 * 4 + 1, y - 4);
             }
 
-            if (index > 0 && (inst->program[index - 1] & 0x8000))
-            {
+            if(index > 0 && (inst->program[index - 1] & 0x8000)) {
                 canvas_draw_line(canvas, 84 + 4 * 4 + 2, y, 84 + 4 * 4 + 2, y - 5);
             }
         }
 
-        else
-        {
-            if (index > 0 && (inst->program[index - 1] & 0x8000))
-            {
+        else {
+            if(index > 0 && (inst->program[index - 1] & 0x8000)) {
                 canvas_draw_line(canvas, 84 + 4 * 4 + 2, y - 3, 84 + 4 * 4 + 2, y - 5);
                 canvas_draw_dot(canvas, 84 + 4 * 4 + 1, y - 2);
             }
         }
     }
 
-    else
-    {
+    else {
         snprintf(buffer, sizeof(buffer), "%01X ---", index);
     }
 
     canvas_draw_str(canvas, 81, y, buffer);
 }
 
-void draw_instrument_program_view(Canvas *canvas, FlizzerTrackerApp *tracker)
-{
-    Instrument *inst = tracker->song.instrument[tracker->current_instrument];
+void draw_instrument_program_view(Canvas* canvas, FlizzerTrackerApp* tracker) {
+    Instrument* inst = tracker->song.instrument[tracker->current_instrument];
 
-    for (uint8_t i = tracker->program_position; i < my_min(INST_PROG_LEN, tracker->program_position + 8); i++)
-    {
+    for(uint8_t i = tracker->program_position;
+        i < my_min(INST_PROG_LEN, tracker->program_position + 8);
+        i++) {
         draw_program_step(canvas, 6 + 6 * i - tracker->program_position * 6, tracker, i);
 
-        if (i == tracker->current_program_step && tracker->focus == EDIT_PROGRAM)
-        {
-            if (tracker->editing)
-            {
-                canvas_draw_box(canvas, 80 + 8 + tracker->current_digit * 4, 6 * i - tracker->program_position * 6, 5, 7);
+        if(i == tracker->current_program_step && tracker->focus == EDIT_PROGRAM) {
+            if(tracker->editing) {
+                canvas_draw_box(
+                    canvas,
+                    80 + 8 + tracker->current_digit * 4,
+                    6 * i - tracker->program_position * 6,
+                    5,
+                    7);
             }
 
-            else
-            {
+            else {
                 canvas_draw_box(canvas, 80, 6 * i - tracker->program_position * 6, 5, 7);
             }
         }
@@ -356,21 +594,29 @@ void draw_instrument_program_view(Canvas *canvas, FlizzerTrackerApp *tracker)
 
     // draw arrow pointing at current program step
 
-    for (uint8_t i = 0; i < SONG_MAX_CHANNELS; i++)
-    {
-        if (tracker->tracker_engine.channel[i].instrument == inst && (tracker->tracker_engine.channel[i].channel_flags & TEC_PROGRAM_RUNNING) && (tracker->tracker_engine.sound_engine->channel[i].flags & SE_ENABLE_GATE))
-        {
-            if (tracker->tracker_engine.channel[i].program_tick >= tracker->program_position && tracker->tracker_engine.channel[i].program_tick < tracker->program_position + 8)
-            {
-                canvas_draw_str(canvas, 85, 6 * tracker->tracker_engine.channel[i].program_tick - tracker->program_position * 6 + 6, ">");
+    for(uint8_t i = 0; i < SONG_MAX_CHANNELS; i++) {
+        if(tracker->tracker_engine.channel[i].instrument == inst &&
+           (tracker->tracker_engine.channel[i].channel_flags & TEC_PROGRAM_RUNNING) &&
+           (tracker->tracker_engine.sound_engine->channel[i].flags & SE_ENABLE_GATE)) {
+            if(tracker->tracker_engine.channel[i].program_tick >= tracker->program_position &&
+               tracker->tracker_engine.channel[i].program_tick < tracker->program_position + 8) {
+                canvas_draw_str(
+                    canvas,
+                    85,
+                    6 * tracker->tracker_engine.channel[i].program_tick -
+                        tracker->program_position * 6 + 6,
+                    ">");
                 break;
             }
         }
     }
 
-    if (tracker->focus == EDIT_PROGRAM)
-    {
+    if(tracker->focus == EDIT_PROGRAM) {
         uint16_t opcode = (inst->program[tracker->current_program_step] & 0x7fff);
-        canvas_draw_str(canvas, 0, 64, get_opcode_description(opcode, false) ? get_opcode_description(opcode, false) : "");
+        canvas_draw_str(
+            canvas,
+            0,
+            64,
+            get_opcode_description(opcode, false) ? get_opcode_description(opcode, false) : "");
     }
 }

view/instrument_editor.h

@@ -7,5 +7,5 @@
 #include <furi.h>
 #include <gui/gui.h>
 
-void draw_instrument_view(Canvas *canvas, FlizzerTrackerApp *tracker);
-void draw_instrument_program_view(Canvas *canvas, FlizzerTrackerApp *tracker);
+void draw_instrument_view(Canvas* canvas, FlizzerTrackerApp* tracker);
+void draw_instrument_program_view(Canvas* canvas, FlizzerTrackerApp* tracker);

view/opcode_description.c

@@ -1,71 +1,67 @@
 #include "opcode_description.h"
 #include <stdint.h>
 
-static const OpcodeDescription opcode_desc[] =
-    {
-        {TE_EFFECT_ARPEGGIO, 0x7f00, "RELATIVE ARPEGGIO NOTE", ""},
-        {TE_EFFECT_PORTAMENTO_UP, 0x7f00, "PORTAMENTO UP", "PORTUP"},
-        {TE_EFFECT_PORTAMENTO_DOWN, 0x7f00, "PORTAMENTO DOWN", "PORTDN"},
-        {TE_EFFECT_SLIDE, 0x7f00, "SLIDE", "SLIDE"},
-        {TE_EFFECT_VIBRATO, 0x7f00, "VIBRATO", "VIB"},
-        {TE_EFFECT_PWM, 0x7f00, "PULSE WIDTH MODIFICATION", "PWM"},
+static const OpcodeDescription opcode_desc[] = {
+    {TE_EFFECT_ARPEGGIO, 0x7f00, "RELATIVE ARPEGGIO NOTE", ""},
+    {TE_EFFECT_PORTAMENTO_UP, 0x7f00, "PORTAMENTO UP", "PORTUP"},
+    {TE_EFFECT_PORTAMENTO_DOWN, 0x7f00, "PORTAMENTO DOWN", "PORTDN"},
+    {TE_EFFECT_SLIDE, 0x7f00, "SLIDE", "SLIDE"},
+    {TE_EFFECT_VIBRATO, 0x7f00, "VIBRATO", "VIB"},
+    {TE_EFFECT_PWM, 0x7f00, "PULSE WIDTH MODIFICATION", "PWM"},
 
-        {TE_EFFECT_SET_PW, 0x7f00, "SET PULSE WIDTH", "SET PW"},
-        {TE_EFFECT_PW_DOWN, 0x7f00, "PULSE WIDTH DOWN", "PWDOWN"},
-        {TE_EFFECT_PW_UP, 0x7f00, "PULSE WIDTH UP", "PW UP"},
-        {TE_EFFECT_SET_CUTOFF, 0x7f00, "SET FILTER CUTOFF", "F.CUT"},
+    {TE_EFFECT_SET_PW, 0x7f00, "SET PULSE WIDTH", "SET PW"},
+    {TE_EFFECT_PW_DOWN, 0x7f00, "PULSE WIDTH DOWN", "PWDOWN"},
+    {TE_EFFECT_PW_UP, 0x7f00, "PULSE WIDTH UP", "PW UP"},
+    {TE_EFFECT_SET_CUTOFF, 0x7f00, "SET FILTER CUTOFF", "F.CUT"},
 
-        {TE_EFFECT_VOLUME_FADE, 0x7f00, "VOLUME FADE", "V.FADE"},
-        {TE_EFFECT_SET_WAVEFORM, 0x7f00, "SET WAVEFORM", "S.WAVE"},
-        {TE_EFFECT_SET_VOLUME, 0x7f00, "SET VOLUME", "VOLUME"},
-        {TE_EFFECT_SKIP_PATTERN, 0x7f00, "SKIP PATTERN", "P.SKIP"},
+    {TE_EFFECT_VOLUME_FADE, 0x7f00, "VOLUME FADE", "V.FADE"},
+    {TE_EFFECT_SET_WAVEFORM, 0x7f00, "SET WAVEFORM", "S.WAVE"},
+    {TE_EFFECT_SET_VOLUME, 0x7f00, "SET VOLUME", "VOLUME"},
+    {TE_EFFECT_SKIP_PATTERN, 0x7f00, "SKIP PATTERN", "P.SKIP"},
 
-        {TE_EFFECT_EXT_TOGGLE_FILTER, 0x7ff0, "TOGGLE FILTER (0=OFF,1-F=ON)", "T.FILT"},
-        {TE_EFFECT_EXT_PORTA_UP, 0x7ff0, "FINE PORTAMENTO UP", "PUP F."},
-        {TE_EFFECT_EXT_PORTA_DN, 0x7ff0, "FINE PORTAMENTO DOWN", "PDN F."},
-        {TE_EFFECT_EXT_FILTER_MODE, 0x7ff0, "SET FILTER MODE", "F.MODE"},
-        {TE_EFFECT_EXT_PATTERN_LOOP, 0x7ff0, "PATTERN LOOP:E60=BEGIN,E6X=END", "PAT.L."},
-        {TE_EFFECT_EXT_RETRIGGER, 0x7ff0, "RETRIGGER AT TICK X (X>0)", "RETRIG"},
-        {TE_EFFECT_EXT_FINE_VOLUME_DOWN, 0x7ff0, "FINE VOLUME DOWN", "VDN F."},
-        {TE_EFFECT_EXT_FINE_VOLUME_UP, 0x7ff0, "FINE VOLUME UP", "VUP F."},
-        {TE_EFFECT_EXT_NOTE_CUT, 0x7ff0, "NOTE CUT", "N.CUT"},
-        {TE_EFFECT_EXT_NOTE_DELAY, 0x7ff0, "NOTE DELAY", "N.DEL."},
-        {TE_EFFECT_EXT_PHASE_RESET, 0x7ff0, "PHASE RESET ON TICK X", "PH.RES."},
+    {TE_EFFECT_EXT_TOGGLE_FILTER, 0x7ff0, "TOGGLE FILTER (0=OFF,1-F=ON)", "T.FILT"},
+    {TE_EFFECT_EXT_PORTA_UP, 0x7ff0, "FINE PORTAMENTO UP", "PUP F."},
+    {TE_EFFECT_EXT_PORTA_DN, 0x7ff0, "FINE PORTAMENTO DOWN", "PDN F."},
+    {TE_EFFECT_EXT_FILTER_MODE, 0x7ff0, "SET FILTER MODE", "F.MODE"},
+    {TE_EFFECT_EXT_PATTERN_LOOP, 0x7ff0, "PATTERN LOOP:E60=BEGIN,E6X=END", "PAT.L."},
+    {TE_EFFECT_EXT_RETRIGGER, 0x7ff0, "RETRIGGER AT TICK X (X>0)", "RETRIG"},
+    {TE_EFFECT_EXT_FINE_VOLUME_DOWN, 0x7ff0, "FINE VOLUME DOWN", "VDN F."},
+    {TE_EFFECT_EXT_FINE_VOLUME_UP, 0x7ff0, "FINE VOLUME UP", "VUP F."},
+    {TE_EFFECT_EXT_NOTE_CUT, 0x7ff0, "NOTE CUT", "N.CUT"},
+    {TE_EFFECT_EXT_NOTE_DELAY, 0x7ff0, "NOTE DELAY", "N.DEL."},
+    {TE_EFFECT_EXT_PHASE_RESET, 0x7ff0, "PHASE RESET ON TICK X", "PH.RES."},
 
-        {TE_EFFECT_SET_SPEED_PROG_PERIOD, 0x7f00, "SET SPEED (PROG.PER.IN PROGRAM)", "P.PER."},
-        {TE_EFFECT_CUTOFF_UP, 0x7f00, "FILTER CUTOFF UP", "CUT.UP"},
-        {TE_EFFECT_CUTOFF_DOWN, 0x7f00, "FILTER CUTOFF DOWN", "CUT.DN"},
-        {TE_EFFECT_SET_RESONANCE, 0x7f00, "SET FILTER RESONANCE", "F.RES."},
-        {TE_EFFECT_RESONANCE_UP, 0x7f00, "FILTER RESONANCE UP", "F.R.UP"},
-        {TE_EFFECT_RESONANCE_DOWN, 0x7f00, "FILTER RESONANCE DOWN", "F.R.DN"},
-        {TE_EFFECT_SET_ATTACK, 0x7f00, "SET ENVELOPE ATTACK", "ADSR A"},
-        {TE_EFFECT_SET_DECAY, 0x7f00, "SET ENVELOPE DECAY", "ADSR D"},
-        {TE_EFFECT_SET_SUSTAIN, 0x7f00, "SET ENVELOPE SUSTAIN", "ADSR S"},
-        {TE_EFFECT_SET_RELEASE, 0x7f00, "SET ENVELOPE RELEASE", "ADSR R"},
-        {TE_EFFECT_PROGRAM_RESTART, 0x7f00, "RESTART INSTRUMENT PROGRAM", "P.RES."},
-        {TE_EFFECT_SET_RING_MOD_SRC, 0x7f00, "SET RING MODULATION SOURCE CH.", "R.SRC"},
-        {TE_EFFECT_SET_HARD_SYNC_SRC, 0x7f00, "SET HARD SYNC SOURCE CHANNEL", "S.SRC"},
-        {TE_EFFECT_PORTA_UP_SEMITONE, 0x7f00, "PORTAMENTO UP (SEMITONES)", "PU.SEM"},
-        {TE_EFFECT_PORTA_DOWN_SEMITONE, 0x7f00, "PORTAMENTO DOWN (SEMITONES)", "PD.SEM"},
-        {TE_EFFECT_LEGATO, 0x7f00, "LEGATO", "LEGATO"},
-        {TE_EFFECT_ARPEGGIO_ABS, 0x7f00, "ABSOLUTE ARPEGGIO NOTE", ""},
-        {TE_EFFECT_TRIGGER_RELEASE, 0x7f00, "TRIGGER RELEASE", "TR.REL"},
+    {TE_EFFECT_SET_SPEED_PROG_PERIOD, 0x7f00, "SET SPEED (PROG.PER.IN PROGRAM)", "P.PER."},
+    {TE_EFFECT_CUTOFF_UP, 0x7f00, "FILTER CUTOFF UP", "CUT.UP"},
+    {TE_EFFECT_CUTOFF_DOWN, 0x7f00, "FILTER CUTOFF DOWN", "CUT.DN"},
+    {TE_EFFECT_SET_RESONANCE, 0x7f00, "SET FILTER RESONANCE", "F.RES."},
+    {TE_EFFECT_RESONANCE_UP, 0x7f00, "FILTER RESONANCE UP", "F.R.UP"},
+    {TE_EFFECT_RESONANCE_DOWN, 0x7f00, "FILTER RESONANCE DOWN", "F.R.DN"},
+    {TE_EFFECT_SET_ATTACK, 0x7f00, "SET ENVELOPE ATTACK", "ADSR A"},
+    {TE_EFFECT_SET_DECAY, 0x7f00, "SET ENVELOPE DECAY", "ADSR D"},
+    {TE_EFFECT_SET_SUSTAIN, 0x7f00, "SET ENVELOPE SUSTAIN", "ADSR S"},
+    {TE_EFFECT_SET_RELEASE, 0x7f00, "SET ENVELOPE RELEASE", "ADSR R"},
+    {TE_EFFECT_PROGRAM_RESTART, 0x7f00, "RESTART INSTRUMENT PROGRAM", "P.RES."},
+    {TE_EFFECT_SET_RING_MOD_SRC, 0x7f00, "SET RING MODULATION SOURCE CH.", "R.SRC"},
+    {TE_EFFECT_SET_HARD_SYNC_SRC, 0x7f00, "SET HARD SYNC SOURCE CHANNEL", "S.SRC"},
+    {TE_EFFECT_PORTA_UP_SEMITONE, 0x7f00, "PORTAMENTO UP (SEMITONES)", "PU.SEM"},
+    {TE_EFFECT_PORTA_DOWN_SEMITONE, 0x7f00, "PORTAMENTO DOWN (SEMITONES)", "PD.SEM"},
+    {TE_EFFECT_LEGATO, 0x7f00, "LEGATO", "LEGATO"},
+    {TE_EFFECT_ARPEGGIO_ABS, 0x7f00, "ABSOLUTE ARPEGGIO NOTE", ""},
+    {TE_EFFECT_TRIGGER_RELEASE, 0x7f00, "TRIGGER RELEASE", "TR.REL"},
 
-        {TE_PROGRAM_LOOP_BEGIN, 0x7f00, "PROGRAM LOOP BEGIN", "L.BEG."},
-        {TE_PROGRAM_LOOP_END, 0x7f00, "PROGRAM LOOP END", "L.END"},
+    {TE_PROGRAM_LOOP_BEGIN, 0x7f00, "PROGRAM LOOP BEGIN", "L.BEG."},
+    {TE_PROGRAM_LOOP_END, 0x7f00, "PROGRAM LOOP END", "L.END"},
 
-        {TE_PROGRAM_NOP, 0x7fff, "NO OPERATION", ""},
-        {TE_PROGRAM_END, 0x7fff, "PROGRAM END", "PR.END"},
-        {TE_PROGRAM_JUMP, 0x7f00, "JUMP TO POSITION", "GOTO"},
-        {0, 0, NULL, NULL},
+    {TE_PROGRAM_NOP, 0x7fff, "NO OPERATION", ""},
+    {TE_PROGRAM_END, 0x7fff, "PROGRAM END", "PR.END"},
+    {TE_PROGRAM_JUMP, 0x7f00, "JUMP TO POSITION", "GOTO"},
+    {0, 0, NULL, NULL},
 };
 
-char *get_opcode_description(uint16_t opcode, bool short_description)
-{
-    for (int i = 0; opcode_desc[i].name != NULL; i++)
-    {
-        if (opcode_desc[i].opcode == (opcode & opcode_desc[i].mask))
-        {
+char* get_opcode_description(uint16_t opcode, bool short_description) {
+    for(int i = 0; opcode_desc[i].name != NULL; i++) {
+        if(opcode_desc[i].opcode == (opcode & opcode_desc[i].mask)) {
             return short_description ? opcode_desc[i].shortname : opcode_desc[i].name;
         }
     }

view/opcode_description.h

@@ -3,11 +3,10 @@
 #include "../tracker_engine/tracker_engine_defs.h"
 #include <stdio.h>
 
-typedef struct
-{
+typedef struct {
     uint16_t opcode;
     uint16_t mask;
     char *name, *shortname;
 } OpcodeDescription;
 
-char *get_opcode_description(uint16_t opcode, bool short_description);
+char* get_opcode_description(uint16_t opcode, bool short_description);

view/pattern_editor.c

@@ -5,52 +5,46 @@
 
 #define PATTERN_EDITOR_Y (64 - (6 * 5) - 1)
 
-static const char *notenames[] =
-    {
-        "C-",
-        "C#",
-        "D-",
-        "D#",
-        "E-",
-        "F-",
-        "F#",
-        "G-",
-        "G#",
-        "A-",
-        "A#",
-        "B-",
+static const char* notenames[] = {
+    "C-",
+    "C#",
+    "D-",
+    "D#",
+    "E-",
+    "F-",
+    "F#",
+    "G-",
+    "G#",
+    "A-",
+    "A#",
+    "B-",
 };
 
-char *notename(uint8_t note)
-{
+char* notename(uint8_t note) {
     static char buffer[6];
 
-    if (note == MUS_NOTE_CUT)
-    {
+    if(note == MUS_NOTE_CUT) {
         snprintf(buffer, sizeof(buffer), "%s", "OFF");
         return buffer;
     }
 
-    if (note == MUS_NOTE_RELEASE)
-    {
+    if(note == MUS_NOTE_RELEASE) {
         snprintf(buffer, sizeof(buffer), "%s", "   ");
         return buffer;
     }
 
-    if (note == 0xf0) // external arpeggio notes
+    if(note == 0xf0) // external arpeggio notes
     {
         snprintf(buffer, sizeof(buffer), "%s", "EXT.0");
         return buffer;
     }
 
-    if (note == 0xf1)
-    {
+    if(note == 0xf1) {
         snprintf(buffer, sizeof(buffer), "%s", "EXT.1");
         return buffer;
     }
 
-    else
-    {
+    else {
         uint8_t final_note = my_min(12 * 7 + 11, note);
         snprintf(buffer, sizeof(buffer), "%s%d", notenames[final_note % 12], final_note / 12);
     }
@@ -58,42 +52,38 @@ char *notename(uint8_t note)
     return buffer;
 }
 
-char to_char(uint8_t number)
-{
+char to_char(uint8_t number) {
     return to_char_array[number];
 }
 
-void draw_pattern_view(Canvas *canvas, FlizzerTrackerApp *tracker)
-{
+void draw_pattern_view(Canvas* canvas, FlizzerTrackerApp* tracker) {
     char command_buffer[6] = {0};
     char buffer[11] = {0};
 
     canvas_draw_line(canvas, 0, PATTERN_EDITOR_Y, 127, PATTERN_EDITOR_Y);
 
-    for (int i = 0; i < SONG_MAX_CHANNELS; ++i)
-    {
+    for(int i = 0; i < SONG_MAX_CHANNELS; ++i) {
         uint8_t sequence_position = tracker->tracker_engine.sequence_position;
-        uint8_t current_pattern = tracker->tracker_engine.song->sequence.sequence_step[sequence_position].pattern_indices[i];
+        uint8_t current_pattern =
+            tracker->tracker_engine.song->sequence.sequence_step[sequence_position]
+                .pattern_indices[i];
         uint16_t pattern_step = tracker->tracker_engine.pattern_position;
 
         uint16_t pattern_length = tracker->tracker_engine.song->pattern_length;
 
-        TrackerSongPattern *pattern = &tracker->tracker_engine.song->pattern[current_pattern];
+        TrackerSongPattern* pattern = &tracker->tracker_engine.song->pattern[current_pattern];
 
-        for (uint8_t pos = 0; pos < 5; ++pos)
-        {
-            TrackerSongPatternStep *step = NULL;
+        for(uint8_t pos = 0; pos < 5; ++pos) {
+            TrackerSongPatternStep* step = NULL;
 
-            if (pattern_step - 2 + pos >= 0 && pattern_step - 2 + pos < pattern_length)
-            {
+            if(pattern_step - 2 + pos >= 0 && pattern_step - 2 + pos < pattern_length) {
                 step = &pattern->step[pattern_step + pos - 2];
             }
 
             uint8_t string_x = i * 32;
             uint8_t string_y = PATTERN_EDITOR_Y + 6 * pos + 6 + 1;
 
-            if (step)
-            {
+            if(step) {
                 uint8_t note = tracker_engine_get_note(step);
                 uint8_t inst = tracker_engine_get_instrument(step);
                 uint8_t vol = tracker_engine_get_volume(step);
@@ -103,41 +93,48 @@ void draw_pattern_view(Canvas *canvas, FlizzerTrackerApp *tracker)
                 char vol_ch = to_char(vol);
                 char command_ch = to_char(command >> 8);
 
-                if (inst == MUS_NOTE_INSTRUMENT_NONE)
-                {
+                if(inst == MUS_NOTE_INSTRUMENT_NONE) {
                     inst_ch = '-';
                 }
 
-                if (vol == MUS_NOTE_VOLUME_NONE)
-                {
+                if(vol == MUS_NOTE_VOLUME_NONE) {
                     vol_ch = '-';
                 }
 
-                if (command == 0)
-                {
+                if(command == 0) {
                     snprintf(command_buffer, sizeof(command_buffer), "---");
                 }
 
-                else
-                {
-                    snprintf(command_buffer, sizeof(command_buffer), "%c%02X", command_ch, (command & 0xff));
+                else {
+                    snprintf(
+                        command_buffer,
+                        sizeof(command_buffer),
+                        "%c%02X",
+                        command_ch,
+                        (command & 0xff));
                 }
 
-                snprintf(buffer, sizeof(buffer), "%s%c%c%s", (note == MUS_NOTE_NONE ? "---" : notename(note)), inst_ch, vol_ch, command_buffer);
+                snprintf(
+                    buffer,
+                    sizeof(buffer),
+                    "%s%c%c%s",
+                    (note == MUS_NOTE_NONE ? "---" : notename(note)),
+                    inst_ch,
+                    vol_ch,
+                    command_buffer);
 
                 canvas_draw_str(canvas, string_x, string_y, buffer);
 
-                if (note == MUS_NOTE_RELEASE)
-                {
+                if(note == MUS_NOTE_RELEASE) {
                     canvas_draw_icon(canvas, string_x, string_y - 5, &I_note_release);
                 }
             }
         }
     }
 
-    if (tracker->editing && tracker->focus == EDIT_PATTERN)
-    {
-        uint16_t x = tracker->current_channel * 32 + tracker->patternx * 4 + (tracker->patternx > 0 ? 4 : 0) - 1;
+    if(tracker->editing && tracker->focus == EDIT_PATTERN) {
+        uint16_t x = tracker->current_channel * 32 + tracker->patternx * 4 +
+                     (tracker->patternx > 0 ? 4 : 0) - 1;
         uint16_t y = PATTERN_EDITOR_Y + 6 * 2 + 1;
 
         canvas_draw_box(canvas, x, y, (tracker->patternx > 0 ? 5 : 9), 7);
@@ -145,23 +142,18 @@ void draw_pattern_view(Canvas *canvas, FlizzerTrackerApp *tracker)
 
     canvas_set_color(canvas, ColorBlack);
 
-    for (int i = 1; i < SONG_MAX_CHANNELS; ++i)
-    {
-        for (int y = PATTERN_EDITOR_Y + 1; y < 64; y += 2)
-        {
+    for(int i = 1; i < SONG_MAX_CHANNELS; ++i) {
+        for(int y = PATTERN_EDITOR_Y + 1; y < 64; y += 2) {
             canvas_draw_dot(canvas, i * 32 - 1, y);
         }
     }
 
-    for (int i = 0; i < SONG_MAX_CHANNELS; ++i)
-    {
-        if (tracker->tracker_engine.channel[i].channel_flags & TEC_DISABLED)
-        {
+    for(int i = 0; i < SONG_MAX_CHANNELS; ++i) {
+        if(tracker->tracker_engine.channel[i].channel_flags & TEC_DISABLED) {
             canvas_draw_icon(canvas, 13 + 32 * i, PATTERN_EDITOR_Y - 3, &I_channel_off);
         }
 
-        else
-        {
+        else {
             canvas_draw_icon(canvas, 13 + 32 * i, PATTERN_EDITOR_Y - 3, &I_channel_on);
         }
     }
@@ -172,20 +164,17 @@ void draw_pattern_view(Canvas *canvas, FlizzerTrackerApp *tracker)
 #define SEQ_SLIDER_X (4 * (4 * 2 + 1) + 2)
 #define SEQ_SLIDER_Y (32)
 
-void draw_sequence_view(Canvas *canvas, FlizzerTrackerApp *tracker)
-{
+void draw_sequence_view(Canvas* canvas, FlizzerTrackerApp* tracker) {
     char buffer[4];
 
     uint8_t sequence_position = tracker->tracker_engine.sequence_position;
-    TrackerSong *song = &tracker->song;
+    TrackerSong* song = &tracker->song;
 
-    for (int pos = sequence_position - 2; pos < sequence_position + 3; pos++)
-    {
-        if (pos >= 0 && pos < tracker->song.num_sequence_steps)
-        {
-            for (int i = 0; i < SONG_MAX_CHANNELS; ++i)
-            {
-                uint8_t current_pattern = tracker->tracker_engine.song->sequence.sequence_step[pos].pattern_indices[i];
+    for(int pos = sequence_position - 2; pos < sequence_position + 3; pos++) {
+        if(pos >= 0 && pos < tracker->song.num_sequence_steps) {
+            for(int i = 0; i < SONG_MAX_CHANNELS; ++i) {
+                uint8_t current_pattern =
+                    tracker->tracker_engine.song->sequence.sequence_step[pos].pattern_indices[i];
 
                 uint8_t x = i * (4 * 2 + 1) + 3;
                 uint8_t y = (pos - (sequence_position - 2)) * 6 + 5;
@@ -196,31 +185,25 @@ void draw_sequence_view(Canvas *canvas, FlizzerTrackerApp *tracker)
         }
     }
 
-    if (song->loop_start != 0 || song->loop_end != 0)
-    {
+    if(song->loop_start != 0 || song->loop_end != 0) {
         canvas_set_color(canvas, ColorBlack);
 
-        for (int pos = sequence_position - 2; pos < sequence_position + 3; pos++)
-        {
-            if (pos >= 0 && pos < tracker->song.num_sequence_steps)
-            {
-                if (pos == song->loop_start)
-                {
+        for(int pos = sequence_position - 2; pos < sequence_position + 3; pos++) {
+            if(pos >= 0 && pos < tracker->song.num_sequence_steps) {
+                if(pos == song->loop_start) {
                     int16_t y = (pos - (sequence_position - 2)) * 6;
 
                     canvas_draw_line(canvas, 0, fmax(y, 0), 1, fmax(y, 0));
                     canvas_draw_line(canvas, 0, fmax(y, 0), 0, fmax(y + 4, 0));
                 }
 
-                if (pos > song->loop_start && pos < song->loop_end)
-                {
+                if(pos > song->loop_start && pos < song->loop_end) {
                     int16_t y = (pos - (sequence_position - 2)) * 6;
 
                     canvas_draw_line(canvas, 0, fmax(y - 1, 0), 0, fmax(y + 4, 0));
                 }
 
-                if (pos == song->loop_end)
-                {
+                if(pos == song->loop_end) {
                     int16_t y = (pos - (sequence_position - 2)) * 6;
 
                     canvas_draw_line(canvas, 0, fmax(y + 4, 0), 1, fmax(y + 4, 0));
@@ -242,15 +225,16 @@ void draw_sequence_view(Canvas *canvas, FlizzerTrackerApp *tracker)
     canvas_draw_line(canvas, SEQ_SLIDER_X, 0, SEQ_SLIDER_X, SEQ_SLIDER_Y);
     canvas_draw_line(canvas, SEQ_SLIDER_X + 2, 0, SEQ_SLIDER_X + 2, SEQ_SLIDER_Y);
 
-    uint8_t start_pos = sequence_position * (SEQ_SLIDER_Y - 2) / tracker->song.num_sequence_steps + 1;
+    uint8_t start_pos =
+        sequence_position * (SEQ_SLIDER_Y - 2) / tracker->song.num_sequence_steps + 1;
     uint8_t slider_length = (SEQ_SLIDER_Y - 2) / tracker->song.num_sequence_steps + 1;
 
-    canvas_draw_line(canvas, SEQ_SLIDER_X + 1, start_pos, SEQ_SLIDER_X + 1, (start_pos + slider_length));
+    canvas_draw_line(
+        canvas, SEQ_SLIDER_X + 1, start_pos, SEQ_SLIDER_X + 1, (start_pos + slider_length));
 
     canvas_set_color(canvas, ColorXOR);
 
-    if (tracker->editing && tracker->focus == EDIT_SEQUENCE)
-    {
+    if(tracker->editing && tracker->focus == EDIT_SEQUENCE) {
         uint8_t x = tracker->current_channel * (4 + 4 + 1) + (tracker->current_digit ? 4 : 0) + 2;
         uint8_t y = 11;
 
@@ -258,84 +242,110 @@ void draw_sequence_view(Canvas *canvas, FlizzerTrackerApp *tracker)
     }
 }
 
-#define member_size(type, member) sizeof(((type *)0)->member)
+#define member_size(type, member) sizeof(((type*)0)->member)
 
-#define SONG_HEADER_SIZE (member_size(TrackerSong, song_name) + member_size(TrackerSong, speed) + member_size(TrackerSong, rate) + member_size(TrackerSong, loop_start) + member_size(TrackerSong, loop_end) + member_size(TrackerSong, num_patterns) + member_size(TrackerSong, num_sequence_steps) + member_size(TrackerSong, num_instruments) + member_size(TrackerSong, pattern_length))
+#define SONG_HEADER_SIZE                                                                        \
+    (member_size(TrackerSong, song_name) + member_size(TrackerSong, speed) +                    \
+     member_size(TrackerSong, rate) + member_size(TrackerSong, loop_start) +                    \
+     member_size(TrackerSong, loop_end) + member_size(TrackerSong, num_patterns) +              \
+     member_size(TrackerSong, num_sequence_steps) + member_size(TrackerSong, num_instruments) + \
+     member_size(TrackerSong, pattern_length))
 
-uint32_t calculate_song_size(TrackerSong *song)
-{
-    uint32_t song_size = SONG_HEADER_SIZE + sizeof(Instrument) * song->num_instruments + sizeof(TrackerSongPatternStep) * song->num_patterns * song->pattern_length + sizeof(TrackerSongSequenceStep) * song->num_sequence_steps;
+uint32_t calculate_song_size(TrackerSong* song) {
+    uint32_t song_size =
+        SONG_HEADER_SIZE + sizeof(Instrument) * song->num_instruments +
+        sizeof(TrackerSongPatternStep) * song->num_patterns * song->pattern_length +
+        sizeof(TrackerSongSequenceStep) * song->num_sequence_steps;
     return song_size;
 }
 
-void draw_generic_n_digit_field(FlizzerTrackerApp *tracker, Canvas *canvas, uint8_t focus, uint8_t param, const char *text, uint8_t x, uint8_t y, uint8_t digits) // last 1-2 symbols are digits we are editing
+void draw_generic_n_digit_field(
+    FlizzerTrackerApp* tracker,
+    Canvas* canvas,
+    uint8_t focus,
+    uint8_t param,
+    const char* text,
+    uint8_t x,
+    uint8_t y,
+    uint8_t digits) // last 1-2 symbols are digits we are editing
 {
     canvas_draw_str(canvas, x, y, text);
 
-    if (tracker->focus == focus && tracker->selected_param == param && tracker->editing)
-    {
+    if(tracker->focus == focus && tracker->selected_param == param && tracker->editing) {
         bool select_string = true;
 
-        if (tracker->focus == EDIT_SONGINFO)
-        {
-            if (param != SI_SONGNAME && param != SI_INSTRUMENTNAME)
-            {
+        if(tracker->focus == EDIT_SONGINFO) {
+            if(param != SI_SONGNAME && param != SI_INSTRUMENTNAME) {
                 select_string = false;
             }
         }
 
-        if (tracker->focus == EDIT_INSTRUMENT)
-        {
-            if (param != INST_INSTRUMENTNAME)
-            {
+        if(tracker->focus == EDIT_INSTRUMENT) {
+            if(param != INST_INSTRUMENTNAME) {
                 select_string = false;
             }
         }
 
-        if (!(select_string))
-        {
-            if (tracker->focus == EDIT_INSTRUMENT && param == INST_CURRENTINSTRUMENT)
-            {
+        if(!(select_string)) {
+            if(tracker->focus == EDIT_INSTRUMENT && param == INST_CURRENTINSTRUMENT) {
                 canvas_draw_box(canvas, x + strlen(text) * 4 - digits * 4 - 1, y - 6, 5, 7);
             }
 
-            else
-            {
-                canvas_draw_box(canvas, x + strlen(text) * 4 - digits * 4 + tracker->current_digit * 4 - 1, y - 6, 5, 7);
+            else {
+                canvas_draw_box(
+                    canvas,
+                    x + strlen(text) * 4 - digits * 4 + tracker->current_digit * 4 - 1,
+                    y - 6,
+                    5,
+                    7);
             }
         }
 
-        else
-        {
+        else {
             canvas_draw_box(canvas, x - 1, y - 6, fmax(5, strlen(text) * 4 + 1), 7);
         }
     }
 }
 
-void draw_songinfo_view(Canvas *canvas, FlizzerTrackerApp *tracker)
-{
+void draw_songinfo_view(Canvas* canvas, FlizzerTrackerApp* tracker) {
     char buffer[30];
 
-    snprintf(buffer, sizeof(buffer), "PAT.P.%02X/%02X", tracker->tracker_engine.pattern_position, tracker->song.pattern_length - 1);
+    snprintf(
+        buffer,
+        sizeof(buffer),
+        "PAT.P.%02X/%02X",
+        tracker->tracker_engine.pattern_position,
+        tracker->song.pattern_length - 1);
     draw_generic_n_digit_field(tracker, canvas, EDIT_SONGINFO, SI_PATTERNPOS, buffer, 42, 5, 2);
-    snprintf(buffer, sizeof(buffer), "SEQ.P.%02X/%02X", tracker->tracker_engine.sequence_position, tracker->song.num_sequence_steps - 1);
+    snprintf(
+        buffer,
+        sizeof(buffer),
+        "SEQ.P.%02X/%02X",
+        tracker->tracker_engine.sequence_position,
+        tracker->song.num_sequence_steps - 1);
     draw_generic_n_digit_field(tracker, canvas, EDIT_SONGINFO, SI_SEQUENCEPOS, buffer, 42, 11, 2);
     snprintf(buffer, sizeof(buffer), "SPD.%02X", tracker->song.speed);
     draw_generic_n_digit_field(tracker, canvas, EDIT_SONGINFO, SI_SONGSPEED, buffer, 42, 17, 2);
     snprintf(buffer, sizeof(buffer), "RATE %02X", tracker->song.rate);
-    draw_generic_n_digit_field(tracker, canvas, EDIT_SONGINFO, SI_SONGRATE, buffer, 42 + 4 * 7, 17, 2);
+    draw_generic_n_digit_field(
+        tracker, canvas, EDIT_SONGINFO, SI_SONGRATE, buffer, 42 + 4 * 7, 17, 2);
     snprintf(buffer, sizeof(buffer), "VOL %02X", tracker->tracker_engine.master_volume);
-    draw_generic_n_digit_field(tracker, canvas, EDIT_SONGINFO, SI_MASTERVOL, buffer, 42 + 4 * 7 + 4 * 8, 17, 2);
+    draw_generic_n_digit_field(
+        tracker, canvas, EDIT_SONGINFO, SI_MASTERVOL, buffer, 42 + 4 * 7 + 4 * 8, 17, 2);
 
     snprintf(buffer, sizeof(buffer), "SONG:");
     canvas_draw_str(canvas, 42, 23, buffer);
     snprintf(buffer, sizeof(buffer), "%s", tracker->song.song_name);
-    draw_generic_n_digit_field(tracker, canvas, EDIT_SONGINFO, SI_SONGNAME, buffer, 42 + 4 * 5, 23, 1);
+    draw_generic_n_digit_field(
+        tracker, canvas, EDIT_SONGINFO, SI_SONGNAME, buffer, 42 + 4 * 5, 23, 1);
 
     snprintf(buffer, sizeof(buffer), "INST:%c", to_char(tracker->current_instrument));
-    draw_generic_n_digit_field(tracker, canvas, EDIT_SONGINFO, SI_CURRENTINSTRUMENT, buffer, 42, 29, 1);
-    snprintf(buffer, sizeof(buffer), "%s", tracker->song.instrument[tracker->current_instrument]->name);
-    draw_generic_n_digit_field(tracker, canvas, EDIT_SONGINFO, SI_INSTRUMENTNAME, buffer, 42 + 4 * 7, 29, 1);
+    draw_generic_n_digit_field(
+        tracker, canvas, EDIT_SONGINFO, SI_CURRENTINSTRUMENT, buffer, 42, 29, 1);
+    snprintf(
+        buffer, sizeof(buffer), "%s", tracker->song.instrument[tracker->current_instrument]->name);
+    draw_generic_n_digit_field(
+        tracker, canvas, EDIT_SONGINFO, SI_INSTRUMENTNAME, buffer, 42 + 4 * 7, 29, 1);
 
     uint32_t song_size = calculate_song_size(&tracker->song);
     uint32_t free_bytes = memmgr_get_free_heap();
@@ -344,23 +354,31 @@ void draw_songinfo_view(Canvas *canvas, FlizzerTrackerApp *tracker)
     char song_size_buffer[19];
     char free_bytes_buffer[19];
 
-    if (song_size > 9999)
-    {
-        snprintf(song_size_buffer, sizeof(song_size_buffer), "TUNE:%ld%c%01ldK", song_size / 1024, '.', (song_size % 1024) / 103);
+    if(song_size > 9999) {
+        snprintf(
+            song_size_buffer,
+            sizeof(song_size_buffer),
+            "TUNE:%ld%c%01ldK",
+            song_size / 1024,
+            '.',
+            (song_size % 1024) / 103);
     }
 
-    else
-    {
+    else {
         snprintf(song_size_buffer, sizeof(song_size_buffer), "TUNE:%ld", song_size);
     }
 
-    if (free_bytes > 9999)
-    {
-        snprintf(free_bytes_buffer, sizeof(song_size_buffer), "FREE:%ld%c%01ldK", free_bytes / 1024, '.', (free_bytes % 1024) / 103);
+    if(free_bytes > 9999) {
+        snprintf(
+            free_bytes_buffer,
+            sizeof(song_size_buffer),
+            "FREE:%ld%c%01ldK",
+            free_bytes / 1024,
+            '.',
+            (free_bytes % 1024) / 103);
     }
 
-    else
-    {
+    else {
         snprintf(free_bytes_buffer, sizeof(song_size_buffer), "FREE:%ld", free_bytes);
     }
 

view/pattern_editor.h

@@ -8,10 +8,18 @@
 
 extern const char to_char_array[];
 
-void draw_pattern_view(Canvas *canvas, FlizzerTrackerApp *tracker);
-void draw_sequence_view(Canvas *canvas, FlizzerTrackerApp *tracker);
-void draw_songinfo_view(Canvas *canvas, FlizzerTrackerApp *tracker);
+void draw_pattern_view(Canvas* canvas, FlizzerTrackerApp* tracker);
+void draw_sequence_view(Canvas* canvas, FlizzerTrackerApp* tracker);
+void draw_songinfo_view(Canvas* canvas, FlizzerTrackerApp* tracker);
 
-void draw_generic_n_digit_field(FlizzerTrackerApp *tracker, Canvas *canvas, uint8_t focus, uint8_t param, const char *text, uint8_t x, uint8_t y, uint8_t digits);
+void draw_generic_n_digit_field(
+    FlizzerTrackerApp* tracker,
+    Canvas* canvas,
+    uint8_t focus,
+    uint8_t param,
+    const char* text,
+    uint8_t x,
+    uint8_t y,
+    uint8_t digits);
 char to_char(uint8_t number);
-char *notename(uint8_t note);
+char* notename(uint8_t note);