Squashed 'tuning_fork/' changes from bd8ef400a..86de894d4

86de894d4 upd tuning fork
590305823 fixing some big bugs
eccdb6a2f categories part 1
ed4e1d738 Screenshots
bd0bc7bcd more manifestos, xbox controller and videopoker ufbt fixes
01dd8a6c7 ufbt fixes part 2
63e0ba09a API 31 / unzip sources
REVERT: bd8ef400a Merge pull request #2 from portalsoup/ukulele
REVERT: c7cc6b428 first pass at new tuning
REVERT: b48e18cef Update README.md
REVERT: 10e3ee075 Init
REVERT: 9b4115937 Initial commit

git-subtree-dir: tuning_fork
git-subtree-split: 86de894d477a0feec249c2d564f52b5cf99430b0

application.fam

@@ -1,14 +1,18 @@
 App(
     appid="tuning_fork",
     name="Tuning Fork",
-    apptype=FlipperAppType.PLUGIN,
+    apptype=FlipperAppType.EXTERNAL,
     entry_point="tuning_fork_app",
     cdefines=["APP_TUNING_FORM"],
     requires=[
         "gui",
     ],
     fap_icon="tuning_fork_icon.png",
-    fap_category="Music",
+    fap_category="Media",
     stack_size=2 * 1024,
     order=20,
+    fap_author="@besya & (Fixes by @Willy-JL)",
+    fap_weburl="https://github.com/besya/flipperzero-tuning-fork",
+    fap_version="1.1",
+    fap_description="Tuning fork for tuning musical instruments",
 )

notes.h

@@ -1,7 +1,6 @@
 #ifndef NOTES
 #define NOTES
 
-
 #define C0 16.35f
 #define Cs0 17.32f
 #define Db0 17.32f
@@ -157,4 +156,3 @@
 #define B8 7902.13f
 
 #endif //NOTES
-

tuning_fork.c

@@ -1,7 +1,6 @@
 #include <furi.h>
 #include <furi_hal.h>
 #include <input/input.h>
-#include <m-string.h>
 #include <string.h>
 #include <stdlib.h>
 
@@ -16,380 +15,391 @@
 #include "tunings.h"
 
 typedef enum {
-  EventTypeTick,
-  EventTypeKey,
+    EventTypeTick,
+    EventTypeKey,
 } EventType;
 
 typedef struct {
-  EventType type;
-  InputEvent input;
+    EventType type;
+    InputEvent input;
 } PluginEvent;
 
-enum Page {
-  Tunings,
-  Notes
-};
+enum Page { Tunings, Notes };
 
 typedef struct {
-  bool playing;
-  enum Page page;
-  int current_tuning_note_index;
-  int current_tuning_index;
-  float volume;
-  TUNING tuning;
+    FuriMutex* mutex;
+    bool playing;
+    enum Page page;
+    int current_tuning_note_index;
+    int current_tuning_index;
+    float volume;
+    TUNING tuning;
 } TuningForkState;
 
 static TUNING current_tuning(TuningForkState* tuningForkState) {
-  return tuningForkState->tuning;
+    return tuningForkState->tuning;
 }
 
 static NOTE current_tuning_note(TuningForkState* tuningForkState) {
-  return current_tuning(tuningForkState).notes[tuningForkState->current_tuning_note_index];
+    return current_tuning(tuningForkState).notes[tuningForkState->current_tuning_note_index];
 }
 
 static float current_tuning_note_freq(TuningForkState* tuningForkState) {
-  return current_tuning_note(tuningForkState).frequency;
+    return current_tuning_note(tuningForkState).frequency;
 }
 
 static void current_tuning_note_label(TuningForkState* tuningForkState, char* outNoteLabel) {
-  for(int i=0; i < 20; ++i){
-    outNoteLabel[i] = current_tuning_note(tuningForkState).label[i];
-  }
+    for(int i = 0; i < 20; ++i) {
+        outNoteLabel[i] = current_tuning_note(tuningForkState).label[i];
+    }
 }
 
 static void current_tuning_label(TuningForkState* tuningForkState, char* outTuningLabel) {
-  for(int i=0; i < 20; ++i){
-    outTuningLabel[i] = current_tuning(tuningForkState).label[i];
-  }
+    for(int i = 0; i < 20; ++i) {
+        outTuningLabel[i] = current_tuning(tuningForkState).label[i];
+    }
 }
 
 static void updateTuning(TuningForkState* tuning_fork_state) {
-  tuning_fork_state->tuning = TuningList[tuning_fork_state->current_tuning_index];
-  tuning_fork_state->current_tuning_note_index = 0;
+    tuning_fork_state->tuning = TuningList[tuning_fork_state->current_tuning_index];
+    tuning_fork_state->current_tuning_note_index = 0;
 }
 
 static void next_tuning(TuningForkState* tuning_fork_state) {
-  if (tuning_fork_state->current_tuning_index == TUNINGS_COUNT - 1) {
-    tuning_fork_state->current_tuning_index = 0;
-  } else {
-    tuning_fork_state->current_tuning_index += 1;
-  }
-  updateTuning(tuning_fork_state);
+    if(tuning_fork_state->current_tuning_index == TUNINGS_COUNT - 1) {
+        tuning_fork_state->current_tuning_index = 0;
+    } else {
+        tuning_fork_state->current_tuning_index += 1;
+    }
+    updateTuning(tuning_fork_state);
 }
 
 static void prev_tuning(TuningForkState* tuning_fork_state) {
-  if (tuning_fork_state->current_tuning_index - 1 < 0) {
-    tuning_fork_state->current_tuning_index = TUNINGS_COUNT - 1;
-  } else {
-    tuning_fork_state->current_tuning_index -= 1;
-  }
-  updateTuning(tuning_fork_state);
+    if(tuning_fork_state->current_tuning_index - 1 < 0) {
+        tuning_fork_state->current_tuning_index = TUNINGS_COUNT - 1;
+    } else {
+        tuning_fork_state->current_tuning_index -= 1;
+    }
+    updateTuning(tuning_fork_state);
 }
 
 static void next_note(TuningForkState* tuning_fork_state) {
-  if (tuning_fork_state->current_tuning_note_index == current_tuning(tuning_fork_state).notes_length - 1) {
-    tuning_fork_state->current_tuning_note_index = 0;
-  } else {
-    tuning_fork_state->current_tuning_note_index += 1;
-  }
+    if(tuning_fork_state->current_tuning_note_index ==
+       current_tuning(tuning_fork_state).notes_length - 1) {
+        tuning_fork_state->current_tuning_note_index = 0;
+    } else {
+        tuning_fork_state->current_tuning_note_index += 1;
+    }
 }
 
 static void prev_note(TuningForkState* tuning_fork_state) {
-  if (tuning_fork_state->current_tuning_note_index == 0) {
-    tuning_fork_state->current_tuning_note_index = current_tuning(tuning_fork_state).notes_length - 1;
-  } else {
-    tuning_fork_state->current_tuning_note_index -= 1;
-  }
+    if(tuning_fork_state->current_tuning_note_index == 0) {
+        tuning_fork_state->current_tuning_note_index =
+            current_tuning(tuning_fork_state).notes_length - 1;
+    } else {
+        tuning_fork_state->current_tuning_note_index -= 1;
+    }
 }
 
 static void increase_volume(TuningForkState* tuning_fork_state) {
-  if (tuning_fork_state->volume < 1.0f) {
-    tuning_fork_state->volume += 0.1f;
-  }
+    if(tuning_fork_state->volume < 1.0f) {
+        tuning_fork_state->volume += 0.1f;
+    }
 }
 
 static void decrease_volume(TuningForkState* tuning_fork_state) {
-  if (tuning_fork_state->volume > 0.0f) {
-    tuning_fork_state->volume -= 0.1f;
-  }
+    if(tuning_fork_state->volume > 0.0f) {
+        tuning_fork_state->volume -= 0.1f;
+    }
 }
 
 static void play(TuningForkState* tuning_fork_state) {
-  furi_hal_speaker_start(current_tuning_note_freq(tuning_fork_state), tuning_fork_state->volume);
+    if(furi_hal_speaker_is_mine() || furi_hal_speaker_acquire(1000)) {
+        furi_hal_speaker_start(
+            current_tuning_note_freq(tuning_fork_state), tuning_fork_state->volume);
+    }
 }
 
 static void stop() {
-  furi_hal_speaker_stop();
+    if(furi_hal_speaker_is_mine()) {
+        furi_hal_speaker_stop();
+        furi_hal_speaker_release();
+    }
 }
 
 static void replay(TuningForkState* tuning_fork_state) {
-  stop();
-  play(tuning_fork_state);
+    stop();
+    play(tuning_fork_state);
 }
 
 static void render_callback(Canvas* const canvas, void* ctx) {
-  TuningForkState* tuning_fork_state = acquire_mutex((ValueMutex*)ctx, 25);
-  if(tuning_fork_state == NULL) {
-    return;
-  }
-
-  string_t tempStr;
-  string_init(tempStr);
-
-  canvas_draw_frame(canvas, 0, 0, 128, 64);
-
-  canvas_set_font(canvas, FontPrimary);
-
-  if (tuning_fork_state->page == Tunings) {
-    char tuningLabel[20];
-    current_tuning_label(tuning_fork_state, tuningLabel);
-    string_printf(tempStr, "< %s >", tuningLabel);
-    canvas_draw_str_aligned(canvas, 64, 28, AlignCenter, AlignCenter, string_get_cstr(tempStr));
-    string_reset(tempStr);
-  } else {
-    char tuningLabel[20];
-    current_tuning_label(tuning_fork_state, tuningLabel);
-    string_printf(tempStr, "%s", tuningLabel);
-    canvas_draw_str_aligned(canvas, 64, 8, AlignCenter, AlignCenter, string_get_cstr(tempStr));
-    string_reset(tempStr);
-
-    char tuningNoteLabel[20];
-    current_tuning_note_label(tuning_fork_state, tuningNoteLabel);
-    string_printf(tempStr, "< %s >", tuningNoteLabel);
-    canvas_draw_str_aligned(canvas, 64, 24, AlignCenter, AlignCenter, string_get_cstr(tempStr));
-    string_reset(tempStr);
-  }
-
-  canvas_set_font(canvas, FontSecondary);
-  elements_button_left(canvas, "Prev");
-  elements_button_right(canvas, "Next");
-
-  if (tuning_fork_state->page == Notes) {
-    if (tuning_fork_state->playing) {
-      elements_button_center(canvas, "Stop ");
+    furi_assert(ctx);
+    TuningForkState* tuning_fork_state = ctx;
+    furi_mutex_acquire(tuning_fork_state->mutex, FuriWaitForever);
+
+    FuriString* tempStr = furi_string_alloc();
+
+    canvas_draw_frame(canvas, 0, 0, 128, 64);
+
+    canvas_set_font(canvas, FontPrimary);
+
+    if(tuning_fork_state->page == Tunings) {
+        char tuningLabel[20];
+        current_tuning_label(tuning_fork_state, tuningLabel);
+        furi_string_printf(tempStr, "< %s >", tuningLabel);
+        canvas_draw_str_aligned(
+            canvas, 64, 28, AlignCenter, AlignCenter, furi_string_get_cstr(tempStr));
+        furi_string_reset(tempStr);
     } else {
-      elements_button_center(canvas, "Play");
+        char tuningLabel[20];
+        current_tuning_label(tuning_fork_state, tuningLabel);
+        furi_string_printf(tempStr, "%s", tuningLabel);
+        canvas_draw_str_aligned(
+            canvas, 64, 8, AlignCenter, AlignCenter, furi_string_get_cstr(tempStr));
+        furi_string_reset(tempStr);
+
+        char tuningNoteLabel[20];
+        current_tuning_note_label(tuning_fork_state, tuningNoteLabel);
+        furi_string_printf(tempStr, "< %s >", tuningNoteLabel);
+        canvas_draw_str_aligned(
+            canvas, 64, 24, AlignCenter, AlignCenter, furi_string_get_cstr(tempStr));
+        furi_string_reset(tempStr);
     }
-  } else {
-    elements_button_center(canvas, "Select");
-  }
-  if (tuning_fork_state->page == Notes) {
-    elements_progress_bar(canvas, 8, 36, 112, tuning_fork_state->volume);
-  }
-
-  string_clear(tempStr);
-  release_mutex((ValueMutex*)ctx, tuning_fork_state);
+
+    canvas_set_font(canvas, FontSecondary);
+    elements_button_left(canvas, "Prev");
+    elements_button_right(canvas, "Next");
+
+    if(tuning_fork_state->page == Notes) {
+        if(tuning_fork_state->playing) {
+            elements_button_center(canvas, "Stop ");
+        } else {
+            elements_button_center(canvas, "Play");
+        }
+    } else {
+        elements_button_center(canvas, "Select");
+    }
+    if(tuning_fork_state->page == Notes) {
+        elements_progress_bar(canvas, 8, 36, 112, tuning_fork_state->volume);
+    }
+
+    furi_string_free(tempStr);
+    furi_mutex_release(tuning_fork_state->mutex);
 }
 
 static void input_callback(InputEvent* input_event, FuriMessageQueue* event_queue) {
-  furi_assert(event_queue);
+    furi_assert(event_queue);
 
-  PluginEvent event = {.type = EventTypeKey, .input = *input_event};
-  furi_message_queue_put(event_queue, &event, FuriWaitForever);
+    PluginEvent event = {.type = EventTypeKey, .input = *input_event};
+    furi_message_queue_put(event_queue, &event, FuriWaitForever);
 }
 
 static void tuning_fork_state_init(TuningForkState* const tuning_fork_state) {
-  tuning_fork_state->playing = false;
-  tuning_fork_state->page = Tunings;
-  tuning_fork_state->volume = 1.0f;
-  tuning_fork_state->tuning = GuitarStandard6;
-  tuning_fork_state->current_tuning_index = 2;
-  tuning_fork_state->current_tuning_note_index = 0;
+    tuning_fork_state->playing = false;
+    tuning_fork_state->page = Tunings;
+    tuning_fork_state->volume = 1.0f;
+    tuning_fork_state->tuning = GuitarStandard6;
+    tuning_fork_state->current_tuning_index = 2;
+    tuning_fork_state->current_tuning_note_index = 0;
 }
 
 int32_t tuning_fork_app() {
-  FuriMessageQueue* event_queue = furi_message_queue_alloc(8, sizeof(PluginEvent));
+    FuriMessageQueue* event_queue = furi_message_queue_alloc(8, sizeof(PluginEvent));
 
-  TuningForkState* tuning_fork_state = malloc(sizeof(TuningForkState));
-  tuning_fork_state_init(tuning_fork_state);
+    TuningForkState* tuning_fork_state = malloc(sizeof(TuningForkState));
+    tuning_fork_state_init(tuning_fork_state);
 
-  ValueMutex state_mutex;
-  if(!init_mutex(&state_mutex, tuning_fork_state, sizeof(TuningForkState))) {
-    FURI_LOG_E("TuningFork", "cannot create mutex\r\n");
-    free(tuning_fork_state);
-    return 255;
-  }
-
-  // Set system callbacks
-  ViewPort* view_port = view_port_alloc();
-  view_port_draw_callback_set(view_port, render_callback, &state_mutex);
-  view_port_input_callback_set(view_port, input_callback, event_queue);
-
-  Gui* gui = furi_record_open("gui");
-  gui_add_view_port(gui, view_port, GuiLayerFullscreen);
-
-  PluginEvent event;
-  for(bool processing = true; processing;) {
-    FuriStatus event_status = furi_message_queue_get(event_queue, &event, 100);
-
-    TuningForkState* tuning_fork_state = (TuningForkState*)acquire_mutex_block(&state_mutex);
-
-    if(event_status == FuriStatusOk) {
-      if(event.type == EventTypeKey) {
-        if(event.input.type == InputTypeShort) {
-          // push events
-          switch(event.input.key) {
-            case InputKeyUp:
-              if (tuning_fork_state->page == Notes) {
-                increase_volume(tuning_fork_state);
-                if (tuning_fork_state->playing) {
-                  replay(tuning_fork_state);
-                }
-              }
-              break;
-            case InputKeyDown:
-              if (tuning_fork_state->page == Notes) {
-                decrease_volume(tuning_fork_state);
-                if (tuning_fork_state->playing) {
-                  replay(tuning_fork_state);
-                }
-              }
-              break;
-            case InputKeyRight:
-              if (tuning_fork_state->page == Tunings) {
-                next_tuning(tuning_fork_state);
-              } else {
-                next_note(tuning_fork_state);
-                if (tuning_fork_state->playing) {
-                  replay(tuning_fork_state);
-                }
-              }
-              break;
-            case InputKeyLeft:
-              if (tuning_fork_state->page == Tunings) {
-                prev_tuning(tuning_fork_state);
-              } else {
-                prev_note(tuning_fork_state);
-                if (tuning_fork_state->playing) {
-                  replay(tuning_fork_state);
-                }
-              }
-              break;
-            case InputKeyOk:
-              if (tuning_fork_state->page == Tunings) {
-                tuning_fork_state->page = Notes;
-              } else {
-                tuning_fork_state->playing = !tuning_fork_state->playing;
-                if (tuning_fork_state->playing) {
-                  play(tuning_fork_state);
-                } else {
-                  stop();
-                }
-              }
-              break;
-            case InputKeyBack:
-              if (tuning_fork_state->page == Tunings) {
-                processing = false;
-              } else {
-                tuning_fork_state->playing = false;
-                tuning_fork_state->current_tuning_note_index = 0;
-                stop();
-                tuning_fork_state->page = Tunings;
-              }
-              break;
-          }
-        } else if (event.input.type == InputTypeLong) {
-          // hold events
-          switch(event.input.key) {
-            case InputKeyUp:
-              break;
-            case InputKeyDown:
-              break;
-            case InputKeyRight:
-              if (tuning_fork_state->page == Tunings) {
-                next_tuning(tuning_fork_state);
-              } else {
-                next_note(tuning_fork_state);
-                if (tuning_fork_state->playing) {
-                  replay(tuning_fork_state);
-                }
-              }
-
-              break;
-            case InputKeyLeft:
-              if (tuning_fork_state->page == Tunings) {
-                prev_tuning(tuning_fork_state);
-              } else {
-                prev_note(tuning_fork_state);
-                if (tuning_fork_state->playing) {
-                  replay(tuning_fork_state);
-                }
-              }
-
-              break;
-            case InputKeyOk:
-              break;
-            case InputKeyBack:
-              if (tuning_fork_state->page == Tunings) {
-                processing = false;
-              } else {
-                tuning_fork_state->playing = false;
-                stop();
-                tuning_fork_state->page = Tunings;
-                tuning_fork_state->current_tuning_note_index = 0;
-              }
-              break;
-          }
-        } else if (event.input.type == InputTypeRepeat) {
-          // repeat events
-          switch(event.input.key) {
-            case InputKeyUp:
-              break;
-            case InputKeyDown:
-              break;
-            case InputKeyRight:
-              if (tuning_fork_state->page == Tunings) {
-                next_tuning(tuning_fork_state);
-              } else {
-                next_note(tuning_fork_state);
-                if (tuning_fork_state->playing) {
-                  replay(tuning_fork_state);
-                }
-              }
-
-              break;
-            case InputKeyLeft:
-              if (tuning_fork_state->page == Tunings) {
-                prev_tuning(tuning_fork_state);
-              } else {
-                prev_note(tuning_fork_state);
-                if (tuning_fork_state->playing) {
-                  replay(tuning_fork_state);
+    tuning_fork_state->mutex = furi_mutex_alloc(FuriMutexTypeNormal);
+    if(!tuning_fork_state->mutex) {
+        FURI_LOG_E("TuningFork", "cannot create mutex\r\n");
+        free(tuning_fork_state);
+        return 255;
+    }
+
+    // Set system callbacks
+    ViewPort* view_port = view_port_alloc();
+    view_port_draw_callback_set(view_port, render_callback, tuning_fork_state);
+    view_port_input_callback_set(view_port, input_callback, event_queue);
+
+    Gui* gui = furi_record_open("gui");
+    gui_add_view_port(gui, view_port, GuiLayerFullscreen);
+
+    PluginEvent event;
+    for(bool processing = true; processing;) {
+        FuriStatus event_status = furi_message_queue_get(event_queue, &event, 100);
+
+        furi_mutex_acquire(tuning_fork_state->mutex, FuriWaitForever);
+
+        if(event_status == FuriStatusOk) {
+            if(event.type == EventTypeKey) {
+                if(event.input.type == InputTypeShort) {
+                    // push events
+                    switch(event.input.key) {
+                    case InputKeyUp:
+                        if(tuning_fork_state->page == Notes) {
+                            increase_volume(tuning_fork_state);
+                            if(tuning_fork_state->playing) {
+                                replay(tuning_fork_state);
+                            }
+                        }
+                        break;
+                    case InputKeyDown:
+                        if(tuning_fork_state->page == Notes) {
+                            decrease_volume(tuning_fork_state);
+                            if(tuning_fork_state->playing) {
+                                replay(tuning_fork_state);
+                            }
+                        }
+                        break;
+                    case InputKeyRight:
+                        if(tuning_fork_state->page == Tunings) {
+                            next_tuning(tuning_fork_state);
+                        } else {
+                            next_note(tuning_fork_state);
+                            if(tuning_fork_state->playing) {
+                                replay(tuning_fork_state);
+                            }
+                        }
+                        break;
+                    case InputKeyLeft:
+                        if(tuning_fork_state->page == Tunings) {
+                            prev_tuning(tuning_fork_state);
+                        } else {
+                            prev_note(tuning_fork_state);
+                            if(tuning_fork_state->playing) {
+                                replay(tuning_fork_state);
+                            }
+                        }
+                        break;
+                    case InputKeyOk:
+                        if(tuning_fork_state->page == Tunings) {
+                            tuning_fork_state->page = Notes;
+                        } else {
+                            tuning_fork_state->playing = !tuning_fork_state->playing;
+                            if(tuning_fork_state->playing) {
+                                play(tuning_fork_state);
+                            } else {
+                                stop();
+                            }
+                        }
+                        break;
+                    case InputKeyBack:
+                        if(tuning_fork_state->page == Tunings) {
+                            processing = false;
+                        } else {
+                            tuning_fork_state->playing = false;
+                            tuning_fork_state->current_tuning_note_index = 0;
+                            stop();
+                            tuning_fork_state->page = Tunings;
+                        }
+                        break;
+                    default:
+                        break;
+                    }
+                } else if(event.input.type == InputTypeLong) {
+                    // hold events
+                    switch(event.input.key) {
+                    case InputKeyUp:
+                        break;
+                    case InputKeyDown:
+                        break;
+                    case InputKeyRight:
+                        if(tuning_fork_state->page == Tunings) {
+                            next_tuning(tuning_fork_state);
+                        } else {
+                            next_note(tuning_fork_state);
+                            if(tuning_fork_state->playing) {
+                                replay(tuning_fork_state);
+                            }
+                        }
+
+                        break;
+                    case InputKeyLeft:
+                        if(tuning_fork_state->page == Tunings) {
+                            prev_tuning(tuning_fork_state);
+                        } else {
+                            prev_note(tuning_fork_state);
+                            if(tuning_fork_state->playing) {
+                                replay(tuning_fork_state);
+                            }
+                        }
+
+                        break;
+                    case InputKeyOk:
+                        break;
+                    case InputKeyBack:
+                        if(tuning_fork_state->page == Tunings) {
+                            processing = false;
+                        } else {
+                            tuning_fork_state->playing = false;
+                            stop();
+                            tuning_fork_state->page = Tunings;
+                            tuning_fork_state->current_tuning_note_index = 0;
+                        }
+                        break;
+                    default:
+                        break;
+                    }
+                } else if(event.input.type == InputTypeRepeat) {
+                    // repeat events
+                    switch(event.input.key) {
+                    case InputKeyUp:
+                        break;
+                    case InputKeyDown:
+                        break;
+                    case InputKeyRight:
+                        if(tuning_fork_state->page == Tunings) {
+                            next_tuning(tuning_fork_state);
+                        } else {
+                            next_note(tuning_fork_state);
+                            if(tuning_fork_state->playing) {
+                                replay(tuning_fork_state);
+                            }
+                        }
+
+                        break;
+                    case InputKeyLeft:
+                        if(tuning_fork_state->page == Tunings) {
+                            prev_tuning(tuning_fork_state);
+                        } else {
+                            prev_note(tuning_fork_state);
+                            if(tuning_fork_state->playing) {
+                                replay(tuning_fork_state);
+                            }
+                        }
+
+                        break;
+                    case InputKeyOk:
+                        break;
+                    case InputKeyBack:
+                        if(tuning_fork_state->page == Tunings) {
+                            processing = false;
+                        } else {
+                            tuning_fork_state->playing = false;
+                            stop();
+                            tuning_fork_state->page = Tunings;
+                            tuning_fork_state->current_tuning_note_index = 0;
+                        }
+                        break;
+                    default:
+                        break;
+                    }
                 }
-              }
-
-              break;
-            case InputKeyOk:
-              break;
-            case InputKeyBack:
-              if (tuning_fork_state->page == Tunings) {
-                processing = false;
-              } else {
-                tuning_fork_state->playing = false;
-                stop();
-                tuning_fork_state->page = Tunings;
-                tuning_fork_state->current_tuning_note_index = 0;
-              }
-              break;
-          }
+            }
         }
-      }
-    } else {
-      FURI_LOG_D("TuningFork", "FuriMessageQueue: event timeout");
-    }
 
-    view_port_update(view_port);
-    release_mutex(&state_mutex, tuning_fork_state);
-  }
+        furi_mutex_release(tuning_fork_state->mutex);
+        view_port_update(view_port);
+    }
 
-  view_port_enabled_set(view_port, false);
-  gui_remove_view_port(gui, view_port);
-  furi_record_close("gui");
-  view_port_free(view_port);
-  furi_message_queue_free(event_queue);
-  delete_mutex(&state_mutex);
-  furi_record_close(RECORD_NOTIFICATION);
-  free(tuning_fork_state);
+    view_port_enabled_set(view_port, false);
+    gui_remove_view_port(gui, view_port);
+    furi_record_close("gui");
+    view_port_free(view_port);
+    furi_message_queue_free(event_queue);
+    furi_mutex_free(tuning_fork_state->mutex);
+    furi_record_close(RECORD_NOTIFICATION);
+    free(tuning_fork_state);
 
-  return 0;
+    return 0;
 }

tunings.h

@@ -4,165 +4,129 @@
 #define TUNINGS
 
 typedef struct {
-  char label[20];
-  float frequency;
+    char label[20];
+    float frequency;
 } NOTE;
 
 typedef struct {
-  char label[20];
-  int notes_length;
-  NOTE notes[20];
+    char label[20];
+    int notes_length;
+    NOTE notes[20];
 } TUNING;
 
 const TUNING TuningForks = {
-  "Tuning forks", 6, {
-    { "Common A4 (440)", 440.00f},
-    { "Sarti's A4 (436)", 436.00f},
-    { "1858 A4 (435)", 435.00f},
-    { "Verdi's A4 (432)", 432.00f},
-    { "1750-1820 A4 (423.5)", 423.50f},
-    { "Verdi's C4 (256.00)", 256.00f},
-  }
-};
+    "Tuning forks",
+    6,
+    {
+        {"Common A4 (440)", 440.00f},
+        {"Sarti's A4 (436)", 436.00f},
+        {"1858 A4 (435)", 435.00f},
+        {"Verdi's A4 (432)", 432.00f},
+        {"1750-1820 A4 (423.5)", 423.50f},
+        {"Verdi's C4 (256.00)", 256.00f},
+    }};
 
 const TUNING ScientificPitch = {
-  "Scientific pitch", 12, {
-    { "C0 (16Hz)", 16.0f},
-    { "C1 (32Hz)", 32.0f},
-    { "C2 (64Hz)", 64.0f},
-    { "C3 (128Hz)", 128.0f},
-    { "C4 (256Hz)", 256.0f},
-    { "C5 (512Hz)", 512.0f},
-    { "C6 (1024Hz)", 1024.0f},
-    { "C7 (2048Hz)", 2048.0f},
-    { "C8 (4096Hz)", 4096.0f},
-    { "C9 (8192Hz)", 8192.0f},
-    { "C10 (16384Hz)", 16384.0f},
-    { "C11 (32768Hz)", 32768.0f}
-  }
-};
+    "Scientific pitch",
+    12,
+    {{"C0 (16Hz)", 16.0f},
+     {"C1 (32Hz)", 32.0f},
+     {"C2 (64Hz)", 64.0f},
+     {"C3 (128Hz)", 128.0f},
+     {"C4 (256Hz)", 256.0f},
+     {"C5 (512Hz)", 512.0f},
+     {"C6 (1024Hz)", 1024.0f},
+     {"C7 (2048Hz)", 2048.0f},
+     {"C8 (4096Hz)", 4096.0f},
+     {"C9 (8192Hz)", 8192.0f},
+     {"C10 (16384Hz)", 16384.0f},
+     {"C11 (32768Hz)", 32768.0f}}};
 
 const TUNING GuitarStandard6 = {
-  "Guitar Standard 6", 6, {
-    {"String 1", E4},
-    {"String 2", B3},
-    {"String 3", G3},
-    {"String 4", D3},
-    {"String 5", A2},
-    {"String 6", E2}
-  }
-};
+    "Guitar Standard 6",
+    6,
+    {{"String 1", E4},
+     {"String 2", B3},
+     {"String 3", G3},
+     {"String 4", D3},
+     {"String 5", A2},
+     {"String 6", E2}}};
 
 const TUNING GuitarDropD6 = {
-  "Guitar Drop D 6", 6, {
-    {"String 1", E4},
-    {"String 2", B3},
-    {"String 3", G3},
-    {"String 4", D3},
-    {"String 5", A2},
-    {"String 6", D2}
-  }
-};
+    "Guitar Drop D 6",
+    6,
+    {{"String 1", E4},
+     {"String 2", B3},
+     {"String 3", G3},
+     {"String 4", D3},
+     {"String 5", A2},
+     {"String 6", D2}}};
 
 const TUNING GuitarD6 = {
-  "Guitar D 6", 6, {
-    {"String 1", D4},
-    {"String 2", A3},
-    {"String 3", F3},
-    {"String 4", C3},
-    {"String 5", G2},
-    {"String 6", D2}
-  }
-};
+    "Guitar D 6",
+    6,
+    {{"String 1", D4},
+     {"String 2", A3},
+     {"String 3", F3},
+     {"String 4", C3},
+     {"String 5", G2},
+     {"String 6", D2}}};
 
 const TUNING GuitarDropC6 = {
-  "Guitar Drop C 6", 6, {
-    {"String 1", D4},
-    {"String 2", A3},
-    {"String 3", F3},
-    {"String 4", C3},
-    {"String 5", G2},
-    {"String 6", C2}
-  }
-};
+    "Guitar Drop C 6",
+    6,
+    {{"String 1", D4},
+     {"String 2", A3},
+     {"String 3", F3},
+     {"String 4", C3},
+     {"String 5", G2},
+     {"String 6", C2}}};
 
 const TUNING GuitarStandard7 = {
-  "Guitar Standard 7", 7, {
-    {"String 1", E4},
-    {"String 2", B3},
-    {"String 3", G3},
-    {"String 4", D3},
-    {"String 5", A2},
-    {"String 6", E2},
-    {"String 7", B1}
-  }
-};
+    "Guitar Standard 7",
+    7,
+    {{"String 1", E4},
+     {"String 2", B3},
+     {"String 3", G3},
+     {"String 4", D3},
+     {"String 5", A2},
+     {"String 6", E2},
+     {"String 7", B1}}};
 
 const TUNING BassStandard4 = {
-  "Bass Standard 4", 4, {
-    {"String 1", G2},
-    {"String 2", D2},
-    {"String 3", A1},
-    {"String 4", E1}
-  }
-};
+    "Bass Standard 4",
+    4,
+    {{"String 1", G2}, {"String 2", D2}, {"String 3", A1}, {"String 4", E1}}};
 
 const TUNING BassStandardTenor4 = {
-  "Bass Stand Tenor 4", 4, {
-    {"String 1", C3},
-    {"String 2", G2},
-    {"String 3", D2},
-    {"String 4", A1}
-  }
-};
+    "Bass Stand Tenor 4",
+    4,
+    {{"String 1", C3}, {"String 2", G2}, {"String 3", D2}, {"String 4", A1}}};
 
 const TUNING BassStandard5 = {
-  "Bass Standard 5", 5, {
-    {"String 1", G2},
-    {"String 2", D2},
-    {"String 3", A1},
-    {"String 4", E1},
-    {"String 5", B0}
-  }
-};
+    "Bass Standard 5",
+    5,
+    {{"String 1", G2}, {"String 2", D2}, {"String 3", A1}, {"String 4", E1}, {"String 5", B0}}};
 
 const TUNING BassStandardTenor5 = {
-  "Bass Stand Tenor 5", 5, {
-    {"String 1", C3},
-    {"String 2", G2},
-    {"String 3", D2},
-    {"String 4", A1},
-    {"String 5", E1}
-  }
-};
+    "Bass Stand Tenor 5",
+    5,
+    {{"String 1", C3}, {"String 2", G2}, {"String 3", D2}, {"String 4", A1}, {"String 5", E1}}};
 
 const TUNING BassDropD4 = {
-  "Bass Drop D 4", 4, {
-    {"String 1", G2},
-    {"String 2", D2},
-    {"String 3", A1},
-    {"String 4", D1}
-  }
-};
+    "Bass Drop D 4",
+    4,
+    {{"String 1", G2}, {"String 2", D2}, {"String 3", A1}, {"String 4", D1}}};
 
 const TUNING BassD4 = {
-  "Bass D 4", 4, {
-    {"String 1", F2},
-    {"String 2", C2},
-    {"String 3", G1},
-    {"String 4", D1}
-  }
-};
+    "Bass D 4",
+    4,
+    {{"String 1", F2}, {"String 2", C2}, {"String 3", G1}, {"String 4", D1}}};
 
 const TUNING BassDropA5 = {
-  "Bass Drop A 5", 5, {
-    {"String 1", G2},
-    {"String 2", D2},
-    {"String 3", A1},
-    {"String 4", E1},
-    {"String 5", A0}
-  }
-};
+    "Bass Drop A 5",
+    5,
+    {{"String 1", G2}, {"String 2", D2}, {"String 3", A1}, {"String 4", E1}, {"String 5", A0}}};
 
 const TUNING UkuleleStandard4 = {
     "Ukulele Standard 4", 4, {
@@ -176,23 +140,23 @@ const TUNING UkuleleStandard4 = {
 #define TUNINGS_COUNT 15
 
 TUNING TuningList[TUNINGS_COUNT] = {
-  ScientificPitch,
-  TuningForks,
-
-  GuitarStandard6,
-  GuitarDropD6,
-  GuitarD6,
-  GuitarDropC6,
-  GuitarStandard7,
-
-  BassStandard4,
-  BassStandardTenor4,
-  BassStandard5,
-  BassStandardTenor5,
-  BassDropD4,
-  BassD4,
-  BassDropA5,
-  UkuleleStandard4
+    ScientificPitch,
+    TuningForks,
+
+    GuitarStandard6,
+    GuitarDropD6,
+    GuitarD6,
+    GuitarDropC6,
+    GuitarStandard7,
+
+    BassStandard4,
+    BassStandardTenor4,
+    BassStandard5,
+    BassStandardTenor5,
+    BassDropD4,
+    BassD4,
+    BassDropA5,
+    UkuleleStandard4
 };
 
 #endif //TUNINGS