/home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-rpp/checkouts/develop/projects/rpp/api/rppdefs.h Source File

/home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-rpp/checkouts/develop/projects/rpp/api/rppdefs.h Source File#

RPP: /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-rpp/checkouts/develop/projects/rpp/api/rppdefs.h Source File
Go to the documentation of this file.
 /*
 MIT License
  
 Copyright (c) 2019 - 2025 Advanced Micro Devices, Inc.
  
 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.
 */
  
 #ifndef RPPDEFS_H
 #define RPPDEFS_H
  
 #include <stddef.h>
  
 #include <cmath>
 #if RPP_BACKEND_HIP
 #include <hip/hip_fp16.h>
 #endif  // RPP_BACKEND_HIP
 #if __has_include(<half/half.hpp>)
 #include <half/half.hpp>
 #else
 #include <half.hpp>
 #endif
 using halfhpp = half_float::half;
 typedef halfhpp Rpp16f;
  
 #if _WIN32
 #include <intrin.h>
 #elif defined(__x86_64__) || defined(_M_X64)
 #include <immintrin.h>
 #include <smmintrin.h>
 #include <x86intrin.h>
 #else
 // HIP device compiler cannot parse altivec.h ("vector" keyword clash),
 // so disable SIMDE native backends during GPU compilation passes.
 #if defined(__HIP_DEVICE_COMPILE__)
 #define SIMDE_NO_NATIVE
 #endif
 #define SIMDE_ENABLE_NATIVE_ALIASES
 #include <simde/x86/avx2.h>
 #include <simde/x86/f16c.h>
 #include <simde/x86/fma.h>
 // SIMDE bug: native alias block omits _MM_FROUND_NO_EXC
 #ifndef _MM_FROUND_NO_EXC
 #define _MM_FROUND_NO_EXC 0x08
 #endif
 #endif
 #include <vector>
  
 #define RPP_MIN_8U (0)
 #define RPP_MAX_8U (255)
 #define RPPT_MAX_DIMS (5)
 #define RPPT_MAX_DIMS_SAMPLE (4)
 #define RPPT_MAX_AUDIO_CHANNELS (16)
  
 #define RPP_RETURN_IF_ERROR(expr)                           \
     do {                                                    \
         RppStatus _rpp_status = (expr);                     \
         if (_rpp_status != RPP_SUCCESS) return _rpp_status; \
     } while (0)
  
 #if RPP_BACKEND_HIP
 #include <hip/hip_runtime.h>
 #define RPP_HOST_DEVICE __host__ __device__
  
 #define RPP_HIP_RETURN_IF_ERROR(expr)                                                          \
     do {                                                                                       \
         hipError_t _rpp_hip_err = (expr);                                                      \
         if (_rpp_hip_err != hipSuccess) {                                                      \
             fprintf(stderr, "HIP runtime error: %s returned %d at %s:%d", #expr, _rpp_hip_err, \
                     __FILE__, __LINE__);                                                       \
             return RPP_ERROR_HIP_RUNTIME;                                                      \
         }                                                                                      \
     } while (0)
  
 #define HIP_CHECK_LAUNCH_RETURN()                                                              \
     do {                                                                                       \
         hipError_t status = hipGetLastError();                                                 \
         if (status != hipSuccess) {                                                            \
             fprintf(stderr, "HIP kernel launch error: returned %d at %s:%d", status, __FILE__, \
                     __LINE__);                                                                 \
             return RPP_ERROR_HIP_LAUNCH;                                                       \
         }                                                                                      \
     } while (0)
 #else
 #define RPP_HOST_DEVICE
 #endif
  
 const float ONE_OVER_6 = 1.0f / 6;
 const float ONE_OVER_3 = 1.0f / 3;
 const float TWO_OVER_3 = 2.0f / 3;
 const float ONE_OVER_255 = 1.0f / 255;
 const uint MMS_MAX_SCRATCH_MEMORY = 115293120;  // maximum scratch memory size (in number of floats)
                                                 // needed for MMS buffer in RNNT training
 const uint SPECTROGRAM_MAX_SCRATCH_MEMORY =
     372877312;  // maximum scratch memory size (in number of floats) needed for spectrogram HIP
                 // kernel in RNNT training
 #define DROPOUT_FIXED_SEED 42  // Constant fixed seed for reproducing the dropout output
 #define RANDOM_ERASE_NOISE_BUFFER_SIDE \
     255  // Random erase spatial noise buffer height and width. Changing this constant will result
          // in QA test failures for tiled noise mapping
  
 /******************** RPP typedefs ********************/
  
 typedef unsigned char Rpp8u;
 typedef signed char Rpp8s;
 typedef unsigned short Rpp16u;
 typedef short Rpp16s;
 typedef unsigned int Rpp32u;
 typedef int Rpp32s;
 typedef unsigned long long Rpp64u;
 typedef long long Rpp64s;
 typedef float Rpp32f;
 typedef double Rpp64f;
 typedef void* RppPtr_t;
 typedef size_t RppSize_t;
  
 typedef enum {
     RPP_SUCCESS = 0,
     RPP_ERROR = -1,
     RPP_ERROR_INVALID_ARGUMENTS = -2,
     RPP_ERROR_LOW_OFFSET = -3,
     RPP_ERROR_ZERO_DIVISION = -4,
     RPP_ERROR_HIGH_SRC_DIMENSION = -5,
     RPP_ERROR_NOT_IMPLEMENTED = -6,
     RPP_ERROR_INVALID_SRC_CHANNELS = -7,
     RPP_ERROR_INVALID_DST_CHANNELS = -8,
     RPP_ERROR_INVALID_SRC_LAYOUT = -9,
     RPP_ERROR_INVALID_DST_LAYOUT = -10,
     RPP_ERROR_INVALID_SRC_DATATYPE = -11,
     RPP_ERROR_INVALID_DST_DATATYPE = -12,
     RPP_ERROR_INVALID_SRC_OR_DST_DATATYPE = -13,
     RPP_ERROR_INSUFFICIENT_DST_BUFFER_LENGTH = -14,
     RPP_ERROR_INVALID_PARAMETER_DATATYPE = -15,
     RPP_ERROR_NOT_ENOUGH_MEMORY = -16,
     RPP_ERROR_OUT_OF_BOUND_SRC_ROI = -17,
     RPP_ERROR_LAYOUT_MISMATCH = -18,
     RPP_ERROR_INVALID_CHANNELS = -19,
     RPP_ERROR_INVALID_OUTPUT_TILE_LENGTH = -20,
     RPP_ERROR_OUT_OF_BOUND_SHARED_MEMORY_SIZE = -21,
     RPP_ERROR_OUT_OF_BOUND_SCRATCH_MEMORY_SIZE = -22,
     RPP_ERROR_INVALID_SRC_DIMS = -23,
     RPP_ERROR_INVALID_DST_DIMS = -24,
     RPP_ERROR_INVALID_DIM_LENGTHS = -25,
     RPP_ERROR_INVALID_AXIS = -26,
     RPP_ERROR_INCOMPATIBLE_BACKEND = -27,
     RPP_ERROR_HIP_LAUNCH = -28,
     RPP_ERROR_HIP_RUNTIME = -29,
 } RppStatus;
  
 inline const char* rppGetStatusString(RppStatus status) noexcept {
     // A switch over string literals keeps this allocation-free and non-throwing, so it stays safe
     // to call from logging and error handling paths.
     switch (status) {
         case RPP_SUCCESS:
             return "RPP_SUCCESS";
         case RPP_ERROR:
             return "RPP_ERROR";
         case RPP_ERROR_INVALID_ARGUMENTS:
             return "RPP_ERROR_INVALID_ARGUMENTS";
         case RPP_ERROR_LOW_OFFSET:
             return "RPP_ERROR_LOW_OFFSET";
         case RPP_ERROR_ZERO_DIVISION:
             return "RPP_ERROR_ZERO_DIVISION";
         case RPP_ERROR_HIGH_SRC_DIMENSION:
             return "RPP_ERROR_HIGH_SRC_DIMENSION";
         case RPP_ERROR_NOT_IMPLEMENTED:
             return "RPP_ERROR_NOT_IMPLEMENTED";
         case RPP_ERROR_INVALID_SRC_CHANNELS:
             return "RPP_ERROR_INVALID_SRC_CHANNELS";
         case RPP_ERROR_INVALID_DST_CHANNELS:
             return "RPP_ERROR_INVALID_DST_CHANNELS";
         case RPP_ERROR_INVALID_SRC_LAYOUT:
             return "RPP_ERROR_INVALID_SRC_LAYOUT";
         case RPP_ERROR_INVALID_DST_LAYOUT:
             return "RPP_ERROR_INVALID_DST_LAYOUT";
         case RPP_ERROR_INVALID_SRC_DATATYPE:
             return "RPP_ERROR_INVALID_SRC_DATATYPE";
         case RPP_ERROR_INVALID_DST_DATATYPE:
             return "RPP_ERROR_INVALID_DST_DATATYPE";
         case RPP_ERROR_INVALID_SRC_OR_DST_DATATYPE:
             return "RPP_ERROR_INVALID_SRC_OR_DST_DATATYPE";
         case RPP_ERROR_INSUFFICIENT_DST_BUFFER_LENGTH:
             return "RPP_ERROR_INSUFFICIENT_DST_BUFFER_LENGTH";
         case RPP_ERROR_INVALID_PARAMETER_DATATYPE:
             return "RPP_ERROR_INVALID_PARAMETER_DATATYPE";
         case RPP_ERROR_NOT_ENOUGH_MEMORY:
             return "RPP_ERROR_NOT_ENOUGH_MEMORY";
         case RPP_ERROR_OUT_OF_BOUND_SRC_ROI:
             return "RPP_ERROR_OUT_OF_BOUND_SRC_ROI";
         case RPP_ERROR_LAYOUT_MISMATCH:
             return "RPP_ERROR_LAYOUT_MISMATCH";
         case RPP_ERROR_INVALID_CHANNELS:
             return "RPP_ERROR_INVALID_CHANNELS";
         case RPP_ERROR_INVALID_OUTPUT_TILE_LENGTH:
             return "RPP_ERROR_INVALID_OUTPUT_TILE_LENGTH";
         case RPP_ERROR_OUT_OF_BOUND_SHARED_MEMORY_SIZE:
             return "RPP_ERROR_OUT_OF_BOUND_SHARED_MEMORY_SIZE";
         case RPP_ERROR_OUT_OF_BOUND_SCRATCH_MEMORY_SIZE:
             return "RPP_ERROR_OUT_OF_BOUND_SCRATCH_MEMORY_SIZE";
         case RPP_ERROR_INVALID_SRC_DIMS:
             return "RPP_ERROR_INVALID_SRC_DIMS";
         case RPP_ERROR_INVALID_DST_DIMS:
             return "RPP_ERROR_INVALID_DST_DIMS";
         case RPP_ERROR_INVALID_DIM_LENGTHS:
             return "RPP_ERROR_INVALID_DIM_LENGTHS";
         case RPP_ERROR_INVALID_AXIS:
             return "RPP_ERROR_INVALID_AXIS";
         case RPP_ERROR_INCOMPATIBLE_BACKEND:
             return "RPP_ERROR_INCOMPATIBLE_BACKEND";
         case RPP_ERROR_HIP_LAUNCH:
             return "RPP_ERROR_HIP_LAUNCH";
         case RPP_ERROR_HIP_RUNTIME:
             return "RPP_ERROR_HIP_RUNTIME";
     }
  
     return "RPP_STATUS_UNKNOWN";
 }
  
 typedef enum { RPP_HOST_BACKEND, RPP_HIP_BACKEND } RppBackend;
  
 typedef enum {
     rppStatusSuccess = 0,
     rppStatusBadParm = -1,
     rppStatusUnknownError = -2,
     rppStatusNotInitialized = -3,
     rppStatusInvalidValue = -4,
     rppStatusAllocFailed = -5,
     rppStatusInternalError = -6,
     rppStatusNotImplemented = -7,
     rppStatusUnsupportedOp = -8,
 } rppStatus_t;
  
 typedef enum {
     RPP_TENSOR_OP_ADD,
     RPP_TENSOR_OP_SUBTRACT,
     RPP_TENSOR_OP_MULTIPLY,
     RPP_TENSOR_OP_DIVIDE
 } RpptOp;
  
 typedef enum { RPP_TENSOR_OP_AND, RPP_TENSOR_OP_OR, RPP_TENSOR_OP_XOR } RpptBitwiseOp;
  
 typedef enum {
     RPP_BROADCAST_ENABLE,
     RPP_BROADCAST_DISABLE  // Broadcasting is disabled; Requires input tensors to be of the same
                            // shape
 } RpptBroadcastMode;
  
 typedef struct {
     Rpp32u channelParam;
     Rpp32u bufferMultiplier;
 } RppLayoutParams;
  
 typedef struct {
     Rpp32f data[6];
 } Rpp32f6;
  
 typedef struct {
     Rpp32f data[9];
 } Rpp32f9;
  
 typedef struct {
     Rpp32s data[24];
 } Rpp32s24;
  
 typedef struct {
     Rpp32f data[24];
 } Rpp32f24;
  
 /******************** RPPT typedefs ********************/
  
 typedef enum { U8, F32, F16, I8, I16, U16, I32, U32 } RpptDataType;
  
 typedef enum {
     NCHW,   // BatchSize-Channels-Height-Width
     NHWC,   // BatchSize-Height-Width-Channels
     NCDHW,  // BatchSize-Channels-Depth-Height-Width
     NDHWC,  // BatchSize-Depth-Height-Width-Channels
     NHW,    // BatchSize-Height-Width
     NFT,    // BatchSize-Frequency-Time -> Frequency Major used for Spectrogram / MelfilterBank
     NTF     // BatchSize-Time-Frequency -> Time Major used for Spectrogram / MelfilterBank
 } RpptLayout;
  
 typedef enum {
     RpptColorStandard_BT709 = 0,      
     RpptColorStandard_FCC = 4,        
     RpptColorStandard_BT470BG = 5,    
     RpptColorStandard_BT601 = 6,      
     RpptColorStandard_SMPTE240M = 7,  
     RpptColorStandard_BT2020_NCL = 9, 
     RpptColorStandard_BT2020_CL = 10  
 } RpptColorStandard;
  
 typedef enum {
     RpptColorRange_STUDIO = 0, 
     RpptColorRange_FULL = 2    
 } RpptColorRange;
  
 typedef enum {
     LTRB,  // Left-Top-Right-Bottom
     XYWH   // X-Y-Width-Height
 } RpptRoiType;
  
 typedef enum {
     LTFRBB,  // Left-Top-Front-Right-Bottom-Back
     XYZWHD   // X-Y-Z-Width-Height-Depth
 } RpptRoi3DType;
  
 typedef enum { RGBtype, BGRtype } RpptSubpixelLayout;
  
 typedef enum {
     NEAREST_NEIGHBOR = 0,
     BILINEAR,
     BICUBIC,
     LANCZOS,
     GAUSSIAN,
     TRIANGULAR
 } RpptInterpolationType;
  
 typedef enum { ZERO = 0, CLAMP, REFLECT } RpptAudioBorderType;
  
 typedef enum { TOP_EDGE = 0, BOTTOM_EDGE, LEFT_EDGE, RIGHT_EDGE } RpptImageBorderEdge;
  
 typedef enum {
     REPLICATE = 0,   // Similar to Nearest Neighbors Padding
     CONSTANT,        // Unsupported Border Type
     REFLECT_NO_EDGE  // Unsupported Border Type
 } RpptImageBorderType;
  
 typedef enum {
     SLANEY = 0,  // Follows Slaney’s MATLAB Auditory Modelling Work behavior
     HTK,  // Follows O’Shaughnessy’s book formula, consistent with Hidden Markov Toolkit(HTK), m =
           // 2595 * log10(1 + (f/700))
 } RpptMelScaleFormula;
  
 typedef struct {
     int x;
     int y;
 } RpptPoint2D;
  
 typedef struct {
     int x;
     int y;
     int z;
 } RpptPoint3D;
  
 typedef struct {
     RpptPoint2D lt, rb;  // Left-Top point and Right-Bottom point
  
 } RpptRoiLtrb;
  
 typedef struct {
     RpptPoint2D r;
     RpptPoint2D g;
     RpptPoint2D b;
 } RpptChannelOffsets;
  
 typedef struct {
     RpptPoint3D ltf, rbb;  // Left-Top-Front point and Right-Bottom-Back point
  
 } RpptRoiLtfrbb;
  
 typedef struct {
     RpptPoint2D xy;
     int roiWidth, roiHeight;
  
 } RpptRoiXywh;
  
 typedef struct {
     RpptPoint3D xyz;
     int roiWidth, roiHeight, roiDepth;
  
 } RpptRoiXyzwhd;
  
 typedef union {
     RpptRoiLtrb ltrbROI;  // ROI defined as Left-Top-Right-Bottom
     RpptRoiXywh xywhROI;  // ROI defined as X-Y-Width-Height
  
 } RpptROI, *RpptROIPtr;
  
 typedef union {
     RpptRoiLtfrbb ltfrbbROI;  // ROI defined as Left-Top-Front-Right-Bottom-Back
     RpptRoiXyzwhd xyzwhdROI;  // ROI defined as X-Y-Z-Width-Height-Depth
  
 } RpptROI3D, *RpptROI3DPtr;
  
 typedef struct {
     Rpp32u nStride;
     Rpp32u cStride;
     Rpp32u hStride;
     Rpp32u wStride;
 } RpptStrides;
  
 struct RpptDesc {
     RppSize_t numDims = 4;
     Rpp32u offsetInBytes = 0;
     RpptDataType dataType;
     Rpp32u n, c, h, w;
     RpptStrides strides;
     RpptLayout layout;
  
     RpptDesc() = default;
  
     RpptDesc(Rpp32u n, Rpp32u c, Rpp32u h, Rpp32u w, RpptDataType dataType, RpptLayout layout)
         : dataType(dataType), n(n), c(c), h(h), w(w), layout(layout) {
         if (layout == NCHW) {
             strides.nStride = c * h * w;
             strides.cStride = h * w;
             strides.hStride = w;
             strides.wStride = 1;
         } else if (layout == NHWC) {
             strides.nStride = h * w * c;
             strides.hStride = w * c;
             strides.wStride = c;
             strides.cStride = 1;
         }
     }
  
     RpptDesc(Rpp32u n, Rpp32u c, Rpp32u h, Rpp32u w, RpptDataType dataType, RpptLayout layout,
              Rpp32u offsetInBytes, RpptStrides strides)
         : offsetInBytes(offsetInBytes),
           dataType(dataType),
           n(n),
           c(c),
           h(h),
           w(w),
           strides(strides),
           layout(layout) {}
 };
 typedef RpptDesc* RpptDescPtr;
  
 typedef struct {
     RppSize_t numDims;
     Rpp32u offsetInBytes;
     RpptDataType dataType;
     Rpp32u dims[RPPT_MAX_DIMS];
     Rpp32u strides[RPPT_MAX_DIMS];
     RpptLayout layout;
 } RpptGenericDesc, *RpptGenericDescPtr;
  
 typedef struct {
     Rpp8u R;
     Rpp8u G;
     Rpp8u B;
 } RpptRGB;
  
 typedef struct {
     Rpp32f R;
     Rpp32f G;
     Rpp32f B;
 } RpptFloatRGB;
  
 typedef struct {
     Rpp32u x;
     Rpp32u y;
 } RpptUintVector2D;
  
 typedef struct {
     Rpp32f x;
     Rpp32f y;
 } RpptFloatVector2D;
  
 typedef struct {
     Rpp32u width;
     Rpp32u height;
 } RpptImagePatch, *RpptImagePatchPtr;
  
 typedef struct {
     Rpp32u x[5];
     Rpp32u counter;
 } RpptXorwowState;
  
 typedef struct {
     Rpp32s x[5];
     Rpp32s counter;
     int boxMullerFlag;
     float boxMullerExtra;
 } RpptXorwowStateBoxMuller;
  
 typedef struct {
     Rpp32s24 srcLocsTL;
     Rpp32s24 srcLocsTR;
     Rpp32s24 srcLocsBL;
     Rpp32s24 srcLocsBR;
 } RpptBilinearNbhoodLocsVecLen8;
  
 typedef struct {
     Rpp32f24 srcValsTL;
     Rpp32f24 srcValsTR;
     Rpp32f24 srcValsBL;
     Rpp32f24 srcValsBR;
 } RpptBilinearNbhoodValsVecLen8;
  
 typedef struct GenericFilter {
     Rpp32f scale = 1.0f;
     Rpp32f radius = 1.0f;
     Rpp32s size;
     GenericFilter(RpptInterpolationType interpolationType, Rpp32s in_size, Rpp32s out_size,
                   Rpp32f scaleRatio) {
         switch (interpolationType) {
             case RpptInterpolationType::BICUBIC: {
                 this->radius = 2.0f;
                 break;
             }
             case RpptInterpolationType::LANCZOS: {
                 if (in_size > out_size) {
                     this->radius = 3.0f * scaleRatio;
                     this->scale = (1 / scaleRatio);
                 } else
                     this->radius = 3.0f;
                 break;
             }
             case RpptInterpolationType::GAUSSIAN: {
                 if (in_size > out_size) {
                     this->radius = scaleRatio;
                     this->scale = (1 / scaleRatio);
                 }
                 break;
             }
             case RpptInterpolationType::TRIANGULAR: {
                 if (in_size > out_size) {
                     this->radius = scaleRatio;
                     this->scale = (1 / scaleRatio);
                 }
                 break;
             }
             default: {
                 this->radius = 1.0f;
                 this->scale = 1.0f;
                 break;
             }
         }
         this->size = std::ceil(2 * this->radius);
     }
 } GenericFilter;
  
 typedef struct RpptResamplingWindow {
     inline RPP_HOST_DEVICE void input_range(Rpp32f x, Rpp32s* loc0, Rpp32s* loc1) {
         Rpp32s xc = std::ceil(x);
         *loc0 = xc - lobes;
         *loc1 = xc + lobes;
     }
  
     inline Rpp32f operator()(Rpp32f x) {
         Rpp32f locRaw = x * scale + center;
         Rpp32s locFloor = std::floor(locRaw);
         Rpp32f weight = locRaw - locFloor;
         locFloor = std::max(std::min(locFloor, lookupSize - 2), 0);
         Rpp32f current = lookup[locFloor];
         Rpp32f next = lookup[locFloor + 1];
         return current + weight * (next - current);
     }
  
     inline __m128 operator()(__m128 x) {
         __m128 pLocRaw = _mm_add_ps(_mm_mul_ps(x, pScale), pCenter);
         __m128i pxLocFloor = _mm_cvttps_epi32(pLocRaw);
         __m128 pLocFloor = _mm_cvtepi32_ps(pxLocFloor);
         __m128 pWeight = _mm_sub_ps(pLocRaw, pLocFloor);
         Rpp32s idx[4];
         _mm_storeu_si128(reinterpret_cast<__m128i*>(idx), pxLocFloor);
         __m128 pCurrent =
             _mm_setr_ps(lookup[idx[0]], lookup[idx[1]], lookup[idx[2]], lookup[idx[3]]);
         __m128 pNext = _mm_setr_ps(lookup[idx[0] + 1], lookup[idx[1] + 1], lookup[idx[2] + 1],
                                    lookup[idx[3] + 1]);
         return _mm_add_ps(pCurrent, _mm_mul_ps(pWeight, _mm_sub_ps(pNext, pCurrent)));
     }
  
     Rpp32f scale = 1, center = 1;
     Rpp32s lobes = 0, coeffs = 0;
     Rpp32s lookupSize = 0;
     Rpp32f* lookupPinned = nullptr;
     std::vector<Rpp32f> lookup;
     __m128 pCenter, pScale;
 } RpptResamplingWindow;
  
 struct BaseMelScale {
    public:
     inline RPP_HOST_DEVICE virtual Rpp32f hz_to_mel(Rpp32f hz) = 0;
     inline RPP_HOST_DEVICE virtual Rpp32f mel_to_hz(Rpp32f mel) = 0;
     virtual ~BaseMelScale() = default;
 };
  
 struct HtkMelScale : public BaseMelScale {
     inline RPP_HOST_DEVICE Rpp32f hz_to_mel(Rpp32f hz) {
         return 1127.0f * std::log(1.0f + (hz / 700.0f));
     }
     inline RPP_HOST_DEVICE Rpp32f mel_to_hz(Rpp32f mel) {
         return 700.0f * (std::exp(mel / 1127.0f) - 1.0f);
     }
  
    public:
     ~HtkMelScale() {};
 };
  
 struct SlaneyMelScale : public BaseMelScale {
     const Rpp32f freqLow = 0;
     const Rpp32f fsp = 66.666667f;
     const Rpp32f minLogHz = 1000.0;
     const Rpp32f minLogMel = (minLogHz - freqLow) / fsp;
     const Rpp32f stepLog = 0.068751777;  // Equivalent to std::log(6.4) / 27.0;
  
     const Rpp32f invMinLogHz = 0.001f;
     const Rpp32f invStepLog = 1.0f / stepLog;
     const Rpp32f invFsp = 1.0f / fsp;
  
     inline RPP_HOST_DEVICE Rpp32f hz_to_mel(Rpp32f hz) {
         Rpp32f mel = 0.0f;
         if (hz >= minLogHz)
             mel = minLogMel + std::log(hz * invMinLogHz) * invStepLog;
         else
             mel = (hz - freqLow) * invFsp;
  
         return mel;
     }
  
     inline RPP_HOST_DEVICE Rpp32f mel_to_hz(Rpp32f mel) {
         Rpp32f hz = 0.0f;
         if (mel >= minLogMel)
             hz = minLogHz * std::exp(stepLog * (mel - minLogMel));
         else
             hz = freqLow + mel * fsp;
         return hz;
     }
  
    public:
     ~SlaneyMelScale() {};
 };
  
 /******************** HOST memory typedefs ********************/
  
 typedef struct {
     Rpp32f* scratchBufferHost;
 } memCPU;
  
 #if RPP_BACKEND_HIP
  
 /******************** HIP memory typedefs ********************/
  
 typedef struct {
     Rpp32f* floatmem;
 } hipMemRpp32f;
  
 typedef struct {
     hipMemRpp32f scratchBufferHip;
     hipMemRpp32f scratchBufferPinned;
 } memGPU;
  
 typedef struct {
     memCPU mcpu;
     memGPU mgpu;
 } memMgmt;
  
 #else
  
 typedef struct {
     memCPU mcpu;
 } memMgmt;
  
 #endif  // BACKEND
  
 typedef struct {
     RppPtr_t cpuHandle;
     Rpp32u nbatchSize;
     memMgmt mem;
 } InitHandle;
  
 #endif /* RPPDEFS_H */