| /* | |
| * Copyright 2023 Google LLC | |
| * | |
| * Licensed under the Apache License, Version 2.0 (the "License"); | |
| * you may not use this file except in compliance with the License. | |
| * You may obtain a copy of the License at | |
| * | |
| * http://www.apache.org/licenses/LICENSE-2.0 | |
| * | |
| * Unless required by applicable law or agreed to in writing, software | |
| * distributed under the License is distributed on an "AS IS" BASIS, | |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. | |
| * See the License for the specific language governing permissions and | |
| * limitations under the License. | |
| */ | |
| // Data structures that hold audio samples are allocated on the heap | |
| // because they are too big (for now) for .data/.bss. We use calloc | |
| // for this and need to override the default quota (4K) to satisfy our | |
| // large'ish requests. | |
| //#define kSamples (5 * 16000) | |
| #define kSamples (5000) // NB: reduced sample count for slow renode | |
| #define kFilterSamples (256) | |
| #define roundup(a, b) (((a) + (b) - 1) / (b)) * (b) | |
| #define MALLOC_QUOTA \ | |
| roundup( \ | |
| (kSamples * sizeof(int32_t)) + 2 * (kFilterSamples * sizeof(int16_t)), \ | |
| 4096) | |
| #include "soundstream.h" | |
| #include <fail-simulator-on-error.h> | |
| #include <thread.h> | |
| #include <debug.hh> | |
| #include "hw/top_matcha/sw/autogen/top_matcha.h" | |
| /// Expose debugging features unconditionally for this compartment. | |
| using Debug = ConditionalDebug<true, "SOUNDSTREAM">; | |
| #include "compat.h" | |
| #define ABS(x) (x > 0 ? x : -x) | |
| void __cheri_compartment("soundstream") entry(void) { | |
| Debug::log("soundstream (Thread {})", thread_id_get()); | |
| i2s_init(); | |
| ml_top_init(); | |
| mailbox_init(); | |
| i2s_rxfifo_clear(); | |
| i2s_irq_acknowledge_all(); | |
| i2s_irq_set_enabled(kI2sIrqRxWatermark, /*enabled=*/true); | |
| // NB: sample buffers are temporarily allocated from the heap because | |
| // the toolchain does not support large'ish data structures. Support | |
| // has been committed upstream but not yet brought in. | |
| // XXX calloc returns 0xffffffff (v:0 0xfffffe00-0xfffffe00 l:0x0 o:0x0 p: - | |
| // ------ -- ---) on failure so cannot check against NULL | |
| // int16_t samples_left[kFilterSamples] = {0}; | |
| // int16_t samples_right[kFilterSamples] = {0}; | |
| int16_t* samples_left = (int16_t*)calloc(sizeof(int16_t), kFilterSamples); | |
| Debug::Assert(__builtin_cheri_length_get(samples_left) > 0, | |
| "samples_left allocation failed {}", samples_left); | |
| int16_t* samples_right = (int16_t*)calloc(sizeof(int16_t), kFilterSamples); | |
| Debug::Assert(__builtin_cheri_length_get(samples_right) > 0, | |
| "samples_right allocation failed {}", samples_right); | |
| size_t index_left = 0; | |
| size_t index_right = 0; | |
| int32_t total_left = 0; | |
| int32_t total_right = 0; | |
| // static int32_t samples[kSamples]; | |
| int32_t* samples = (int32_t*)calloc(sizeof(int32_t), kSamples); | |
| Debug::Assert(__builtin_cheri_length_get(samples) > 0, | |
| "Sample allocation failed {}", samples); | |
| memset(samples, 0xa5, sizeof(int32_t) * kSamples); | |
| Debug::log("Setup complete"); | |
| while (true) { | |
| // TODO(sleffler): need custom security core code running and | |
| // a way to toggle the gpio associated with the button; for now | |
| // just force it to appear as though the button has been pressed. | |
| mailbox_set_button_pressed(true); | |
| // Wait until the record switch is pushed | |
| Debug::log("Wait for button press..."); | |
| while (!mailbox_button_pressed()) { | |
| wait_for_interrupt(); | |
| } | |
| mailbox_set_led(/*enabled=*/true); | |
| Debug::log("Start recording (max {} samples)...", kSamples); | |
| i2s_record_begin(); | |
| // Record until our buffer is full or the switch is released. | |
| int sample = 0; | |
| while (sample < kSamples && mailbox_button_pressed()) { | |
| i2s_irq_set_enabled(kI2sIrqRxWatermark, /*enabled=*/true); | |
| while (!i2s_rx_watermark_seen()) { | |
| wait_for_interrupt(); | |
| } | |
| while (!i2s_rxfifo_is_empty()) { | |
| uint32_t reg_val = i2s_get_rdata(); | |
| // For each sample, split into left and right channel values, | |
| // and update the moving average. | |
| int16_t left = reg_val >> 16; | |
| int16_t right = reg_val & 0xFFFF; | |
| total_left -= samples_left[index_left]; | |
| total_right -= samples_right[index_right]; | |
| total_left += left; | |
| samples_left[index_left] = left; | |
| total_right += right; | |
| samples_right[index_right] = right; | |
| index_left = (index_left + 1) % kFilterSamples; | |
| index_right = (index_right + 1) % kFilterSamples; | |
| int16_t mean_left = total_left / kFilterSamples; | |
| int16_t mean_right = total_right / kFilterSamples; | |
| // Subtract the moving average from each channel, and repack into the | |
| // sample buffer. | |
| uint32_t offset_reg_val = (((left - mean_left) & 0xFFFF) << 16) | | |
| ((right - mean_right) & 0xFFFF); | |
| samples[sample++] = offset_reg_val; | |
| if (sample == kSamples || !mailbox_button_pressed()) { | |
| break; | |
| } | |
| } | |
| } | |
| i2s_record_end(); | |
| mailbox_set_led(/*enabled=*/false); | |
| Debug::log("Done recording {} samples", sample); | |
| int samples_captured = sample; | |
| // Calculate the min/max of the audio, after correcting DC offsets | |
| int32_t max = INT16_MIN; | |
| int32_t min = INT16_MAX; | |
| for (int i = 1; i < (samples_captured * 2); i += 2) { | |
| int16_t* samples_s16 = (int16_t*)samples; | |
| int32_t sample = samples_s16[i]; | |
| if (sample < min) { | |
| min = sample; | |
| } | |
| if (sample > max) { | |
| max = sample; | |
| } | |
| } | |
| // Calculate a scaling factor, and use this to scale the waveform | |
| // to a peak of 75% amplitude. | |
| int32_t scale_max = ((int32_t)max * 100) / ((int32_t)INT16_MAX); | |
| int32_t scale_min = ABS(((int32_t)min * 100) / ((int32_t)INT16_MIN)); | |
| int32_t scale = scale_max > scale_min ? scale_max : scale_min; | |
| for (int i = 1; i < (samples_captured * 2); i += 2) { | |
| int16_t* samples_s16 = (int16_t*)samples; | |
| int16_t sample = samples_s16[i]; | |
| int16_t scaled_sample = (int16_t)(((int32_t)sample * 100) / scale); | |
| scaled_sample = (((int32_t)scaled_sample * 75) / 100); | |
| samples_s16[i] = scaled_sample; | |
| } | |
| Debug::log("Processing recorded audio..."); | |
| // 320 x int16 | |
| int iterations_to_process = samples_captured / 320; | |
| int16_t process_buffer[320]; | |
| int16_t result_buffer[64]; | |
| char result_buffer_encoded[ENCODE_OUT_SIZE(sizeof(result_buffer))]; | |
| struct output_header header; | |
| memset(&header, 0, sizeof(header)); // NB: resume_pc = 0 | |
| for (int i = 0; i < iterations_to_process; ++i) { | |
| Debug::log("Iteration {}", i); | |
| int16_t* samples_s16 = (int16_t*)samples; | |
| // Extract left channel audio | |
| for (int j = 0; j < 320; ++j) { | |
| process_buffer[j] = samples_s16[(i * 320 * 2) + (j * 2) + 1]; | |
| } | |
| ml_top_set_input(process_buffer, sizeof(process_buffer)); | |
| // Start/resume kelvin | |
| (void) ml_top_finish_done(); // NB: reset state | |
| ml_top_resume_ctrl_en(header.resume_pc); | |
| // wfi | |
| while (!ml_top_finish_done()) { | |
| wait_for_interrupt(); | |
| } | |
| ml_top_get_output_header(&header); | |
| CHECK(header.length == sizeof(result_buffer), "Unexpected ML result size"); | |
| ml_top_get_output_data(&header, result_buffer); | |
| encode((const unsigned char*)result_buffer, sizeof(result_buffer), | |
| result_buffer_encoded); | |
| Debug::log("[sound]::ENCODER:{}", | |
| std::string_view(result_buffer_encoded, sizeof(result_buffer_encoded))); | |
| } | |
| Debug::log("[sound]::ENCODER: done"); | |
| Debug::log("Done with processing."); | |
| } | |
| panic(); | |
| } |