Merge branch 'ci/sync_gh_tflite-lib' into 'master'

Update tflite-lib (synced from github) - 562024

See merge request app-frameworks/tflite-micro-esp-examples!107

components/tflite-lib/CMakeLists.txt

@@ -65,7 +65,6 @@ set(lib_srcs
           "${tflite_dir}/core/c/common.cc"
           "${tflite_dir}/core/api/error_reporter.cc"
           "${tflite_dir}/core/api/flatbuffer_conversions.cc"
-          "${tflite_dir}/core/api/op_resolver.cc"
           "${tflite_dir}/core/api/tensor_utils.cc"
           "${tflite_dir}/kernels/internal/common.cc"
           "${tflite_dir}/kernels/internal/quantization_util.cc"

components/tflite-lib/signal/micro/kernels/delay.cc

@@ -0,0 +1,154 @@
+/* Copyright 2021 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 <stdint.h>
+
+#include "signal/src/circular_buffer.h"
+#include "tensorflow/lite/kernels/internal/tensor_ctypes.h"
+#include "tensorflow/lite/kernels/kernel_util.h"
+#include "tensorflow/lite/micro/flatbuffer_utils.h"
+#include "tensorflow/lite/micro/kernels/kernel_util.h"
+#include "tensorflow/lite/micro/memory_helpers.h"
+#include "tensorflow/lite/micro/micro_context.h"
+#include "tensorflow/lite/micro/micro_utils.h"
+
+namespace tflite {
+namespace {
+
+constexpr int kInputTensor = 0;
+constexpr int kOutputTensor = 0;
+
+// Indices into the init flexbuffer's vector.
+// The parameter's name is in the comment that follows.
+// Elements in the vectors are ordered alphabetically by parameter name.
+constexpr int kDelayLengthIndex = 0;  // 'delay_length'
+
+struct TFLMSignalFrontendDelayParams {
+  int32_t frame_size;
+  int32_t delay_length;
+  int32_t outer_dims;
+
+  int8_t** state_buffers;
+  tflm_signal::CircularBuffer** circular_buffers;
+};
+
+void* Init(TfLiteContext* context, const char* buffer, size_t length) {
+  auto* params = static_cast<TFLMSignalFrontendDelayParams*>(
+      context->AllocatePersistentBuffer(context,
+                                        sizeof(TFLMSignalFrontendDelayParams)));
+
+  if (params == nullptr) {
+    return nullptr;
+  }
+
+  FlexbufferWrapper fbw(reinterpret_cast<const uint8_t*>(buffer), length);
+  params->delay_length = fbw.ElementAsInt32(kDelayLengthIndex);
+  return params;
+}
+
+TfLiteStatus Prepare(TfLiteContext* context, TfLiteNode* node) {
+  TF_LITE_ENSURE_EQ(context, NumInputs(node), 1);
+  TF_LITE_ENSURE_EQ(context, NumOutputs(node), 1);
+
+  MicroContext* micro_context = GetMicroContext(context);
+  TfLiteTensor* input =
+      micro_context->AllocateTempInputTensor(node, kInputTensor);
+  TF_LITE_ENSURE(context, input != nullptr);
+  TfLiteTensor* output =
+      micro_context->AllocateTempOutputTensor(node, kOutputTensor);
+  TF_LITE_ENSURE(context, output != nullptr);
+
+  TF_LITE_ENSURE_TYPES_EQ(context, input->type, kTfLiteInt16);
+  TF_LITE_ENSURE_TYPES_EQ(context, output->type, kTfLiteInt16);
+
+  auto* params =
+      reinterpret_cast<TFLMSignalFrontendDelayParams*>(node->user_data);
+
+  TF_LITE_ENSURE(context, params != nullptr);
+
+  RuntimeShape input_shape = GetTensorShape(input);
+  int innermost_dim = input_shape.Dims(input_shape.DimensionsCount() - 1);
+  params->outer_dims = input_shape.FlatSize() / innermost_dim;
+  params->frame_size = innermost_dim;
+
+  params->state_buffers =
+      static_cast<int8_t**>(context->AllocatePersistentBuffer(
+          context, params->outer_dims * sizeof(int8_t*)));
+  params->circular_buffers = static_cast<tflm_signal::CircularBuffer**>(
+      context->AllocatePersistentBuffer(
+          context, params->outer_dims * sizeof(tflm_signal::CircularBuffer*)));
+
+  for (int i = 0; i < params->outer_dims; i++) {
+    size_t capacity = params->frame_size + params->delay_length;
+
+    size_t state_size = tflm_signal::CircularBufferGetNeededMemory(capacity);
+    params->state_buffers[i] =
+        static_cast<int8_t*>(context->AllocatePersistentBuffer(
+            context, state_size * sizeof(int8_t)));
+    params->circular_buffers[i] = tflm_signal::CircularBufferInit(
+        capacity, params->state_buffers[i], state_size);
+    tflm_signal::CircularBufferWriteZeros(params->circular_buffers[i],
+                                          params->delay_length);
+  }
+
+  micro_context->DeallocateTempTfLiteTensor(input);
+  micro_context->DeallocateTempTfLiteTensor(output);
+  return kTfLiteOk;
+}
+
+TfLiteStatus Eval(TfLiteContext* context, TfLiteNode* node) {
+  auto* params =
+      reinterpret_cast<TFLMSignalFrontendDelayParams*>(node->user_data);
+  const TfLiteEvalTensor* input =
+      micro::GetEvalInput(context, node, kInputTensor);
+  TfLiteEvalTensor* output = micro::GetEvalOutput(context, node, kOutputTensor);
+
+  const int16_t* input_data = micro::GetTensorData<int16_t>(input);
+  int16_t* output_data = micro::GetTensorData<int16_t>(output);
+
+  for (int dim_index = 0, sample_index = 0; dim_index < params->outer_dims;
+       dim_index++, sample_index += params->frame_size) {
+    tflm_signal::CircularBufferWrite(params->circular_buffers[dim_index],
+                                     &input_data[sample_index],
+                                     params->frame_size);
+    tflm_signal::CircularBufferGet(params->circular_buffers[dim_index],
+                                   params->frame_size,
+                                   &output_data[sample_index]);
+    tflm_signal::CircularBufferDiscard(params->circular_buffers[dim_index],
+                                       params->frame_size);
+  }
+  return kTfLiteOk;
+}
+
+void Reset(TfLiteContext* context, void* buffer) {
+  auto* params = static_cast<TFLMSignalFrontendDelayParams*>(buffer);
+  for (int i = 0; i < params->outer_dims; ++i) {
+    tflm_signal::CircularBufferReset(params->circular_buffers[i]);
+    tflm_signal::CircularBufferWriteZeros(params->circular_buffers[i],
+                                          params->delay_length);
+  }
+}
+
+}  // namespace
+
+namespace tflm_signal {
+TFLMRegistration* Register_DELAY() {
+  static TFLMRegistration r =
+      micro::RegisterOp(Init, Prepare, Eval, nullptr, Reset);
+  return &r;
+}
+}  // namespace tflm_signal
+
+}  // namespace tflite

components/tflite-lib/signal/micro/kernels/delay_flexbuffers_generated_data.h

@@ -0,0 +1,25 @@
+/* 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 SIGNAL_MICRO_KERNELS_DELAY_FLEXBUFFERS_GENERATED_DATA_H_
+#define SIGNAL_MICRO_KERNELS_DELAY_FLEXBUFFERS_GENERATED_DATA_H_
+
+extern const int g_gen_data_size_3_delay;
+extern const unsigned char g_gen_data_3_delay[];
+
+extern const int g_gen_data_size_5_delay;
+extern const unsigned char g_gen_data_5_delay[];
+
+#endif  // SIGNAL_MICRO_KERNELS_DELAY_FLEXBUFFERS_GENERATED_DATA_H_

components/tflite-lib/signal/micro/kernels/energy.cc

@@ -0,0 +1,112 @@
+/* Copyright 2021 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 "signal/src/energy.h"
+
+#include <math.h>
+#include <stddef.h>
+#include <stdint.h>
+
+#include "tensorflow/lite/kernels/internal/tensor_ctypes.h"
+#include "tensorflow/lite/kernels/kernel_util.h"
+#include "tensorflow/lite/micro/flatbuffer_utils.h"
+#include "tensorflow/lite/micro/kernels/kernel_util.h"
+#include "tensorflow/lite/micro/micro_context.h"
+
+namespace tflite {
+namespace {
+
+constexpr int kInputTensor = 0;
+constexpr int kOutputTensor = 0;
+
+// Indices into the init flexbuffer's vector.
+// The parameter's name is in the comment that follows.
+// Elements in the vectors are ordered alphabetically by parameter name.
+constexpr int kEndIndexIndex = 0;    // 'end_index'
+constexpr int kStartIndexIndex = 1;  // 'start_index'
+
+struct TFLMSignalEnergyParams {
+  int32_t end_index;
+  int32_t start_index;
+};
+
+void* Init(TfLiteContext* context, const char* buffer, size_t length) {
+  TFLITE_DCHECK(context->AllocatePersistentBuffer != nullptr);
+
+  auto* data =
+      static_cast<TFLMSignalEnergyParams*>(context->AllocatePersistentBuffer(
+          context, sizeof(TFLMSignalEnergyParams)));
+
+  if (data == nullptr) {
+    return nullptr;
+  }
+
+  tflite::FlexbufferWrapper fbw(reinterpret_cast<const uint8_t*>(buffer),
+                                length);
+  data->end_index = fbw.ElementAsInt32(kEndIndexIndex);
+  data->start_index = fbw.ElementAsInt32(kStartIndexIndex);
+  return data;
+}
+
+TfLiteStatus Prepare(TfLiteContext* context, TfLiteNode* node) {
+  TF_LITE_ENSURE_EQ(context, NumInputs(node), 1);
+  TF_LITE_ENSURE_EQ(context, NumOutputs(node), 1);
+
+  MicroContext* micro_context = GetMicroContext(context);
+  TfLiteTensor* input =
+      micro_context->AllocateTempInputTensor(node, kInputTensor);
+  TF_LITE_ENSURE(context, input != nullptr);
+  TfLiteTensor* output =
+      micro_context->AllocateTempOutputTensor(node, kOutputTensor);
+  TF_LITE_ENSURE(context, output != nullptr);
+
+  TF_LITE_ENSURE_EQ(context, NumDimensions(input), 1);
+  TF_LITE_ENSURE_EQ(context, NumDimensions(output), 1);
+
+  TF_LITE_ENSURE_TYPES_EQ(context, input->type, kTfLiteInt16);
+  TF_LITE_ENSURE_TYPES_EQ(context, output->type, kTfLiteUInt32);
+
+  micro_context->DeallocateTempTfLiteTensor(input);
+  micro_context->DeallocateTempTfLiteTensor(output);
+  return kTfLiteOk;
+}
+
+TfLiteStatus Eval(TfLiteContext* context, TfLiteNode* node) {
+  auto* params = reinterpret_cast<TFLMSignalEnergyParams*>(node->user_data);
+
+  const TfLiteEvalTensor* input =
+      tflite::micro::GetEvalInput(context, node, kInputTensor);
+  TfLiteEvalTensor* output =
+      tflite::micro::GetEvalOutput(context, node, kOutputTensor);
+
+  const Complex<int16_t>* input_data =
+      tflite::micro::GetTensorData<Complex<int16_t>>(input);
+  uint32_t* output_data = tflite::micro::GetTensorData<uint32_t>(output);
+
+  tflm_signal::SpectrumToEnergy(input_data, params->start_index,
+                                params->end_index, output_data);
+  return kTfLiteOk;
+}
+
+}  // namespace
+
+namespace tflm_signal {
+TFLMRegistration* Register_ENERGY() {
+  static TFLMRegistration r = tflite::micro::RegisterOp(Init, Prepare, Eval);
+  return &r;
+}
+}  // namespace tflm_signal
+
+}  // namespace tflite

components/tflite-lib/signal/micro/kernels/energy_flexbuffers_generated_data.h

@@ -0,0 +1,28 @@
+/* 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 SIGNAL_MICRO_KERNELS_TEST_DATA_GENERATION_GENERATE_ENERGY_FLEXBUFFERS_DATA_H_
+#define SIGNAL_MICRO_KERNELS_TEST_DATA_GENERATION_GENERATE_ENERGY_FLEXBUFFERS_DATA_H_
+
+extern const int g_gen_data_size_start_index_2_end_index_4;
+extern const unsigned char g_gen_data_start_index_2_end_index_4[];
+
+extern const int g_gen_data_size_start_index_0_end_index_4;
+extern const unsigned char g_gen_data_start_index_0_end_index_4[];
+
+extern const int g_gen_data_size_start_index_4_end_index_8;
+extern const unsigned char g_gen_data_start_index_4_end_index_8[];
+
+#endif  // SIGNAL_MICRO_KERNELS_TEST_DATA_GENERATION_GENERATE_ENERGY_FLEXBUFFERS_DATA_H_