Audio PR - Augmentation support [ Non Silent Region Detection and Slice ]

CHANGELOG.md

@@ -14,6 +14,7 @@ Documentation for MIVisionX is available at
 * Support for Spectrogram augmentation in openVX extensions
 * Support for Downmix and ToDecibels augmentations in openVX extensions
 * Support for Resample augmentation and Operator overloading nodes in openVX extensions
+* Support for NonSilentRegion and Slice augmentations in openVX extensions
 
 ### Optimizations
 

amd_openvx_extensions/amd_rpp/CMakeLists.txt

@@ -146,6 +146,7 @@ list(APPEND SOURCES
         source/tensor/Jitter.cpp
         source/tensor/LensCorrection.cpp
         source/tensor/Noise.cpp
+        source/tensor/NonSilentRegionDetection.cpp
         source/tensor/Nop.cpp
         source/tensor/Rotate.cpp
         source/tensor/Pixelate.cpp
@@ -165,6 +166,7 @@ list(APPEND SOURCES
         source/tensor/ToDecibels.cpp
         source/tensor/Vignette.cpp
         source/tensor/WarpAffine.cpp
+        source/tensor/Slice.cpp
         source/kernel_rpp.cpp
         source/internal_publishKernels.cpp
     )

amd_openvx_extensions/amd_rpp/include/internal_publishKernels.h

@@ -162,6 +162,8 @@ vx_status ToDecibels_Register(vx_context);
 vx_status Resample_Register(vx_context);
 vx_status TensorMulScalar_Register(vx_context);
 vx_status TensorAddTensor_Register(vx_context);
+vx_status NonSilentRegionDetection_Register(vx_context);
+vx_status Slice_Register(vx_context);
 
 // kernel names
 #define VX_KERNEL_RPP_NOPBATCHPD_NAME                           "org.rpp.NopbatchPD"
@@ -293,5 +295,7 @@ vx_status TensorAddTensor_Register(vx_context);
 #define VX_KERNEL_RPP_RESAMPLE_NAME                             "org.rpp.Resample"
 #define VX_KERNEL_RPP_TENSORMULSCALAR_NAME                      "org.rpp.TensorMulScalar"
 #define VX_KERNEL_RPP_TENSORADDTENSOR_NAME                      "org.rpp.TensorAddTensor"
+#define VX_KERNEL_RPP_NONSILENTREGIONDETECTION_NAME             "org.rpp.NonSilentRegionDetection"
+#define VX_KERNEL_RPP_SLICE_NAME                                "org.rpp.Slice"
 
 #endif //_AMDVX_EXT__PUBLISH_KERNELS_H_

amd_openvx_extensions/amd_rpp/include/internal_rpp.h

@@ -92,7 +92,8 @@ vx_node createNode(vx_graph graph, vx_enum kernelEnum, vx_reference params[], vx
 vx_status createRPPHandle(vx_node node, vxRppHandle ** pHandle, Rpp32u batchSize, Rpp32u deviceType);
 vx_status releaseRPPHandle(vx_node node, vxRppHandle * handle, Rpp32u deviceType);
 void fillDescriptionPtrfromDims(RpptDescPtr &descPtr, vxTensorLayout layout, size_t *tensorDims);
-void fillAudioDescriptionPtrFromDims(RpptDescPtr &descPtr, size_t *tensorDims, vxTensorLayout layout = vxTensorLayout::VX_NHW);
+void fillGenericDescriptionPtrfromDims(RpptGenericDescPtr &genericDescPtr, vxTensorLayout layout, size_t *maxTensorDims);
+void fillAudioDescriptionPtrFromDims(RpptDescPtr &descPtr, size_t *maxTensorDims, vxTensorLayout layout = vxTensorLayout::VX_NHW);
 RpptDataType getRpptDataType(vx_enum dataType);
 
 class Kernellist

amd_openvx_extensions/amd_rpp/include/kernels_rpp.h

@@ -154,7 +154,9 @@ extern "C"
         VX_KERNEL_RPP_TODECIBELS = VX_KERNEL_BASE(VX_ID_AMD, VX_LIBRARY_RPP) + 0x77,
         VX_KERNEL_RPP_RESAMPLE = VX_KERNEL_BASE(VX_ID_AMD, VX_LIBRARY_RPP) + 0x78,
         VX_KERNEL_RPP_TENSORMULSCALAR = VX_KERNEL_BASE(VX_ID_AMD, VX_LIBRARY_RPP) + 0x79,
-        VX_KERNEL_RPP_TENSORADDTENSOR = VX_KERNEL_BASE(VX_ID_AMD, VX_LIBRARY_RPP) + 0x7a
+        VX_KERNEL_RPP_TENSORADDTENSOR = VX_KERNEL_BASE(VX_ID_AMD, VX_LIBRARY_RPP) + 0x7a,
+        VX_KERNEL_RPP_NONSILENTREGIONDETECTION = VX_KERNEL_BASE(VX_ID_AMD, VX_LIBRARY_RPP) + 0x7b,
+        VX_KERNEL_RPP_SLICE = VX_KERNEL_BASE(VX_ID_AMD, VX_LIBRARY_RPP) + 0x7c,
     };
 
 #ifdef __cplusplus

amd_openvx_extensions/amd_rpp/include/vx_ext_rpp.h

@@ -1957,6 +1957,38 @@ extern "C"
 	 */
 	SHARED_PUBLIC vx_node VX_API_CALL vxExtRppTensorAddTensor(vx_graph graph, vx_tensor pSrc1, vx_tensor pSrc2, vx_tensor pDst, vx_tensor pSrcRoi, vx_tensor pDstRoi);
 
+	/*! \brief [Graph] Performs leading and trailing silence detection to the input tensor.
+	* \ingroup group_amd_rpp
+	* \param [in] graph The handle to the graph.
+	* \param [in] pSrc The input tensor in <tt>\ref VX_TYPE_FLOAT32</tt> format data.
+	* \param [in] pSrcRoi The input tensor in <tt>unsigned int<tt> containing the roi values for each input in the format <begin_dim1, begin_dim2 .., length_dim1, length_dim2> format for each dimension.
+	* \param [out] pBegin The output tensor containing begin values of the non-silent region of the audio-data in <tt>\ref VX_TYPE_INT32</tt> format data.
+	* \param [out] pLength The output tensor containing length values of the non-silent region of the audio-data in <tt>\ref VX_TYPE_INT32</tt> format data.
+	* \param [in] cutOffDB The input scalar in <tt>\ref VX_TYPE_FLOAT32</tt> format containing the threshold, in dB, below which the signal is considered silent.
+	* \param [in] referencePower The input scalar in <tt>\ref VX_TYPE_FLOAT32</tt> format containing the reference power used for converting the signal to dB.
+	* \param [in] windowLength The input scalar in <tt>\ref VX_TYPE_INT32</tt> format containing the size of the sliding window.
+	* \param [in] resetInterval The input scalar in <tt>\ref VX_TYPE_INT32</tt> format containing the frequency at which the moving mean average is recalculated to mitigate precision loss.
+	* \return A node reference <tt>\ref vx_node</tt>. Any possible errors preventing a successful creation should be checked using <tt>\ref vxGetStatus</tt>.
+	*/
+	SHARED_PUBLIC vx_node VX_API_CALL vxExtRppNonSilentRegionDetection(vx_graph graph, vx_tensor pSrc, vx_tensor pSrcRoi, vx_tensor pDst1, vx_tensor pDst2, vx_scalar cutOffDB, vx_scalar referencePower, vx_scalar windowLength, vx_scalar resetInterval);
+
+	/*! \brief [Graph] Slice's the input tensor using anchors and shapes values
+	* \ingroup group_amd_rpp
+	* \param [in] graph The handle to the graph.
+	* \param [in] pSrc The input tensor in <tt>\ref VX_TYPE_UINT8</tt> or <tt>\ref VX_TYPE_FLOAT32</tt> format data.
+	* \param [in] pSrcRoi The input tensor in <tt>unsigned int<tt> format containing the roi values for the input format <begin_dim1, begin_dim2 .., length_dim1, length_dim2> format for each dimension.
+	* \param [out] pDst The output tensor in <tt>\ref VX_TYPE_UINT8</tt> or <tt>\ref VX_TYPE_FLOAT32</tt> format data.
+	* \param [in] pDstRoi The input tensor in <tt>unsigned int<tt> format containing the roi values for the output tensor format <begin_dim1, begin_dim2 .., length_dim1, length_dim2> format for each dimension.
+	* \param [in] pAnchor The input array in <tt>\ref VX_TYPE_INT32</tt> format containing the absolute coordinates for the starting point of the slice.
+	* \param [in] pShape The input array in <tt>\ref VX_TYPE_INT32</tt> format containing the absolute coordinates for the dimensions of the slice
+	* \param [in] pFillValue The input array in <tt>\ref VX_TYPE_INT32</tt> format which determines the values to be padded and is only relevant if policy is set to “pad”.
+	* \param [in] policy The input scalar in <tt>\ref VX_TYPE_INT32</tt> format which determines the policy when slicing the out of bounds area of the input. The values can be "error", "pad", "trim_to_shape"
+	* \param [in] inputLayout The input scalar in <tt>\ref VX_TYPE_INT32</tt> format containing the layout of the input tensor.
+	* \param [in] roiType The input scalar in <tt>\ref VX_TYPE_INT32</tt> format containing the roi type which can be ltrb/xywh.
+	* \return A node reference <tt>\ref vx_node</tt>. Any possible errors preventing a successful creation should be checked using <tt>\ref vxGetStatus</tt>.
+	*/
+	SHARED_PUBLIC vx_node VX_API_CALL vxExtRppSlice(vx_graph graph, vx_tensor pSrc, vx_tensor pSrcRoi, vx_tensor pDst, vx_tensor pDstRoi, vx_tensor pAnchor, vx_tensor pShape, vx_array pFillValue, vx_scalar policy, vx_scalar inputLayout, vx_scalar roiType);
+
 #ifdef __cplusplus
 }
 #endif

amd_openvx_extensions/amd_rpp/source/internal_publishKernels.cpp

@@ -167,7 +167,8 @@ vx_status get_kernels_to_publish()
     STATUS_ERROR_CHECK(ADD_KERNEL(Resample_Register));
     STATUS_ERROR_CHECK(ADD_KERNEL(TensorMulScalar_Register));
     STATUS_ERROR_CHECK(ADD_KERNEL(TensorAddTensor_Register));
-
+    STATUS_ERROR_CHECK(ADD_KERNEL(NonSilentRegionDetection_Register));
+    STATUS_ERROR_CHECK(ADD_KERNEL(Slice_Register));
     return status;
 }
 

amd_openvx_extensions/amd_rpp/source/kernel_rpp.cpp

@@ -2584,6 +2584,51 @@ VX_API_ENTRY vx_node VX_API_CALL vxExtRppSpectrogram(vx_graph graph, vx_tensor p
     return node;
 }
 
+VX_API_ENTRY vx_node VX_API_CALL vxExtRppNonSilentRegionDetection(vx_graph graph, vx_tensor pSrc, vx_tensor pSrcRoi, vx_tensor pBegin, vx_tensor pLength, vx_scalar cutOffDB, vx_scalar referencePower, vx_scalar windowLength, vx_scalar resetInterval) {
+    vx_node node = NULL;
+    vx_context context = vxGetContext((vx_reference)graph);
+    if (vxGetStatus((vx_reference)context) == VX_SUCCESS) {
+        vx_uint32 devType = getGraphAffinity(graph);
+        vx_scalar deviceType = vxCreateScalar(vxGetContext((vx_reference)graph), VX_TYPE_UINT32, &devType);
+        vx_reference params[] = {
+            (vx_reference)pSrc,
+            (vx_reference)pSrcRoi,
+            (vx_reference)pBegin,
+            (vx_reference)pLength,
+            (vx_reference)cutOffDB,
+            (vx_reference)referencePower,
+            (vx_reference)windowLength,
+            (vx_reference)resetInterval,
+            (vx_reference)deviceType};
+        node = createNode(graph, VX_KERNEL_RPP_NONSILENTREGIONDETECTION, params, 9);
+    }
+    return node;
+}
+
+VX_API_ENTRY vx_node VX_API_CALL vxExtRppSlice(vx_graph graph, vx_tensor pSrc, vx_tensor pSrcRoi, vx_tensor pDst, vx_tensor pDstRoi, vx_tensor pAnchor, vx_tensor pShape,
+                                               vx_array pFillValue, vx_scalar policy, vx_scalar inputLayout, vx_scalar roiType) {
+    vx_node node = NULL;
+    vx_context context = vxGetContext((vx_reference)graph);
+    if (vxGetStatus((vx_reference)context) == VX_SUCCESS) {
+        vx_uint32 devType = getGraphAffinity(graph);
+        vx_scalar deviceType = vxCreateScalar(vxGetContext((vx_reference)graph), VX_TYPE_UINT32, &devType);
+        vx_reference params[] = {
+            (vx_reference)pSrc,
+            (vx_reference)pSrcRoi,
+            (vx_reference)pDst,
+            (vx_reference)pDstRoi,
+            (vx_reference)pAnchor,
+            (vx_reference)pShape,
+            (vx_reference)pFillValue,
+            (vx_reference)policy,
+            (vx_reference)inputLayout,
+            (vx_reference)roiType,
+            (vx_reference)deviceType};
+        node = createNode(graph, VX_KERNEL_RPP_SLICE, params, 11);
+    }
+    return node;
+}
+
 VX_API_ENTRY vx_node VX_API_CALL vxExtRppDownmix(vx_graph graph, vx_tensor pSrc, vx_tensor pDst, vx_tensor pSrcRoi) {
     vx_node node = NULL;
     vx_context context = vxGetContext((vx_reference)graph);
@@ -2762,6 +2807,25 @@ void fillAudioDescriptionPtrFromDims(RpptDescPtr &descPtr, size_t *maxTensorDims
     }
 }
 
+void fillGenericDescriptionPtrfromDims(RpptGenericDescPtr &genericDescPtr, vxTensorLayout layout, size_t *maxTensorDims) {
+    if (layout != vxTensorLayout::VX_NHW && layout != vxTensorLayout::VX_NFT && layout != vxTensorLayout::VX_NTF)
+        throw std::runtime_error("Invalid layout value in fillGenericDescriptionPtrfromDims, currently supports only NHW/NFT/NTF layouts");
+    else if(tensorLayoutMapping.find(layout) != tensorLayoutMapping.end())
+        genericDescPtr->layout = tensorLayoutMapping.at(layout);
+
+    genericDescPtr->dims[0] = maxTensorDims[0];
+    genericDescPtr->dims[1] = maxTensorDims[1];
+    genericDescPtr->dims[2] = maxTensorDims[2];
+    genericDescPtr->dims[3] = 1;
+    if(genericDescPtr->dims[2] == 1)
+        genericDescPtr->numDims = 2;
+    else
+        genericDescPtr->numDims = 3;
+    genericDescPtr->strides[0] = genericDescPtr->dims[1] * genericDescPtr->dims[2] * genericDescPtr->dims[3];
+    genericDescPtr->strides[1] = genericDescPtr->dims[2] * genericDescPtr->dims[3];
+    genericDescPtr->strides[2] = genericDescPtr->dims[3];
+}
+
 // utility functions
 vx_node createNode(vx_graph graph, vx_enum kernelEnum, vx_reference params[], vx_uint32 num)
 {