Unique Init, Prepare, Eval functions of signal kernels. (#2497) Refactor init, prepare , and eval functions to be unique names for signal/ kernels BUG=b/327655885

diff --git a/signal/micro/kernels/delay.cc b/signal/micro/kernels/delay.cc
index 155e198..33ef35e 100644
--- a/signal/micro/kernels/delay.cc
+++ b/signal/micro/kernels/delay.cc

@@ -44,7 +44,7 @@
   tflm_signal::CircularBuffer** circular_buffers;
 };
 
-void* Init(TfLiteContext* context, const char* buffer, size_t length) {
+void* DelayInit(TfLiteContext* context, const char* buffer, size_t length) {
   auto* params = static_cast<TFLMSignalFrontendDelayParams*>(
       context->AllocatePersistentBuffer(context,
                                         sizeof(TFLMSignalFrontendDelayParams)));
@@ -58,7 +58,7 @@
   return params;
 }
 
-TfLiteStatus Prepare(TfLiteContext* context, TfLiteNode* node) {
+TfLiteStatus DelayPrepare(TfLiteContext* context, TfLiteNode* node) {
   TF_LITE_ENSURE_EQ(context, NumInputs(node), 1);
   TF_LITE_ENSURE_EQ(context, NumOutputs(node), 1);
 
@@ -108,7 +108,7 @@
   return kTfLiteOk;
 }
 
-TfLiteStatus Eval(TfLiteContext* context, TfLiteNode* node) {
+TfLiteStatus DelayEval(TfLiteContext* context, TfLiteNode* node) {
   auto* params =
       reinterpret_cast<TFLMSignalFrontendDelayParams*>(node->user_data);
   const TfLiteEvalTensor* input =
@@ -132,7 +132,7 @@
   return kTfLiteOk;
 }
 
-void Reset(TfLiteContext* context, void* buffer) {
+void DelayReset(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]);
@@ -145,8 +145,8 @@
 
 namespace tflm_signal {
 TFLMRegistration* Register_DELAY() {
-  static TFLMRegistration r =
-      micro::RegisterOp(Init, Prepare, Eval, nullptr, Reset);
+  static TFLMRegistration r = micro::RegisterOp(DelayInit, DelayPrepare,
+                                                DelayEval, nullptr, DelayReset);
   return &r;
 }
 }  // namespace tflm_signal

diff --git a/signal/micro/kernels/energy.cc b/signal/micro/kernels/energy.cc
index fa79bc8..6a86366 100644
--- a/signal/micro/kernels/energy.cc
+++ b/signal/micro/kernels/energy.cc

@@ -42,7 +42,7 @@
   int32_t start_index;
 };
 
-void* Init(TfLiteContext* context, const char* buffer, size_t length) {
+void* EnergyInit(TfLiteContext* context, const char* buffer, size_t length) {
   TFLITE_DCHECK(context->AllocatePersistentBuffer != nullptr);
 
   auto* data =
@@ -60,7 +60,7 @@
   return data;
 }
 
-TfLiteStatus Prepare(TfLiteContext* context, TfLiteNode* node) {
+TfLiteStatus EnergyPrepare(TfLiteContext* context, TfLiteNode* node) {
   TF_LITE_ENSURE_EQ(context, NumInputs(node), 1);
   TF_LITE_ENSURE_EQ(context, NumOutputs(node), 1);
 
@@ -83,7 +83,7 @@
   return kTfLiteOk;
 }
 
-TfLiteStatus Eval(TfLiteContext* context, TfLiteNode* node) {
+TfLiteStatus EnergyEval(TfLiteContext* context, TfLiteNode* node) {
   auto* params = reinterpret_cast<TFLMSignalEnergyParams*>(node->user_data);
 
   const TfLiteEvalTensor* input =
@@ -104,7 +104,8 @@
 
 namespace tflm_signal {
 TFLMRegistration* Register_ENERGY() {
-  static TFLMRegistration r = tflite::micro::RegisterOp(Init, Prepare, Eval);
+  static TFLMRegistration r =
+      tflite::micro::RegisterOp(EnergyInit, EnergyPrepare, EnergyEval);
   return &r;
 }
 }  // namespace tflm_signal

diff --git a/signal/micro/kernels/fft_auto_scale_kernel.cc b/signal/micro/kernels/fft_auto_scale_kernel.cc
index d44bc18..4946fb3 100644
--- a/signal/micro/kernels/fft_auto_scale_kernel.cc
+++ b/signal/micro/kernels/fft_auto_scale_kernel.cc

@@ -32,7 +32,7 @@
 constexpr int kOutputTensor = 0;
 constexpr int kScaleBitTensor = 1;
 
-TfLiteStatus Eval(TfLiteContext* context, TfLiteNode* node) {
+TfLiteStatus FftAutoScaleEval(TfLiteContext* context, TfLiteNode* node) {
   const TfLiteEvalTensor* input =
       tflite::micro::GetEvalInput(context, node, kInputTensor);
   TfLiteEvalTensor* output =
@@ -56,7 +56,7 @@
 
 TFLMRegistration* Register_FFT_AUTO_SCALE() {
   static TFLMRegistration r =
-      tflite::micro::RegisterOp(nullptr, FftAutoScalePrepare, Eval);
+      tflite::micro::RegisterOp(nullptr, FftAutoScalePrepare, FftAutoScaleEval);
   return &r;
 }
 

diff --git a/signal/micro/kernels/filter_bank.cc b/signal/micro/kernels/filter_bank.cc
index 7866ac3..1cf08d2 100644
--- a/signal/micro/kernels/filter_bank.cc
+++ b/signal/micro/kernels/filter_bank.cc

@@ -46,7 +46,8 @@
   uint64_t* work_area;
 };
 
-void* Init(TfLiteContext* context, const char* buffer, size_t length) {
+void* FilterBankInit(TfLiteContext* context, const char* buffer,
+                     size_t length) {
   TFLITE_DCHECK(context->AllocatePersistentBuffer != nullptr);
 
   auto* params = static_cast<TFLMSignalFilterBankParams*>(
@@ -70,7 +71,7 @@
   return params;
 }
 
-TfLiteStatus Prepare(TfLiteContext* context, TfLiteNode* node) {
+TfLiteStatus FilterBankPrepare(TfLiteContext* context, TfLiteNode* node) {
   TF_LITE_ENSURE_EQ(context, NumInputs(node), 6);
   TF_LITE_ENSURE_EQ(context, NumOutputs(node), 1);
 
@@ -122,7 +123,7 @@
   return kTfLiteOk;
 }
 
-TfLiteStatus Eval(TfLiteContext* context, TfLiteNode* node) {
+TfLiteStatus FilterBankEval(TfLiteContext* context, TfLiteNode* node) {
   auto* params = reinterpret_cast<TFLMSignalFilterBankParams*>(node->user_data);
 
   const TfLiteEvalTensor* input0 =
@@ -166,7 +167,8 @@
 namespace tflm_signal {
 
 TFLMRegistration* Register_FILTER_BANK() {
-  static TFLMRegistration r = tflite::micro::RegisterOp(Init, Prepare, Eval);
+  static TFLMRegistration r = tflite::micro::RegisterOp(
+      FilterBankInit, FilterBankPrepare, FilterBankEval);
   return &r;
 }
 

diff --git a/signal/micro/kernels/filter_bank_log.cc b/signal/micro/kernels/filter_bank_log.cc
index ea0cdb7..3d38e61 100644
--- a/signal/micro/kernels/filter_bank_log.cc
+++ b/signal/micro/kernels/filter_bank_log.cc

@@ -42,7 +42,8 @@
   int output_scale;
 };
 
-void* Init(TfLiteContext* context, const char* buffer, size_t length) {
+void* FilterBankLogInit(TfLiteContext* context, const char* buffer,
+                        size_t length) {
   TFLITE_DCHECK(context->AllocatePersistentBuffer != nullptr);
 
   auto* params = static_cast<TFLMSignalLogParams*>(
@@ -59,7 +60,7 @@
   return params;
 }
 
-TfLiteStatus Prepare(TfLiteContext* context, TfLiteNode* node) {
+TfLiteStatus FilterBankLogPrepare(TfLiteContext* context, TfLiteNode* node) {
   TF_LITE_ENSURE_EQ(context, NumInputs(node), 1);
   TF_LITE_ENSURE_EQ(context, NumOutputs(node), 1);
 
@@ -82,7 +83,7 @@
   return kTfLiteOk;
 }
 
-TfLiteStatus Eval(TfLiteContext* context, TfLiteNode* node) {
+TfLiteStatus FilterBankLogEval(TfLiteContext* context, TfLiteNode* node) {
   auto* params = reinterpret_cast<TFLMSignalLogParams*>(node->user_data);
 
   const TfLiteEvalTensor* input =
@@ -103,7 +104,8 @@
 namespace tflm_signal {
 
 TFLMRegistration* Register_FILTER_BANK_LOG() {
-  static TFLMRegistration r = tflite::micro::RegisterOp(Init, Prepare, Eval);
+  static TFLMRegistration r = tflite::micro::RegisterOp(
+      FilterBankLogInit, FilterBankLogPrepare, FilterBankLogEval);
   return &r;
 }
 

diff --git a/signal/micro/kernels/filter_bank_spectral_subtraction.cc b/signal/micro/kernels/filter_bank_spectral_subtraction.cc
index f5ea4d7..e069323 100644
--- a/signal/micro/kernels/filter_bank_spectral_subtraction.cc
+++ b/signal/micro/kernels/filter_bank_spectral_subtraction.cc

@@ -51,12 +51,14 @@
   size_t noise_estimate_size;
 };
 
-void ResetState(TFLMSignalSpectralSubtractionParams* params) {
+void FilterBankSpectralSubtractionResetState(
+    TFLMSignalSpectralSubtractionParams* params) {
   memset(params->noise_estimate, 0,
          sizeof(uint32_t) * params->config.num_channels);
 }
 
-void* Init(TfLiteContext* context, const char* buffer, size_t length) {
+void* FilterBankSpectralSubtractionInit(TfLiteContext* context,
+                                        const char* buffer, size_t length) {
   TFLITE_DCHECK(context->AllocatePersistentBuffer != nullptr);
 
   auto* params = static_cast<TFLMSignalSpectralSubtractionParams*>(
@@ -96,7 +98,8 @@
   return params;
 }
 
-TfLiteStatus Prepare(TfLiteContext* context, TfLiteNode* node) {
+TfLiteStatus FilterBankSpectralSubtractionPrepare(TfLiteContext* context,
+                                                  TfLiteNode* node) {
   TF_LITE_ENSURE_EQ(context, NumInputs(node), 1);
   TF_LITE_ENSURE_EQ(context, NumOutputs(node), 2);
 
@@ -125,7 +128,7 @@
   TfLiteTypeSizeOf(output->type, &params->noise_estimate_size);
   params->noise_estimate_size *= ElementCount(*noise_estimate->dims);
 
-  ResetState(params);
+  FilterBankSpectralSubtractionResetState(params);
 
   micro_context->DeallocateTempTfLiteTensor(input);
   micro_context->DeallocateTempTfLiteTensor(output);
@@ -133,7 +136,8 @@
   return kTfLiteOk;
 }
 
-TfLiteStatus Eval(TfLiteContext* context, TfLiteNode* node) {
+TfLiteStatus FilterBankSpectralSubtractionEval(TfLiteContext* context,
+                                               TfLiteNode* node) {
   auto* params =
       reinterpret_cast<TFLMSignalSpectralSubtractionParams*>(node->user_data);
 
@@ -158,8 +162,9 @@
   return kTfLiteOk;
 }
 
-void Reset(TfLiteContext* context, void* buffer) {
-  ResetState(static_cast<TFLMSignalSpectralSubtractionParams*>(buffer));
+void FilterBankSpectralSubtractionReset(TfLiteContext* context, void* buffer) {
+  FilterBankSpectralSubtractionResetState(
+      static_cast<TFLMSignalSpectralSubtractionParams*>(buffer));
 }
 
 }  // namespace
@@ -167,8 +172,10 @@
 namespace tflm_signal {
 
 TFLMRegistration* Register_FILTER_BANK_SPECTRAL_SUBTRACTION() {
-  static TFLMRegistration r =
-      tflite::micro::RegisterOp(Init, Prepare, Eval, /*Free*/ nullptr, Reset);
+  static TFLMRegistration r = tflite::micro::RegisterOp(
+      FilterBankSpectralSubtractionInit, FilterBankSpectralSubtractionPrepare,
+      FilterBankSpectralSubtractionEval,
+      /*Free*/ nullptr, FilterBankSpectralSubtractionReset);
   return &r;
 }
 

diff --git a/signal/micro/kernels/filter_bank_square_root.cc b/signal/micro/kernels/filter_bank_square_root.cc
index be10c2d..bd7eff9 100644
--- a/signal/micro/kernels/filter_bank_square_root.cc
+++ b/signal/micro/kernels/filter_bank_square_root.cc

@@ -31,7 +31,8 @@
 constexpr int kScaleBitsTensor = 1;
 constexpr int kOutputTensor = 0;
 
-TfLiteStatus Eval(TfLiteContext* context, TfLiteNode* node) {
+TfLiteStatus FilterBankSquareRootEval(TfLiteContext* context,
+                                      TfLiteNode* node) {
   const TfLiteEvalTensor* input =
       tflite::micro::GetEvalInput(context, node, kInputTensor);
   const TfLiteEvalTensor* scale_bits =
@@ -54,8 +55,8 @@
 namespace tflm_signal {
 
 TFLMRegistration* Register_FILTER_BANK_SQUARE_ROOT() {
-  static TFLMRegistration r =
-      tflite::micro::RegisterOp(nullptr, FilterBankSquareRootPrepare, Eval);
+  static TFLMRegistration r = tflite::micro::RegisterOp(
+      nullptr, FilterBankSquareRootPrepare, FilterBankSquareRootEval);
   return &r;
 }
 

diff --git a/signal/micro/kernels/framer.cc b/signal/micro/kernels/framer.cc
index 8437bd0..36f189c 100644
--- a/signal/micro/kernels/framer.cc
+++ b/signal/micro/kernels/framer.cc

@@ -48,7 +48,7 @@
   tflite::tflm_signal::CircularBuffer** circular_buffers;
 };
 
-void ResetState(TFLMSignalFramerParams* params) {
+void FramerResetState(TFLMSignalFramerParams* params) {
   for (int i = 0; i < params->outer_dims; ++i) {
     tflite::tflm_signal::CircularBufferReset(params->circular_buffers[i]);
     if (params->prefill) {
@@ -58,7 +58,7 @@
   }
 }
 
-void* Init(TfLiteContext* context, const char* buffer, size_t length) {
+void* FramerInit(TfLiteContext* context, const char* buffer, size_t length) {
   const uint8_t* buffer_t = reinterpret_cast<const uint8_t*>(buffer);
 
   auto* params =
@@ -76,7 +76,7 @@
   return params;
 }
 
-TfLiteStatus Prepare(TfLiteContext* context, TfLiteNode* node) {
+TfLiteStatus FramerPrepare(TfLiteContext* context, TfLiteNode* node) {
   TF_LITE_ENSURE_EQ(context, NumInputs(node), 1);
   TF_LITE_ENSURE_EQ(context, NumOutputs(node), 2);
 
@@ -132,7 +132,7 @@
         capacity, params->state_buffers[i], state_size);
   }
 
-  ResetState(params);
+  FramerResetState(params);
 
   micro_context->DeallocateTempTfLiteTensor(input);
   micro_context->DeallocateTempTfLiteTensor(output);
@@ -141,7 +141,7 @@
   return kTfLiteOk;
 }
 
-TfLiteStatus Eval(TfLiteContext* context, TfLiteNode* node) {
+TfLiteStatus FramerEval(TfLiteContext* context, TfLiteNode* node) {
   auto* params = reinterpret_cast<TFLMSignalFramerParams*>(node->user_data);
 
   const TfLiteEvalTensor* input =
@@ -181,8 +181,8 @@
   return kTfLiteOk;
 }
 
-void Reset(TfLiteContext* context, void* buffer) {
-  ResetState(static_cast<TFLMSignalFramerParams*>(buffer));
+void FramerReset(TfLiteContext* context, void* buffer) {
+  FramerResetState(static_cast<TFLMSignalFramerParams*>(buffer));
 }
 
 }  // namespace
@@ -190,8 +190,8 @@
 namespace tflm_signal {
 // TODO(b/286250473): remove namespace once de-duped libraries above
 TFLMRegistration* Register_FRAMER() {
-  static TFLMRegistration r =
-      tflite::micro::RegisterOp(Init, Prepare, Eval, nullptr, Reset);
+  static TFLMRegistration r = tflite::micro::RegisterOp(
+      FramerInit, FramerPrepare, FramerEval, nullptr, FramerReset);
   return &r;
 }
 }  // namespace tflm_signal

diff --git a/signal/micro/kernels/irfft.cc b/signal/micro/kernels/irfft.cc
index 6cb3d7c..b0d58d5 100644
--- a/signal/micro/kernels/irfft.cc
+++ b/signal/micro/kernels/irfft.cc

@@ -50,7 +50,7 @@
 
 template <typename T, size_t (*get_needed_memory_func)(int32_t),
           void* (*init_func)(int32_t, void*, size_t)>
-void* Init(TfLiteContext* context, const char* buffer, size_t length) {
+void* IrfftInit(TfLiteContext* context, const char* buffer, size_t length) {
   TFLITE_DCHECK(context->AllocatePersistentBuffer != nullptr);
 
   auto* params = static_cast<TfLiteAudioFrontendIrfftParams*>(
@@ -79,7 +79,7 @@
 }
 
 template <TfLiteType TfLiteTypeEnum>
-TfLiteStatus Prepare(TfLiteContext* context, TfLiteNode* node) {
+TfLiteStatus IrfftPrepare(TfLiteContext* context, TfLiteNode* node) {
   TF_LITE_ENSURE_EQ(context, NumInputs(node), 1);
   TF_LITE_ENSURE_EQ(context, NumOutputs(node), 1);
 
@@ -113,7 +113,7 @@
 }
 
 template <typename T, void (*apply_func)(void*, const Complex<T>* input, T*)>
-TfLiteStatus Eval(TfLiteContext* context, TfLiteNode* node) {
+TfLiteStatus IrfftEval(TfLiteContext* context, TfLiteNode* node) {
   auto* params =
       reinterpret_cast<TfLiteAudioFrontendIrfftParams*>(node->user_data);
 
@@ -133,61 +133,61 @@
   return kTfLiteOk;
 }
 
-void* InitAll(TfLiteContext* context, const char* buffer, size_t length) {
+void* IrfftInitAll(TfLiteContext* context, const char* buffer, size_t length) {
   const uint8_t* buffer_t = reinterpret_cast<const uint8_t*>(buffer);
   const flexbuffers::Map& m = flexbuffers::GetRoot(buffer_t, length).AsMap();
   auto tensor_type = static_cast<tflite::TensorType>(m["T"].AsInt32());
 
   switch (tensor_type) {
     case TensorType_INT16: {
-      return Init<int16_t, tflm_signal::IrfftInt16GetNeededMemory,
-                  tflm_signal::IrfftInt16Init>(context, buffer, length);
+      return IrfftInit<int16_t, tflm_signal::IrfftInt16GetNeededMemory,
+                       tflm_signal::IrfftInt16Init>(context, buffer, length);
     }
     case TensorType_INT32: {
-      return Init<int32_t, tflm_signal::IrfftInt32GetNeededMemory,
-                  tflm_signal::IrfftInt32Init>(context, buffer, length);
+      return IrfftInit<int32_t, tflm_signal::IrfftInt32GetNeededMemory,
+                       tflm_signal::IrfftInt32Init>(context, buffer, length);
     }
     case TensorType_FLOAT32: {
-      return Init<float, tflm_signal::IrfftFloatGetNeededMemory,
-                  tflm_signal::IrfftFloatInit>(context, buffer, length);
+      return IrfftInit<float, tflm_signal::IrfftFloatGetNeededMemory,
+                       tflm_signal::IrfftFloatInit>(context, buffer, length);
     }
     default:
       return nullptr;
   }
 }
 
-TfLiteStatus PrepareAll(TfLiteContext* context, TfLiteNode* node) {
+TfLiteStatus IrfftPrepareAll(TfLiteContext* context, TfLiteNode* node) {
   auto* params =
       reinterpret_cast<TfLiteAudioFrontendIrfftParams*>(node->user_data);
 
   switch (params->fft_type) {
     case kTfLiteInt16: {
-      return Prepare<kTfLiteInt16>(context, node);
+      return IrfftPrepare<kTfLiteInt16>(context, node);
     }
     case kTfLiteInt32: {
-      return Prepare<kTfLiteInt32>(context, node);
+      return IrfftPrepare<kTfLiteInt32>(context, node);
     }
     case kTfLiteFloat32: {
-      return Prepare<kTfLiteFloat32>(context, node);
+      return IrfftPrepare<kTfLiteFloat32>(context, node);
     }
     default:
       return kTfLiteError;
   }
 }
 
-TfLiteStatus EvalAll(TfLiteContext* context, TfLiteNode* node) {
+TfLiteStatus IrfftEvalAll(TfLiteContext* context, TfLiteNode* node) {
   auto* params =
       reinterpret_cast<TfLiteAudioFrontendIrfftParams*>(node->user_data);
 
   switch (params->fft_type) {
     case kTfLiteInt16: {
-      return Eval<int16_t, tflm_signal::IrfftInt16Apply>(context, node);
+      return IrfftEval<int16_t, tflm_signal::IrfftInt16Apply>(context, node);
     }
     case kTfLiteInt32: {
-      return Eval<int32_t, tflm_signal::IrfftInt32Apply>(context, node);
+      return IrfftEval<int32_t, tflm_signal::IrfftInt32Apply>(context, node);
     }
     case kTfLiteFloat32: {
-      return Eval<float, tflm_signal::IrfftFloatApply>(context, node);
+      return IrfftEval<float, tflm_signal::IrfftFloatApply>(context, node);
     }
     default:
       return kTfLiteError;
@@ -201,28 +201,28 @@
 
 TFLMRegistration* Register_IRFFT() {
   static TFLMRegistration r =
-      tflite::micro::RegisterOp(InitAll, PrepareAll, EvalAll);
+      tflite::micro::RegisterOp(IrfftInitAll, IrfftPrepareAll, IrfftEvalAll);
   return &r;
 }
 
 TFLMRegistration* Register_IRFFT_FLOAT() {
   static TFLMRegistration r = tflite::micro::RegisterOp(
-      Init<float, IrfftFloatGetNeededMemory, IrfftFloatInit>,
-      Prepare<kTfLiteFloat32>, Eval<float, IrfftFloatApply>);
+      IrfftInit<float, IrfftFloatGetNeededMemory, IrfftFloatInit>,
+      IrfftPrepare<kTfLiteFloat32>, IrfftEval<float, IrfftFloatApply>);
   return &r;
 }
 
 TFLMRegistration* Register_IRFFT_INT16() {
   static TFLMRegistration r = tflite::micro::RegisterOp(
-      Init<int16_t, IrfftInt16GetNeededMemory, IrfftInt16Init>,
-      Prepare<kTfLiteInt16>, Eval<int16_t, IrfftInt16Apply>);
+      IrfftInit<int16_t, IrfftInt16GetNeededMemory, IrfftInt16Init>,
+      IrfftPrepare<kTfLiteInt16>, IrfftEval<int16_t, IrfftInt16Apply>);
   return &r;
 }
 
 TFLMRegistration* Register_IRFFT_INT32() {
   static TFLMRegistration r = tflite::micro::RegisterOp(
-      Init<int32_t, IrfftInt32GetNeededMemory, IrfftInt32Init>,
-      Prepare<kTfLiteInt32>, Eval<int32_t, IrfftInt32Apply>);
+      IrfftInit<int32_t, IrfftInt32GetNeededMemory, IrfftInt32Init>,
+      IrfftPrepare<kTfLiteInt32>, IrfftEval<int32_t, IrfftInt32Apply>);
   return &r;
 }
 

diff --git a/signal/micro/kernels/overlap_add.cc b/signal/micro/kernels/overlap_add.cc
index 8de7463..c365cd8 100644
--- a/signal/micro/kernels/overlap_add.cc
+++ b/signal/micro/kernels/overlap_add.cc

@@ -48,14 +48,15 @@
 };
 
 template <typename T>
-void ResetState(TFLMSignalOverlapAddParams<T>* params) {
+void OverlapAddResetState(TFLMSignalOverlapAddParams<T>* params) {
   for (int i = 0; i < params->outer_dims; i++) {
     memset(params->state_buffers[i], 0, sizeof(T) * params->frame_size);
   }
 }
 
 template <typename T>
-void* Init(TfLiteContext* context, const char* buffer, size_t length) {
+void* OverlapAddInit(TfLiteContext* context, const char* buffer,
+                     size_t length) {
   const uint8_t* buffer_t = reinterpret_cast<const uint8_t*>(buffer);
 
   auto* params = static_cast<TFLMSignalOverlapAddParams<T>*>(
@@ -73,7 +74,7 @@
 }
 
 template <typename T, TfLiteType TfLiteTypeEnum>
-TfLiteStatus Prepare(TfLiteContext* context, TfLiteNode* node) {
+TfLiteStatus OverlapAddPrepare(TfLiteContext* context, TfLiteNode* node) {
   TF_LITE_ENSURE_EQ(context, NumInputs(node), 1);
   TF_LITE_ENSURE_EQ(context, NumOutputs(node), 1);
 
@@ -112,7 +113,7 @@
         static_cast<T*>(context->AllocatePersistentBuffer(
             context, params->frame_size * sizeof(T)));
   }
-  ResetState(params);
+  OverlapAddResetState(params);
 
   micro_context->DeallocateTempTfLiteTensor(input);
   micro_context->DeallocateTempTfLiteTensor(output);
@@ -120,7 +121,7 @@
 }
 
 template <typename T>
-TfLiteStatus Eval(TfLiteContext* context, TfLiteNode* node) {
+TfLiteStatus OverlapAddEval(TfLiteContext* context, TfLiteNode* node) {
   auto* params =
       reinterpret_cast<TFLMSignalOverlapAddParams<T>*>(node->user_data);
   const TfLiteEvalTensor* input =
@@ -144,69 +145,70 @@
 }
 
 template <typename T>
-void Reset(TfLiteContext* context, void* buffer) {
-  ResetState(static_cast<TFLMSignalOverlapAddParams<T>*>(buffer));
+void OverlapAddReset(TfLiteContext* context, void* buffer) {
+  OverlapAddResetState(static_cast<TFLMSignalOverlapAddParams<T>*>(buffer));
 }
 
-void* InitAll(TfLiteContext* context, const char* buffer, size_t length) {
+void* OverlapAddInitAll(TfLiteContext* context, const char* buffer,
+                        size_t length) {
   const uint8_t* buffer_t = reinterpret_cast<const uint8_t*>(buffer);
   const flexbuffers::Map& m = flexbuffers::GetRoot(buffer_t, length).AsMap();
   auto tensor_type = static_cast<tflite::TensorType>(m["T"].AsInt32());
 
   switch (tensor_type) {
     case TensorType_INT16: {
-      return Init<int16_t>(context, buffer, length);
+      return OverlapAddInit<int16_t>(context, buffer, length);
     }
     case TensorType_FLOAT32: {
-      return Init<float>(context, buffer, length);
+      return OverlapAddInit<float>(context, buffer, length);
     }
     default:
       return nullptr;
   }
 }
 
-TfLiteStatus PrepareAll(TfLiteContext* context, TfLiteNode* node) {
+TfLiteStatus OverlapAddPrepareAll(TfLiteContext* context, TfLiteNode* node) {
   auto* params =
       reinterpret_cast<TFLMSignalOverlapAddParams<void>*>(node->user_data);
 
   switch (params->type) {
     case kTfLiteInt16: {
-      return Prepare<int16_t, kTfLiteInt16>(context, node);
+      return OverlapAddPrepare<int16_t, kTfLiteInt16>(context, node);
     }
     case kTfLiteFloat32: {
-      return Prepare<float, kTfLiteFloat32>(context, node);
+      return OverlapAddPrepare<float, kTfLiteFloat32>(context, node);
     }
     default:
       return kTfLiteError;
   }
 }
 
-TfLiteStatus EvalAll(TfLiteContext* context, TfLiteNode* node) {
+TfLiteStatus OverlapAddEvalAll(TfLiteContext* context, TfLiteNode* node) {
   auto* params =
       reinterpret_cast<TFLMSignalOverlapAddParams<void>*>(node->user_data);
 
   switch (params->type) {
     case kTfLiteInt16: {
-      return Eval<int16_t>(context, node);
+      return OverlapAddEval<int16_t>(context, node);
     }
     case kTfLiteFloat32: {
-      return Eval<float>(context, node);
+      return OverlapAddEval<float>(context, node);
     }
     default:
       return kTfLiteError;
   }
 }
 
-void ResetAll(TfLiteContext* context, void* buffer) {
+void OverlapAddResetAll(TfLiteContext* context, void* buffer) {
   auto* params = reinterpret_cast<TFLMSignalOverlapAddParams<void>*>(buffer);
 
   switch (params->type) {
     case kTfLiteInt16: {
-      Reset<int16_t>(context, buffer);
+      OverlapAddReset<int16_t>(context, buffer);
       break;
     }
     case kTfLiteFloat32: {
-      Reset<float>(context, buffer);
+      OverlapAddReset<float>(context, buffer);
       break;
     }
     default:
@@ -218,22 +220,23 @@
 
 namespace tflm_signal {
 TFLMRegistration* Register_OVERLAP_ADD() {
-  static TFLMRegistration r = tflite::micro::RegisterOp(
-      InitAll, PrepareAll, EvalAll, nullptr, ResetAll);
+  static TFLMRegistration r =
+      tflite::micro::RegisterOp(OverlapAddInitAll, OverlapAddPrepareAll,
+                                OverlapAddEvalAll, nullptr, OverlapAddResetAll);
   return &r;
 }
 
 TFLMRegistration* Register_OVERLAP_ADD_FLOAT() {
-  static TFLMRegistration r =
-      tflite::micro::RegisterOp(Init<float>, Prepare<float, kTfLiteFloat32>,
-                                Eval<float>, nullptr, Reset<float>);
+  static TFLMRegistration r = tflite::micro::RegisterOp(
+      OverlapAddInit<float>, OverlapAddPrepare<float, kTfLiteFloat32>,
+      OverlapAddEval<float>, nullptr, OverlapAddReset<float>);
   return &r;
 }
 
 TFLMRegistration* Register_OVERLAP_ADD_INT16() {
-  static TFLMRegistration r =
-      tflite::micro::RegisterOp(Init<int16_t>, Prepare<int16_t, kTfLiteInt16>,
-                                Eval<int16_t>, nullptr, Reset<int16_t>);
+  static TFLMRegistration r = tflite::micro::RegisterOp(
+      OverlapAddInit<int16_t>, OverlapAddPrepare<int16_t, kTfLiteInt16>,
+      OverlapAddEval<int16_t>, nullptr, OverlapAddReset<int16_t>);
   return &r;
 }
 }  // namespace tflm_signal

diff --git a/signal/micro/kernels/pcan.cc b/signal/micro/kernels/pcan.cc
index 71df3e0..9473e1b 100644
--- a/signal/micro/kernels/pcan.cc
+++ b/signal/micro/kernels/pcan.cc

@@ -42,7 +42,7 @@
   int snr_shift;
 };
 
-void* Init(TfLiteContext* context, const char* buffer, size_t length) {
+void* PcanInit(TfLiteContext* context, const char* buffer, size_t length) {
   auto* params = static_cast<TfLitePcanParams*>(
       context->AllocatePersistentBuffer(context, sizeof(TfLitePcanParams)));
 
@@ -52,7 +52,7 @@
   return params;
 }
 
-TfLiteStatus Prepare(TfLiteContext* context, TfLiteNode* node) {
+TfLiteStatus PcanPrepare(TfLiteContext* context, TfLiteNode* node) {
   TF_LITE_ENSURE_EQ(context, NumInputs(node), 3);
   TF_LITE_ENSURE_EQ(context, NumOutputs(node), 1);
 
@@ -88,7 +88,7 @@
   return kTfLiteOk;
 }
 
-TfLiteStatus Eval(TfLiteContext* context, TfLiteNode* node) {
+TfLiteStatus PcanEval(TfLiteContext* context, TfLiteNode* node) {
   auto* params = reinterpret_cast<TfLitePcanParams*>(node->user_data);
 
   const TfLiteEvalTensor* input =
@@ -126,7 +126,8 @@
 }
 
 TFLMRegistration* Register_PCAN() {
-  static TFLMRegistration r = tflite::micro::RegisterOp(Init, Prepare, Eval);
+  static TFLMRegistration r =
+      tflite::micro::RegisterOp(PcanInit, PcanPrepare, PcanEval);
   return &r;
 }
 

diff --git a/signal/micro/kernels/rfft.cc b/signal/micro/kernels/rfft.cc
index fccc6eb..2ee8e7a 100644
--- a/signal/micro/kernels/rfft.cc
+++ b/signal/micro/kernels/rfft.cc

@@ -53,7 +53,7 @@
 
 template <typename T, size_t (*get_needed_memory_func)(int32_t),
           void* (*init_func)(int32_t, void*, size_t)>
-void* Init(TfLiteContext* context, const char* buffer, size_t length) {
+void* RfftInit(TfLiteContext* context, const char* buffer, size_t length) {
   TFLITE_DCHECK(context->AllocatePersistentBuffer != nullptr);
 
   const uint8_t* buffer_t = reinterpret_cast<const uint8_t*>(buffer);
@@ -76,7 +76,7 @@
 }
 
 template <typename T, TfLiteType TfLiteTypeEnum>
-TfLiteStatus Prepare(TfLiteContext* context, TfLiteNode* node) {
+TfLiteStatus RfftPrepare(TfLiteContext* context, TfLiteNode* node) {
   TF_LITE_ENSURE_EQ(context, NumInputs(node), 1);
   TF_LITE_ENSURE_EQ(context, NumOutputs(node), 1);
 
@@ -109,7 +109,7 @@
 }
 
 template <typename T, void (*apply_func)(void*, const T* input, Complex<T>*)>
-TfLiteStatus Eval(TfLiteContext* context, TfLiteNode* node) {
+TfLiteStatus RfftEval(TfLiteContext* context, TfLiteNode* node) {
   auto* params =
       reinterpret_cast<TfLiteAudioFrontendRfftParams<T>*>(node->user_data);
 
@@ -135,61 +135,61 @@
   return kTfLiteOk;
 }
 
-void* InitAll(TfLiteContext* context, const char* buffer, size_t length) {
+void* RfftInitAll(TfLiteContext* context, const char* buffer, size_t length) {
   const uint8_t* buffer_t = reinterpret_cast<const uint8_t*>(buffer);
   const flexbuffers::Map& m = flexbuffers::GetRoot(buffer_t, length).AsMap();
   auto tensor_type = static_cast<tflite::TensorType>(m["T"].AsInt32());
 
   switch (tensor_type) {
     case TensorType_INT16: {
-      return Init<int16_t, ::tflm_signal::RfftInt16GetNeededMemory,
-                  ::tflm_signal::RfftInt16Init>(context, buffer, length);
+      return RfftInit<int16_t, ::tflm_signal::RfftInt16GetNeededMemory,
+                      ::tflm_signal::RfftInt16Init>(context, buffer, length);
     }
     case TensorType_INT32: {
-      return Init<int32_t, ::tflm_signal::RfftInt32GetNeededMemory,
-                  ::tflm_signal::RfftInt32Init>(context, buffer, length);
+      return RfftInit<int32_t, ::tflm_signal::RfftInt32GetNeededMemory,
+                      ::tflm_signal::RfftInt32Init>(context, buffer, length);
     }
     case TensorType_FLOAT32: {
-      return Init<float, ::tflm_signal::RfftFloatGetNeededMemory,
-                  ::tflm_signal::RfftFloatInit>(context, buffer, length);
+      return RfftInit<float, ::tflm_signal::RfftFloatGetNeededMemory,
+                      ::tflm_signal::RfftFloatInit>(context, buffer, length);
     }
     default:
       return nullptr;
   }
 }
 
-TfLiteStatus PrepareAll(TfLiteContext* context, TfLiteNode* node) {
+TfLiteStatus RfftPrepareAll(TfLiteContext* context, TfLiteNode* node) {
   auto* params =
       reinterpret_cast<TfLiteAudioFrontendRfftParams<void>*>(node->user_data);
 
   switch (params->fft_type) {
     case kTfLiteInt16: {
-      return Prepare<int16_t, kTfLiteInt16>(context, node);
+      return RfftPrepare<int16_t, kTfLiteInt16>(context, node);
     }
     case kTfLiteInt32: {
-      return Prepare<int32_t, kTfLiteInt32>(context, node);
+      return RfftPrepare<int32_t, kTfLiteInt32>(context, node);
     }
     case kTfLiteFloat32: {
-      return Prepare<float, kTfLiteFloat32>(context, node);
+      return RfftPrepare<float, kTfLiteFloat32>(context, node);
     }
     default:
       return kTfLiteError;
   }
 }
 
-TfLiteStatus EvalAll(TfLiteContext* context, TfLiteNode* node) {
+TfLiteStatus RfftEvalAll(TfLiteContext* context, TfLiteNode* node) {
   auto* params =
       reinterpret_cast<TfLiteAudioFrontendRfftParams<void>*>(node->user_data);
 
   switch (params->fft_type) {
     case kTfLiteInt16: {
-      return Eval<int16_t, ::tflm_signal::RfftInt16Apply>(context, node);
+      return RfftEval<int16_t, ::tflm_signal::RfftInt16Apply>(context, node);
     }
     case kTfLiteInt32: {
-      return Eval<int32_t, ::tflm_signal::RfftInt32Apply>(context, node);
+      return RfftEval<int32_t, ::tflm_signal::RfftInt32Apply>(context, node);
     }
     case kTfLiteFloat32: {
-      return Eval<float, ::tflm_signal::RfftFloatApply>(context, node);
+      return RfftEval<float, ::tflm_signal::RfftFloatApply>(context, node);
     }
     default:
       return kTfLiteError;
@@ -202,34 +202,34 @@
 
 TFLMRegistration* Register_RFFT() {
   static TFLMRegistration r =
-      tflite::micro::RegisterOp(InitAll, PrepareAll, EvalAll);
+      tflite::micro::RegisterOp(RfftInitAll, RfftPrepareAll, RfftEvalAll);
   return &r;
 }
 
 TFLMRegistration* Register_RFFT_FLOAT() {
   static TFLMRegistration r = tflite::micro::RegisterOp(
-      Init<float, ::tflm_signal::RfftFloatGetNeededMemory,
-           ::tflm_signal::RfftFloatInit>,
-      Prepare<float, kTfLiteFloat32>,
-      Eval<float, ::tflm_signal::RfftFloatApply>);
+      RfftInit<float, ::tflm_signal::RfftFloatGetNeededMemory,
+               ::tflm_signal::RfftFloatInit>,
+      RfftPrepare<float, kTfLiteFloat32>,
+      RfftEval<float, ::tflm_signal::RfftFloatApply>);
   return &r;
 }
 
 TFLMRegistration* Register_RFFT_INT16() {
   static TFLMRegistration r = tflite::micro::RegisterOp(
-      Init<int16_t, ::tflm_signal::RfftInt16GetNeededMemory,
-           ::tflm_signal::RfftInt16Init>,
-      Prepare<int16_t, kTfLiteInt16>,
-      Eval<int16_t, ::tflm_signal::RfftInt16Apply>);
+      RfftInit<int16_t, ::tflm_signal::RfftInt16GetNeededMemory,
+               ::tflm_signal::RfftInt16Init>,
+      RfftPrepare<int16_t, kTfLiteInt16>,
+      RfftEval<int16_t, ::tflm_signal::RfftInt16Apply>);
   return &r;
 }
 
 TFLMRegistration* Register_RFFT_INT32() {
   static TFLMRegistration r = tflite::micro::RegisterOp(
-      Init<int32_t, ::tflm_signal::RfftInt32GetNeededMemory,
-           ::tflm_signal::RfftInt32Init>,
-      Prepare<int32_t, kTfLiteInt32>,
-      Eval<int32_t, ::tflm_signal::RfftInt32Apply>);
+      RfftInit<int32_t, ::tflm_signal::RfftInt32GetNeededMemory,
+               ::tflm_signal::RfftInt32Init>,
+      RfftPrepare<int32_t, kTfLiteInt32>,
+      RfftEval<int32_t, ::tflm_signal::RfftInt32Apply>);
   return &r;
 }
 

diff --git a/signal/micro/kernels/stacker.cc b/signal/micro/kernels/stacker.cc
index 42a2ee6..fc1a4a3 100644
--- a/signal/micro/kernels/stacker.cc
+++ b/signal/micro/kernels/stacker.cc

@@ -52,7 +52,7 @@
   tflm_signal::CircularBuffer* circular_buffer;
 };
 
-void* Init(TfLiteContext* context, const char* buffer, size_t length) {
+void* StackerInit(TfLiteContext* context, const char* buffer, size_t length) {
   const uint8_t* buffer_t = reinterpret_cast<const uint8_t*>(buffer);
 
   auto* params =
@@ -88,7 +88,7 @@
   return params;
 }
 
-TfLiteStatus Prepare(TfLiteContext* context, TfLiteNode* node) {
+TfLiteStatus StackerPrepare(TfLiteContext* context, TfLiteNode* node) {
   TF_LITE_ENSURE_EQ(context, NumInputs(node), 1);
   TF_LITE_ENSURE_EQ(context, NumOutputs(node), 2);
 
@@ -118,7 +118,7 @@
   return kTfLiteOk;
 }
 
-TfLiteStatus Eval(TfLiteContext* context, TfLiteNode* node) {
+TfLiteStatus StackerEval(TfLiteContext* context, TfLiteNode* node) {
   auto* params = reinterpret_cast<TFLMSignalStackerParams*>(node->user_data);
   TF_LITE_ENSURE(context, params != nullptr);
 
@@ -157,7 +157,7 @@
   return kTfLiteOk;
 }
 
-void Reset(TfLiteContext* context, void* buffer) {
+void StackerReset(TfLiteContext* context, void* buffer) {
   auto* params = static_cast<TFLMSignalStackerParams*>(buffer);
   tflm_signal::CircularBufferReset(params->circular_buffer);
   params->stacker_has_first_frame = false;
@@ -167,8 +167,8 @@
 
 namespace tflm_signal {
 TFLMRegistration* Register_STACKER() {
-  static TFLMRegistration r =
-      tflite::micro::RegisterOp(Init, Prepare, Eval, /*Free*/ nullptr, Reset);
+  static TFLMRegistration r = tflite::micro::RegisterOp(
+      StackerInit, StackerPrepare, StackerEval, /*Free*/ nullptr, StackerReset);
   return &r;
 }
 }  // namespace tflm_signal

diff --git a/signal/micro/kernels/window.cc b/signal/micro/kernels/window.cc
index e850898..cd9c462 100644
--- a/signal/micro/kernels/window.cc
+++ b/signal/micro/kernels/window.cc

@@ -41,7 +41,7 @@
   int32_t input_size;
 };
 
-void* Init(TfLiteContext* context, const char* buffer, size_t length) {
+void* WindowInit(TfLiteContext* context, const char* buffer, size_t length) {
   const uint8_t* buffer_t = reinterpret_cast<const uint8_t*>(buffer);
 
   auto* params =
@@ -53,7 +53,7 @@
   return params;
 }
 
-TfLiteStatus Prepare(TfLiteContext* context, TfLiteNode* node) {
+TfLiteStatus WindowPrepare(TfLiteContext* context, TfLiteNode* node) {
   TF_LITE_ENSURE_EQ(context, NumInputs(node), 2);
   TF_LITE_ENSURE_EQ(context, NumOutputs(node), 1);
 
@@ -87,7 +87,7 @@
   return kTfLiteOk;
 }
 
-TfLiteStatus Eval(TfLiteContext* context, TfLiteNode* node) {
+TfLiteStatus WindowEval(TfLiteContext* context, TfLiteNode* node) {
   auto* params = reinterpret_cast<TFLMSignalWindowParams*>(node->user_data);
 
   const TfLiteEvalTensor* input =
@@ -114,7 +114,8 @@
 namespace tflm_signal {
 
 TFLMRegistration* Register_WINDOW() {
-  static TFLMRegistration r = tflite::micro::RegisterOp(Init, Prepare, Eval);
+  static TFLMRegistration r =
+      tflite::micro::RegisterOp(WindowInit, WindowPrepare, WindowEval);
   return &r;
 }