GNU Radio 3.6.4.2 C++ API
volk_32fc_deinterleave_64f_x2.h
Go to the documentation of this file.
00001 #ifndef INCLUDED_volk_32fc_deinterleave_64f_x2_u_H
00002 #define INCLUDED_volk_32fc_deinterleave_64f_x2_u_H
00003 
00004 #include <inttypes.h>
00005 #include <stdio.h>
00006 
00007 #ifdef LV_HAVE_SSE2
00008 #include <emmintrin.h>
00009 /*!
00010   \brief Deinterleaves the lv_32fc_t vector into double I & Q vector data
00011   \param complexVector The complex input vector
00012   \param iBuffer The I buffer output data
00013   \param qBuffer The Q buffer output data
00014   \param num_points The number of complex data values to be deinterleaved
00015 */
00016 static inline void volk_32fc_deinterleave_64f_x2_u_sse2(double* iBuffer, double* qBuffer, const lv_32fc_t* complexVector, unsigned int num_points){
00017   unsigned int number = 0;
00018 
00019     const float* complexVectorPtr = (float*)complexVector;
00020     double* iBufferPtr = iBuffer;
00021     double* qBufferPtr = qBuffer;
00022 
00023     const unsigned int halfPoints = num_points / 2;
00024     __m128 cplxValue, fVal;
00025     __m128d dVal;
00026 
00027     for(;number < halfPoints; number++){
00028 
00029       cplxValue = _mm_loadu_ps(complexVectorPtr);
00030       complexVectorPtr += 4;
00031 
00032       // Arrange in i1i2i1i2 format
00033       fVal = _mm_shuffle_ps(cplxValue, cplxValue, _MM_SHUFFLE(2,0,2,0));
00034       dVal = _mm_cvtps_pd(fVal);
00035       _mm_storeu_pd(iBufferPtr, dVal);
00036 
00037       // Arrange in q1q2q1q2 format
00038       fVal = _mm_shuffle_ps(cplxValue, cplxValue, _MM_SHUFFLE(3,1,3,1));
00039       dVal = _mm_cvtps_pd(fVal);
00040       _mm_storeu_pd(qBufferPtr, dVal);
00041 
00042       iBufferPtr += 2;
00043       qBufferPtr += 2;
00044     }
00045 
00046     number = halfPoints * 2;
00047     for(; number < num_points; number++){
00048       *iBufferPtr++ = *complexVectorPtr++;
00049       *qBufferPtr++ = *complexVectorPtr++;
00050     }
00051 }
00052 #endif /* LV_HAVE_SSE */
00053 
00054 #ifdef LV_HAVE_GENERIC
00055 /*!
00056   \brief Deinterleaves the lv_32fc_t vector into double I & Q vector data
00057   \param complexVector The complex input vector
00058   \param iBuffer The I buffer output data
00059   \param qBuffer The Q buffer output data
00060   \param num_points The number of complex data values to be deinterleaved
00061 */
00062 static inline void volk_32fc_deinterleave_64f_x2_generic(double* iBuffer, double* qBuffer, const lv_32fc_t* complexVector, unsigned int num_points){
00063   unsigned int number = 0;
00064   const float* complexVectorPtr = (float*)complexVector;
00065   double* iBufferPtr = iBuffer;
00066   double* qBufferPtr = qBuffer;
00067 
00068   for(number = 0; number < num_points; number++){
00069     *iBufferPtr++ = (double)*complexVectorPtr++;
00070     *qBufferPtr++ = (double)*complexVectorPtr++;
00071   }
00072 }
00073 #endif /* LV_HAVE_GENERIC */
00074 
00075 
00076 
00077 
00078 #endif /* INCLUDED_volk_32fc_deinterleave_64f_x2_u_H */
00079 #ifndef INCLUDED_volk_32fc_deinterleave_64f_x2_a_H
00080 #define INCLUDED_volk_32fc_deinterleave_64f_x2_a_H
00081 
00082 #include <inttypes.h>
00083 #include <stdio.h>
00084 
00085 #ifdef LV_HAVE_SSE2
00086 #include <emmintrin.h>
00087 /*!
00088   \brief Deinterleaves the lv_32fc_t vector into double I & Q vector data
00089   \param complexVector The complex input vector
00090   \param iBuffer The I buffer output data
00091   \param qBuffer The Q buffer output data
00092   \param num_points The number of complex data values to be deinterleaved
00093 */
00094 static inline void volk_32fc_deinterleave_64f_x2_a_sse2(double* iBuffer, double* qBuffer, const lv_32fc_t* complexVector, unsigned int num_points){
00095   unsigned int number = 0;
00096 
00097     const float* complexVectorPtr = (float*)complexVector;
00098     double* iBufferPtr = iBuffer;
00099     double* qBufferPtr = qBuffer;
00100 
00101     const unsigned int halfPoints = num_points / 2;
00102     __m128 cplxValue, fVal;
00103     __m128d dVal;
00104 
00105     for(;number < halfPoints; number++){
00106 
00107       cplxValue = _mm_load_ps(complexVectorPtr);
00108       complexVectorPtr += 4;
00109 
00110       // Arrange in i1i2i1i2 format
00111       fVal = _mm_shuffle_ps(cplxValue, cplxValue, _MM_SHUFFLE(2,0,2,0));
00112       dVal = _mm_cvtps_pd(fVal);
00113       _mm_store_pd(iBufferPtr, dVal);
00114 
00115       // Arrange in q1q2q1q2 format
00116       fVal = _mm_shuffle_ps(cplxValue, cplxValue, _MM_SHUFFLE(3,1,3,1));
00117       dVal = _mm_cvtps_pd(fVal);
00118       _mm_store_pd(qBufferPtr, dVal);
00119 
00120       iBufferPtr += 2;
00121       qBufferPtr += 2;
00122     }
00123 
00124     number = halfPoints * 2;
00125     for(; number < num_points; number++){
00126       *iBufferPtr++ = *complexVectorPtr++;
00127       *qBufferPtr++ = *complexVectorPtr++;
00128     }
00129 }
00130 #endif /* LV_HAVE_SSE */
00131 
00132 #ifdef LV_HAVE_GENERIC
00133 /*!
00134   \brief Deinterleaves the lv_32fc_t vector into double I & Q vector data
00135   \param complexVector The complex input vector
00136   \param iBuffer The I buffer output data
00137   \param qBuffer The Q buffer output data
00138   \param num_points The number of complex data values to be deinterleaved
00139 */
00140 static inline void volk_32fc_deinterleave_64f_x2_a_generic(double* iBuffer, double* qBuffer, const lv_32fc_t* complexVector, unsigned int num_points){
00141   unsigned int number = 0;
00142   const float* complexVectorPtr = (float*)complexVector;
00143   double* iBufferPtr = iBuffer;
00144   double* qBufferPtr = qBuffer;
00145 
00146   for(number = 0; number < num_points; number++){
00147     *iBufferPtr++ = (double)*complexVectorPtr++;
00148     *qBufferPtr++ = (double)*complexVectorPtr++;
00149   }
00150 }
00151 #endif /* LV_HAVE_GENERIC */
00152 
00153 
00154 
00155 
00156 #endif /* INCLUDED_volk_32fc_deinterleave_64f_x2_a_H */