mlonmcu 0.3.0.dev0__3-none-any.whl

resources/platforms/espidf/micro_speech_esp32devboard/main/kissfft/tools/kiss_fftr.h

@@ -0,0 +1,46 @@
+#ifndef KISS_FTR_H
+#define KISS_FTR_H
+
+#include "kiss_fft.h"
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+    
+/* 
+ 
+ Real optimized version can save about 45% cpu time vs. complex fft of a real seq.
+
+ 
+ 
+ */
+
+typedef struct kiss_fftr_state *kiss_fftr_cfg;
+
+
+kiss_fftr_cfg kiss_fftr_alloc(int nfft,int inverse_fft,void * mem, size_t * lenmem);
+/*
+ nfft must be even
+
+ If you don't care to allocate space, use mem = lenmem = NULL 
+*/
+
+
+void kiss_fftr(kiss_fftr_cfg cfg,const kiss_fft_scalar *timedata,kiss_fft_cpx *freqdata);
+/*
+ input timedata has nfft scalar points
+ output freqdata has nfft/2+1 complex points
+*/
+
+void kiss_fftri(kiss_fftr_cfg cfg,const kiss_fft_cpx *freqdata,kiss_fft_scalar *timedata);
+/*
+ input freqdata has  nfft/2+1 complex points
+ output timedata has nfft scalar points
+*/
+
+#define kiss_fftr_free free
+
+#ifdef __cplusplus
+}
+#endif
+#endif

resources/platforms/espidf/micro_speech_esp32devboard/main/main.cc

@@ -0,0 +1,63 @@
+/*
+ * Copyright (c) 2022 TUM Department of Electrical and Computer Engineering.
+ *
+ * This file is part of MLonMCU.
+ * See https://github.com/tum-ei-eda/mlonmcu.git for further info.
+ *
+ * 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.
+ */
+#include <stdio.h>
+#include <stdint.h>
+#include "sdkconfig.h"
+#include "freertos/FreeRTOS.h"
+#include "freertos/task.h"
+#include "driver/gpio.h"
+#include "esp_system.h"
+#include "esp_timer.h"
+// #include "esp_private/esp_clk.h"
+// #include "esp_spi_flash.h"
+#include "pins.h"
+
+#include "ml_interface.h"
+#include "main_functions.h"
+
+extern "C" void app_main(void)
+{
+    printf("MLonMCU: START\n");
+    gpio_init();
+    uint64_t us_before = esp_timer_get_time();
+    esp_cpu_ccount_t cc_before = esp_cpu_get_ccount();
+    //mlif_run();
+    setup();
+    while (true) {
+        loop();
+    }
+    uint64_t us_after = esp_timer_get_time();
+    uint64_t us_diff = us_after - us_before;
+    esp_cpu_ccount_t cc_after = esp_cpu_get_ccount();
+    // Warning:
+    // 32 bit printf only for newlib nano...
+    printf("Total Time: %u us\n", (uint32_t)us_diff);
+    printf("Total Cycles: %u\n", (uint32_t)(cc_after - cc_before));  // TODO: overflow possible?
+    printf("MLonMCU: STOP\n");
+    // printf("Minimum free heap size: %d bytes\n", esp_get_minimum_free_heap_size());
+    fflush(stdout);
+
+    for (int i = 10; i >= 0; i--) {
+        printf("Restarting in %d seconds...\n", i);
+        vTaskDelay(1000 / portTICK_PERIOD_MS);
+    }
+    printf("Restarting now.\n");
+    fflush(stdout);
+    esp_restart();
+}

resources/platforms/espidf/micro_speech_esp32devboard/main/main_functions.cc

@@ -0,0 +1,204 @@
+/* Copyright 2020 The TensorFlow Authors. All Rights Reserved.
+
+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.
+==============================================================================*/
+
+#include "main_functions.h"
+
+#include "freertos/FreeRTOS.h"
+#include "freertos/task.h"
+#include "audio_provider.h"
+#include "command_responder.h"
+#include "feature_provider.h"
+#include "micro_model_settings.h"
+#include "recognize_commands.h"
+#include "ml_interface.h"
+
+// #include "tvm_wrapper.h"
+// #include "tensorflow/lite/micro/micro_error_reporter.h"
+// #include "tensorflow/lite/micro/micro_interpreter.h"
+// #include "tensorflow/lite/micro/micro_mutable_op_resolver.h"
+// #include "tensorflow/lite/micro/system_setup.h"
+// #include "tensorflow/lite/schema/schema_generated.h"
+
+// Globals, used for compatibility with Arduino-style sketches.
+namespace {
+// tflite::ErrorReporter* error_reporter = nullptr;
+// const tflite::Model* model = nullptr;
+// tflite::MicroInterpreter* interpreter = nullptr;
+// TfLiteTensor* model_input = nullptr;
+FeatureProvider* feature_provider = nullptr;
+RecognizeCommands* recognizer = nullptr;
+int32_t previous_time = 0;
+
+// Create an area of memory to use for input, output, and intermediate arrays.
+// The size of this will depend on the model you're using, and may need to be
+// determined by experimentation.
+// constexpr int kTensorArenaSize = 30 * 1024;
+// uint8_t tensor_arena[kTensorArenaSize];
+int8_t feature_buffer[kFeatureElementCount];
+int8_t* model_input_buffer = nullptr;
+}  // namespace
+
+// The name of this function is important for Arduino compatibility.
+void setup() {
+  mlif_init();
+  // Set up logging. Google style is to avoid globals or statics because of
+  // lifetime uncertainty, but since this has a trivial destructor it's okay.
+  // NOLINTNEXTLINE(runtime-global-variables)
+  // static tflite::MicroErrorReporter micro_error_reporter;
+  // error_reporter = &micro_error_reporter;
+
+  // // Map the model into a usable data structure. This doesn't involve any
+  // // copying or parsing, it's a very lightweight operation.
+  // model = tflite::GetModel(g_model);
+  // if (model->version() != TFLITE_SCHEMA_VERSION) {
+  //   TF_LITE_REPORT_ERROR(error_reporter,
+  //                        "Model provided is schema version %d not equal "
+  //                        "to supported version %d.",
+  //                        model->version(), TFLITE_SCHEMA_VERSION);
+  //   return;
+  // }
+
+  // // Pull in only the operation implementations we need.
+  // // This relies on a complete list of all the ops needed by this graph.
+  // // An easier approach is to just use the AllOpsResolver, but this will
+  // // incur some penalty in code space for op implementations that are not
+  // // needed by this graph.
+  // //
+  // // tflite::AllOpsResolver resolver;
+  // // NOLINTNEXTLINE(runtime-global-variables)
+  // static tflite::MicroMutableOpResolver<4> micro_op_resolver(error_reporter);
+  // if (micro_op_resolver.AddDepthwiseConv2D() != kTfLiteOk) {
+  //   return;
+  // }
+  // if (micro_op_resolver.AddFullyConnected() != kTfLiteOk) {
+  //   return;
+  // }
+  // if (micro_op_resolver.AddSoftmax() != kTfLiteOk) {
+  //   return;
+  // }
+  // if (micro_op_resolver.AddReshape() != kTfLiteOk) {
+  //   return;
+  // }
+
+  // // Build an interpreter to run the model with.
+  // static tflite::MicroInterpreter static_interpreter(
+  //     model, micro_op_resolver, tensor_arena, kTensorArenaSize, error_reporter);
+  // interpreter = &static_interpreter;
+
+  // // Allocate memory from the tensor_arena for the model's tensors.
+  // TfLiteStatus allocate_status = interpreter->AllocateTensors();
+  // if (allocate_status != kTfLiteOk) {
+  //   TF_LITE_REPORT_ERROR(error_reporter, "AllocateTensors() failed");
+  //   return;
+  // }
+
+  // // Get information about the memory area to use for the model's input.
+  // model_input = interpreter->input(0);
+  // if ((model_input->dims->size != 2) || (model_input->dims->data[0] != 1) ||
+  //     (model_input->dims->data[1] !=
+  //      (kFeatureSliceCount * kFeatureSliceSize)) ||
+  //     (model_input->type != kTfLiteInt8)) {
+  //   TF_LITE_REPORT_ERROR(error_reporter,
+  //                        "Bad input tensor parameters in model");
+  //   return;
+  // }
+  // model_input_buffer = model_input->data.int8;
+  model_input_buffer = (int8_t*)mlif_input_ptr(0);
+
+  // Prepare to access the audio spectrograms from a microphone or other source
+  // that will provide the inputs to the neural network.
+  // NOLINTNEXTLINE(runtime-global-variables)
+  static FeatureProvider static_feature_provider(kFeatureElementCount,
+                                                 feature_buffer);
+  feature_provider = &static_feature_provider;
+
+  // static RecognizeCommands static_recognizer(error_reporter);
+  static RecognizeCommands static_recognizer;
+  recognizer = &static_recognizer;
+
+  previous_time = 0;
+}
+
+// The name of this function is important for Arduino compatibility.
+void loop() {
+  // Fetch the spectrogram for the current time.
+  uint32_t start1 = xTaskGetTickCount();
+  const int32_t current_time = LatestAudioTimestamp();
+  int how_many_new_slices = 0;
+  // TfLiteStatus feature_status = feature_provider->PopulateFeatureData(
+  //     error_reporter, previous_time, current_time, &how_many_new_slices);
+  int feature_status = feature_provider->PopulateFeatureData(
+      previous_time, current_time, &how_many_new_slices);
+  // printf("how_many_new_slices=%d\n", how_many_new_slices);
+  if (feature_status != 0) {
+    // TF_LITE_REPORT_ERROR(error_reporter, "Feature generation failed");
+    printf("Feature generation failed\n");
+    return;
+  }
+  // printf("current_time=%ld\n", current_time);
+  previous_time = current_time;
+  // If no new audio samples have been received since last time, don't bother
+  // running the network model.
+  if (how_many_new_slices == 0) {
+    return;
+  }
+  uint32_t end1 = xTaskGetTickCount();
+  // printf("ticks1=%lu\n", end1-start1);
+
+  // Copy feature buffer to input tensor
+  for (int i = 0; i < kFeatureElementCount; i++) {
+    model_input_buffer[i] = feature_buffer[i];
+  }
+
+  // Run the model on the spectrogram input and make sure it succeeds.
+  // TfLiteStatus invoke_status = interpreter->Invoke();
+  // if (invoke_status != kTfLiteOk) {
+  //   TF_LITE_REPORT_ERROR(error_reporter, "Invoke failed");
+  //   return;
+  // }
+  uint32_t start2 = xTaskGetTickCount();
+  mlif_invoke();
+  uint32_t end2 = xTaskGetTickCount();
+  // printf("ticks2=%lu\n", end2-start2);
+
+  // Obtain a pointer to the output tensor
+  // TfLiteTensor* output = interpreter->output(0);
+  int8_t* output_ptr = (int8_t*)mlif_output_ptr(0);
+  printf("%4d, \t%d, \t%4d, \t%4d\n", output_ptr[0]+128, output_ptr[1]+128, output_ptr[2]+128, output_ptr[3]+128);
+  // Determine whether a command was recognized based on the output of inference
+  const char* found_command = nullptr;
+  uint8_t score = 0;
+  bool is_new_command = false;
+  uint32_t start3 = xTaskGetTickCount();
+  // TfLiteStatus process_status = recognizer->ProcessLatestResults(
+  //     output, current_time, &found_command, &score, &is_new_command);
+  int process_status = recognizer->ProcessLatestResults(
+      output_ptr, current_time, &found_command, &score, &is_new_command);
+  if (process_status != 0) {
+    // TF_LITE_REPORT_ERROR(error_reporter,
+    //                      "RecognizeCommands::ProcessLatestResults() failed");
+    printf("RecognizeCommands::ProcessLatestResults() failed\n");
+    return;
+  }
+  // Do something based on the recognized command. The default implementation
+  // just prints to the error console, but you should replace this with your
+  // own function for a real application.
+  // RespondToCommand(error_reporter, current_time, found_command, score,
+  //                  is_new_command);
+  RespondToCommand(current_time, found_command, score,
+                   is_new_command);
+  uint32_t end3 = xTaskGetTickCount();
+  // printf("ticks3=%lu\n", end3-start3);
+}

resources/platforms/espidf/micro_speech_esp32devboard/main/main_functions.h

@@ -0,0 +1,37 @@
+/* Copyright 2019 The TensorFlow Authors. All Rights Reserved.
+
+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.
+==============================================================================*/
+
+#ifndef TENSORFLOW_LITE_MICRO_EXAMPLES_MICRO_SPEECH_MAIN_FUNCTIONS_H_
+#define TENSORFLOW_LITE_MICRO_EXAMPLES_MICRO_SPEECH_MAIN_FUNCTIONS_H_
+
+// Expose a C friendly interface for main functions.
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+// Initializes all data needed for the example. The name is important, and needs
+// to be setup() for Arduino compatibility.
+void setup();
+
+// Runs one iteration of data gathering and inference. This should be called
+// repeatedly from the application code. The name needs to be loop() for Arduino
+// compatibility.
+void loop();
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif  // TENSORFLOW_LITE_MICRO_EXAMPLES_MICRO_SPEECH_MAIN_FUNCTIONS_H_

resources/platforms/espidf/micro_speech_esp32devboard/main/micro_features_generator.cc

@@ -0,0 +1,121 @@
+/* Copyright 2019 The TensorFlow Authors. All Rights Reserved.
+
+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.
+==============================================================================*/
+
+#include "micro_features_generator.h"
+
+#include <cmath>
+#include <stdio.h>
+#include <cstring>
+
+#include "microfrontend/lib/frontend.h"
+#include "microfrontend/lib/frontend_util.h"
+#include "micro_model_settings.h"
+
+// Configure FFT to output 16 bit fixed point.
+#define FIXED_POINT 16
+
+namespace {
+
+FrontendState g_micro_features_state;
+bool g_is_first_time = true;
+
+}  // namespace
+
+// TfLiteStatus InitializeMicroFeatures(tflite::ErrorReporter* error_reporter) {
+int InitializeMicroFeatures() {
+  FrontendConfig config;
+  config.window.size_ms = kFeatureSliceDurationMs;
+  config.window.step_size_ms = kFeatureSliceStrideMs;
+  config.noise_reduction.smoothing_bits = 10;
+  config.filterbank.num_channels = kFeatureSliceSize;
+  config.filterbank.lower_band_limit = 125.0;
+  config.filterbank.upper_band_limit = 7500.0;
+  config.noise_reduction.smoothing_bits = 10;
+  config.noise_reduction.even_smoothing = 0.025;
+  config.noise_reduction.odd_smoothing = 0.06;
+  config.noise_reduction.min_signal_remaining = 0.05;
+  config.pcan_gain_control.enable_pcan = 1;
+  config.pcan_gain_control.strength = 0.95;
+  config.pcan_gain_control.offset = 80.0;
+  config.pcan_gain_control.gain_bits = 21;
+  config.log_scale.enable_log = 1;
+  config.log_scale.scale_shift = 6;
+  if (!FrontendPopulateState(&config, &g_micro_features_state,
+                             kAudioSampleFrequency)) {
+    printf("FrontendPopulateState() failed\n");
+    return -1;
+  }
+  g_is_first_time = true;
+  return 0;
+}
+
+// This is not exposed in any header, and is only used for testing, to ensure
+// that the state is correctly set up before generating results.
+void SetMicroFeaturesNoiseEstimates(const uint32_t* estimate_presets) {
+  for (int i = 0; i < g_micro_features_state.filterbank.num_channels; ++i) {
+    g_micro_features_state.noise_reduction.estimate[i] = estimate_presets[i];
+  }
+}
+
+// TfLiteStatus GenerateMicroFeatures(tflite::ErrorReporter* error_reporter,
+//                                    const int16_t* input, int input_size,
+//                                    int output_size, int8_t* output,
+//                                    size_t* num_samples_read) {
+int GenerateMicroFeatures(const int16_t* input, int input_size,
+                                   int output_size, int8_t* output,
+                                   size_t* num_samples_read) {
+  const int16_t* frontend_input;
+  if (g_is_first_time) {
+    frontend_input = input;
+    g_is_first_time = false;
+  } else {
+    frontend_input = input + 160;
+  }
+  FrontendOutput frontend_output = FrontendProcessSamples(
+      &g_micro_features_state, frontend_input, input_size, num_samples_read);
+
+  for (size_t i = 0; i < frontend_output.size; ++i) {
+    // These scaling values are derived from those used in input_data.py in the
+    // training pipeline.
+    // The feature pipeline outputs 16-bit signed integers in roughly a 0 to 670
+    // range. In training, these are then arbitrarily divided by 25.6 to get
+    // float values in the rough range of 0.0 to 26.0. This scaling is performed
+    // for historical reasons, to match up with the output of other feature
+    // generators.
+    // The process is then further complicated when we quantize the model. This
+    // means we have to scale the 0.0 to 26.0 real values to the -128 to 127
+    // signed integer numbers.
+    // All this means that to get matching values from our integer feature
+    // output into the tensor input, we have to perform:
+    // input = (((feature / 25.6) / 26.0) * 256) - 128
+    // To simplify this and perform it in 32-bit integer math, we rearrange to:
+    // input = (feature * 256) / (25.6 * 26.0) - 128
+    constexpr int32_t value_scale = 256;
+    constexpr int32_t value_div = static_cast<int32_t>((25.6f * 26.0f) + 0.5f);
+    int32_t value =
+        ((frontend_output.values[i] * value_scale) + (value_div / 2)) /
+        value_div;
+    value -= 128;
+    if (value < -128) {
+      value = -128;
+    }
+    if (value > 127) {
+      value = 127;
+    }
+    output[i] = value;
+  }
+
+  return 0;
+}

resources/platforms/espidf/micro_speech_esp32devboard/main/micro_features_generator.h

@@ -0,0 +1,38 @@
+/* Copyright 2019 The TensorFlow Authors. All Rights Reserved.
+
+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.
+==============================================================================*/
+
+#ifndef TENSORFLOW_LITE_MICRO_EXAMPLES_MICRO_SPEECH_MICRO_FEATURES_MICRO_FEATURES_GENERATOR_H_
+#define TENSORFLOW_LITE_MICRO_EXAMPLES_MICRO_SPEECH_MICRO_FEATURES_MICRO_FEATURES_GENERATOR_H_
+
+#include <stdint.h>
+#include <stddef.h>
+// #include "tensorflow/lite/c/common.h"
+// #include "tensorflow/lite/micro/micro_error_reporter.h"
+
+// Sets up any resources needed for the feature generation pipeline.
+// TfLiteStatus InitializeMicroFeatures(tflite::ErrorReporter* error_reporter);
+int InitializeMicroFeatures();
+
+// Converts audio sample data into a more compact form that's appropriate for
+// feeding into a neural network.
+// TfLiteStatus GenerateMicroFeatures(tflite::ErrorReporter* error_reporter,
+//                                    const int16_t* input, int input_size,
+//                                    int output_size, int8_t* output,
+//                                    size_t* num_samples_read);
+int GenerateMicroFeatures(const int16_t* input, int input_size,
+                                   int output_size, int8_t* output,
+                                   size_t* num_samples_read);
+
+#endif  // TENSORFLOW_LITE_MICRO_EXAMPLES_MICRO_SPEECH_MICRO_FEATURES_MICRO_FEATURES_GENERATOR_H_

resources/platforms/espidf/micro_speech_esp32devboard/main/micro_model_settings.cc

@@ -0,0 +1,23 @@
+/* Copyright 2018 The TensorFlow Authors. All Rights Reserved.
+
+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.
+==============================================================================*/
+
+#include "micro_model_settings.h"
+
+const char* kCategoryLabels[kCategoryCount] = {
+    "silence",
+    "unknown",
+    "up", // TODO: make this variable/generic
+    "down",
+};

resources/platforms/espidf/micro_speech_esp32devboard/main/micro_model_settings.h

@@ -0,0 +1,43 @@
+/* Copyright 2020 The TensorFlow Authors. All Rights Reserved.
+
+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.
+==============================================================================*/
+
+#ifndef TENSORFLOW_LITE_MICRO_EXAMPLES_MICRO_SPEECH_MICRO_FEATURES_MICRO_MODEL_SETTINGS_H_
+#define TENSORFLOW_LITE_MICRO_EXAMPLES_MICRO_SPEECH_MICRO_FEATURES_MICRO_MODEL_SETTINGS_H_
+
+// Keeping these as constant expressions allow us to allocate fixed-sized arrays
+// on the stack for our working memory.
+
+// The size of the input time series data we pass to the FFT to produce the
+// frequency information. This has to be a power of two, and since we're dealing
+// with 30ms of 16KHz inputs, which means 480 samples, this is the next value.
+constexpr int kMaxAudioSampleSize = 512;
+constexpr int kAudioSampleFrequency = 16000;
+
+// The following values are derived from values used during model training.
+// If you change the way you preprocess the input, update all these constants.
+constexpr int kFeatureSliceSize = 40;
+constexpr int kFeatureSliceCount = 49;
+constexpr int kFeatureElementCount = (kFeatureSliceSize * kFeatureSliceCount);
+constexpr int kFeatureSliceStrideMs = 20;
+constexpr int kFeatureSliceDurationMs = 30;
+
+// Variables for the model's output categories.
+constexpr int kSilenceIndex = 0;
+constexpr int kUnknownIndex = 1;
+// If you modify the output categories, you need to update the following values.
+constexpr int kCategoryCount = 4;
+extern const char* kCategoryLabels[kCategoryCount];
+
+#endif  // TENSORFLOW_LITE_MICRO_EXAMPLES_MICRO_SPEECH_MICRO_FEATURES_MICRO_MODEL_SETTINGS_H_

resources/platforms/espidf/micro_speech_esp32devboard/main/microfrontend/lib/bits.h

@@ -0,0 +1,102 @@
+/* Copyright 2018 The TensorFlow Authors. All Rights Reserved.
+
+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.
+==============================================================================*/
+#ifndef TENSORFLOW_LITE_EXPERIMENTAL_MICROFRONTEND_LIB_BITS_H_
+#define TENSORFLOW_LITE_EXPERIMENTAL_MICROFRONTEND_LIB_BITS_H_
+
+#ifdef __cplusplus
+#include <cstdint>
+
+extern "C" {
+#endif
+
+static inline int CountLeadingZeros32Slow(uint64_t n) {
+  int zeroes = 28;
+  if (n >> 16) zeroes -= 16, n >>= 16;
+  if (n >> 8) zeroes -= 8, n >>= 8;
+  if (n >> 4) zeroes -= 4, n >>= 4;
+  return "\4\3\2\2\1\1\1\1\0\0\0\0\0\0\0"[n] + zeroes;
+}
+
+static inline int CountLeadingZeros32(uint32_t n) {
+#if defined(_MSC_VER)
+  unsigned long result = 0;  // NOLINT(runtime/int)
+  if (_BitScanReverse(&result, n)) {
+    return 31 - result;
+  }
+  return 32;
+#elif defined(__GNUC__)
+
+  // Handle 0 as a special case because __builtin_clz(0) is undefined.
+  if (n == 0) {
+    return 32;
+  }
+  return __builtin_clz(n);
+#else
+  return CountLeadingZeros32Slow(n);
+#endif
+}
+
+static inline int MostSignificantBit32(uint32_t n) {
+  return 32 - CountLeadingZeros32(n);
+}
+
+static inline int CountLeadingZeros64Slow(uint64_t n) {
+  int zeroes = 60;
+  if (n >> 32) zeroes -= 32, n >>= 32;
+  if (n >> 16) zeroes -= 16, n >>= 16;
+  if (n >> 8) zeroes -= 8, n >>= 8;
+  if (n >> 4) zeroes -= 4, n >>= 4;
+  return "\4\3\2\2\1\1\1\1\0\0\0\0\0\0\0"[n] + zeroes;
+}
+
+static inline int CountLeadingZeros64(uint64_t n) {
+#if defined(_MSC_VER) && defined(_M_X64)
+  // MSVC does not have __builtin_clzll. Use _BitScanReverse64.
+  unsigned long result = 0;  // NOLINT(runtime/int)
+  if (_BitScanReverse64(&result, n)) {
+    return 63 - result;
+  }
+  return 64;
+#elif defined(_MSC_VER)
+  // MSVC does not have __builtin_clzll. Compose two calls to _BitScanReverse
+  unsigned long result = 0;  // NOLINT(runtime/int)
+  if ((n >> 32) && _BitScanReverse(&result, n >> 32)) {
+    return 31 - result;
+  }
+  if (_BitScanReverse(&result, n)) {
+    return 63 - result;
+  }
+  return 64;
+#elif defined(__GNUC__)
+
+  // Handle 0 as a special case because __builtin_clzll(0) is undefined.
+  if (n == 0) {
+    return 64;
+  }
+  return __builtin_clzll(n);
+#else
+  return CountLeadingZeros64Slow(n);
+#endif
+}
+
+static inline int MostSignificantBit64(uint64_t n) {
+  return 64 - CountLeadingZeros64(n);
+}
+
+#ifdef __cplusplus
+}  // extern "C"
+#endif
+
+#endif  // TENSORFLOW_LITE_EXPERIMENTAL_MICROFRONTEND_LIB_BITS_H_