RPP Tensor Audio Support - Pre Emphasis Filter

include/rppdefs.h

@@ -386,6 +386,16 @@ typedef enum
     TRIANGULAR
 } RpptInterpolationType;
 
+/*! \brief RPPT Audio Border Type
+ * \ingroup group_rppdefs
+ */
+typedef enum
+{
+    ZERO = 0,
+    CLAMP,
+    REFLECT
+} RpptAudioBorderType;
+
 /*! \brief RPPT Tensor 2D ROI LTRB struct
  * \ingroup group_rppdefs
  */

include/rppt_tensor_audio_augmentations.h

@@ -60,6 +60,39 @@ extern "C" {
  */
 RppStatus rppt_non_silent_region_detection_host(RppPtr_t srcPtr, RpptDescPtr srcDescPtr, Rpp32s *srcLengthTensor, Rpp32f *detectedIndexTensor, Rpp32f *detectionLengthTensor, Rpp32f cutOffDB, Rpp32s windowLength, Rpp32f referencePower, Rpp32s resetInterval, rppHandle_t rppHandle);
 
+/*! \brief To Decibels augmentation on HOST backend
+ * \details To Decibels augmentation for 1D audio buffer converts magnitude values to decibel values
+ * \param[in] srcPtr source tensor in HOST memory
+ * \param[in] srcDescPtr source tensor descriptor (Restrictions - numDims = 3, offsetInBytes >= 0, dataType = F32)
+ * \param[out] dstPtr destination tensor in HOST memory
+ * \param[in] dstDescPtr destination tensor descriptor (Restrictions - numDims = 3, offsetInBytes >= 0, dataType = F32)
+ * \param[in] srcDims source tensor sizes for each element in batch (2D tensor in HOST memory, of size batchSize * 2)
+ * \param[in] cutOffDB  minimum or cut-off ratio in dB
+ * \param[in] multiplier factor by which the logarithm is multiplied
+ * \param[in] referenceMagnitude Reference magnitude if not provided maximum value of input used as reference
+ * \param[in] rppHandle RPP HOST handle created with <tt>\ref rppCreateWithBatchSize()</tt>
+ * \return A <tt> \ref RppStatus</tt> enumeration.
+ * \retval RPP_SUCCESS Successful completion.
+ * \retval RPP_ERROR* Unsuccessful completion.
+ */
+RppStatus rppt_to_decibels_host(RppPtr_t srcPtr, RpptDescPtr srcDescPtr, RppPtr_t dstPtr, RpptDescPtr dstDescPtr, RpptImagePatchPtr srcDims, Rpp32f cutOffDB, Rpp32f multiplier, Rpp32f referenceMagnitude, rppHandle_t rppHandle);
+
+/*! \brief Pre Emphasis Filter augmentation on HOST backend
+ * \details Pre Emphasis Filter augmentation for audio data
+ * \param[in] srcPtr source tensor in HOST memory
+ * \param[in] srcDescPtr source tensor descriptor (Restrictions - numDims = 3, offsetInBytes >= 0, dataType = F32)
+ * \param[out] dstPtr destination tensor in HOST memory
+ * \param[in] dstDescPtr destination tensor descriptor (Restrictions - numDims = 3, offsetInBytes >= 0, dataType = F32)
+ * \param[in] srcLengthTensor source audio buffer length (1D tensor in HOST memory, of size batchSize)
+ * \param[in] coeffTensor preemphasis coefficient (1D tensor in HOST memory, of size batchSize)
+ * \param[in] borderType border value policy
+ * \param[in] rppHandle RPP HOST handle created with <tt>\ref rppCreateWithBatchSize()</tt>
+ * \return A <tt> \ref RppStatus</tt> enumeration.
+ * \retval RPP_SUCCESS Successful completion.
+ * \retval RPP_ERROR* Unsuccessful completion.
+ */
+RppStatus rppt_pre_emphasis_filter_host(RppPtr_t srcPtr, RpptDescPtr srcDescPtr, RppPtr_t dstPtr, RpptDescPtr dstDescPtr, Rpp32s *srcLengthTensor, Rpp32f *coeffTensor, RpptAudioBorderType borderType, rppHandle_t rppHandle);
+
 #ifdef __cplusplus
 }
 #endif

src/modules/cpu/host_tensor_audio_augmentations.hpp

@@ -21,5 +21,7 @@ THE SOFTWARE.
 #define HOST_TENSOR_AUDIO_AUGMENTATIONS_HPP
 
 #include "kernel/non_silent_region_detection.hpp"
+#include "kernel/to_decibels.hpp"
+#include "kernel/pre_emphasis_filter.hpp"
 
 #endif // HOST_TENSOR_AUDIO_AUGMENTATIONS_HPP

src/modules/cpu/kernel/pre_emphasis_filter.hpp

@@ -0,0 +1,87 @@
+/*
+Copyright (c) 2019 - 2023 Advanced Micro Devices, Inc. All rights reserved.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+*/
+
+#include "rppdefs.h"
+#include "rpp_cpu_simd.hpp"
+#include "rpp_cpu_common.hpp"
+
+RppStatus pre_emphasis_filter_host_tensor(Rpp32f *srcPtr,
+                                          RpptDescPtr srcDescPtr,
+                                          Rpp32f *dstPtr,
+                                          RpptDescPtr dstDescPtr,
+                                          Rpp32s *srcLengthTensor,
+                                          Rpp32f *coeffTensor,
+                                          Rpp32u borderType,
+                                          rpp::Handle& handle)
+{
+    Rpp32u numThreads = handle.GetNumThreads();
+
+    omp_set_dynamic(0);
+#pragma omp parallel for num_threads(numThreads)
+    for(int batchCount = 0; batchCount < srcDescPtr->n; batchCount++)
+    {
+        Rpp32f *srcPtrTemp = srcPtr + batchCount * srcDescPtr->strides.nStride;
+        Rpp32f *dstPtrTemp = dstPtr + batchCount * dstDescPtr->strides.nStride;
+        Rpp32s bufferLength = srcLengthTensor[batchCount];
+        Rpp32f coeff = coeffTensor[batchCount];
+
+        if(borderType == RpptAudioBorderType::ZERO)
+            dstPtrTemp[0] = srcPtrTemp[0];
+        else if(borderType == RpptAudioBorderType::CLAMP)
+        {
+            Rpp32f border = srcPtrTemp[0];
+            dstPtrTemp[0] = srcPtrTemp[0] - coeff * border;
+        }
+        else if(borderType == RpptAudioBorderType::REFLECT)
+        {
+            Rpp32f border = srcPtrTemp[1];
+            dstPtrTemp[0] = srcPtrTemp[0] - coeff * border;
+        }
+
+        Rpp32s vectorIncrement = 8;
+        Rpp32s alignedLength = (bufferLength / 8) * 8;
+        __m256 pCoeff = _mm256_set1_ps(coeff);
+
+        Rpp32s vectorLoopCount = 1;
+        dstPtrTemp++;
+        srcPtrTemp++;
+        for(; vectorLoopCount < alignedLength; vectorLoopCount += vectorIncrement)
+        {
+            __m256 pSrc[2];
+            pSrc[0] = _mm256_loadu_ps(srcPtrTemp);
+            pSrc[1] = _mm256_loadu_ps(srcPtrTemp - 1);
+            pSrc[1] = _mm256_sub_ps(pSrc[0], _mm256_mul_ps(pSrc[1], pCoeff));
+            _mm256_storeu_ps(dstPtrTemp, pSrc[1]);
+            srcPtrTemp += vectorIncrement;
+            dstPtrTemp += vectorIncrement;
+        }
+
+        for(; vectorLoopCount < bufferLength; vectorLoopCount++)
+        {
+            *dstPtrTemp++ = *srcPtrTemp - coeff * (*(srcPtrTemp - 1));
+            srcPtrTemp++;
+        }
+
+    }
+
+    return RPP_SUCCESS;
+}

src/modules/cpu/kernel/to_decibels.hpp

@@ -0,0 +1,106 @@
+/*
+Copyright (c) 2019 - 2023 Advanced Micro Devices, Inc. All rights reserved.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+*/
+
+#include "rppdefs.h"
+#include <omp.h>
+
+RppStatus to_decibels_host_tensor(Rpp32f *srcPtr,
+                                  RpptDescPtr srcDescPtr,
+                                  Rpp32f *dstPtr,
+                                  RpptDescPtr dstDescPtr,
+                                  RpptImagePatchPtr srcDims,
+                                  Rpp32f cutOffDB,
+                                  Rpp32f multiplier,
+                                  Rpp32f referenceMagnitude,
+                                  rpp::Handle& handle)
+{
+    Rpp32u numThreads = handle.GetNumThreads();
+
+    // Calculate the intermediate values needed for DB conversion
+    Rpp32f minRatio = std::pow(10, cutOffDB / multiplier);
+    if(minRatio == 0.0f)
+        minRatio = std::nextafter(0.0f, 1.0f);
+
+    const Rpp32f log10Factor = 0.3010299956639812;      //1 / std::log(10);
+    multiplier *= log10Factor;
+
+    omp_set_dynamic(0);
+#pragma omp parallel for num_threads(numThreads)
+    for(int batchCount = 0; batchCount < srcDescPtr->n; batchCount++)
+    {
+        Rpp32f *srcPtrCurrent = srcPtr + batchCount * srcDescPtr->strides.nStride;
+        Rpp32f *dstPtrCurrent = dstPtr + batchCount * dstDescPtr->strides.nStride;
+
+        Rpp32u height = srcDims[batchCount].height;
+        Rpp32u width = srcDims[batchCount].width;
+        Rpp32f refMag = referenceMagnitude;
+
+        // Compute maximum value in the input buffer
+        if(!referenceMagnitude)
+        {
+            refMag = -std::numeric_limits<Rpp32f>::max();
+            Rpp32f *srcPtrTemp = srcPtrCurrent;
+            if(width == 1)
+                refMag = std::max(refMag, *(std::max_element(srcPtrTemp, srcPtrTemp + height)));
+            else
+            {
+                for(int i = 0; i < height; i++)
+                {
+                    refMag = std::max(refMag, *(std::max_element(srcPtrTemp, srcPtrTemp + width)));
+                    srcPtrTemp += srcDescPtr->strides.hStride;
+                }
+            }
+        }
+
+        // Avoid division by zero
+        if(!refMag)
+            refMag = 1.0f;
+
+        Rpp32f invReferenceMagnitude = 1.f / refMag;
+        // Interpret as 1D array
+        if(width == 1)
+        {
+            for(Rpp32s vectorLoopCount = 0; vectorLoopCount < height; vectorLoopCount++)
+                *dstPtrCurrent++ = multiplier * std::log2(std::max(minRatio, (*srcPtrCurrent++) * invReferenceMagnitude));
+        }
+        else
+        {
+            Rpp32f *srcPtrRow, *dstPtrRow;
+            srcPtrRow = srcPtrCurrent;
+            dstPtrRow = dstPtrCurrent;
+            for(int i = 0; i < height; i++)
+            {
+                Rpp32f *srcPtrTemp, *dstPtrTemp;
+                srcPtrTemp = srcPtrRow;
+                dstPtrTemp = dstPtrRow;
+                Rpp32s vectorLoopCount = 0;
+                for(; vectorLoopCount < width; vectorLoopCount++)
+                    *dstPtrTemp++ = multiplier * std::log2(std::max(minRatio, (*srcPtrTemp++) * invReferenceMagnitude));
+
+                srcPtrRow += srcDescPtr->strides.hStride;
+                dstPtrRow += dstDescPtr->strides.hStride;
+            }
+        }
+    }
+
+    return RPP_SUCCESS;
+}

src/modules/rppt_tensor_audio_augmentations.cpp

@@ -60,3 +60,67 @@ RppStatus rppt_non_silent_region_detection_host(RppPtr_t srcPtr,
 
     return RPP_SUCCESS;
 }
+
+/******************** to_decibels ********************/
+
+RppStatus rppt_to_decibels_host(RppPtr_t srcPtr,
+                                RpptDescPtr srcDescPtr,
+                                RppPtr_t dstPtr,
+                                RpptDescPtr dstDescPtr,
+                                RpptImagePatchPtr srcDims,
+                                Rpp32f cutOffDB,
+                                Rpp32f multiplier,
+                                Rpp32f referenceMagnitude,
+                                rppHandle_t rppHandle)
+{
+    if (multiplier == 0)
+        return RPP_ERROR_ZERO_DIVISION;
+    if ((srcDescPtr->dataType == RpptDataType::F32) && (dstDescPtr->dataType == RpptDataType::F32))
+    {
+        to_decibels_host_tensor(static_cast<Rpp32f*>(srcPtr),
+                                srcDescPtr,
+                                static_cast<Rpp32f*>(dstPtr),
+                                dstDescPtr,
+                                srcDims,
+                                cutOffDB,
+                                multiplier,
+                                referenceMagnitude,
+                                rpp::deref(rppHandle));
+
+        return RPP_SUCCESS;
+    }
+    else
+    {
+        return RPP_ERROR_INVALID_SRC_OR_DST_DATATYPE;
+    }
+}
+
+/******************** pre_emphasis_filter ********************/
+
+RppStatus rppt_pre_emphasis_filter_host(RppPtr_t srcPtr,
+                                        RpptDescPtr srcDescPtr,
+                                        RppPtr_t dstPtr,
+                                        RpptDescPtr dstDescPtr,
+                                        Rpp32s *srcLengthTensor,
+                                        Rpp32f *coeffTensor,
+                                        RpptAudioBorderType borderType,
+                                        rppHandle_t rppHandle)
+{
+    if ((srcDescPtr->dataType == RpptDataType::F32) && (dstDescPtr->dataType == RpptDataType::F32))
+    {
+        pre_emphasis_filter_host_tensor(static_cast<Rpp32f*>(srcPtr),
+                                        srcDescPtr,
+                                        static_cast<Rpp32f*>(dstPtr),
+                                        dstDescPtr,
+                                        srcLengthTensor,
+                                        coeffTensor,
+                                        borderType,
+                                        rpp::deref(rppHandle));
+
+        return RPP_SUCCESS;
+    }
+    else
+    {
+        return RPP_ERROR_NOT_IMPLEMENTED;
+    }
+}

utilities/test_suite/CMakeLists.txt

@@ -115,4 +115,4 @@ if(Python3_FOUND)
 
 else()
   message("-- ${Yellow}Test Warning: Python3 must be installed to run RPP test_suite successfully!${ColourReset}")
-endif(Python3_FOUND)
+endif(Python3_FOUND)

utilities/test_suite/HIP/Tensor_hip.cpp

@@ -320,6 +320,18 @@ int main(int argc, char **argv)
     double wallTime;
     string testCaseName;
 
+    if(testCase == 82 && imagesMixed)
+    {
+        std::cerr<<"\n RICAP only works with same dimension images";
+        exit(0);
+    }
+
+    if(testCase == 82 && batchSize < 2)
+    {
+        std::cerr<<"\n RICAP only works with BatchSize > 1";
+        exit(0);
+    }
+
     // Initialize buffers for any reductionType functions
     void *reductionFuncResultArr;
     Rpp32u reductionFuncResultArrLength = srcDescPtr->n * 4;

utilities/test_suite/HOST/Tensor_host.cpp

@@ -318,6 +318,18 @@ int main(int argc, char **argv)
     double cpuTime, wallTime;
     string testCaseName;
 
+    if(testCase == 82 && imagesMixed)
+    {
+        std::cerr<<"\n RICAP only works with same dimension images";
+        exit(0);
+    }
+
+    if(testCase == 82 && batchSize < 2)
+    {
+        std::cerr<<"\n RICAP only works with BatchSize > 1";
+        exit(0);
+    }
+
     // Initialize buffers for any reductionType functions
     void *reductionFuncResultArr;
     Rpp32u reductionFuncResultArrLength = srcDescPtr->n * 4;