logo

qmk_firmware

custom branch of QMK firmware git clone https://anongit.hacktivis.me/git/qmk_firmware.git

audio.c (20590B)

    

  1. /* Copyright 2016-2020 Jack Humbert
  2.  * Copyright 2020 JohSchneider
  4.  * This program is free software: you can redistribute it and/or modify
  5.  * it under the terms of the GNU General Public License as published by
  6.  * the Free Software Foundation, either version 2 of the License, or
  7.  * (at your option) any later version.
  8.  *
  9.  * This program is distributed in the hope that it will be useful,
  10.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12.  * GNU General Public License for more details.
  13.  *
  14.  * You should have received a copy of the GNU General Public License
  15.  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  16.  */
  17. #include "audio.h"
  18. #include "eeconfig.h"
  19. #include "timer.h"
  20. #include "debug.h"
  21. #include "wait.h"
  22. #include "util.h"
  23. #include "gpio.h"
  25. /* audio system:
  26.  *
  27.  * audio.[ch] takes care of all overall state, tracking the actively playing
  28.  *            notes/tones; the notes a SONG consists of;
  29.  *            ...
  30.  *            = everything audio-related that is platform agnostic
  31.  *
  32.  * driver_[avr|chibios]_[dac|pwm] take care of the lower hardware dependent parts,
  33.  *            specific to each platform and the used subsystem/driver to drive
  34.  *            the output pins/channels with the calculated frequencies for each
  35.  *            active tone
  36.  *            as part of this, the driver has to trigger regular state updates by
  37.  *            calling 'audio_update_state' through some sort of timer - be it a
  38.  *            dedicated one or piggybacking on for example the timer used to
  39.  *            generate a pwm signal/clock.
  40.  *
  41.  *
  42.  * A Note on terminology:
  43.  * tone, pitch and frequency are used somewhat interchangeably, in a strict Wikipedia-sense:
  44.  *    "(Musical) tone, a sound characterized by its duration, pitch (=frequency),
  45.  *    intensity (=volume), and timbre"
  46.  * - intensity/volume is currently not handled at all, although the 'dac_additive' driver could do so
  47.  * - timbre is handled globally (TODO: only used with the pwm drivers at the moment)
  48.  *
  49.  * in musical_note.h a 'note' is the combination of a pitch and a duration
  50.  * these are used to create SONG arrays; during playback their frequencies
  51.  * are handled as single successive tones, while the durations are
  52.  * kept track of in 'audio_update_state'
  53.  *
  54.  * 'voice' as it is used here, equates to a sort of instrument with its own
  55.  * characteristics sound and effects
  56.  * the audio system as-is deals only with (possibly multiple) tones of one
  57.  * instrument/voice at a time (think: chords). since the number of tones that
  58.  * can be reproduced depends on the hardware/driver in use: pwm can only
  59.  * reproduce one tone per output/speaker; DACs can reproduce/mix multiple
  60.  * when doing additive synthesis.
  61.  *
  62.  * 'duration' can either be in the beats-per-minute related unit found in
  63.  * musical_notes.h, OR in ms; keyboards create SONGs with the former, while
  64.  * the internal state of the audio system does its calculations with the later - ms
  65.  */
  67. #ifndef AUDIO_DEFAULT_ON
  68. #    define AUDIO_DEFAULT_ON true
  69. #endif
  70. #ifndef AUDIO_DEFAULT_CLICKY_ON
  71. #    define AUDIO_DEFAULT_CLICKY_ON true
  72. #endif
  74. #ifndef AUDIO_TONE_STACKSIZE
  75. #    define AUDIO_TONE_STACKSIZE 8
  76. #endif
  77. uint8_t        active_tones = 0;            // number of tones pushed onto the stack by audio_play_tone - might be more than the hardware is able to reproduce at any single time
  78. musical_tone_t tones[AUDIO_TONE_STACKSIZE]; // stack of currently active tones
  80. bool playing_melody = false; // playing a SONG?
  81. bool playing_note   = false; // or (possibly multiple simultaneous) tones
  82. bool state_changed  = false; // global flag, which is set if anything changes with the active_tones
  84. // melody/SONG related state variables
  85. float (*notes_pointer)[][2];                           // SONG, an array of MUSICAL_NOTEs
  86. uint16_t notes_count;                                  // length of the notes_pointer array
  87. bool     notes_repeat;                                 // PLAY_SONG or PLAY_LOOP?
  88. uint16_t melody_current_note_duration = 0;             // duration of the currently playing note from the active melody, in ms
  89. uint8_t  note_tempo                   = TEMPO_DEFAULT; // beats-per-minute
  90. uint16_t current_note                 = 0;             // index into the array at notes_pointer
  91. bool     note_resting                 = false;         // if a short pause was introduced between two notes with the same frequency while playing a melody
  92. uint16_t last_timestamp               = 0;
  94. #ifdef AUDIO_ENABLE_TONE_MULTIPLEXING
  95. #    ifndef AUDIO_MAX_SIMULTANEOUS_TONES
  96. #        define AUDIO_MAX_SIMULTANEOUS_TONES 3
  97. #    endif
  98. uint16_t tone_multiplexing_rate        = AUDIO_TONE_MULTIPLEXING_RATE_DEFAULT;
  99. uint8_t  tone_multiplexing_index_shift = 0; // offset used on active-tone array access
  100. #endif
  102. // provided and used by voices.c
  103. extern uint8_t  note_timbre;
  104. extern bool     glissando;
  105. extern bool     vibrato;
  106. extern uint16_t voices_timer;
  108. #ifndef STARTUP_SONG
  109. #    define STARTUP_SONG SONG(STARTUP_SOUND)
  110. #endif
  111. #ifndef AUDIO_ON_SONG
  112. #    define AUDIO_ON_SONG SONG(AUDIO_ON_SOUND)
  113. #endif
  114. #ifndef AUDIO_OFF_SONG
  115. #    define AUDIO_OFF_SONG SONG(AUDIO_OFF_SOUND)
  116. #endif
  117. float startup_song[][2]   = STARTUP_SONG;
  118. float audio_on_song[][2]  = AUDIO_ON_SONG;
  119. float audio_off_song[][2] = AUDIO_OFF_SONG;
  121. static bool    audio_initialized    = false;
  122. static bool    audio_driver_stopped = true;
  123. audio_config_t audio_config;
  125. #ifndef AUDIO_POWER_CONTROL_PIN_ON_STATE
  126. #    define AUDIO_POWER_CONTROL_PIN_ON_STATE 1
  127. #endif
  129. void audio_driver_initialize(void) {
  130. #ifdef AUDIO_POWER_CONTROL_PIN
  131.     gpio_set_pin_output_push_pull(AUDIO_POWER_CONTROL_PIN);
  132.     gpio_write_pin(AUDIO_POWER_CONTROL_PIN, !AUDIO_POWER_CONTROL_PIN_ON_STATE);
  133. #endif
  134.     audio_driver_initialize_impl();
  135. }
  137. void audio_driver_stop(void) {
  138.     audio_driver_stop_impl();
  139. #ifdef AUDIO_POWER_CONTROL_PIN
  140.     gpio_write_pin(AUDIO_POWER_CONTROL_PIN, !AUDIO_POWER_CONTROL_PIN_ON_STATE);
  141. #endif
  142. }
  144. void audio_driver_start(void) {
  145. #ifdef AUDIO_POWER_CONTROL_PIN
  146.     gpio_write_pin(AUDIO_POWER_CONTROL_PIN, AUDIO_POWER_CONTROL_PIN_ON_STATE);
  147. #endif
  148.     audio_driver_start_impl();
  149. }
  151. void eeconfig_update_audio_current(void) {
  152.     eeconfig_update_audio(&audio_config);
  153. }
  155. void eeconfig_update_audio_default(void) {
  156.     audio_config.valid         = true;
  157.     audio_config.enable        = AUDIO_DEFAULT_ON;
  158.     audio_config.clicky_enable = AUDIO_DEFAULT_CLICKY_ON;
  159.     eeconfig_update_audio(&audio_config);
  160. }
  162. void audio_init(void) {
  163.     if (audio_initialized) {
  164.         return;
  165.     }
  167.     eeconfig_read_audio(&audio_config);
  168.     if (!audio_config.valid) {
  169.         dprintf("audio_init audio_config.valid = 0. Write default values to EEPROM.\n");
  170.         eeconfig_update_audio_default();
  171.     }
  173.     for (uint8_t i = 0; i < AUDIO_TONE_STACKSIZE; i++) {
  174.         tones[i] = (musical_tone_t){.time_started = 0, .pitch = -1.0f, .duration = 0};
  175.     }
  177.     audio_driver_initialize();
  178.     audio_initialized = true;
  180.     stop_all_notes();
  181. #ifndef AUDIO_INIT_DELAY
  182.     audio_startup();
  183. #endif
  184. }
  186. void audio_startup(void) {
  187.     if (audio_config.enable) {
  188.         PLAY_SONG(startup_song);
  189.     }
  191.     last_timestamp = timer_read();
  192. }
  194. void audio_toggle(void) {
  195.     if (audio_config.enable) {
  196.         stop_all_notes();
  197.     }
  198.     audio_config.enable ^= 1;
  199.     eeconfig_update_audio(&audio_config);
  200.     if (audio_config.enable) {
  201.         audio_on_user();
  202.     } else {
  203.         audio_off_user();
  204.     }
  205. }
  207. void audio_on(void) {
  208.     audio_config.enable = 1;
  209.     eeconfig_update_audio(&audio_config);
  210.     audio_on_user();
  211.     PLAY_SONG(audio_on_song);
  212. }
  214. void audio_off(void) {
  215.     PLAY_SONG(audio_off_song);
  216.     audio_off_user();
  217.     wait_ms(100);
  218.     audio_stop_all();
  219.     audio_config.enable = 0;
  220.     eeconfig_update_audio(&audio_config);
  221. }
  223. bool audio_is_on(void) {
  224.     return (audio_config.enable != 0);
  225. }
  227. void audio_stop_all(void) {
  228.     if (audio_driver_stopped) {
  229.         return;
  230.     }
  232.     active_tones = 0;
  234.     audio_driver_stop();
  236.     playing_melody = false;
  237.     playing_note   = false;
  239.     melody_current_note_duration = 0;
  241.     for (uint8_t i = 0; i < AUDIO_TONE_STACKSIZE; i++) {
  242.         tones[i] = (musical_tone_t){.time_started = 0, .pitch = -1.0f, .duration = 0};
  243.     }
  245.     audio_driver_stopped = true;
  246. }
  248. void audio_stop_tone(float pitch) {
  249.     if (pitch < 0.0f) {
  250.         pitch = -1 * pitch;
  251.     }
  253.     if (playing_note) {
  254.         if (!audio_initialized) {
  255.             audio_init();
  256.         }
  257.         bool found = false;
  258.         for (int i = AUDIO_TONE_STACKSIZE - 1; i >= 0; i--) {
  259.             found = (tones[i].pitch == pitch);
  260.             if (found) {
  261.                 for (int j = i; (j < AUDIO_TONE_STACKSIZE - 1); j++) {
  262.                     tones[j] = tones[j + 1];
  263.                 }
  264.                 tones[AUDIO_TONE_STACKSIZE - 1] = (musical_tone_t){.time_started = 0, .pitch = -1.0f, .duration = 0};
  265.                 break;
  266.             }
  267.         }
  268.         if (!found) {
  269.             return;
  270.         }
  272.         state_changed = true;
  273.         active_tones--;
  274.         if (active_tones < 0) active_tones = 0;
  275. #ifdef AUDIO_ENABLE_TONE_MULTIPLEXING
  276.         if (tone_multiplexing_index_shift >= active_tones) {
  277.             tone_multiplexing_index_shift = 0;
  278.         }
  279. #endif
  280.         if (active_tones == 0) {
  281.             audio_driver_stop();
  282.             audio_driver_stopped = true;
  283.             playing_note         = false;
  284.         }
  285.     }
  286. }
  288. void audio_play_note(float pitch, uint16_t duration) {
  289.     if (!audio_config.enable) {
  290.         return;
  291.     }
  293.     if (!audio_initialized) {
  294.         audio_init();
  295.     }
  297.     if (pitch < 0.0f) {
  298.         pitch = -1 * pitch;
  299.     }
  301.     // round-robin: shifting out old tones, keeping only unique ones
  302.     // if the new frequency is already amongst the active tones, shift it to the top of the stack
  303.     bool found = false;
  304.     for (int i = active_tones - 1; i >= 0; i--) {
  305.         found = (tones[i].pitch == pitch);
  306.         if (found) {
  307.             for (int j = i; (j < active_tones - 1); j++) {
  308.                 tones[j]     = tones[j + 1];
  309.                 tones[j + 1] = (musical_tone_t){.time_started = timer_read(), .pitch = pitch, .duration = duration};
  310.             }
  311.             return; // since this frequency played already, the hardware was already started
  312.         }
  313.     }
  315.     // frequency/tone is actually new, so we put it on the top of the stack
  316.     active_tones++;
  317.     if (active_tones > AUDIO_TONE_STACKSIZE) {
  318.         active_tones = AUDIO_TONE_STACKSIZE;
  319.         // shift out the oldest tone to make room
  320.         for (int i = 0; i < active_tones - 1; i++) {
  321.             tones[i] = tones[i + 1];
  322.         }
  323.     }
  324.     state_changed           = true;
  325.     playing_note            = true;
  326.     tones[active_tones - 1] = (musical_tone_t){.time_started = timer_read(), .pitch = pitch, .duration = duration};
  328.     // TODO: needs to be handled per note/tone -> use its timestamp instead?
  329.     voices_timer = timer_read(); // reset to zero, for the effects added by voices.c
  331.     if (audio_driver_stopped) {
  332.         audio_driver_start();
  333.         audio_driver_stopped = false;
  334.     }
  335. }
  337. void audio_play_tone(float pitch) {
  338.     audio_play_note(pitch, 0xffff);
  339. }
  341. void audio_play_melody(float (*np)[][2], uint16_t n_count, bool n_repeat) {
  342.     if (!audio_config.enable) {
  343.         audio_stop_all();
  344.         return;
  345.     }
  347.     if (n_count == 0) {
  348.         return;
  349.     }
  351.     if (!audio_initialized) {
  352.         audio_init();
  353.     }
  355.     // Cancel note if a note is playing
  356.     if (playing_note) audio_stop_all();
  358.     playing_melody = true;
  359.     note_resting   = false;
  361.     notes_pointer = np;
  362.     notes_count   = n_count;
  363.     notes_repeat  = n_repeat;
  365.     current_note = 0; // note in the melody-array/list at note_pointer
  367.     // start first note manually, which also starts the audio_driver
  368.     // all following/remaining notes are played by 'audio_update_state'
  369.     audio_play_note((*notes_pointer)[current_note][0], audio_duration_to_ms((*notes_pointer)[current_note][1]));
  370.     last_timestamp               = timer_read();
  371.     melody_current_note_duration = audio_duration_to_ms((*notes_pointer)[current_note][1]);
  372. }
  374. float click[2][2];
  375. void  audio_play_click(uint16_t delay, float pitch, uint16_t duration) {
  376.     uint16_t duration_tone  = audio_ms_to_duration(duration);
  377.     uint16_t duration_delay = audio_ms_to_duration(delay);
  379.     if (delay <= 0.0f) {
  380.         click[0][0] = pitch;
  381.         click[0][1] = duration_tone;
  382.         click[1][0] = 0.0f;
  383.         click[1][1] = 0.0f;
  384.         audio_play_melody(&click, 1, false);
  385.     } else {
  386.         // first note is a rest/pause
  387.         click[0][0] = 0.0f;
  388.         click[0][1] = duration_delay;
  389.         // second note is the actual click
  390.         click[1][0] = pitch;
  391.         click[1][1] = duration_tone;
  392.         audio_play_melody(&click, 2, false);
  393.     }
  394. }
  396. bool audio_is_playing_note(void) {
  397.     return playing_note;
  398. }
  400. bool audio_is_playing_melody(void) {
  401.     return playing_melody;
  402. }
  404. uint8_t audio_get_number_of_active_tones(void) {
  405.     return active_tones;
  406. }
  408. float audio_get_frequency(uint8_t tone_index) {
  409.     if (tone_index >= active_tones) {
  410.         return 0.0f;
  411.     }
  412.     return tones[active_tones - tone_index - 1].pitch;
  413. }
  415. float audio_get_processed_frequency(uint8_t tone_index) {
  416.     if (tone_index >= active_tones) {
  417.         return 0.0f;
  418.     }
  420.     int8_t index = active_tones - tone_index - 1;
  421.     // new tones are stacked on top (= appended at the end), so the most recent/current is MAX-1
  423. #ifdef AUDIO_ENABLE_TONE_MULTIPLEXING
  424.     index = index - tone_multiplexing_index_shift;
  425.     if (index < 0) // wrap around
  426.         index += active_tones;
  427. #endif
  429.     if (tones[index].pitch <= 0.0f) {
  430.         return 0.0f;
  431.     }
  433.     return voice_envelope(tones[index].pitch);
  434. }
  436. bool audio_update_state(void) {
  437.     if (!playing_note && !playing_melody) {
  438.         return false;
  439.     }
  441.     bool     goto_next_note = false;
  442.     uint16_t current_time   = timer_read();
  444.     if (playing_melody) {
  445.         goto_next_note = timer_elapsed(last_timestamp) >= melody_current_note_duration;
  446.         if (goto_next_note) {
  447.             uint16_t delta         = timer_elapsed(last_timestamp) - melody_current_note_duration;
  448.             last_timestamp         = current_time;
  449.             uint16_t previous_note = current_note;
  450.             current_note++;
  451.             voices_timer = timer_read(); // reset to zero, for the effects added by voices.c
  453.             if (current_note >= notes_count) {
  454.                 if (notes_repeat) {
  455.                     current_note = 0;
  456.                 } else {
  457.                     audio_stop_all();
  458.                     return false;
  459.                 }
  460.             }
  462.             if (!note_resting && (*notes_pointer)[previous_note][0] == (*notes_pointer)[current_note][0]) {
  463.                 note_resting = true;
  465.                 // special handling for successive notes of the same frequency:
  466.                 // insert a short pause to separate them audibly
  467.                 audio_play_note(0.0f, audio_duration_to_ms(2));
  468.                 current_note                 = previous_note;
  469.                 melody_current_note_duration = audio_duration_to_ms(2);
  471.             } else {
  472.                 note_resting = false;
  474.                 // TODO: handle glissando here (or remember previous and current tone)
  475.                 /* there would need to be a freq(here we are) -> freq(next note)
  476.                  * and do slide/glissando in between problem here is to know which
  477.                  * frequency on the stack relates to what other? e.g. a melody starts
  478.                  * tones in a sequence, and stops expiring one, so the most recently
  479.                  * stopped is the starting point for a glissando to the most recently started?
  480.                  * how to detect and preserve this relation?
  481.                  * and what about user input, chords, ...?
  482.                  */
  484.                 // '- delta': Skip forward in the next note's length if we've over shot
  485.                 //            the last, so the overall length of the song is the same
  486.                 uint16_t duration = audio_duration_to_ms((*notes_pointer)[current_note][1]);
  488.                 // Skip forward past any completely missed notes
  489.                 while (delta > duration && current_note < notes_count - 1) {
  490.                     delta -= duration;
  491.                     current_note++;
  492.                     duration = audio_duration_to_ms((*notes_pointer)[current_note][1]);
  493.                 }
  495.                 if (delta < duration) {
  496.                     duration -= delta;
  497.                 } else {
  498.                     // Only way to get here is if it is the last note and
  499.                     // we have completely missed it. Play it for 1ms...
  500.                     duration = 1;
  501.                 }
  503.                 audio_play_note((*notes_pointer)[current_note][0], duration);
  504.                 melody_current_note_duration = duration;
  505.             }
  506.         }
  507.     }
  509.     if (playing_note) {
  510. #ifdef AUDIO_ENABLE_TONE_MULTIPLEXING
  511.         tone_multiplexing_index_shift = (int)(current_time / tone_multiplexing_rate) % MIN(AUDIO_MAX_SIMULTANEOUS_TONES, active_tones);
  512.         goto_next_note                = true;
  513. #endif
  514.         if (vibrato || glissando) {
  515.             // force update on each cycle, since vibrato shifts the frequency slightly
  516.             goto_next_note = true;
  517.         }
  519.         // housekeeping: stop notes that have no playtime left
  520.         for (int i = 0; i < active_tones; i++) {
  521.             if ((tones[i].duration != 0xffff) // indefinitely playing notes, started by 'audio_play_tone'
  522.                 && (tones[i].duration != 0)   // 'uninitialized'
  523.             ) {
  524.                 if (timer_elapsed(tones[i].time_started) >= tones[i].duration) {
  525.                     audio_stop_tone(tones[i].pitch); // also sets 'state_changed=true'
  526.                 }
  527.             }
  528.         }
  529.     }
  531.     // state-changes have a higher priority, always triggering the hardware to update
  532.     if (state_changed) {
  533.         state_changed = false;
  534.         return true;
  535.     }
  537.     return goto_next_note;
  538. }
  540. // Tone-multiplexing functions
  541. #ifdef AUDIO_ENABLE_TONE_MULTIPLEXING
  542. void audio_set_tone_multiplexing_rate(uint16_t rate) {
  543.     tone_multiplexing_rate = rate;
  544. }
  545. void audio_enable_tone_multiplexing(void) {
  546.     tone_multiplexing_rate = AUDIO_TONE_MULTIPLEXING_RATE_DEFAULT;
  547. }
  548. void audio_disable_tone_multiplexing(void) {
  549.     tone_multiplexing_rate = 0;
  550. }
  551. void audio_increase_tone_multiplexing_rate(uint16_t change) {
  552.     if ((0xffff - change) > tone_multiplexing_rate) {
  553.         tone_multiplexing_rate += change;
  554.     }
  555. }
  556. void audio_decrease_tone_multiplexing_rate(uint16_t change) {
  557.     if (change <= tone_multiplexing_rate) {
  558.         tone_multiplexing_rate -= change;
  559.     }
  560. }
  561. #endif
  563. // Tempo functions
  565. void audio_set_tempo(uint8_t tempo) {
  566.     if (tempo < 10) note_tempo = 10;
  567.     //  else if (tempo > 250)
  568.     //      note_tempo = 250;
  569.     else
  570.         note_tempo = tempo;
  571. }
  573. void audio_increase_tempo(uint8_t tempo_change) {
  574.     if (tempo_change > 255 - note_tempo)
  575.         note_tempo = 255;
  576.     else
  577.         note_tempo += tempo_change;
  578. }
  580. void audio_decrease_tempo(uint8_t tempo_change) {
  581.     if (tempo_change >= note_tempo - 10)
  582.         note_tempo = 10;
  583.     else
  584.         note_tempo -= tempo_change;
  585. }
  587. /**
  588.  * Converts from units of 1/64ths of a beat to milliseconds.
  589.  *
  590.  * Round-off error is at most 1 millisecond.
  591.  *
  592.  * Conversion will never overflow for duration_bpm <= 699, provided that
  593.  * note_tempo is at least 10. This is quite a long duration, over ten beats.
  594.  *
  595.  * Beware that for duration_bpm > 699, the result may overflow uint16_t range
  596.  * when duration_bpm is large compared to note_tempo:
  597.  *
  598.  *    duration_bpm * 60 * 1000 / (64 * note_tempo) > UINT16_MAX
  599.  *
  600.  *    duration_bpm > (2 * 65535 / 1875) * note_tempo
  601.  *                 = 69.904 * note_tempo.
  602.  */
  603. uint16_t audio_duration_to_ms(uint16_t duration_bpm) {
  604.     return ((uint32_t)duration_bpm * 1875) / ((uint_fast16_t)note_tempo * 2);
  605. }
  607. /**
  608.  * Converts from units of milliseconds to 1/64ths of a beat.
  609.  *
  610.  * Round-off error is at most 1/64th of a beat.
  611.  *
  612.  * This conversion never overflows: since duration_ms <= UINT16_MAX = 65535
  613.  * and note_tempo <= 255, the result is always in uint16_t range:
  614.  *
  615.  *     duration_ms * 64 * note_tempo / 60 / 1000
  616.  *     <= 65535 * 2 * 255 / 1875
  617.  *      = 17825.52
  618.  *     <= UINT16_MAX.
  619.  */
  620. uint16_t audio_ms_to_duration(uint16_t duration_ms) {
  621.     return ((uint32_t)duration_ms * 2 * note_tempo) / 1875;
  622. }
  624. __attribute__((weak)) void audio_on_user(void) {}
  625. __attribute__((weak)) void audio_off_user(void) {}