← Back to branch summary

~ubuntu-branches/ubuntu/trusty/gnuradio/trusty-updates

« back to all changes in this revision

Viewing changes to volk/include/volk/volk_32f_s32f_convert_32i_u.h

  • Committer: Package Import Robot
  • Author(s): A. Maitland Bottoms
  • Date: 2012-03-16 20:30:18 UTC
  • mfrom: (1.1.5)
  • Revision ID: package-import@ubuntu.com-20120316203018-o9cvujkbn563d8ou
Tags: 3.5.2.1-1
New upstream release.

Show diffs side-by-side

added added

removed removed

Lines of Context:
volk/include/volk/volk_32f_s32f_convert_32i_u.h
21
21
    
22
22
  const float* inputVectorPtr = (const float*)inputVector;
23
23
  int32_t* outputVectorPtr = outputVector;
 
24
 
 
25
  float min_val = -2147483647;
 
26
  float max_val = 2147483647;
 
27
  float r;
 
28
 
24
29
  __m128 vScalar = _mm_set_ps1(scalar);
25
30
  __m128 inputVal1;
26
31
  __m128i intInputVal1;
 
32
  __m128 vmin_val = _mm_set_ps1(min_val);
 
33
  __m128 vmax_val = _mm_set_ps1(max_val);
27
34
 
28
35
  for(;number < quarterPoints; number++){
29
36
    inputVal1 = _mm_loadu_ps(inputVectorPtr); inputVectorPtr += 4;
30
37
 
31
 
    intInputVal1 = _mm_cvtps_epi32(_mm_mul_ps(inputVal1, vScalar));
 
38
    inputVal1 = _mm_max_ps(_mm_min_ps(_mm_mul_ps(inputVal1, vScalar), vmax_val), vmin_val);
 
39
    intInputVal1 = _mm_cvtps_epi32(inputVal1);
32
40
 
33
41
    _mm_storeu_si128((__m128i*)outputVectorPtr, intInputVal1);
34
42
    outputVectorPtr += 4;
36
44
 
37
45
  number = quarterPoints * 4;    
38
46
  for(; number < num_points; number++){
39
 
    outputVector[number] = (int32_t)(inputVector[number] * scalar);
 
47
    r = inputVector[number] * scalar;
 
48
    if(r > max_val)
 
49
      r = max_val;
 
50
    else if(r < min_val)
 
51
      r = min_val;
 
52
    outputVector[number] = (int32_t)(r);
40
53
  }
41
54
}
42
55
#endif /* LV_HAVE_SSE2 */
58
71
    
59
72
  const float* inputVectorPtr = (const float*)inputVector;
60
73
  int32_t* outputVectorPtr = outputVector;
 
74
 
 
75
  float min_val = -2147483647;
 
76
  float max_val = 2147483647;
 
77
  float r;
 
78
 
61
79
  __m128 vScalar = _mm_set_ps1(scalar);
62
80
  __m128 ret;
 
81
  __m128 vmin_val = _mm_set_ps1(min_val);
 
82
  __m128 vmax_val = _mm_set_ps1(max_val);
63
83
 
64
84
  __VOLK_ATTR_ALIGNED(16) float outputFloatBuffer[4];
65
85
 
67
87
    ret = _mm_loadu_ps(inputVectorPtr);
68
88
    inputVectorPtr += 4;
69
89
 
70
 
    ret = _mm_mul_ps(ret, vScalar);
 
90
    ret = _mm_max_ps(_mm_min_ps(_mm_mul_ps(ret, vScalar), vmax_val), vmin_val);
71
91
 
72
92
    _mm_store_ps(outputFloatBuffer, ret);
73
93
    *outputVectorPtr++ = (int32_t)(outputFloatBuffer[0]);
78
98
 
79
99
  number = quarterPoints * 4;    
80
100
  for(; number < num_points; number++){
81
 
    outputVector[number] = (int32_t)(inputVector[number] * scalar);
 
101
    r = inputVector[number] * scalar;
 
102
    if(r > max_val)
 
103
      r = max_val;
 
104
    else if(r < min_val)
 
105
      r = min_val;
 
106
    outputVector[number] = (int32_t)(r);
82
107
  }
83
108
}
84
109
#endif /* LV_HAVE_SSE */
96
121
  int32_t* outputVectorPtr = outputVector;
97
122
  const float* inputVectorPtr = inputVector;
98
123
  unsigned int number = 0;
 
124
  float min_val = -2147483647;
 
125
  float max_val = 2147483647;
 
126
  float r;
99
127
 
100
128
  for(number = 0; number < num_points; number++){
101
 
    *outputVectorPtr++ = ((int32_t)(*inputVectorPtr++  * scalar));
 
129
    r = *inputVectorPtr++ * scalar;
 
130
    if(r > max_val)
 
131
      r = max_val;
 
132
    else if(r < min_val)
 
133
      r = min_val;
 
134
    *outputVectorPtr++ = (int32_t)(r);
102
135
  }
103
136
}
104
137
#endif /* LV_HAVE_GENERIC */