MLECO-1868: Code static analyzer warnings fixes

Signed-off-by: alexander <alexander.efremov@arm.com>
Change-Id: Ie423e9cad3fabec6ab077ded7236813fe4933dea

6 files changed, 35 insertions, 34 deletions

diff --git a/source/use_case/kws_asr/include/AsrClassifier.hpp b/source/use_case/kws_asr/include/AsrClassifier.hpp
index de18aa8..7dbb6e9 100644
--- a/source/use_case/kws_asr/include/AsrClassifier.hpp
+++ b/source/use_case/kws_asr/include/AsrClassifier.hpp
@@ -53,9 +53,9 @@ namespace app {
          * @return      true if successful, false otherwise.
          **/
         template<typename T>
-        bool _GetTopResults(TfLiteTensor* tensor,
-                            std::vector<ClassificationResult>& vecResults,
-                            const std::vector <std::string>& labels, double scale, double zeroPoint);
+        bool GetTopResults(TfLiteTensor* tensor,
+                           std::vector<ClassificationResult>& vecResults,
+                           const std::vector <std::string>& labels, double scale, double zeroPoint);
     };
 
 } /* namespace app */
diff --git a/source/use_case/kws_asr/include/DsCnnModel.hpp b/source/use_case/kws_asr/include/DsCnnModel.hpp
index 150a48c..f9d4357 100644
--- a/source/use_case/kws_asr/include/DsCnnModel.hpp
+++ b/source/use_case/kws_asr/include/DsCnnModel.hpp
@@ -55,10 +55,10 @@ namespace app {
 
     private:
         /* Maximum number of individual operations that can be enlisted. */
-        static constexpr int _ms_maxOpCnt = 10;
+        static constexpr int ms_maxOpCnt = 10;
 
         /* A mutable op resolver instance. */
-        tflite::MicroMutableOpResolver<_ms_maxOpCnt> _m_opResolver;
+        tflite::MicroMutableOpResolver<ms_maxOpCnt> _m_opResolver;
     };
 
 } /* namespace app */
diff --git a/source/use_case/kws_asr/include/Wav2LetterMfcc.hpp b/source/use_case/kws_asr/include/Wav2LetterMfcc.hpp
index 0852cbf..75d75da 100644
--- a/source/use_case/kws_asr/include/Wav2LetterMfcc.hpp
+++ b/source/use_case/kws_asr/include/Wav2LetterMfcc.hpp
@@ -60,8 +60,8 @@ namespace audio {
         bool ApplyMelFilterBank(
                 std::vector<float>&                 fftVec,
                 std::vector<std::vector<float>>&    melFilterBank,
-                std::vector<int32_t>&               filterBankFilterFirst,
-                std::vector<int32_t>&               filterBankFilterLast,
+                std::vector<uint32_t>&              filterBankFilterFirst,
+                std::vector<uint32_t>&              filterBankFilterLast,
                 std::vector<float>&                 melEnergies) override;
 
         /**
@@ -103,6 +103,7 @@ namespace audio {
                 const float&   leftMel,
                 const float&   rightMel,
                 bool     useHTKMethod) override;
+
     };
 
 } /* namespace audio */
diff --git a/source/use_case/kws_asr/include/Wav2LetterModel.hpp b/source/use_case/kws_asr/include/Wav2LetterModel.hpp
index fb701ea..9a86bd9 100644
--- a/source/use_case/kws_asr/include/Wav2LetterModel.hpp
+++ b/source/use_case/kws_asr/include/Wav2LetterModel.hpp
@@ -55,10 +55,10 @@ namespace app {
 
     private:
         /* Maximum number of individual operations that can be enlisted. */
-        static constexpr int _ms_maxOpCnt = 5;
+        static constexpr int ms_maxOpCnt = 5;
 
         /* A mutable op resolver instance. */
-        tflite::MicroMutableOpResolver<_ms_maxOpCnt> _m_opResolver;
+        tflite::MicroMutableOpResolver<ms_maxOpCnt> _m_opResolver;
     };
 
 } /* namespace app */
diff --git a/source/use_case/kws_asr/include/Wav2LetterPostprocess.hpp b/source/use_case/kws_asr/include/Wav2LetterPostprocess.hpp
index 3a9d401..fe60923 100644
--- a/source/use_case/kws_asr/include/Wav2LetterPostprocess.hpp
+++ b/source/use_case/kws_asr/include/Wav2LetterPostprocess.hpp
@@ -72,24 +72,24 @@ namespace asr {
          *              initialised.
          * @return      true if valid, false otherwise.
          */
-        bool _IsInputValid(TfLiteTensor*  tensor,
-                           uint32_t axisIdx) const;
+        bool IsInputValid(TfLiteTensor*  tensor,
+                          const uint32_t axisIdx) const;
 
         /**
          * @brief       Gets the tensor data element size in bytes based
          *              on the tensor type.
          * @return      Size in bytes, 0 if not supported.
          */
-        uint32_t _GetTensorElementSize(TfLiteTensor* tensor);
+        uint32_t GetTensorElementSize(TfLiteTensor* tensor);
 
         /**
          * @brief       Erases sections from the data assuming row-wise
          *              arrangement along the context axis.
          * @return      true if successful, false otherwise.
          */
-        bool _EraseSectionsRowWise(uint8_t* ptrData,
-                                   uint32_t strideSzBytes,
-                                   bool lastIteration);
+        bool EraseSectionsRowWise(uint8_t* ptrData,
+                                  const uint32_t strideSzBytes,
+                                  const bool lastIteration);
 
     };
 
diff --git a/source/use_case/kws_asr/include/Wav2LetterPreprocess.hpp b/source/use_case/kws_asr/include/Wav2LetterPreprocess.hpp
index 3ffabb4..cf40fa8 100644
--- a/source/use_case/kws_asr/include/Wav2LetterPreprocess.hpp
+++ b/source/use_case/kws_asr/include/Wav2LetterPreprocess.hpp
@@ -75,16 +75,16 @@ namespace asr {
           *
           * @return true if successful, false otherwise.
           */
-         static bool _ComputeDeltas(Array2d<float>& mfcc,
-                                    Array2d<float>& delta1,
-                                    Array2d<float>& delta2);
+         static bool ComputeDeltas(Array2d<float>& mfcc,
+                                   Array2d<float>& delta1,
+                                   Array2d<float>& delta2);
 
         /**
          * @brief       Given a 2D vector of floats, computes the mean.
          * @param[in]   vec   Vector of vector of floats.
          * @return      Mean value.
          */
-        static float _GetMean(Array2d<float>& vec);
+        static float GetMean(Array2d<float>& vec);
 
         /**
          * @brief       Given a 2D vector of floats, computes the stddev.
@@ -92,20 +92,20 @@ namespace asr {
          * @param[in]   mean   Mean value of the vector passed in.
          * @return      stddev value.
          */
-        static float _GetStdDev(Array2d<float>& vec,
-                                float mean);
+        static float GetStdDev(Array2d<float>& vec,
+                               const float mean);
 
         /**
          * @brief           Given a 2D vector of floats, normalises it using
          *                  the mean and the stddev
          * @param[in,out]   vec   Vector of vector of floats.
          */
-        static void _NormaliseVec(Array2d<float>& vec);
+        static void NormaliseVec(Array2d<float>& vec);
 
         /**
          * @brief       Normalises the MFCC and delta buffers.
          */
-        void _Normalise();
+        void Normalise();
 
         /**
          * @brief       Given the quantisation and data type limits, computes
@@ -117,7 +117,7 @@ namespace asr {
          * @param[in]   maxVal          Numerical limit - maximum.
          * @return      Floating point quantised value.
          */
-        static float _GetQuantElem(
+        static float GetQuantElem(
                 float     elem,
                 float     quantScale,
                 int       quantOffset,
@@ -138,7 +138,7 @@ namespace asr {
          * @param[in]   quantOffset     Quantisation offset.
          */
         template <typename T>
-        bool _Quantise(
+        bool Quantise(
                 T *             outputBuf,
                 const uint32_t  outputBufSz,
                 const float     quantScale,
@@ -163,15 +163,15 @@ namespace asr {
              * the tensor. */
             for (uint32_t j = 0; j < this->_m_numFeatVectors; ++j) {
                 for (uint32_t i = 0; i < this->_m_numMfccFeats; ++i) {
-                    *outputBufMfcc++ = static_cast<T>(this->_GetQuantElem(
-                                        this->_m_mfccBuf(i, j), quantScale,
-                                        quantOffset, minVal, maxVal));
-                    *outputBufD1++ = static_cast<T>(this->_GetQuantElem(
-                                        this->_m_delta1Buf(i, j), quantScale,
-                                        quantOffset, minVal, maxVal));
-                    *outputBufD2++ = static_cast<T>(this->_GetQuantElem(
-                                        this->_m_delta2Buf(i, j), quantScale,
-                                        quantOffset, minVal, maxVal));
+                    *outputBufMfcc++ = static_cast<T>(this->GetQuantElem(
+                            this->_m_mfccBuf(i, j), quantScale,
+                            quantOffset, minVal, maxVal));
+                    *outputBufD1++ = static_cast<T>(this->GetQuantElem(
+                            this->_m_delta1Buf(i, j), quantScale,
+                            quantOffset, minVal, maxVal));
+                    *outputBufD2++ = static_cast<T>(this->GetQuantElem(
+                            this->_m_delta2Buf(i, j), quantScale,
+                            quantOffset, minVal, maxVal));
                 }
                 outputBufMfcc += ptrIncr;
                 outputBufD1 += ptrIncr;