-find_package(Boost COMPONENTS unit_test_framework)

- DIRECTORY ${CMAKE_SOURCE_DIR}/include/volk

- //VOLK_PROFILE(volk_16i_x5_add_quad_16i_x4_a, 1e-4, 2046, 10000, &results);

- //VOLK_PROFILE(volk_16i_branch_4_state_8_a, 1e-4, 2046, 10000, &results);

- VOLK_PUPPET_PROFILE(volk_32fc_s32fc_rotatorpuppet_32fc_a, volk_32fc_s32fc_x2_rotator_32fc_a, 1e-2, (lv_32fc_t)lv_cmake(.95393, .3), 20460, 10000, &results);

- VOLK_PROFILE(volk_16ic_s32f_deinterleave_real_32f_a, 1e-5, 32768.0, 204600, 10000, &results);

- VOLK_PROFILE(volk_16ic_deinterleave_real_8i_a, 0, 0, 204600, 10000, &results);

- VOLK_PROFILE(volk_16ic_deinterleave_16i_x2_a, 0, 0, 204600, 10000, &results);

- VOLK_PROFILE(volk_16ic_s32f_deinterleave_32f_x2_a, 1e-4, 32768.0, 204600, 1000, &results);

- VOLK_PROFILE(volk_16ic_deinterleave_real_16i_a, 0, 0, 204600, 10000, &results);

- VOLK_PROFILE(volk_16ic_magnitude_16i_a, 1, 0, 204600, 100, &results);

- VOLK_PROFILE(volk_16ic_s32f_magnitude_32f_a, 1e-5, 32768.0, 204600, 1000, &results);

- VOLK_PROFILE(volk_16i_s32f_convert_32f_a, 1e-4, 32768.0, 204600, 10000, &results);

- VOLK_PROFILE(volk_16i_s32f_convert_32f_u, 1e-4, 32768.0, 204600, 10000, &results);

- VOLK_PROFILE(volk_16i_convert_8i_a, 0, 0, 204600, 10000, &results);

- VOLK_PROFILE(volk_16i_convert_8i_u, 0, 0, 204600, 10000, &results);

- //VOLK_PROFILE(volk_16i_max_star_16i_a, 0, 0, 204600, 10000, &results);

- //VOLK_PROFILE(volk_16i_max_star_horizontal_16i_a, 0, 0, 204600, 10000, &results);

- //VOLK_PROFILE(volk_16i_permute_and_scalar_add_a, 1e-4, 0, 2046, 10000, &results);

- //VOLK_PROFILE(volk_16i_x4_quad_max_star_16i_a, 1e-4, 0, 2046, 10000, &results);

- VOLK_PROFILE(volk_16u_byteswap_a, 0, 0, 204600, 10000, &results);

- VOLK_PROFILE(volk_16u_byteswap_u, 0, 0, 204600, 10000, &results);

- VOLK_PROFILE(volk_16i_32fc_dot_prod_32fc_a, 1e-4, 0, 204600, 10000, &results);

- VOLK_PROFILE(volk_32f_accumulator_s32f_a, 1e-4, 0, 204600, 10000, &results);

- VOLK_PROFILE(volk_32f_x2_add_32f_a, 1e-4, 0, 204600, 10000, &results);

- VOLK_PROFILE(volk_32f_x2_add_32f_u, 1e-4, 0, 204600, 10000, &results);

- VOLK_PROFILE(volk_32fc_32f_multiply_32fc_a, 1e-4, 0, 204600, 1000, &results);

- VOLK_PROFILE(volk_32fc_s32f_power_32fc_a, 1e-4, 0, 204600, 50, &results);

- VOLK_PROFILE(volk_32f_s32f_calc_spectral_noise_floor_32f_a, 1e-4, 20.0, 204600, 1000, &results);

- VOLK_PROFILE(volk_32fc_s32f_atan2_32f_a, 1e-4, 10.0, 204600, 100, &results);

- //VOLK_PROFILE(volk_32fc_x2_conjugate_dot_prod_32fc_a, 1e-4, 0, 2046, 10000, &results);

- VOLK_PROFILE(volk_32fc_x2_conjugate_dot_prod_32fc_u, 1e-4, 0, 204600, 10000, &results);

- VOLK_PROFILE(volk_32fc_deinterleave_32f_x2_a, 1e-4, 0, 204600, 1000, &results);

- VOLK_PROFILE(volk_32fc_deinterleave_64f_x2_a, 1e-4, 0, 204600, 1000, &results);

- VOLK_PROFILE(volk_32fc_deinterleave_64f_x2_u, 1e-4, 0, 204600, 1000, &results);

- VOLK_PROFILE(volk_32fc_s32f_deinterleave_real_16i_a, 0, 32768, 204600, 10000, &results);

- VOLK_PROFILE(volk_32fc_deinterleave_imag_32f_a, 1e-4, 0, 204600, 5000, &results);

- VOLK_PROFILE(volk_32fc_deinterleave_real_32f_a, 1e-4, 0, 204600, 5000, &results);

- VOLK_PROFILE(volk_32fc_deinterleave_real_64f_a, 1e-4, 0, 204600, 1000, &results);

- VOLK_PROFILE(volk_32fc_x2_dot_prod_32fc_a, 1e-4, 0, 204600, 10000, &results);

- VOLK_PROFILE(volk_32fc_32f_dot_prod_32fc_a, 1e-4, 0, 204600, 10000, &results);

- VOLK_PROFILE(volk_32fc_index_max_16u_a, 3, 0, 204600, 10000, &results);

- VOLK_PROFILE(volk_32fc_s32f_magnitude_16i_a, 1, 32768, 204600, 100, &results);

- VOLK_PROFILE(volk_32fc_magnitude_32f_a, 1e-4, 0, 204600, 1000, &results);

- VOLK_PROFILE(volk_32fc_magnitude_32f_u, 1e-4, 0, 204600, 1000, &results);

- VOLK_PROFILE(volk_32fc_magnitude_squared_32f_a, 1e-4, 0, 204600, 1000, &results);

- VOLK_PROFILE(volk_32fc_magnitude_squared_32f_u, 1e-4, 0, 204600, 1000, &results);

- VOLK_PROFILE(volk_32fc_x2_multiply_32fc_a, 1e-4, 0, 204600, 1000, &results);

- VOLK_PROFILE(volk_32fc_x2_multiply_32fc_u, 1e-4, 0, 204600, 1000, &results);

- VOLK_PROFILE(volk_32fc_x2_multiply_conjugate_32fc_a, 1e-4, 0, 204600, 1000, &results);

- VOLK_PROFILE(volk_32fc_x2_multiply_conjugate_32fc_u, 1e-4, 0, 204600, 1000, &results);

- VOLK_PROFILE(volk_32fc_conjugate_32fc_a, 1e-4, 0, 204600, 1000, &results);

- VOLK_PROFILE(volk_32fc_conjugate_32fc_u, 1e-4, 0, 204600, 1000, &results);

- VOLK_PROFILE(volk_32f_s32f_convert_16i_a, 1, 32768, 204600, 10000, &results);

- VOLK_PROFILE(volk_32f_s32f_convert_16i_u, 1, 32768, 204600, 10000, &results);

- VOLK_PROFILE(volk_32f_s32f_convert_32i_a, 1, 2<<31, 204600, 10000, &results);

- VOLK_PROFILE(volk_32f_s32f_convert_32i_u, 1, 2<<31, 204600, 10000, &results);

- VOLK_PROFILE(volk_32f_convert_64f_a, 1e-4, 0, 204600, 10000, &results);

- VOLK_PROFILE(volk_32f_convert_64f_u, 1e-4, 0, 204600, 10000, &results);

- VOLK_PROFILE(volk_32f_s32f_convert_8i_a, 1, 128, 204600, 10000, &results);

- VOLK_PROFILE(volk_32f_s32f_convert_8i_u, 1, 128, 204600, 10000, &results);

- //VOLK_PROFILE(volk_32fc_s32f_x2_power_spectral_density_32f_a, 1e-4, 2046, 10000, &results);

- VOLK_PROFILE(volk_32fc_s32f_power_spectrum_32f_a, 1e-4, 0, 20460, 100, &results);

- VOLK_PROFILE(volk_32fc_x2_square_dist_32f_a, 1e-4, 0, 204600, 10000, &results);

- VOLK_PROFILE(volk_32fc_x2_s32f_square_dist_scalar_mult_32f_a, 1e-4, 10, 204600, 10000, &results);

- VOLK_PROFILE(volk_32f_x2_divide_32f_a, 1e-4, 0, 204600, 2000, &results);

- VOLK_PROFILE(volk_32f_x2_dot_prod_32f_a, 1e-4, 0, 204600, 5000, &results);

- VOLK_PROFILE(volk_32f_x2_dot_prod_32f_u, 1e-4, 0, 204600, 5000, &results);

- VOLK_PROFILE(volk_32f_x2_dot_prod_16i_a, 1e-4, 0, 204600, 5000, &results);

- //VOLK_PROFILE(volk_32f_s32f_32f_fm_detect_32f_a, 1e-4, 2046, 10000, &results);

- VOLK_PROFILE(volk_32f_index_max_16u_a, 3, 0, 204600, 5000, &results);

- VOLK_PROFILE(volk_32f_x2_s32f_interleave_16ic_a, 1, 32768, 204600, 3000, &results);

- VOLK_PROFILE(volk_32f_x2_interleave_32fc_a, 0, 0, 204600, 5000, &results);

- VOLK_PROFILE(volk_32f_x2_max_32f_a, 1e-4, 0, 204600, 2000, &results);

- VOLK_PROFILE(volk_32f_x2_min_32f_a, 1e-4, 0, 204600, 2000, &results);

- VOLK_PROFILE(volk_32f_x2_multiply_32f_a, 1e-4, 0, 204600, 10000, &results);

- VOLK_PROFILE(volk_32f_x2_multiply_32f_u, 1e-4, 0, 204600, 10000, &results);

- VOLK_PROFILE(volk_32f_s32f_normalize_a, 1e-4, 100, 204600, 10000, &results);

- VOLK_PROFILE(volk_32f_s32f_power_32f_a, 1e-4, 4, 204600, 100, &results);

- VOLK_PROFILE(volk_32f_sqrt_32f_a, 1e-4, 0, 204600, 100, &results);

- VOLK_PROFILE(volk_32f_s32f_stddev_32f_a, 1e-4, 100, 204600, 3000, &results);

- VOLK_PROFILE(volk_32f_stddev_and_mean_32f_x2_a, 1e-4, 0, 204600, 3000, &results);

- VOLK_PROFILE(volk_32f_x2_subtract_32f_a, 1e-4, 0, 204600, 5000, &results);

- VOLK_PROFILE(volk_32f_x3_sum_of_poly_32f_a, 1e-4, 0, 204600, 5000, &results);

- VOLK_PROFILE(volk_32i_x2_and_32i_a, 0, 0, 204600, 10000, &results);

- VOLK_PROFILE(volk_32i_s32f_convert_32f_a, 1e-4, 100, 204600, 10000, &results);

- VOLK_PROFILE(volk_32i_s32f_convert_32f_u, 1e-4, 100, 204600, 10000, &results);

- VOLK_PROFILE(volk_32i_x2_or_32i_a, 0, 0, 204600, 10000, &results);

- VOLK_PROFILE(volk_32u_byteswap_a, 0, 0, 204600, 2000, &results);

- //VOLK_PROFILE(volk_32u_popcnt_a, 0, 0, 2046, 10000, &results);

- VOLK_PROFILE(volk_64f_convert_32f_a, 1e-4, 0, 204600, 10000, &results);

- VOLK_PROFILE(volk_64f_convert_32f_u, 1e-4, 0, 204600, 10000, &results);

- VOLK_PROFILE(volk_64f_x2_max_64f_a, 1e-4, 0, 204600, 1000, &results);

- VOLK_PROFILE(volk_64f_x2_min_64f_a, 1e-4, 0, 204600, 1000, &results);

- VOLK_PROFILE(volk_64u_byteswap_a, 0, 0, 204600, 1000, &results);

- //VOLK_PROFILE(volk_64u_popcnt_a, 0, 0, 2046, 10000, &results);

- VOLK_PROFILE(volk_8ic_deinterleave_16i_x2_a, 0, 0, 204600, 3000, &results);

- VOLK_PROFILE(volk_8ic_s32f_deinterleave_32f_x2_a, 1e-4, 100, 204600, 3000, &results);

- VOLK_PROFILE(volk_8ic_deinterleave_real_16i_a, 0, 256, 204600, 3000, &results);

- VOLK_PROFILE(volk_8ic_s32f_deinterleave_real_32f_a, 1e-4, 100, 204600, 3000, &results);

- VOLK_PROFILE(volk_8ic_deinterleave_real_8i_a, 0, 0, 204600, 10000, &results);

- VOLK_PROFILE(volk_8ic_x2_multiply_conjugate_16ic_a, 0, 0, 204600, 400, &results);

- VOLK_PROFILE(volk_8ic_x2_s32f_multiply_conjugate_32fc_a, 1e-4, 100, 204600, 400, &results);

- VOLK_PROFILE(volk_8i_convert_16i_a, 0, 0, 204600, 20000, &results);

- VOLK_PROFILE(volk_8i_convert_16i_u, 0, 0, 204600, 2000, &results);

- VOLK_PROFILE(volk_8i_s32f_convert_32f_a, 1e-4, 100, 204600, 2000, &results);

- VOLK_PROFILE(volk_8i_s32f_convert_32f_u, 1e-4, 100, 204600, 2000, &results);

- //VOLK_PROFILE(volk_32fc_s32fc_multiply_32fc_a, 1e-4, lv_32fc_t(1.0, 0.5), 204600, 1000, &results);

- VOLK_PROFILE(volk_32fc_s32fc_multiply_32fc_u, 1e-4, 0, 204600, 1000, &results);

- VOLK_PROFILE(volk_32f_s32f_multiply_32f_a, 1e-4, 1.0, 204600, 10000, &results);

- VOLK_PROFILE(volk_32f_s32f_multiply_32f_u, 1e-4, 0, 204600, 1000, &results);

- char path[256];

- get_config_path(path);

- std::string config_path(path);

- std::ofstream config;

- std::cout << "filename: " << config_path << std::endl;

- config.open(config_path.c_str());

- std::string dir(getenv("HOME"));

- dir += "/.volk";

- if(mkdir(dir.c_str(), 0777) == -1) {

- std::cout << "Error creating directory " << dir << std::endl;

- return -1;

- }

- config.open(config_path.c_str());

- if(!config.is_open()) {

- std::cout << "Error opening file " << config_path << std::endl;

- return -1;

- }

- <alignment>1</alignment>

-#TODO enable this when we are ready

-create_unaligned_archs = False

-

- if arch.alignment > 1 and create_unaligned_archs:

- kwargs['name'] += '_u'

- kwargs['alignment'] = 1

- register_arch(**kwargs)

-from volk_arch_defs import archs

-

-remove_after_underscore = re.compile("_.*");

-space_remove = re.compile(" ");

-leading_space_remove = re.compile("^ *");

-replace_arch = re.compile(", const char\* arch");

-replace_bracket = re.compile(" {");

-replace_volk = re.compile("volk");

-

-def strip_trailing(tostrip, stripstr):

- lindex = tostrip.rfind(stripstr)

- tostrip = tostrip[0:lindex] + tostrip[lindex:len(tostrip)].replace(stripstr, "");

- return tostrip

-srcdir = os.path.dirname(os.path.dirname(__file__))

-hdr_files = glob.glob(os.path.join(srcdir, "include/volk/*.h"))

-

-datatypes = [];

-functions = [];

-

-for line in hdr_files:

- subline = re.search(".*_(a|u)\.h.*", os.path.basename(line))

- if subline:

- subsubline = re.search("(?<=volk_).*", subline.group(0));

- if subsubline:

- dtype = remove_after_underscore.sub("", subsubline.group(0));

- subdtype = re.search("[0-9]+[A-z]+", dtype);

- if subdtype:

- datatypes.append(subdtype.group(0));

-

-

-datatypes = set(datatypes);

-

-for line in hdr_files:

- for dt in datatypes:

- if dt in line:

- subline = re.search("(volk_" + dt +"_.*(a|u).*\.h)", line);

- if subline:

-

- subsubline = re.search(".+(?=\.h)", subline.group(0));

- functions.append(subsubline.group(0));

-

-archs_or = "("

-for arch in archs:

- archs_or = archs_or + arch.name.upper() + "|";

-archs_or = archs_or[0:len(archs_or)-1];

-archs_or = archs_or + ")";

-

-taglist = [];

-fcountlist = [];

-arched_arglist = [];

-retlist = [];

-my_arglist = [];

-my_argtypelist = [];

-for func in functions:

- tags = [];

- fcount = [];

- infile_source = open(os.path.join(srcdir, 'include', 'volk', func + ".h"))

- begun_name = 0;

- begun_paren = 0;

- sourcefile = infile_source.readlines();

- infile_source.close();

- for line in sourcefile:

-#FIXME: make it work for multiple #if define()s

- archline = re.search("^\#if.*?LV_HAVE_" + archs_or + ".*", line);

- if archline:

- arch = archline.group(0);

- archline = re.findall(archs_or + "(?=( |\n|&))", line);

- if archline:

- archsublist = [];

- for tup in archline:

- archsublist.append(tup[0]);

- fcount.append(archsublist);

- testline = re.search("static inline.*?" + func, line);

- if (not testline):

- tagline = re.search(func + "_.+", line);

- if tagline:

- tag = re.search("(?<=" + func + "_)\w+(?= *\()",line);

- if tag:

- tag = re.search("\w+", tag.group(0));

- if tag:

- tags.append(tag.group(0));

- if begun_name == 0:

- retline = re.search(".+(?=" + func + ")", line);

- if retline:

- ret = retline.group(0);

- subline = re.search(func + ".*", line);

- if subline:

- subsubline = re.search("\(.*?\)", subline.group(0));

- if subsubline:

- args = subsubline.group(0);

- else:

- begun_name = 1;

- subsubline = re.search("\(.*", subline.group(0));

- if subsubline:

- args = subsubline.group(0);

- begun_paren = 1;

- else:

- if begun_paren == 1:

- subline = re.search(".*?\)", line);

- if subline:

- args = args + subline.group(0);

- begun_name = 0;

- begun_paren = 0;

- else:

- subline = re.search(".*", line);

- args = args + subline.group(0);

- else:

- subline = re.search("\(.*?\)", line);

- if subline:

- args = subline.group(0);

- begun_name = 0;

- else:

- subline = re.search("\(.*", line);

- if subline:

- args = subline.group(0);

- begun_paren = 1;

-

- replace = re.compile("static ");

- ret = replace.sub("", ret);

- replace = re.compile("inline ");

- ret = replace.sub("", ret);

- arched_args = args[args.find('(')+1:args.find(')')]

-

- remove = re.compile('\)|\(|{');

- rargs = remove.sub("", args);

- sargs = rargs.split(',');

-

-

-

- margs = [];

- atypes = [];

- for arg in sargs:

- temp = arg.split(" ");

- margs.append(temp[-1]);

- replace = re.compile(" " + temp[-1]);

- atypes.append(replace.sub("", arg));

-

-

- my_args = ""

- arg_types = ""

- for arg in range(0, len(margs) - 1):

- this_arg = leading_space_remove.sub("", margs[arg]);

- my_args = my_args + this_arg + ", ";

- this_type = leading_space_remove.sub("", atypes[arg]);

- arg_types = arg_types + this_type + ", ";

-

- this_arg = leading_space_remove.sub("", margs[-1]);

- my_args = my_args + this_arg;

- this_type = leading_space_remove.sub("", atypes[-1]);

- arg_types = arg_types + this_type;

- my_argtypelist.append(arg_types);

-

- if(ret[-1] != ' '):

- ret = ret + ' ';

-

- arched_arglist.append(arched_args); #!!!!!!!!!!!

- my_arglist.append(my_args) #!!!!!!!!!!!!!!!!!

- retlist.append(ret);

- fcountlist.append(fcount);

- taglist.append(tags);

- def __init__(self, index):

- self.name = functions[index]

- self.rettype = retlist[index]

- self.arglist_defs = my_argtypelist[index]

- self.arglist_namedefs = arched_arglist[index]

- self.arglist_names = my_arglist[index]

- self._tagdeps = fcountlist[index]

- self._taglist = taglist[index]

-

- def get_tags(self, archs):

- def is_in(x): return x.lower() in archs

- taglist = list()

- tagdeps = list()

- for i in range(len(self._tagdeps)):

- if all(map(is_in, self._tagdeps[i])):

- taglist.append(self._taglist[i])

- tagdeps.append(self._tagdeps[i])

- return taglist, tagdeps

-kernels = map(kernel_class, range(len(retlist)))

- arch_name += '_u'

- if arch.alignment > 1 and arch_dict.has_key(arch_name):

- arch = arch_dict[arch_name]

- self.archs.append(arch)

-#ifndef INCLUDED_volk_16i_convert_8i_a_H

-#define INCLUDED_volk_16i_convert_8i_a_H

-

-#include <inttypes.h>

-#include <stdio.h>

-

-#ifdef LV_HAVE_SSE2

-#include <emmintrin.h>

-/*!

- \brief Converts the input 16 bit integer data into 8 bit integer data

- \param inputVector The 16 bit input data buffer

- \param outputVector The 8 bit output data buffer

- \param num_points The number of data values to be converted

-*/

-static inline void volk_16i_convert_8i_a_sse2(int8_t* outputVector, const int16_t* inputVector, unsigned int num_points){

- unsigned int number = 0;

- const unsigned int sixteenthPoints = num_points / 16;

-

- int8_t* outputVectorPtr = outputVector;

- int16_t* inputPtr = (int16_t*)inputVector;

- __m128i inputVal1;

- __m128i inputVal2;

- __m128i ret;

-

- for(;number < sixteenthPoints; number++){

-

- // Load the 16 values

- inputVal1 = _mm_load_si128((__m128i*)inputPtr); inputPtr += 8;

- inputVal2 = _mm_load_si128((__m128i*)inputPtr); inputPtr += 8;

-

- inputVal1 = _mm_srai_epi16(inputVal1, 8);

- inputVal2 = _mm_srai_epi16(inputVal2, 8);

-

- ret = _mm_packs_epi16(inputVal1, inputVal2);

-

- _mm_store_si128((__m128i*)outputVectorPtr, ret);

-

- outputVectorPtr += 16;

- }

-

- number = sixteenthPoints * 16;

- for(; number < num_points; number++){

- outputVector[number] =(int8_t)(inputVector[number] >> 8);

- }

-}

-#endif /* LV_HAVE_SSE2 */

-

-#ifdef LV_HAVE_GENERIC

-/*!

- \brief Converts the input 16 bit integer data into 8 bit integer data

- \param inputVector The 16 bit input data buffer

- \param outputVector The 8 bit output data buffer

- \param num_points The number of data values to be converted

-*/

-static inline void volk_16i_convert_8i_a_generic(int8_t* outputVector, const int16_t* inputVector, unsigned int num_points){

- int8_t* outputVectorPtr = outputVector;

- const int16_t* inputVectorPtr = inputVector;

- unsigned int number = 0;

-

- for(number = 0; number < num_points; number++){

- *outputVectorPtr++ = ((int8_t)(*inputVectorPtr++ >> 8));

- }

-}

-#endif /* LV_HAVE_GENERIC */

-

-

-

-

-#endif /* INCLUDED_volk_16i_convert_8i_a_H */

-#ifndef INCLUDED_volk_16i_s32f_convert_32f_a_H

-#define INCLUDED_volk_16i_s32f_convert_32f_a_H

-

-#include <inttypes.h>

-#include <stdio.h>

-

-#ifdef LV_HAVE_SSE4_1

-#include <smmintrin.h>

-

- /*!

- \brief Converts the input 16 bit integer data into floating point data, and divides the each floating point output data point by the scalar value

- \param inputVector The 16 bit input data buffer

- \param outputVector The floating point output data buffer

- \param scalar The value divided against each point in the output buffer

- \param num_points The number of data values to be converted

- */

-static inline void volk_16i_s32f_convert_32f_a_sse4_1(float* outputVector, const int16_t* inputVector, const float scalar, unsigned int num_points){

- unsigned int number = 0;

- const unsigned int eighthPoints = num_points / 8;

-

- float* outputVectorPtr = outputVector;

- __m128 invScalar = _mm_set_ps1(1.0/scalar);

- int16_t* inputPtr = (int16_t*)inputVector;

- __m128i inputVal;

- __m128i inputVal2;

- __m128 ret;

-

- for(;number < eighthPoints; number++){

-

- // Load the 8 values

- inputVal = _mm_loadu_si128((__m128i*)inputPtr);

-

- // Shift the input data to the right by 64 bits ( 8 bytes )

- inputVal2 = _mm_srli_si128(inputVal, 8);

-

- // Convert the lower 4 values into 32 bit words

- inputVal = _mm_cvtepi16_epi32(inputVal);

- inputVal2 = _mm_cvtepi16_epi32(inputVal2);

-

- ret = _mm_cvtepi32_ps(inputVal);

- ret = _mm_mul_ps(ret, invScalar);

- _mm_storeu_ps(outputVectorPtr, ret);

- outputVectorPtr += 4;

-

- ret = _mm_cvtepi32_ps(inputVal2);

- ret = _mm_mul_ps(ret, invScalar);

- _mm_storeu_ps(outputVectorPtr, ret);

-

- outputVectorPtr += 4;

-

- inputPtr += 8;

- }

-

- number = eighthPoints * 8;

- for(; number < num_points; number++){

- outputVector[number] =((float)(inputVector[number])) / scalar;

- }

-}

-#endif /* LV_HAVE_SSE4_1 */

-

-#ifdef LV_HAVE_SSE

-#include <xmmintrin.h>

-

- /*!

- \brief Converts the input 16 bit integer data into floating point data, and divides the each floating point output data point by the scalar value

- \param inputVector The 16 bit input data buffer

- \param outputVector The floating point output data buffer

- \param scalar The value divided against each point in the output buffer

- \param num_points The number of data values to be converted

- */

-static inline void volk_16i_s32f_convert_32f_a_sse(float* outputVector, const int16_t* inputVector, const float scalar, unsigned int num_points){

- unsigned int number = 0;

- const unsigned int quarterPoints = num_points / 4;

-

- float* outputVectorPtr = outputVector;

- __m128 invScalar = _mm_set_ps1(1.0/scalar);

- int16_t* inputPtr = (int16_t*)inputVector;

- __m128 ret;

-

- for(;number < quarterPoints; number++){

- ret = _mm_set_ps((float)(inputPtr[3]), (float)(inputPtr[2]), (float)(inputPtr[1]), (float)(inputPtr[0]));

-

- ret = _mm_mul_ps(ret, invScalar);

- _mm_storeu_ps(outputVectorPtr, ret);

-

- inputPtr += 4;

- outputVectorPtr += 4;

- }

-

- number = quarterPoints * 4;

- for(; number < num_points; number++){

- outputVector[number] = (float)(inputVector[number]) / scalar;

- }

-}

-#endif /* LV_HAVE_SSE */

-

-#ifdef LV_HAVE_GENERIC

- /*!

- \brief Converts the input 16 bit integer data into floating point data, and divides the each floating point output data point by the scalar value

- \param inputVector The 16 bit input data buffer

- \param outputVector The floating point output data buffer

- \param scalar The value divided against each point in the output buffer

- \param num_points The number of data values to be converted

- */

-static inline void volk_16i_s32f_convert_32f_a_generic(float* outputVector, const int16_t* inputVector, const float scalar, unsigned int num_points){

- float* outputVectorPtr = outputVector;

- const int16_t* inputVectorPtr = inputVector;

- unsigned int number = 0;

-

- for(number = 0; number < num_points; number++){

- *outputVectorPtr++ = ((float)(*inputVectorPtr++)) / scalar;

- }

-}

-#endif /* LV_HAVE_GENERIC */

-

-

-

-

-#endif /* INCLUDED_volk_16i_s32f_convert_32f_a_H */

-#ifndef INCLUDED_volk_16u_byteswap_u_H

-#define INCLUDED_volk_16u_byteswap_u_H

-

-#include <inttypes.h>

-#include <stdio.h>

-

-#ifdef LV_HAVE_SSE2

-#include <emmintrin.h>

-

-/*!

- \brief Byteswaps (in-place) an unaligned vector of int16_t's.

- \param intsToSwap The vector of data to byte swap

- \param numDataPoints The number of data points

-*/

-static inline void volk_16u_byteswap_u_sse2(uint16_t* intsToSwap, unsigned int num_points){

- unsigned int number = 0;

- uint16_t* inputPtr = intsToSwap;

- __m128i input, left, right, output;

-

- const unsigned int eighthPoints = num_points / 8;

- for(;number < eighthPoints; number++){

- // Load the 16t values, increment inputPtr later since we're doing it in-place.

- input = _mm_loadu_si128((__m128i*)inputPtr);

- // Do the two shifts

- left = _mm_slli_epi16(input, 8);

- right = _mm_srli_epi16(input, 8);

- // Or the left and right halves together

- output = _mm_or_si128(left, right);

- // Store the results

- _mm_storeu_si128((__m128i*)inputPtr, output);

- inputPtr += 8;

- }

-

- // Byteswap any remaining points:

- number = eighthPoints*8;

- for(; number < num_points; number++){

- uint16_t outputVal = *inputPtr;

- outputVal = (((outputVal >> 8) & 0xff) | ((outputVal << 8) & 0xff00));

- *inputPtr = outputVal;

- inputPtr++;

- }

-}

-#endif /* LV_HAVE_SSE2 */

-

-#ifdef LV_HAVE_GENERIC

-/*!

- \brief Byteswaps (in-place) an unaligned vector of int16_t's.

- \param intsToSwap The vector of data to byte swap

- \param numDataPoints The number of data points

-*/

-static inline void volk_16u_byteswap_u_generic(uint16_t* intsToSwap, unsigned int num_points){

- unsigned int point;

- uint16_t* inputPtr = intsToSwap;

- for(point = 0; point < num_points; point++){

- uint16_t output = *inputPtr;

- output = (((output >> 8) & 0xff) | ((output << 8) & 0xff00));

- *inputPtr = output;

- inputPtr++;

- }

-}

-#endif /* LV_HAVE_GENERIC */

-

-#endif /* INCLUDED_volk_16u_byteswap_u_H */

-#ifndef INCLUDED_volk_32f_convert_64f_a_H

-#define INCLUDED_volk_32f_convert_64f_a_H

-

-#include <inttypes.h>

-#include <stdio.h>

-

-#ifdef LV_HAVE_SSE2

-#include <emmintrin.h>

- /*!

- \brief Converts the float values into double values

- \param dVector The converted double vector values

- \param fVector The float vector values to be converted

- \param num_points The number of points in the two vectors to be converted

- */

-static inline void volk_32f_convert_64f_a_sse2(double* outputVector, const float* inputVector, unsigned int num_points){

- unsigned int number = 0;

-

- const unsigned int quarterPoints = num_points / 4;

-

- const float* inputVectorPtr = (const float*)inputVector;

- double* outputVectorPtr = outputVector;

- __m128d ret;

- __m128 inputVal;

-

- for(;number < quarterPoints; number++){

- inputVal = _mm_load_ps(inputVectorPtr); inputVectorPtr += 4;

-

- ret = _mm_cvtps_pd(inputVal);

-

- _mm_store_pd(outputVectorPtr, ret);

- outputVectorPtr += 2;

-

- inputVal = _mm_movehl_ps(inputVal, inputVal);

-

- ret = _mm_cvtps_pd(inputVal);

-

- _mm_store_pd(outputVectorPtr, ret);

- outputVectorPtr += 2;

- }

-

- number = quarterPoints * 4;

- for(; number < num_points; number++){

- outputVector[number] = (double)(inputVector[number]);

- }

-}

-#endif /* LV_HAVE_SSE2 */

-

-

-#ifdef LV_HAVE_GENERIC

-/*!

- \brief Converts the float values into double values

- \param dVector The converted double vector values

- \param fVector The float vector values to be converted

- \param num_points The number of points in the two vectors to be converted

-*/

-static inline void volk_32f_convert_64f_a_generic(double* outputVector, const float* inputVector, unsigned int num_points){

- double* outputVectorPtr = outputVector;

- const float* inputVectorPtr = inputVector;

- unsigned int number = 0;

-

- for(number = 0; number < num_points; number++){

- *outputVectorPtr++ = ((double)(*inputVectorPtr++));

- }

-}

-#endif /* LV_HAVE_GENERIC */

-

-

-

-

-#endif /* INCLUDED_volk_32f_convert_64f_a_H */

-#ifndef INCLUDED_volk_32f_convert_64f_u_H

-#define INCLUDED_volk_32f_convert_64f_u_H

-

-#include <inttypes.h>

-#include <stdio.h>

-

-#ifdef LV_HAVE_SSE2

-#include <emmintrin.h>

- /*!

- \brief Converts the float values into double values

- \param dVector The converted double vector values

- \param fVector The float vector values to be converted

- \param num_points The number of points in the two vectors to be converted

- */

-static inline void volk_32f_convert_64f_u_sse2(double* outputVector, const float* inputVector, unsigned int num_points){

- unsigned int number = 0;

-

- const unsigned int quarterPoints = num_points / 4;

-

- const float* inputVectorPtr = (const float*)inputVector;

- double* outputVectorPtr = outputVector;

- __m128d ret;

- __m128 inputVal;

-

- for(;number < quarterPoints; number++){

- inputVal = _mm_loadu_ps(inputVectorPtr); inputVectorPtr += 4;

-

- ret = _mm_cvtps_pd(inputVal);

-

- _mm_storeu_pd(outputVectorPtr, ret);

- outputVectorPtr += 2;

-

- inputVal = _mm_movehl_ps(inputVal, inputVal);

-

- ret = _mm_cvtps_pd(inputVal);

-

- _mm_storeu_pd(outputVectorPtr, ret);

- outputVectorPtr += 2;

- }

-

- number = quarterPoints * 4;

- for(; number < num_points; number++){

- outputVector[number] = (double)(inputVector[number]);

- }

-}

-#endif /* LV_HAVE_SSE2 */

-

-

-#ifdef LV_HAVE_GENERIC

-/*!

- \brief Converts the float values into double values

- \param dVector The converted double vector values

- \param fVector The float vector values to be converted

- \param num_points The number of points in the two vectors to be converted

-*/

-static inline void volk_32f_convert_64f_u_generic(double* outputVector, const float* inputVector, unsigned int num_points){

- double* outputVectorPtr = outputVector;

- const float* inputVectorPtr = inputVector;

- unsigned int number = 0;

-

- for(number = 0; number < num_points; number++){

- *outputVectorPtr++ = ((double)(*inputVectorPtr++));

- }

-}

-#endif /* LV_HAVE_GENERIC */

-

-

-

-

-#endif /* INCLUDED_volk_32f_convert_64f_u_H */

-#ifndef INCLUDED_volk_32f_s32f_convert_16i_a_H

-#define INCLUDED_volk_32f_s32f_convert_16i_a_H

-

-#include <volk/volk_common.h>

-#include <inttypes.h>

-#include <stdio.h>

-#include <math.h>

-

-#ifdef LV_HAVE_SSE2

-#include <emmintrin.h>

- /*!

- \brief Multiplies each point in the input buffer by the scalar value, then converts the result into a 16 bit integer value

- \param inputVector The floating point input data buffer

- \param outputVector The 16 bit output data buffer

- \param scalar The value multiplied against each point in the input buffer

- \param num_points The number of data values to be converted

- */

-static inline void volk_32f_s32f_convert_16i_a_sse2(int16_t* outputVector, const float* inputVector, const float scalar, unsigned int num_points){

- unsigned int number = 0;

-

- const unsigned int eighthPoints = num_points / 8;

-

- const float* inputVectorPtr = (const float*)inputVector;

- int16_t* outputVectorPtr = outputVector;

-

- float min_val = -32768;

- float max_val = 32767;

- float r;

-

- __m128 vScalar = _mm_set_ps1(scalar);

- __m128 inputVal1, inputVal2;

- __m128i intInputVal1, intInputVal2;

- __m128 ret1, ret2;

- __m128 vmin_val = _mm_set_ps1(min_val);

- __m128 vmax_val = _mm_set_ps1(max_val);

-

- for(;number < eighthPoints; number++){

- inputVal1 = _mm_load_ps(inputVectorPtr); inputVectorPtr += 4;

- inputVal2 = _mm_load_ps(inputVectorPtr); inputVectorPtr += 4;

-

- // Scale and clip

- ret1 = _mm_max_ps(_mm_min_ps(_mm_mul_ps(inputVal1, vScalar), vmax_val), vmin_val);

- ret2 = _mm_max_ps(_mm_min_ps(_mm_mul_ps(inputVal2, vScalar), vmax_val), vmin_val);

-

- intInputVal1 = _mm_cvtps_epi32(ret1);

- intInputVal2 = _mm_cvtps_epi32(ret2);

-

- intInputVal1 = _mm_packs_epi32(intInputVal1, intInputVal2);

-

- _mm_store_si128((__m128i*)outputVectorPtr, intInputVal1);

- outputVectorPtr += 8;

- }

-

- number = eighthPoints * 8;

- for(; number < num_points; number++){

- r = inputVector[number] * scalar;

- if(r > max_val)

- r = max_val;

- else if(r < min_val)

- r = min_val;

- outputVector[number] = (int16_t)rintf(r);

- }

-}

-#endif /* LV_HAVE_SSE2 */

-

-#ifdef LV_HAVE_SSE

-#include <xmmintrin.h>

- /*!

- \brief Multiplies each point in the input buffer by the scalar value, then converts the result into a 16 bit integer value

- \param inputVector The floating point input data buffer

- \param outputVector The 16 bit output data buffer

- \param scalar The value multiplied against each point in the input buffer

- \param num_points The number of data values to be converted

- */

-static inline void volk_32f_s32f_convert_16i_a_sse(int16_t* outputVector, const float* inputVector, const float scalar, unsigned int num_points){

- unsigned int number = 0;

-

- const unsigned int quarterPoints = num_points / 4;

-

- const float* inputVectorPtr = (const float*)inputVector;

- int16_t* outputVectorPtr = outputVector;

-

- float min_val = -32768;

- float max_val = 32767;

- float r;

-

- __m128 vScalar = _mm_set_ps1(scalar);

- __m128 ret;

- __m128 vmin_val = _mm_set_ps1(min_val);

- __m128 vmax_val = _mm_set_ps1(max_val);

-

- __VOLK_ATTR_ALIGNED(16) float outputFloatBuffer[4];

-

- for(;number < quarterPoints; number++){

- ret = _mm_load_ps(inputVectorPtr);

- inputVectorPtr += 4;

-

- // Scale and clip

- ret = _mm_max_ps(_mm_min_ps(_mm_mul_ps(ret, vScalar), vmax_val), vmin_val);

-

- _mm_store_ps(outputFloatBuffer, ret);

- *outputVectorPtr++ = (int16_t)rintf(outputFloatBuffer[0]);

- *outputVectorPtr++ = (int16_t)rintf(outputFloatBuffer[1]);

- *outputVectorPtr++ = (int16_t)rintf(outputFloatBuffer[2]);

- *outputVectorPtr++ = (int16_t)rintf(outputFloatBuffer[3]);

- }

-

- number = quarterPoints * 4;

- for(; number < num_points; number++){

- r = inputVector[number] * scalar;

- if(r > max_val)

- r = max_val;

- else if(r < min_val)

- r = min_val;

- outputVector[number] = (int16_t)rintf(r);

- }

-}

-#endif /* LV_HAVE_SSE */

-

-#ifdef LV_HAVE_GENERIC

- /*!

- \brief Multiplies each point in the input buffer by the scalar value, then converts the result into a 16 bit integer value

- \param inputVector The floating point input data buffer

- \param outputVector The 16 bit output data buffer

- \param scalar The value multiplied against each point in the input buffer

- \param num_points The number of data values to be converted

- */

-static inline void volk_32f_s32f_convert_16i_a_generic(int16_t* outputVector, const float* inputVector, const float scalar, unsigned int num_points){

- int16_t* outputVectorPtr = outputVector;

- const float* inputVectorPtr = inputVector;

- unsigned int number = 0;

- float min_val = -32768;

- float max_val = 32767;

- float r;

-

- for(number = 0; number < num_points; number++){

- r = *inputVectorPtr++ * scalar;

- if(r < min_val)

- r = min_val;

- else if(r > max_val)

- r = max_val;

- *outputVectorPtr++ = (int16_t)rintf(r);

- }

-}

-#endif /* LV_HAVE_GENERIC */

-

-

-

-

-#endif /* INCLUDED_volk_32f_s32f_convert_16i_a_H */

-#ifndef INCLUDED_volk_32f_s32f_convert_32i_u_H

-#define INCLUDED_volk_32f_s32f_convert_32i_u_H

-

-#include <inttypes.h>

-#include <stdio.h>

-

-#ifdef LV_HAVE_SSE2

-#include <emmintrin.h>

- /*!

- \brief Multiplies each point in the input buffer by the scalar value, then converts the result into a 32 bit integer value

- \param inputVector The floating point input data buffer

- \param outputVector The 32 bit output data buffer

- \param scalar The value multiplied against each point in the input buffer

- \param num_points The number of data values to be converted

- \note Input buffer does NOT need to be properly aligned

- */

-static inline void volk_32f_s32f_convert_32i_u_sse2(int32_t* outputVector, const float* inputVector, const float scalar, unsigned int num_points){

- unsigned int number = 0;

-

- const unsigned int quarterPoints = num_points / 4;

-

- const float* inputVectorPtr = (const float*)inputVector;

- int32_t* outputVectorPtr = outputVector;

-

- float min_val = -2147483647;

- float max_val = 2147483647;

- float r;

-

- __m128 vScalar = _mm_set_ps1(scalar);

- __m128 inputVal1;

- __m128i intInputVal1;

- __m128 vmin_val = _mm_set_ps1(min_val);

- __m128 vmax_val = _mm_set_ps1(max_val);

-

- for(;number < quarterPoints; number++){

- inputVal1 = _mm_loadu_ps(inputVectorPtr); inputVectorPtr += 4;

-

- inputVal1 = _mm_max_ps(_mm_min_ps(_mm_mul_ps(inputVal1, vScalar), vmax_val), vmin_val);

- intInputVal1 = _mm_cvtps_epi32(inputVal1);

-

- _mm_storeu_si128((__m128i*)outputVectorPtr, intInputVal1);

- outputVectorPtr += 4;

- }

-

- number = quarterPoints * 4;

- for(; number < num_points; number++){

- r = inputVector[number] * scalar;

- if(r > max_val)

- r = max_val;

- else if(r < min_val)

- r = min_val;

- outputVector[number] = (int32_t)(r);

- }

-}

-#endif /* LV_HAVE_SSE2 */

-

-#ifdef LV_HAVE_SSE

-#include <xmmintrin.h>

- /*!

- \brief Multiplies each point in the input buffer by the scalar value, then converts the result into a 32 bit integer value

- \param inputVector The floating point input data buffer

- \param outputVector The 32 bit output data buffer

- \param scalar The value multiplied against each point in the input buffer

- \param num_points The number of data values to be converted

- \note Input buffer does NOT need to be properly aligned

- */

-static inline void volk_32f_s32f_convert_32i_u_sse(int32_t* outputVector, const float* inputVector, const float scalar, unsigned int num_points){

- unsigned int number = 0;

-

- const unsigned int quarterPoints = num_points / 4;

-

- const float* inputVectorPtr = (const float*)inputVector;

- int32_t* outputVectorPtr = outputVector;

-

- float min_val = -2147483647;

- float max_val = 2147483647;

- float r;

-

- __m128 vScalar = _mm_set_ps1(scalar);

- __m128 ret;

- __m128 vmin_val = _mm_set_ps1(min_val);

- __m128 vmax_val = _mm_set_ps1(max_val);

-

- __VOLK_ATTR_ALIGNED(16) float outputFloatBuffer[4];

-

- for(;number < quarterPoints; number++){

- ret = _mm_loadu_ps(inputVectorPtr);

- inputVectorPtr += 4;

-

- ret = _mm_max_ps(_mm_min_ps(_mm_mul_ps(ret, vScalar), vmax_val), vmin_val);

-

- _mm_store_ps(outputFloatBuffer, ret);

- *outputVectorPtr++ = (int32_t)(outputFloatBuffer[0]);

- *outputVectorPtr++ = (int32_t)(outputFloatBuffer[1]);

- *outputVectorPtr++ = (int32_t)(outputFloatBuffer[2]);

- *outputVectorPtr++ = (int32_t)(outputFloatBuffer[3]);

- }

-

- number = quarterPoints * 4;

- for(; number < num_points; number++){

- r = inputVector[number] * scalar;

- if(r > max_val)

- r = max_val;

- else if(r < min_val)

- r = min_val;

- outputVector[number] = (int32_t)(r);

- }

-}

-#endif /* LV_HAVE_SSE */

-

-#ifdef LV_HAVE_GENERIC

- /*!

- \brief Multiplies each point in the input buffer by the scalar value, then converts the result into a 32 bit integer value

- \param inputVector The floating point input data buffer

- \param outputVector The 32 bit output data buffer

- \param scalar The value multiplied against each point in the input buffer

- \param num_points The number of data values to be converted

- \note Input buffer does NOT need to be properly aligned

- */

-static inline void volk_32f_s32f_convert_32i_u_generic(int32_t* outputVector, const float* inputVector, const float scalar, unsigned int num_points){

- int32_t* outputVectorPtr = outputVector;

- const float* inputVectorPtr = inputVector;

- unsigned int number = 0;

- float min_val = -2147483647;

- float max_val = 2147483647;

- float r;

-

- for(number = 0; number < num_points; number++){

- r = *inputVectorPtr++ * scalar;

- if(r > max_val)

- r = max_val;

- else if(r < min_val)

- r = min_val;

- *outputVectorPtr++ = (int32_t)(r);

- }

-}

-#endif /* LV_HAVE_GENERIC */

-

-

-

-

-#endif /* INCLUDED_volk_32f_s32f_convert_32i_u_H */

-#ifndef INCLUDED_volk_32f_s32f_convert_8i_a_H

-#define INCLUDED_volk_32f_s32f_convert_8i_a_H

-

-#include <volk/volk_common.h>

-#include <inttypes.h>

-#include <stdio.h>

-

-#ifdef LV_HAVE_SSE2

-#include <emmintrin.h>

- /*!

- \brief Multiplies each point in the input buffer by the scalar value, then converts the result into a 8 bit integer value

- \param inputVector The floating point input data buffer

- \param outputVector The 8 bit output data buffer

- \param scalar The value multiplied against each point in the input buffer

- \param num_points The number of data values to be converted

- */

-static inline void volk_32f_s32f_convert_8i_a_sse2(int8_t* outputVector, const float* inputVector, const float scalar, unsigned int num_points){

- unsigned int number = 0;

-

- const unsigned int sixteenthPoints = num_points / 16;

-

- const float* inputVectorPtr = (const float*)inputVector;

- int8_t* outputVectorPtr = outputVector;

-

- float min_val = -128;

- float max_val = 127;

- float r;

-

- __m128 vScalar = _mm_set_ps1(scalar);

- __m128 inputVal1, inputVal2, inputVal3, inputVal4;

- __m128i intInputVal1, intInputVal2, intInputVal3, intInputVal4;

- __m128 vmin_val = _mm_set_ps1(min_val);

- __m128 vmax_val = _mm_set_ps1(max_val);

-

- for(;number < sixteenthPoints; number++){

- inputVal1 = _mm_load_ps(inputVectorPtr); inputVectorPtr += 4;

- inputVal2 = _mm_load_ps(inputVectorPtr); inputVectorPtr += 4;

- inputVal3 = _mm_load_ps(inputVectorPtr); inputVectorPtr += 4;

- inputVal4 = _mm_load_ps(inputVectorPtr); inputVectorPtr += 4;

-

- inputVal1 = _mm_max_ps(_mm_min_ps(_mm_mul_ps(inputVal1, vScalar), vmax_val), vmin_val);

- inputVal2 = _mm_max_ps(_mm_min_ps(_mm_mul_ps(inputVal2, vScalar), vmax_val), vmin_val);

- inputVal3 = _mm_max_ps(_mm_min_ps(_mm_mul_ps(inputVal3, vScalar), vmax_val), vmin_val);

- inputVal4 = _mm_max_ps(_mm_min_ps(_mm_mul_ps(inputVal4, vScalar), vmax_val), vmin_val);

-

- intInputVal1 = _mm_cvtps_epi32(inputVal1);

- intInputVal2 = _mm_cvtps_epi32(inputVal2);

- intInputVal3 = _mm_cvtps_epi32(inputVal3);

- intInputVal4 = _mm_cvtps_epi32(inputVal4);

-

- intInputVal1 = _mm_packs_epi32(intInputVal1, intInputVal2);

- intInputVal3 = _mm_packs_epi32(intInputVal3, intInputVal4);

-

- intInputVal1 = _mm_packs_epi16(intInputVal1, intInputVal3);

-

- _mm_store_si128((__m128i*)outputVectorPtr, intInputVal1);

- outputVectorPtr += 16;

- }

-

- number = sixteenthPoints * 16;

- for(; number < num_points; number++){

- r = inputVector[number] * scalar;

- if(r > max_val)

- r = max_val;

- else if(r < min_val)

- r = min_val;

- outputVector[number] = (int8_t)(r);

- }

-}

-#endif /* LV_HAVE_SSE2 */

-

-#ifdef LV_HAVE_SSE

-#include <xmmintrin.h>

- /*!

- \brief Multiplies each point in the input buffer by the scalar value, then converts the result into a 8 bit integer value

- \param inputVector The floating point input data buffer

- \param outputVector The 8 bit output data buffer

- \param scalar The value multiplied against each point in the input buffer

- \param num_points The number of data values to be converted

- */

-static inline void volk_32f_s32f_convert_8i_a_sse(int8_t* outputVector, const float* inputVector, const float scalar, unsigned int num_points){

- unsigned int number = 0;

-

- const unsigned int quarterPoints = num_points / 4;

-

- const float* inputVectorPtr = (const float*)inputVector;

-

- float min_val = -128;

- float max_val = 127;

- float r;

-

- int8_t* outputVectorPtr = outputVector;

- __m128 vScalar = _mm_set_ps1(scalar);

- __m128 ret;

- __m128 vmin_val = _mm_set_ps1(min_val);

- __m128 vmax_val = _mm_set_ps1(max_val);

-

- __VOLK_ATTR_ALIGNED(16) float outputFloatBuffer[4];

-

- for(;number < quarterPoints; number++){

- ret = _mm_load_ps(inputVectorPtr);

- inputVectorPtr += 4;

-

- ret = _mm_max_ps(_mm_min_ps(_mm_mul_ps(ret, vScalar), vmax_val), vmin_val);

-

- _mm_store_ps(outputFloatBuffer, ret);

- *outputVectorPtr++ = (int8_t)(outputFloatBuffer[0]);

- *outputVectorPtr++ = (int8_t)(outputFloatBuffer[1]);

- *outputVectorPtr++ = (int8_t)(outputFloatBuffer[2]);

- *outputVectorPtr++ = (int8_t)(outputFloatBuffer[3]);

- }

-

- number = quarterPoints * 4;

- for(; number < num_points; number++){

- r = inputVector[number] * scalar;

- if(r > max_val)

- r = max_val;

- else if(r < min_val)

- r = min_val;

- outputVector[number] = (int8_t)(r);

- }

-}

-#endif /* LV_HAVE_SSE */

-

-#ifdef LV_HAVE_GENERIC

- /*!

- \brief Multiplies each point in the input buffer by the scalar value, then converts the result into a 8 bit integer value

- \param inputVector The floating point input data buffer

- \param outputVector The 8 bit output data buffer

- \param scalar The value multiplied against each point in the input buffer

- \param num_points The number of data values to be converted

- */

-static inline void volk_32f_s32f_convert_8i_a_generic(int8_t* outputVector, const float* inputVector, const float scalar, unsigned int num_points){

- int8_t* outputVectorPtr = outputVector;

- const float* inputVectorPtr = inputVector;

- unsigned int number = 0;

- float min_val = -128;

- float max_val = 127;

- float r;

-

- for(number = 0; number < num_points; number++){

- r = *inputVectorPtr++ * scalar;

- if(r > max_val)

- r = max_val;

- else if(r < min_val)

- r = min_val;

- *outputVectorPtr++ = (int8_t)(r);

- }

-}

-#endif /* LV_HAVE_GENERIC */

-

-

-

-

-#endif /* INCLUDED_volk_32f_s32f_convert_8i_a_H */

-#ifndef INCLUDED_volk_32f_s32f_multiply_32f_u_H

-#define INCLUDED_volk_32f_s32f_multiply_32f_u_H

-

-#include <inttypes.h>

-#include <stdio.h>

-

-#ifdef LV_HAVE_SSE

-#include <xmmintrin.h>

-/*!

- \brief Scalar float multiply

- \param cVector The vector where the results will be stored

- \param aVector One of the vectors to be multiplied

- \param scalar the scalar value

- \param num_points The number of values in aVector and bVector to be multiplied together and stored into cVector

-*/

-static inline void volk_32f_s32f_multiply_32f_u_sse(float* cVector, const float* aVector, const float scalar, unsigned int num_points){

- unsigned int number = 0;

- const unsigned int quarterPoints = num_points / 4;

-

- float* cPtr = cVector;

- const float* aPtr = aVector;

-

- __m128 aVal, bVal, cVal;

- bVal = _mm_set_ps1(scalar);

- for(;number < quarterPoints; number++){

-

- aVal = _mm_loadu_ps(aPtr);

-

- cVal = _mm_mul_ps(aVal, bVal);

-

- _mm_storeu_ps(cPtr,cVal); // Store the results back into the C container

-

- aPtr += 4;

- cPtr += 4;

- }

-

- number = quarterPoints * 4;

- for(;number < num_points; number++){

- *cPtr++ = (*aPtr++) * scalar;

- }

-}

-#endif /* LV_HAVE_SSE */

-

-#ifdef LV_HAVE_AVX

-#include <immintrin.h>

-/*!

- \brief Scalar float multiply

- \param cVector The vector where the results will be stored

- \param aVector One of the vectors to be multiplied

- \param scalar the scalar value

- \param num_points The number of values in aVector and bVector to be multiplied together and stored into cVector

-*/

-static inline void volk_32f_s32f_multiply_32f_u_avx(float* cVector, const float* aVector, const float scalar, unsigned int num_points){

- unsigned int number = 0;

- const unsigned int eighthPoints = num_points / 8;

-

- float* cPtr = cVector;

- const float* aPtr = aVector;

-

- __m256 aVal, bVal, cVal;

- bVal = _mm256_set1_ps(scalar);

- for(;number < eighthPoints; number++){

-

- aVal = _mm256_loadu_ps(aPtr);

-

- cVal = _mm256_mul_ps(aVal, bVal);

-

- _mm256_storeu_ps(cPtr,cVal); // Store the results back into the C container

-

- aPtr += 8;

- cPtr += 8;

- }

-

- number = eighthPoints * 8;

- for(;number < num_points; number++){

- *cPtr++ = (*aPtr++) * scalar;

- }

-}

-#endif /* LV_HAVE_AVX */

-

-#ifdef LV_HAVE_GENERIC

-/*!

- \brief Scalar float multiply

- \param cVector The vector where the results will be stored

- \param aVector One of the vectors to be multiplied

- \param scalar the scalar value

- \param num_points The number of values in aVector and bVector to be multiplied together and stored into cVector

-*/

-static inline void volk_32f_s32f_multiply_32f_u_generic(float* cVector, const float* aVector, const float scalar, unsigned int num_points){

- unsigned int number = 0;

- const float* inputPtr = aVector;

- float* outputPtr = cVector;

- for(number = 0; number < num_points; number++){

- *outputPtr = (*inputPtr) * scalar;

- inputPtr++;

- outputPtr++;

- }

-}

-#endif /* LV_HAVE_GENERIC */

-

-

-#endif /* INCLUDED_volk_32f_s32f_multiply_32f_u_H */

-#ifndef INCLUDED_volk_32f_x2_add_32f_u_H

-#define INCLUDED_volk_32f_x2_add_32f_u_H

-

-#include <inttypes.h>

-#include <stdio.h>

-

-#ifdef LV_HAVE_SSE

-#include <xmmintrin.h>

-/*!

- \brief Adds the two input vectors and store their results in the third vector

- \param cVector The vector where the results will be stored

- \param aVector One of the vectors to be added

- \param bVector One of the vectors to be added

- \param num_points The number of values in aVector and bVector to be added together and stored into cVector

-*/

-static inline void volk_32f_x2_add_32f_u_sse(float* cVector, const float* aVector, const float* bVector, unsigned int num_points){

- unsigned int number = 0;

- const unsigned int quarterPoints = num_points / 4;

-

- float* cPtr = cVector;

- const float* aPtr = aVector;

- const float* bPtr= bVector;

-

- __m128 aVal, bVal, cVal;

- for(;number < quarterPoints; number++){

-

- aVal = _mm_loadu_ps(aPtr);

- bVal = _mm_loadu_ps(bPtr);

-

- cVal = _mm_add_ps(aVal, bVal);

-

- _mm_storeu_ps(cPtr,cVal); // Store the results back into the C container

-

- aPtr += 4;

- bPtr += 4;

- cPtr += 4;

- }

-

- number = quarterPoints * 4;

- for(;number < num_points; number++){

- *cPtr++ = (*aPtr++) + (*bPtr++);

- }

-}

-#endif /* LV_HAVE_SSE */

-

-#ifdef LV_HAVE_GENERIC

-/*!

- \brief Adds the two input vectors and store their results in the third vector

- \param cVector The vector where the results will be stored

- \param aVector One of the vectors to be added

- \param bVector One of the vectors to be added

- \param num_points The number of values in aVector and bVector to be added together and stored into cVector

-*/

-static inline void volk_32f_x2_add_32f_u_generic(float* cVector, const float* aVector, const float* bVector, unsigned int num_points){

- float* cPtr = cVector;

- const float* aPtr = aVector;

- const float* bPtr= bVector;

- unsigned int number = 0;

-

- for(number = 0; number < num_points; number++){

- *cPtr++ = (*aPtr++) + (*bPtr++);

- }

-}

-#endif /* LV_HAVE_GENERIC */

-

-#endif /* INCLUDED_volk_32f_x2_add_32f_u_H */

-#ifndef INCLUDED_volk_32f_x2_dot_prod_32f_a_H

-#define INCLUDED_volk_32f_x2_dot_prod_32f_a_H

-

-#include <volk/volk_common.h>

-#include<stdio.h>

-

-

-#ifdef LV_HAVE_GENERIC

-

-

-static inline void volk_32f_x2_dot_prod_32f_a_generic(float * result, const float * input, const float * taps, unsigned int num_points) {

-

- float dotProduct = 0;

- const float* aPtr = input;

- const float* bPtr= taps;

- unsigned int number = 0;

-

- for(number = 0; number < num_points; number++){

- dotProduct += ((*aPtr++) * (*bPtr++));

- }

-

- *result = dotProduct;

-}

-

-#endif /*LV_HAVE_GENERIC*/

-

-

-#ifdef LV_HAVE_SSE

-

-

-static inline void volk_32f_x2_dot_prod_32f_a_sse( float* result, const float* input, const float* taps, unsigned int num_points) {

-

- unsigned int number = 0;

- const unsigned int sixteenthPoints = num_points / 16;

-

- float dotProduct = 0;

- const float* aPtr = input;

- const float* bPtr = taps;

-

- __m128 a0Val, a1Val, a2Val, a3Val;

- __m128 b0Val, b1Val, b2Val, b3Val;

- __m128 c0Val, c1Val, c2Val, c3Val;

-

- __m128 dotProdVal0 = _mm_setzero_ps();

- __m128 dotProdVal1 = _mm_setzero_ps();

- __m128 dotProdVal2 = _mm_setzero_ps();

- __m128 dotProdVal3 = _mm_setzero_ps();

-

- for(;number < sixteenthPoints; number++){

-

- a0Val = _mm_load_ps(aPtr);

- a1Val = _mm_load_ps(aPtr+4);

- a2Val = _mm_load_ps(aPtr+8);

- a3Val = _mm_load_ps(aPtr+12);

- b0Val = _mm_load_ps(bPtr);

- b1Val = _mm_load_ps(bPtr+4);

- b2Val = _mm_load_ps(bPtr+8);

- b3Val = _mm_load_ps(bPtr+12);

-

- c0Val = _mm_mul_ps(a0Val, b0Val);

- c1Val = _mm_mul_ps(a1Val, b1Val);

- c2Val = _mm_mul_ps(a2Val, b2Val);

- c3Val = _mm_mul_ps(a3Val, b3Val);

-

- dotProdVal0 = _mm_add_ps(c0Val, dotProdVal0);

- dotProdVal1 = _mm_add_ps(c1Val, dotProdVal1);

- dotProdVal2 = _mm_add_ps(c2Val, dotProdVal2);

- dotProdVal3 = _mm_add_ps(c3Val, dotProdVal3);

-

- aPtr += 16;

- bPtr += 16;

- }

-

- dotProdVal0 = _mm_add_ps(dotProdVal0, dotProdVal1);

- dotProdVal0 = _mm_add_ps(dotProdVal0, dotProdVal2);

- dotProdVal0 = _mm_add_ps(dotProdVal0, dotProdVal3);

-

- __VOLK_ATTR_ALIGNED(16) float dotProductVector[4];

-

- _mm_store_ps(dotProductVector,dotProdVal0); // Store the results back into the dot product vector

-

- dotProduct = dotProductVector[0];

- dotProduct += dotProductVector[1];

- dotProduct += dotProductVector[2];

- dotProduct += dotProductVector[3];

-

- number = sixteenthPoints*16;

- for(;number < num_points; number++){

- dotProduct += ((*aPtr++) * (*bPtr++));

- }

-

- *result = dotProduct;

-

-}

-

-#endif /*LV_HAVE_SSE*/

-

-#ifdef LV_HAVE_SSE3

-

-#include <pmmintrin.h>

-

-static inline void volk_32f_x2_dot_prod_32f_a_sse3(float * result, const float * input, const float * taps, unsigned int num_points) {

- unsigned int number = 0;

- const unsigned int sixteenthPoints = num_points / 16;

-

- float dotProduct = 0;

- const float* aPtr = input;

- const float* bPtr = taps;

-

- __m128 a0Val, a1Val, a2Val, a3Val;

- __m128 b0Val, b1Val, b2Val, b3Val;

- __m128 c0Val, c1Val, c2Val, c3Val;

-

- __m128 dotProdVal0 = _mm_setzero_ps();

- __m128 dotProdVal1 = _mm_setzero_ps();

- __m128 dotProdVal2 = _mm_setzero_ps();

- __m128 dotProdVal3 = _mm_setzero_ps();

-

- for(;number < sixteenthPoints; number++){

-

- a0Val = _mm_load_ps(aPtr);

- a1Val = _mm_load_ps(aPtr+4);

- a2Val = _mm_load_ps(aPtr+8);

- a3Val = _mm_load_ps(aPtr+12);

- b0Val = _mm_load_ps(bPtr);

- b1Val = _mm_load_ps(bPtr+4);

- b2Val = _mm_load_ps(bPtr+8);

- b3Val = _mm_load_ps(bPtr+12);

-

- c0Val = _mm_mul_ps(a0Val, b0Val);

- c1Val = _mm_mul_ps(a1Val, b1Val);

- c2Val = _mm_mul_ps(a2Val, b2Val);

- c3Val = _mm_mul_ps(a3Val, b3Val);

-

- dotProdVal0 = _mm_add_ps(dotProdVal0, c0Val);

- dotProdVal1 = _mm_add_ps(dotProdVal1, c1Val);

- dotProdVal2 = _mm_add_ps(dotProdVal2, c2Val);

- dotProdVal3 = _mm_add_ps(dotProdVal3, c3Val);

-

- aPtr += 16;

- bPtr += 16;

- }

-

- dotProdVal0 = _mm_add_ps(dotProdVal0, dotProdVal1);

- dotProdVal0 = _mm_add_ps(dotProdVal0, dotProdVal2);

- dotProdVal0 = _mm_add_ps(dotProdVal0, dotProdVal3);

-

- __VOLK_ATTR_ALIGNED(16) float dotProductVector[4];

- _mm_store_ps(dotProductVector,dotProdVal0); // Store the results back into the dot product vector

-

- dotProduct = dotProductVector[0];

- dotProduct += dotProductVector[1];

- dotProduct += dotProductVector[2];

- dotProduct += dotProductVector[3];

-

- number = sixteenthPoints*16;

- for(;number < num_points; number++){

- dotProduct += ((*aPtr++) * (*bPtr++));

- }

-

- *result = dotProduct;

-}

-

-#endif /*LV_HAVE_SSE3*/

-

-#ifdef LV_HAVE_SSE4_1

-

-#include <smmintrin.h>

-

-static inline void volk_32f_x2_dot_prod_32f_a_sse4_1(float * result, const float * input, const float* taps, unsigned int num_points) {

- unsigned int number = 0;

- const unsigned int sixteenthPoints = num_points / 16;

-

- float dotProduct = 0;

- const float* aPtr = input;

- const float* bPtr = taps;

-

- __m128 aVal1, bVal1, cVal1;

- __m128 aVal2, bVal2, cVal2;

- __m128 aVal3, bVal3, cVal3;

- __m128 aVal4, bVal4, cVal4;

-

- __m128 dotProdVal = _mm_setzero_ps();

-

- for(;number < sixteenthPoints; number++){

-

- aVal1 = _mm_load_ps(aPtr); aPtr += 4;

- aVal2 = _mm_load_ps(aPtr); aPtr += 4;

- aVal3 = _mm_load_ps(aPtr); aPtr += 4;

- aVal4 = _mm_load_ps(aPtr); aPtr += 4;

-

- bVal1 = _mm_load_ps(bPtr); bPtr += 4;

- bVal2 = _mm_load_ps(bPtr); bPtr += 4;

- bVal3 = _mm_load_ps(bPtr); bPtr += 4;

- bVal4 = _mm_load_ps(bPtr); bPtr += 4;

-

- cVal1 = _mm_dp_ps(aVal1, bVal1, 0xF1);

- cVal2 = _mm_dp_ps(aVal2, bVal2, 0xF2);

- cVal3 = _mm_dp_ps(aVal3, bVal3, 0xF4);

- cVal4 = _mm_dp_ps(aVal4, bVal4, 0xF8);

-

- cVal1 = _mm_or_ps(cVal1, cVal2);

- cVal3 = _mm_or_ps(cVal3, cVal4);

- cVal1 = _mm_or_ps(cVal1, cVal3);

-

- dotProdVal = _mm_add_ps(dotProdVal, cVal1);

- }

-

- __VOLK_ATTR_ALIGNED(16) float dotProductVector[4];

- _mm_store_ps(dotProductVector, dotProdVal); // Store the results back into the dot product vector

-

- dotProduct = dotProductVector[0];

- dotProduct += dotProductVector[1];

- dotProduct += dotProductVector[2];

- dotProduct += dotProductVector[3];

-

- number = sixteenthPoints * 16;

- for(;number < num_points; number++){

- dotProduct += ((*aPtr++) * (*bPtr++));

- }

-

- *result = dotProduct;

-}

-

-#endif /*LV_HAVE_SSE4_1*/

-

-#ifdef LV_HAVE_AVX

-

-#include <immintrin.h>

-

-static inline void volk_32f_x2_dot_prod_32f_a_avx( float* result, const float* input, const float* taps, unsigned int num_points) {

-

- unsigned int number = 0;

- const unsigned int sixteenthPoints = num_points / 16;

-

- float dotProduct = 0;

- const float* aPtr = input;

- const float* bPtr = taps;

-

- __m256 a0Val, a1Val;

- __m256 b0Val, b1Val;

- __m256 c0Val, c1Val;

-

- __m256 dotProdVal0 = _mm256_setzero_ps();

- __m256 dotProdVal1 = _mm256_setzero_ps();

-

- for(;number < sixteenthPoints; number++){

-

- a0Val = _mm256_load_ps(aPtr);

- a1Val = _mm256_load_ps(aPtr+8);

- b0Val = _mm256_load_ps(bPtr);

- b1Val = _mm256_load_ps(bPtr+8);

-

- c0Val = _mm256_mul_ps(a0Val, b0Val);

- c1Val = _mm256_mul_ps(a1Val, b1Val);

-

- dotProdVal0 = _mm256_add_ps(c0Val, dotProdVal0);

- dotProdVal1 = _mm256_add_ps(c1Val, dotProdVal1);

-

- aPtr += 16;

- bPtr += 16;

- }

-

- dotProdVal0 = _mm256_add_ps(dotProdVal0, dotProdVal1);

-

- __VOLK_ATTR_ALIGNED(32) float dotProductVector[8];

-

- _mm256_store_ps(dotProductVector,dotProdVal0); // Store the results back into the dot product vector

-

- dotProduct = dotProductVector[0];

- dotProduct += dotProductVector[1];

- dotProduct += dotProductVector[2];

- dotProduct += dotProductVector[3];

- dotProduct += dotProductVector[4];

- dotProduct += dotProductVector[5];

- dotProduct += dotProductVector[6];

- dotProduct += dotProductVector[7];

-

- number = sixteenthPoints*16;

- for(;number < num_points; number++){

- dotProduct += ((*aPtr++) * (*bPtr++));

- }

-

- *result = dotProduct;

-

-}

-

-#endif /*LV_HAVE_AVX*/

-

-#endif /*INCLUDED_volk_32f_x2_dot_prod_32f_a_H*/

-#ifndef INCLUDED_volk_32f_x2_dot_prod_32f_u_H

-#define INCLUDED_volk_32f_x2_dot_prod_32f_u_H

-

-#include <volk/volk_common.h>

-#include<stdio.h>

-

-

-#ifdef LV_HAVE_GENERIC

-

-

-static inline void volk_32f_x2_dot_prod_32f_u_generic(float * result, const float * input, const float * taps, unsigned int num_points) {

-

- float dotProduct = 0;

- const float* aPtr = input;

- const float* bPtr= taps;

- unsigned int number = 0;

-

- for(number = 0; number < num_points; number++){

- dotProduct += ((*aPtr++) * (*bPtr++));

- }

-

- *result = dotProduct;

-}

-

-#endif /*LV_HAVE_GENERIC*/

-

-

-#ifdef LV_HAVE_SSE

-

-

-static inline void volk_32f_x2_dot_prod_32f_u_sse( float* result, const float* input, const float* taps, unsigned int num_points) {

-

- unsigned int number = 0;

- const unsigned int sixteenthPoints = num_points / 16;

-

- float dotProduct = 0;

- const float* aPtr = input;

- const float* bPtr = taps;

-

- __m128 a0Val, a1Val, a2Val, a3Val;

- __m128 b0Val, b1Val, b2Val, b3Val;

- __m128 c0Val, c1Val, c2Val, c3Val;

-

- __m128 dotProdVal0 = _mm_setzero_ps();

- __m128 dotProdVal1 = _mm_setzero_ps();

- __m128 dotProdVal2 = _mm_setzero_ps();

- __m128 dotProdVal3 = _mm_setzero_ps();

-

- for(;number < sixteenthPoints; number++){

-

- a0Val = _mm_loadu_ps(aPtr);

- a1Val = _mm_loadu_ps(aPtr+4);

- a2Val = _mm_loadu_ps(aPtr+8);

- a3Val = _mm_loadu_ps(aPtr+12);

- b0Val = _mm_loadu_ps(bPtr);

- b1Val = _mm_loadu_ps(bPtr+4);

- b2Val = _mm_loadu_ps(bPtr+8);

- b3Val = _mm_loadu_ps(bPtr+12);

-

- c0Val = _mm_mul_ps(a0Val, b0Val);

- c1Val = _mm_mul_ps(a1Val, b1Val);

- c2Val = _mm_mul_ps(a2Val, b2Val);

- c3Val = _mm_mul_ps(a3Val, b3Val);

-

- dotProdVal0 = _mm_add_ps(c0Val, dotProdVal0);

- dotProdVal1 = _mm_add_ps(c1Val, dotProdVal1);

- dotProdVal2 = _mm_add_ps(c2Val, dotProdVal2);

- dotProdVal3 = _mm_add_ps(c3Val, dotProdVal3);

-

- aPtr += 16;

- bPtr += 16;

- }

-

- dotProdVal0 = _mm_add_ps(dotProdVal0, dotProdVal1);

- dotProdVal0 = _mm_add_ps(dotProdVal0, dotProdVal2);

- dotProdVal0 = _mm_add_ps(dotProdVal0, dotProdVal3);

-

- __VOLK_ATTR_ALIGNED(16) float dotProductVector[4];

-

- _mm_store_ps(dotProductVector,dotProdVal0); // Store the results back into the dot product vector

-

- dotProduct = dotProductVector[0];

- dotProduct += dotProductVector[1];

- dotProduct += dotProductVector[2];

- dotProduct += dotProductVector[3];

-

- number = sixteenthPoints*16;

- for(;number < num_points; number++){

- dotProduct += ((*aPtr++) * (*bPtr++));

- }

-

- *result = dotProduct;

-

-}

-

-#endif /*LV_HAVE_SSE*/

-

-#ifdef LV_HAVE_SSE3

-

-#include <pmmintrin.h>

-

-static inline void volk_32f_x2_dot_prod_32f_u_sse3(float * result, const float * input, const float * taps, unsigned int num_points) {

- unsigned int number = 0;

- const unsigned int sixteenthPoints = num_points / 16;

-

- float dotProduct = 0;

- const float* aPtr = input;

- const float* bPtr = taps;

-

- __m128 a0Val, a1Val, a2Val, a3Val;

- __m128 b0Val, b1Val, b2Val, b3Val;

- __m128 c0Val, c1Val, c2Val, c3Val;

-

- __m128 dotProdVal0 = _mm_setzero_ps();

- __m128 dotProdVal1 = _mm_setzero_ps();

- __m128 dotProdVal2 = _mm_setzero_ps();

- __m128 dotProdVal3 = _mm_setzero_ps();

-

- for(;number < sixteenthPoints; number++){

-

- a0Val = _mm_loadu_ps(aPtr);

- a1Val = _mm_loadu_ps(aPtr+4);

- a2Val = _mm_loadu_ps(aPtr+8);

- a3Val = _mm_loadu_ps(aPtr+12);

- b0Val = _mm_loadu_ps(bPtr);

- b1Val = _mm_loadu_ps(bPtr+4);

- b2Val = _mm_loadu_ps(bPtr+8);

- b3Val = _mm_loadu_ps(bPtr+12);

-

- c0Val = _mm_mul_ps(a0Val, b0Val);

- c1Val = _mm_mul_ps(a1Val, b1Val);

- c2Val = _mm_mul_ps(a2Val, b2Val);

- c3Val = _mm_mul_ps(a3Val, b3Val);

-

- dotProdVal0 = _mm_add_ps(dotProdVal0, c0Val);

- dotProdVal1 = _mm_add_ps(dotProdVal1, c1Val);

- dotProdVal2 = _mm_add_ps(dotProdVal2, c2Val);

- dotProdVal3 = _mm_add_ps(dotProdVal3, c3Val);

-

- aPtr += 16;

- bPtr += 16;

- }

-

- dotProdVal0 = _mm_add_ps(dotProdVal0, dotProdVal1);

- dotProdVal0 = _mm_add_ps(dotProdVal0, dotProdVal2);

- dotProdVal0 = _mm_add_ps(dotProdVal0, dotProdVal3);

-

- __VOLK_ATTR_ALIGNED(16) float dotProductVector[4];

- _mm_store_ps(dotProductVector,dotProdVal0); // Store the results back into the dot product vector

-

- dotProduct = dotProductVector[0];

- dotProduct += dotProductVector[1];

- dotProduct += dotProductVector[2];

- dotProduct += dotProductVector[3];

-

- number = sixteenthPoints*16;

- for(;number < num_points; number++){

- dotProduct += ((*aPtr++) * (*bPtr++));

- }

-

- *result = dotProduct;

-}

-

-#endif /*LV_HAVE_SSE3*/

-

-#ifdef LV_HAVE_SSE4_1

-

-#include <smmintrin.h>

-

-static inline void volk_32f_x2_dot_prod_32f_u_sse4_1(float * result, const float * input, const float* taps, unsigned int num_points) {

- unsigned int number = 0;

- const unsigned int sixteenthPoints = num_points / 16;

-

- float dotProduct = 0;

- const float* aPtr = input;

- const float* bPtr = taps;

-

- __m128 aVal1, bVal1, cVal1;

- __m128 aVal2, bVal2, cVal2;

- __m128 aVal3, bVal3, cVal3;

- __m128 aVal4, bVal4, cVal4;

-

- __m128 dotProdVal = _mm_setzero_ps();

-

- for(;number < sixteenthPoints; number++){

-

- aVal1 = _mm_loadu_ps(aPtr); aPtr += 4;

- aVal2 = _mm_loadu_ps(aPtr); aPtr += 4;

- aVal3 = _mm_loadu_ps(aPtr); aPtr += 4;

- aVal4 = _mm_loadu_ps(aPtr); aPtr += 4;

-

- bVal1 = _mm_loadu_ps(bPtr); bPtr += 4;

- bVal2 = _mm_loadu_ps(bPtr); bPtr += 4;

- bVal3 = _mm_loadu_ps(bPtr); bPtr += 4;

- bVal4 = _mm_loadu_ps(bPtr); bPtr += 4;

-

- cVal1 = _mm_dp_ps(aVal1, bVal1, 0xF1);

- cVal2 = _mm_dp_ps(aVal2, bVal2, 0xF2);

- cVal3 = _mm_dp_ps(aVal3, bVal3, 0xF4);

- cVal4 = _mm_dp_ps(aVal4, bVal4, 0xF8);

-

- cVal1 = _mm_or_ps(cVal1, cVal2);

- cVal3 = _mm_or_ps(cVal3, cVal4);

- cVal1 = _mm_or_ps(cVal1, cVal3);

-

- dotProdVal = _mm_add_ps(dotProdVal, cVal1);

- }

-

- __VOLK_ATTR_ALIGNED(16) float dotProductVector[4];

- _mm_store_ps(dotProductVector, dotProdVal); // Store the results back into the dot product vector

-

- dotProduct = dotProductVector[0];

- dotProduct += dotProductVector[1];

- dotProduct += dotProductVector[2];

- dotProduct += dotProductVector[3];

-

- number = sixteenthPoints * 16;

- for(;number < num_points; number++){

- dotProduct += ((*aPtr++) * (*bPtr++));

- }

-

- *result = dotProduct;

-}

-

-#endif /*LV_HAVE_SSE4_1*/

-

-#ifdef LV_HAVE_AVX

-

-#include <immintrin.h>

-

-static inline void volk_32f_x2_dot_prod_32f_u_avx( float* result, const float* input, const float* taps, unsigned int num_points) {

-

- unsigned int number = 0;

- const unsigned int sixteenthPoints = num_points / 16;

-

- float dotProduct = 0;

- const float* aPtr = input;

- const float* bPtr = taps;

-

- __m256 a0Val, a1Val;

- __m256 b0Val, b1Val;

- __m256 c0Val, c1Val;

-

- __m256 dotProdVal0 = _mm256_setzero_ps();

- __m256 dotProdVal1 = _mm256_setzero_ps();

-

- for(;number < sixteenthPoints; number++){

-

- a0Val = _mm256_loadu_ps(aPtr);

- a1Val = _mm256_loadu_ps(aPtr+8);

- b0Val = _mm256_loadu_ps(bPtr);

- b1Val = _mm256_loadu_ps(bPtr+8);

-

- c0Val = _mm256_mul_ps(a0Val, b0Val);

- c1Val = _mm256_mul_ps(a1Val, b1Val);

-

- dotProdVal0 = _mm256_add_ps(c0Val, dotProdVal0);

- dotProdVal1 = _mm256_add_ps(c1Val, dotProdVal1);

-

- aPtr += 16;

- bPtr += 16;

- }

-

- dotProdVal0 = _mm256_add_ps(dotProdVal0, dotProdVal1);

-

- __VOLK_ATTR_ALIGNED(32) float dotProductVector[8];

-

- _mm256_storeu_ps(dotProductVector,dotProdVal0); // Store the results back into the dot product vector

-

- dotProduct = dotProductVector[0];

- dotProduct += dotProductVector[1];

- dotProduct += dotProductVector[2];

- dotProduct += dotProductVector[3];

- dotProduct += dotProductVector[4];

- dotProduct += dotProductVector[5];

- dotProduct += dotProductVector[6];

- dotProduct += dotProductVector[7];

-

- number = sixteenthPoints*16;

- for(;number < num_points; number++){

- dotProduct += ((*aPtr++) * (*bPtr++));

- }

-

- *result = dotProduct;

-

-}

-

-#endif /*LV_HAVE_AVX*/

-

-#endif /*INCLUDED_volk_32f_x2_dot_prod_32f_u_H*/

-#ifndef INCLUDED_volk_32f_x2_multiply_32f_u_H

-#define INCLUDED_volk_32f_x2_multiply_32f_u_H

-

-#include <inttypes.h>

-#include <stdio.h>

-

-#ifdef LV_HAVE_SSE

-#include <xmmintrin.h>

-/*!

- \brief Multiplys the two input vectors and store their results in the third vector

- \param cVector The vector where the results will be stored

- \param aVector One of the vectors to be multiplied

- \param bVector One of the vectors to be multiplied

- \param num_points The number of values in aVector and bVector to be multiplied together and stored into cVector

-*/

-static inline void volk_32f_x2_multiply_32f_u_sse(float* cVector, const float* aVector, const float* bVector, unsigned int num_points){

- unsigned int number = 0;

- const unsigned int quarterPoints = num_points / 4;

-

- float* cPtr = cVector;

- const float* aPtr = aVector;

- const float* bPtr= bVector;

-

- __m128 aVal, bVal, cVal;

- for(;number < quarterPoints; number++){

-

- aVal = _mm_loadu_ps(aPtr);

- bVal = _mm_loadu_ps(bPtr);

-

- cVal = _mm_mul_ps(aVal, bVal);

-

- _mm_storeu_ps(cPtr,cVal); // Store the results back into the C container

-

- aPtr += 4;

- bPtr += 4;

- cPtr += 4;

- }

-

- number = quarterPoints * 4;

- for(;number < num_points; number++){

- *cPtr++ = (*aPtr++) * (*bPtr++);

- }

-}

-#endif /* LV_HAVE_SSE */

-

-#ifdef LV_HAVE_AVX

-#include <immintrin.h>

-/*!

- \brief Multiplies the two input vectors and store their results in the third vector

- \param cVector The vector where the results will be stored

- \param aVector One of the vectors to be multiplied

- \param bVector One of the vectors to be multiplied

- \param num_points The number of values in aVector and bVector to be multiplied together and stored into cVector

-*/

-static inline void volk_32f_x2_multiply_32f_u_avx(float* cVector, const float* aVector, const float* bVector, unsigned int num_points){

- unsigned int number = 0;

- const unsigned int eighthPoints = num_points / 8;

-

- float* cPtr = cVector;

- const float* aPtr = aVector;

- const float* bPtr= bVector;

-

- __m256 aVal, bVal, cVal;

- for(;number < eighthPoints; number++){

-

- aVal = _mm256_loadu_ps(aPtr);

- bVal = _mm256_loadu_ps(bPtr);

-

- cVal = _mm256_mul_ps(aVal, bVal);

-

- _mm256_storeu_ps(cPtr,cVal); // Store the results back into the C container

-

- aPtr += 8;

- bPtr += 8;

- cPtr += 8;

- }

-

- number = eighthPoints * 8;

- for(;number < num_points; number++){

- *cPtr++ = (*aPtr++) * (*bPtr++);

- }

-}

-#endif /* LV_HAVE_AVX */

-

-#ifdef LV_HAVE_GENERIC

-/*!

- \brief Multiplys the two input vectors and store their results in the third vector

- \param cVector The vector where the results will be stored

- \param aVector One of the vectors to be multiplied

- \param bVector One of the vectors to be multiplied

- \param num_points The number of values in aVector and bVector to be multiplied together and stored into cVector

-*/

-static inline void volk_32f_x2_multiply_32f_u_generic(float* cVector, const float* aVector, const float* bVector, unsigned int num_points){

- float* cPtr = cVector;

- const float* aPtr = aVector;

- const float* bPtr= bVector;

- unsigned int number = 0;

-

- for(number = 0; number < num_points; number++){

- *cPtr++ = (*aPtr++) * (*bPtr++);

- }

-}

-#endif /* LV_HAVE_GENERIC */

-

-

-#endif /* INCLUDED_volk_32f_x2_multiply_32f_u_H */

-#ifndef INCLUDED_volk_32fc_conjugate_32fc_u_H

-#define INCLUDED_volk_32fc_conjugate_32fc_u_H

-

-#include <inttypes.h>

-#include <stdio.h>

-#include <volk/volk_complex.h>

-#include <float.h>

-

-#ifdef LV_HAVE_SSE3

-#include <pmmintrin.h>

- /*!

- \brief Takes the conjugate of a complex vector.

- \param cVector The vector where the results will be stored

- \param aVector Vector to be conjugated

- \param num_points The number of complex values in aVector to be conjugated and stored into cVector

- */

-static inline void volk_32fc_conjugate_32fc_u_sse3(lv_32fc_t* cVector, const lv_32fc_t* aVector, unsigned int num_points){

- unsigned int number = 0;

- const unsigned int halfPoints = num_points / 2;

-

- __m128 x;

- lv_32fc_t* c = cVector;

- const lv_32fc_t* a = aVector;

-

- __m128 conjugator = _mm_setr_ps(0, -0.f, 0, -0.f);

-

- for(;number < halfPoints; number++){

-

- x = _mm_loadu_ps((float*)a); // Load the complex data as ar,ai,br,bi

-

- x = _mm_xor_ps(x, conjugator); // conjugate register

-

- _mm_storeu_ps((float*)c,x); // Store the results back into the C container

-

- a += 2;

- c += 2;

- }

-

- if((num_points % 2) != 0) {

- *c = lv_conj(*a);

- }

-}

-#endif /* LV_HAVE_SSE3 */

-

-#ifdef LV_HAVE_GENERIC

- /*!

- \brief Takes the conjugate of a complex vector.

- \param cVector The vector where the results will be stored

- \param aVector Vector to be conjugated

- \param num_points The number of complex values in aVector to be conjugated and stored into cVector

- */

-static inline void volk_32fc_conjugate_32fc_u_generic(lv_32fc_t* cVector, const lv_32fc_t* aVector, unsigned int num_points){

- lv_32fc_t* cPtr = cVector;

- const lv_32fc_t* aPtr = aVector;

- unsigned int number = 0;

-

- for(number = 0; number < num_points; number++){

- *cPtr++ = lv_conj(*aPtr++);

- }

-}

-#endif /* LV_HAVE_GENERIC */

-

-

-#endif /* INCLUDED_volk_32fc_conjugate_32fc_u_H */

-#ifndef INCLUDED_volk_32fc_deinterleave_64f_x2_a_H

-#define INCLUDED_volk_32fc_deinterleave_64f_x2_a_H

-

-#include <inttypes.h>

-#include <stdio.h>

-

-#ifdef LV_HAVE_SSE2

-#include <emmintrin.h>

-/*!

- \brief Deinterleaves the lv_32fc_t vector into double I & Q vector data

- \param complexVector The complex input vector

- \param iBuffer The I buffer output data

- \param qBuffer The Q buffer output data

- \param num_points The number of complex data values to be deinterleaved

-*/

-static inline void volk_32fc_deinterleave_64f_x2_a_sse2(double* iBuffer, double* qBuffer, const lv_32fc_t* complexVector, unsigned int num_points){

- unsigned int number = 0;

-

- const float* complexVectorPtr = (float*)complexVector;

- double* iBufferPtr = iBuffer;

- double* qBufferPtr = qBuffer;

-

- const unsigned int halfPoints = num_points / 2;

- __m128 cplxValue, fVal;

- __m128d dVal;

-

- for(;number < halfPoints; number++){

-

- cplxValue = _mm_load_ps(complexVectorPtr);

- complexVectorPtr += 4;

-

- // Arrange in i1i2i1i2 format

- fVal = _mm_shuffle_ps(cplxValue, cplxValue, _MM_SHUFFLE(2,0,2,0));

- dVal = _mm_cvtps_pd(fVal);

- _mm_store_pd(iBufferPtr, dVal);

-

- // Arrange in q1q2q1q2 format

- fVal = _mm_shuffle_ps(cplxValue, cplxValue, _MM_SHUFFLE(3,1,3,1));

- dVal = _mm_cvtps_pd(fVal);

- _mm_store_pd(qBufferPtr, dVal);

-

- iBufferPtr += 2;

- qBufferPtr += 2;

- }

-

- number = halfPoints * 2;

- for(; number < num_points; number++){

- *iBufferPtr++ = *complexVectorPtr++;

- *qBufferPtr++ = *complexVectorPtr++;

- }

-}

-#endif /* LV_HAVE_SSE */

-

-#ifdef LV_HAVE_GENERIC

-/*!

- \brief Deinterleaves the lv_32fc_t vector into double I & Q vector data

- \param complexVector The complex input vector

- \param iBuffer The I buffer output data

- \param qBuffer The Q buffer output data

- \param num_points The number of complex data values to be deinterleaved

-*/

-static inline void volk_32fc_deinterleave_64f_x2_a_generic(double* iBuffer, double* qBuffer, const lv_32fc_t* complexVector, unsigned int num_points){

- unsigned int number = 0;

- const float* complexVectorPtr = (float*)complexVector;

- double* iBufferPtr = iBuffer;

- double* qBufferPtr = qBuffer;

-

- for(number = 0; number < num_points; number++){

- *iBufferPtr++ = (double)*complexVectorPtr++;

- *qBufferPtr++ = (double)*complexVectorPtr++;

- }

-}

-#endif /* LV_HAVE_GENERIC */

-

-

-

-

-#endif /* INCLUDED_volk_32fc_deinterleave_64f_x2_a_H */

-#ifndef INCLUDED_volk_32fc_deinterleave_64f_x2_u_H

-#define INCLUDED_volk_32fc_deinterleave_64f_x2_u_H

-

-#include <inttypes.h>

-#include <stdio.h>

-

-#ifdef LV_HAVE_SSE2

-#include <emmintrin.h>

-/*!

- \brief Deinterleaves the lv_32fc_t vector into double I & Q vector data

- \param complexVector The complex input vector

- \param iBuffer The I buffer output data

- \param qBuffer The Q buffer output data

- \param num_points The number of complex data values to be deinterleaved

-*/

-static inline void volk_32fc_deinterleave_64f_x2_u_sse2(double* iBuffer, double* qBuffer, const lv_32fc_t* complexVector, unsigned int num_points){

- unsigned int number = 0;

-

- const float* complexVectorPtr = (float*)complexVector;

- double* iBufferPtr = iBuffer;

- double* qBufferPtr = qBuffer;

-

- const unsigned int halfPoints = num_points / 2;

- __m128 cplxValue, fVal;

- __m128d dVal;

-

- for(;number < halfPoints; number++){

-

- cplxValue = _mm_loadu_ps(complexVectorPtr);

- complexVectorPtr += 4;

-

- // Arrange in i1i2i1i2 format

- fVal = _mm_shuffle_ps(cplxValue, cplxValue, _MM_SHUFFLE(2,0,2,0));

- dVal = _mm_cvtps_pd(fVal);

- _mm_storeu_pd(iBufferPtr, dVal);

-

- // Arrange in q1q2q1q2 format

- fVal = _mm_shuffle_ps(cplxValue, cplxValue, _MM_SHUFFLE(3,1,3,1));

- dVal = _mm_cvtps_pd(fVal);

- _mm_storeu_pd(qBufferPtr, dVal);

-

- iBufferPtr += 2;

- qBufferPtr += 2;

- }

-

- number = halfPoints * 2;

- for(; number < num_points; number++){

- *iBufferPtr++ = *complexVectorPtr++;

- *qBufferPtr++ = *complexVectorPtr++;

- }

-}

-#endif /* LV_HAVE_SSE */

-

-#ifdef LV_HAVE_GENERIC

-/*!

- \brief Deinterleaves the lv_32fc_t vector into double I & Q vector data

- \param complexVector The complex input vector

- \param iBuffer The I buffer output data

- \param qBuffer The Q buffer output data

- \param num_points The number of complex data values to be deinterleaved

-*/

-static inline void volk_32fc_deinterleave_64f_x2_u_generic(double* iBuffer, double* qBuffer, const lv_32fc_t* complexVector, unsigned int num_points){

- unsigned int number = 0;

- const float* complexVectorPtr = (float*)complexVector;

- double* iBufferPtr = iBuffer;

- double* qBufferPtr = qBuffer;

-

- for(number = 0; number < num_points; number++){

- *iBufferPtr++ = (double)*complexVectorPtr++;

- *qBufferPtr++ = (double)*complexVectorPtr++;

- }

-}

-#endif /* LV_HAVE_GENERIC */

-

-

-

-

-#endif /* INCLUDED_volk_32fc_deinterleave_64f_x2_u_H */

-#ifndef INCLUDED_volk_32fc_magnitude_32f_u_H

-#define INCLUDED_volk_32fc_magnitude_32f_u_H

-

-#include <inttypes.h>

-#include <stdio.h>

-#include <math.h>

-

-#ifdef LV_HAVE_SSE3

-#include <pmmintrin.h>

- /*!

- \brief Calculates the magnitude of the complexVector and stores the results in the magnitudeVector

- \param complexVector The vector containing the complex input values

- \param magnitudeVector The vector containing the real output values

- \param num_points The number of complex values in complexVector to be calculated and stored into cVector

- */

-static inline void volk_32fc_magnitude_32f_u_sse3(float* magnitudeVector, const lv_32fc_t* complexVector, unsigned int num_points){

- unsigned int number = 0;

- const unsigned int quarterPoints = num_points / 4;

-

- const float* complexVectorPtr = (float*)complexVector;

- float* magnitudeVectorPtr = magnitudeVector;

-

- __m128 cplxValue1, cplxValue2, result;

- for(;number < quarterPoints; number++){

- cplxValue1 = _mm_loadu_ps(complexVectorPtr);

- complexVectorPtr += 4;

-

- cplxValue2 = _mm_loadu_ps(complexVectorPtr);

- complexVectorPtr += 4;

-

- cplxValue1 = _mm_mul_ps(cplxValue1, cplxValue1); // Square the values

- cplxValue2 = _mm_mul_ps(cplxValue2, cplxValue2); // Square the Values

-

- result = _mm_hadd_ps(cplxValue1, cplxValue2); // Add the I2 and Q2 values

-

- result = _mm_sqrt_ps(result);

-

- _mm_storeu_ps(magnitudeVectorPtr, result);

- magnitudeVectorPtr += 4;

- }

-

- number = quarterPoints * 4;

- for(; number < num_points; number++){

- float val1Real = *complexVectorPtr++;

- float val1Imag = *complexVectorPtr++;

- *magnitudeVectorPtr++ = sqrtf((val1Real * val1Real) + (val1Imag * val1Imag));

- }

-}

-#endif /* LV_HAVE_SSE3 */

-

-#ifdef LV_HAVE_SSE

-#include <xmmintrin.h>

- /*!

- \brief Calculates the magnitude of the complexVector and stores the results in the magnitudeVector

- \param complexVector The vector containing the complex input values

- \param magnitudeVector The vector containing the real output values

- \param num_points The number of complex values in complexVector to be calculated and stored into cVector

- */

-static inline void volk_32fc_magnitude_32f_u_sse(float* magnitudeVector, const lv_32fc_t* complexVector, unsigned int num_points){

- unsigned int number = 0;

- const unsigned int quarterPoints = num_points / 4;

-

- const float* complexVectorPtr = (float*)complexVector;

- float* magnitudeVectorPtr = magnitudeVector;

-

- __m128 cplxValue1, cplxValue2, iValue, qValue, result;

- for(;number < quarterPoints; number++){

- cplxValue1 = _mm_loadu_ps(complexVectorPtr);

- complexVectorPtr += 4;

-

- cplxValue2 = _mm_loadu_ps(complexVectorPtr);

- complexVectorPtr += 4;

-

- // Arrange in i1i2i3i4 format

- iValue = _mm_shuffle_ps(cplxValue1, cplxValue2, _MM_SHUFFLE(2,0,2,0));

- // Arrange in q1q2q3q4 format

- qValue = _mm_shuffle_ps(cplxValue1, cplxValue2, _MM_SHUFFLE(3,1,3,1));

-

- iValue = _mm_mul_ps(iValue, iValue); // Square the I values

- qValue = _mm_mul_ps(qValue, qValue); // Square the Q Values

-

- result = _mm_add_ps(iValue, qValue); // Add the I2 and Q2 values

-

- result = _mm_sqrt_ps(result);

-

- _mm_storeu_ps(magnitudeVectorPtr, result);

- magnitudeVectorPtr += 4;

- }

-

- number = quarterPoints * 4;

- for(; number < num_points; number++){

- float val1Real = *complexVectorPtr++;

- float val1Imag = *complexVectorPtr++;

- *magnitudeVectorPtr++ = sqrtf((val1Real * val1Real) + (val1Imag * val1Imag));

- }

-}

-#endif /* LV_HAVE_SSE */

-

-#ifdef LV_HAVE_GENERIC

- /*!

- \brief Calculates the magnitude of the complexVector and stores the results in the magnitudeVector

- \param complexVector The vector containing the complex input values

- \param magnitudeVector The vector containing the real output values

- \param num_points The number of complex values in complexVector to be calculated and stored into cVector

- */

-static inline void volk_32fc_magnitude_32f_u_generic(float* magnitudeVector, const lv_32fc_t* complexVector, unsigned int num_points){

- const float* complexVectorPtr = (float*)complexVector;

- float* magnitudeVectorPtr = magnitudeVector;

- unsigned int number = 0;

- for(number = 0; number < num_points; number++){

- const float real = *complexVectorPtr++;

- const float imag = *complexVectorPtr++;

- *magnitudeVectorPtr++ = sqrtf((real*real) + (imag*imag));

- }

-}

-#endif /* LV_HAVE_GENERIC */

-

-#endif /* INCLUDED_volk_32fc_magnitude_32f_u_H */

-#ifndef INCLUDED_volk_32fc_magnitude_squared_32f_a_H

-#define INCLUDED_volk_32fc_magnitude_squared_32f_a_H

-

-#include <inttypes.h>

-#include <stdio.h>

-#include <math.h>

-

-#ifdef LV_HAVE_SSE3

-#include <pmmintrin.h>

- /*!

- \brief Calculates the magnitude squared of the complexVector and stores the results in the magnitudeVector

- \param complexVector The vector containing the complex input values

- \param magnitudeVector The vector containing the real output values

- \param num_points The number of complex values in complexVector to be calculated and stored into cVector

- */

-static inline void volk_32fc_magnitude_squared_32f_a_sse3(float* magnitudeVector, const lv_32fc_t* complexVector, unsigned int num_points){

- unsigned int number = 0;

- const unsigned int quarterPoints = num_points / 4;

-

- const float* complexVectorPtr = (float*)complexVector;

- float* magnitudeVectorPtr = magnitudeVector;

-

- __m128 cplxValue1, cplxValue2, result;

- for(;number < quarterPoints; number++){

- cplxValue1 = _mm_load_ps(complexVectorPtr);

- complexVectorPtr += 4;

-

- cplxValue2 = _mm_load_ps(complexVectorPtr);

- complexVectorPtr += 4;

-

- cplxValue1 = _mm_mul_ps(cplxValue1, cplxValue1); // Square the values

- cplxValue2 = _mm_mul_ps(cplxValue2, cplxValue2); // Square the Values

-

- result = _mm_hadd_ps(cplxValue1, cplxValue2); // Add the I2 and Q2 values

-

- _mm_store_ps(magnitudeVectorPtr, result);

- magnitudeVectorPtr += 4;

- }

-

- number = quarterPoints * 4;

- for(; number < num_points; number++){

- float val1Real = *complexVectorPtr++;

- float val1Imag = *complexVectorPtr++;

- *magnitudeVectorPtr++ = (val1Real * val1Real) + (val1Imag * val1Imag);

- }

-}

-#endif /* LV_HAVE_SSE3 */

-

-#ifdef LV_HAVE_SSE

-#include <xmmintrin.h>

- /*!

- \brief Calculates the magnitude squared of the complexVector and stores the results in the magnitudeVector

- \param complexVector The vector containing the complex input values

- \param magnitudeVector The vector containing the real output values

- \param num_points The number of complex values in complexVector to be calculated and stored into cVector

- */

-static inline void volk_32fc_magnitude_squared_32f_a_sse(float* magnitudeVector, const lv_32fc_t* complexVector, unsigned int num_points){

- unsigned int number = 0;

- const unsigned int quarterPoints = num_points / 4;

-

- const float* complexVectorPtr = (float*)complexVector;

- float* magnitudeVectorPtr = magnitudeVector;

-

- __m128 cplxValue1, cplxValue2, iValue, qValue, result;

- for(;number < quarterPoints; number++){

- cplxValue1 = _mm_load_ps(complexVectorPtr);

- complexVectorPtr += 4;

-

- cplxValue2 = _mm_load_ps(complexVectorPtr);

- complexVectorPtr += 4;

-

- // Arrange in i1i2i3i4 format

- iValue = _mm_shuffle_ps(cplxValue1, cplxValue2, _MM_SHUFFLE(2,0,2,0));

- // Arrange in q1q2q3q4 format

- qValue = _mm_shuffle_ps(cplxValue1, cplxValue2, _MM_SHUFFLE(3,1,3,1));

-

- iValue = _mm_mul_ps(iValue, iValue); // Square the I values

- qValue = _mm_mul_ps(qValue, qValue); // Square the Q Values

-

- result = _mm_add_ps(iValue, qValue); // Add the I2 and Q2 values

-

- _mm_store_ps(magnitudeVectorPtr, result);

- magnitudeVectorPtr += 4;

- }

-

- number = quarterPoints * 4;

- for(; number < num_points; number++){

- float val1Real = *complexVectorPtr++;

- float val1Imag = *complexVectorPtr++;

- *magnitudeVectorPtr++ = (val1Real * val1Real) + (val1Imag * val1Imag);

- }

-}

-#endif /* LV_HAVE_SSE */

-

-#ifdef LV_HAVE_GENERIC

- /*!

- \brief Calculates the magnitude squared of the complexVector and stores the results in the magnitudeVector

- \param complexVector The vector containing the complex input values

- \param magnitudeVector The vector containing the real output values

- \param num_points The number of complex values in complexVector to be calculated and stored into cVector

- */

-static inline void volk_32fc_magnitude_squared_32f_a_generic(float* magnitudeVector, const lv_32fc_t* complexVector, unsigned int num_points){

- const float* complexVectorPtr = (float*)complexVector;

- float* magnitudeVectorPtr = magnitudeVector;

- unsigned int number = 0;

- for(number = 0; number < num_points; number++){

- const float real = *complexVectorPtr++;

- const float imag = *complexVectorPtr++;

- *magnitudeVectorPtr++ = (real*real) + (imag*imag);

- }

-}

-#endif /* LV_HAVE_GENERIC */

-

-#endif /* INCLUDED_volk_32fc_magnitude_32f_a_H */

-#ifndef INCLUDED_volk_32fc_magnitude_squared_32f_u_H

-#define INCLUDED_volk_32fc_magnitude_squared_32f_u_H

-

-#include <inttypes.h>

-#include <stdio.h>

-#include <math.h>

-

-#ifdef LV_HAVE_SSE3

-#include <pmmintrin.h>

- /*!

- \brief Calculates the magnitude squared of the complexVector and stores the results in the magnitudeVector

- \param complexVector The vector containing the complex input values

- \param magnitudeVector The vector containing the real output values

- \param num_points The number of complex values in complexVector to be calculated and stored into cVector

- */

-static inline void volk_32fc_magnitude_squared_32f_u_sse3(float* magnitudeVector, const lv_32fc_t* complexVector, unsigned int num_points){

- unsigned int number = 0;

- const unsigned int quarterPoints = num_points / 4;

-

- const float* complexVectorPtr = (float*)complexVector;

- float* magnitudeVectorPtr = magnitudeVector;

-

- __m128 cplxValue1, cplxValue2, result;

- for(;number < quarterPoints; number++){

- cplxValue1 = _mm_loadu_ps(complexVectorPtr);

- complexVectorPtr += 4;

-

- cplxValue2 = _mm_loadu_ps(complexVectorPtr);

- complexVectorPtr += 4;

-

- cplxValue1 = _mm_mul_ps(cplxValue1, cplxValue1); // Square the values

- cplxValue2 = _mm_mul_ps(cplxValue2, cplxValue2); // Square the Values

-

- result = _mm_hadd_ps(cplxValue1, cplxValue2); // Add the I2 and Q2 values

-

- _mm_storeu_ps(magnitudeVectorPtr, result);

- magnitudeVectorPtr += 4;

- }

-

- number = quarterPoints * 4;

- for(; number < num_points; number++){

- float val1Real = *complexVectorPtr++;

- float val1Imag = *complexVectorPtr++;

- *magnitudeVectorPtr++ = (val1Real * val1Real) + (val1Imag * val1Imag);

- }

-}

-#endif /* LV_HAVE_SSE3 */

-

-#ifdef LV_HAVE_SSE

-#include <xmmintrin.h>

- /*!

- \brief Calculates the magnitude squared of the complexVector and stores the results in the magnitudeVector

- \param complexVector The vector containing the complex input values

- \param magnitudeVector The vector containing the real output values

- \param num_points The number of complex values in complexVector to be calculated and stored into cVector

- */

-static inline void volk_32fc_magnitude_squared_32f_u_sse(float* magnitudeVector, const lv_32fc_t* complexVector, unsigned int num_points){

- unsigned int number = 0;

- const unsigned int quarterPoints = num_points / 4;

-

- const float* complexVectorPtr = (float*)complexVector;

- float* magnitudeVectorPtr = magnitudeVector;

-

- __m128 cplxValue1, cplxValue2, iValue, qValue, result;

- for(;number < quarterPoints; number++){

- cplxValue1 = _mm_loadu_ps(complexVectorPtr);

- complexVectorPtr += 4;

-

- cplxValue2 = _mm_loadu_ps(complexVectorPtr);

- complexVectorPtr += 4;

-

- // Arrange in i1i2i3i4 format

- iValue = _mm_shuffle_ps(cplxValue1, cplxValue2, _MM_SHUFFLE(2,0,2,0));

- // Arrange in q1q2q3q4 format

- qValue = _mm_shuffle_ps(cplxValue1, cplxValue2, _MM_SHUFFLE(3,1,3,1));

-

- iValue = _mm_mul_ps(iValue, iValue); // Square the I values

- qValue = _mm_mul_ps(qValue, qValue); // Square the Q Values

-

- result = _mm_add_ps(iValue, qValue); // Add the I2 and Q2 values

-

- _mm_storeu_ps(magnitudeVectorPtr, result);

- magnitudeVectorPtr += 4;

- }

-

- number = quarterPoints * 4;

- for(; number < num_points; number++){

- float val1Real = *complexVectorPtr++;

- float val1Imag = *complexVectorPtr++;

- *magnitudeVectorPtr++ = (val1Real * val1Real) + (val1Imag * val1Imag);

- }

-}

-#endif /* LV_HAVE_SSE */

-

-#ifdef LV_HAVE_GENERIC

- /*!

- \brief Calculates the magnitude squared of the complexVector and stores the results in the magnitudeVector

- \param complexVector The vector containing the complex input values

- \param magnitudeVector The vector containing the real output values

- \param num_points The number of complex values in complexVector to be calculated and stored into cVector

- */

-static inline void volk_32fc_magnitude_squared_32f_u_generic(float* magnitudeVector, const lv_32fc_t* complexVector, unsigned int num_points){

- const float* complexVectorPtr = (float*)complexVector;

- float* magnitudeVectorPtr = magnitudeVector;

- unsigned int number = 0;

- for(number = 0; number < num_points; number++){

- const float real = *complexVectorPtr++;

- const float imag = *complexVectorPtr++;

- *magnitudeVectorPtr++ = (real*real) + (imag*imag);

- }

-}

-#endif /* LV_HAVE_GENERIC */

-

-#endif /* INCLUDED_volk_32fc_magnitude_32f_u_H */

-#ifndef INCLUDED_volk_32fc_s32fc_multiply_32fc_u_H

-#define INCLUDED_volk_32fc_s32fc_multiply_32fc_u_H

-

-#include <inttypes.h>

-#include <stdio.h>

-#include <volk/volk_complex.h>

-#include <float.h>

-

-#ifdef LV_HAVE_SSE3

-#include <pmmintrin.h>

-/*!

- \brief Multiplies the input vector by a scalar and stores the results in the third vector

- \param cVector The vector where the results will be stored

- \param aVector The vector to be multiplied

- \param scalar The complex scalar to multiply aVector

- \param num_points The number of complex values in aVector and bVector to be multiplied together and stored into cVector

-*/

-static inline void volk_32fc_s32fc_multiply_32fc_u_sse3(lv_32fc_t* cVector, const lv_32fc_t* aVector, const lv_32fc_t scalar, unsigned int num_points){

- unsigned int number = 0;

- const unsigned int halfPoints = num_points / 2;

-

- __m128 x, yl, yh, z, tmp1, tmp2;

- lv_32fc_t* c = cVector;

- const lv_32fc_t* a = aVector;

-

- // Set up constant scalar vector

- yl = _mm_set_ps1(lv_creal(scalar));

- yh = _mm_set_ps1(lv_cimag(scalar));

-

- for(;number < halfPoints; number++){

-

- x = _mm_loadu_ps((float*)a); // Load the ar + ai, br + bi as ar,ai,br,bi

-

- tmp1 = _mm_mul_ps(x,yl); // tmp1 = ar*cr,ai*cr,br*dr,bi*dr

-

- x = _mm_shuffle_ps(x,x,0xB1); // Re-arrange x to be ai,ar,bi,br

-

- tmp2 = _mm_mul_ps(x,yh); // tmp2 = ai*ci,ar*ci,bi*di,br*di

-

- z = _mm_addsub_ps(tmp1,tmp2); // ar*cr-ai*ci, ai*cr+ar*ci, br*dr-bi*di, bi*dr+br*di

-

- _mm_storeu_ps((float*)c,z); // Store the results back into the C container

-

- a += 2;

- c += 2;

- }

-

- if((num_points % 2) != 0) {

- *c = (*a) * scalar;

- }

-}

-#endif /* LV_HAVE_SSE */

-

-#ifdef LV_HAVE_GENERIC

-/*!

- \brief Multiplies the input vector by a scalar and stores the results in the third vector

- \param cVector The vector where the results will be stored

- \param aVector The vector to be multiplied

- \param scalar The complex scalar to multiply aVector

- \param num_points The number of complex values in aVector and bVector to be multiplied together and stored into cVector

-*/

-static inline void volk_32fc_s32fc_multiply_32fc_u_generic(lv_32fc_t* cVector, const lv_32fc_t* aVector, const lv_32fc_t scalar, unsigned int num_points){

- lv_32fc_t* cPtr = cVector;

- const lv_32fc_t* aPtr = aVector;

- unsigned int number = num_points;

-

- // unwrap loop

- while (number >= 8){

- *cPtr++ = (*aPtr++) * scalar;

- *cPtr++ = (*aPtr++) * scalar;

- *cPtr++ = (*aPtr++) * scalar;

- *cPtr++ = (*aPtr++) * scalar;

- *cPtr++ = (*aPtr++) * scalar;

- *cPtr++ = (*aPtr++) * scalar;

- *cPtr++ = (*aPtr++) * scalar;

- *cPtr++ = (*aPtr++) * scalar;

- number -= 8;

- }

-

- // clean up any remaining

- while (number-- > 0)

- *cPtr++ = *aPtr++ * scalar;

-}

-#endif /* LV_HAVE_GENERIC */

-

-

-#endif /* INCLUDED_volk_32fc_x2_multiply_32fc_u_H */

-#ifndef INCLUDED_volk_32fc_x2_conjugate_dot_prod_32fc_u_H

-#define INCLUDED_volk_32fc_x2_conjugate_dot_prod_32fc_u_H

-

-

-#include<volk/volk_complex.h>

-

-

-#ifdef LV_HAVE_GENERIC

-

-

-static inline void volk_32fc_x2_conjugate_dot_prod_32fc_u_generic(lv_32fc_t* result, const lv_32fc_t* input, const lv_32fc_t* taps, unsigned int num_points) {

-

- const unsigned int num_bytes = num_points*8;

-

- float * res = (float*) result;

- float * in = (float*) input;

- float * tp = (float*) taps;

- unsigned int n_2_ccomplex_blocks = num_bytes >> 4;

- unsigned int isodd = (num_bytes >> 3) &1;

-

-

-

- float sum0[2] = {0,0};

- float sum1[2] = {0,0};

- unsigned int i = 0;

-

-

- for(i = 0; i < n_2_ccomplex_blocks; ++i) {

-

- sum0[0] += in[0] * tp[0] + in[1] * tp[1];

- sum0[1] += (-in[0] * tp[1]) + in[1] * tp[0];

- sum1[0] += in[2] * tp[2] + in[3] * tp[3];

- sum1[1] += (-in[2] * tp[3]) + in[3] * tp[2];

-

-

- in += 4;

- tp += 4;

-

- }

-

-

- res[0] = sum0[0] + sum1[0];

- res[1] = sum0[1] + sum1[1];

-

-

-

- for(i = 0; i < isodd; ++i) {

-

-

- *result += input[(num_bytes >> 3) - 1] * lv_conj(taps[(num_bytes >> 3) - 1]);

-

- }

- /*

- for(i = 0; i < num_bytes >> 3; ++i) {

- *result += input[i] * conjf(taps[i]);

- }

- */

-}

-

-#endif /*LV_HAVE_GENERIC*/

-

-#ifdef LV_HAVE_SSE3

-

-#include <xmmintrin.h>

-#include <pmmintrin.h>

-#include <mmintrin.h>

-

-

-static inline void volk_32fc_x2_conjugate_dot_prod_32fc_u_sse3(lv_32fc_t* result, const lv_32fc_t* input, const lv_32fc_t* taps, unsigned int num_points) {

-

- unsigned int num_bytes = num_points*8;

-

- // Variable never used?

- //__VOLK_ATTR_ALIGNED(16) static const uint32_t conjugator[4]= {0x00000000, 0x80000000, 0x00000000, 0x80000000};

-

- union HalfMask {

- uint32_t intRep[4];

- __m128 vec;

- } halfMask;

-

- union NegMask {

- int intRep[4];

- __m128 vec;

- } negMask;

-

- unsigned int offset = 0;

- float Rsum=0, Isum=0;

- float Im,Re;

-

- __m128 in1, in2, Rv, fehg, Iv, Rs, Ivm, Is;

- __m128 zv = {0,0,0,0};

-

- halfMask.intRep[0] = halfMask.intRep[1] = 0xFFFFFFFF;

- halfMask.intRep[2] = halfMask.intRep[3] = 0x00000000;

-

- negMask.intRep[0] = negMask.intRep[2] = 0x80000000;

- negMask.intRep[1] = negMask.intRep[3] = 0;

-

- // main loop

- while(num_bytes >= 4*sizeof(float)){

-

- in1 = _mm_loadu_ps( (float*) (input+offset) );

- in2 = _mm_loadu_ps( (float*) (taps+offset) );

- Rv = _mm_mul_ps(in1, in2);

- fehg = _mm_shuffle_ps(in2, in2, _MM_SHUFFLE(2,3,0,1));

- Iv = _mm_mul_ps(in1, fehg);

- Rs = _mm_hadd_ps( _mm_hadd_ps(Rv, zv) ,zv);

- Ivm = _mm_xor_ps( negMask.vec, Iv );

- Is = _mm_hadd_ps( _mm_hadd_ps(Ivm, zv) ,zv);

- _mm_store_ss( &Im, Is );

- _mm_store_ss( &Re, Rs );

- num_bytes -= 4*sizeof(float);

- offset += 2;

- Rsum += Re;

- Isum += Im;

- }

-

- // handle the last complex case ...

- if(num_bytes > 0){

-

- if(num_bytes != 4){

- // bad things are happening

- }

-

- in1 = _mm_loadu_ps( (float*) (input+offset) );

- in2 = _mm_loadu_ps( (float*) (taps+offset) );

- Rv = _mm_and_ps(_mm_mul_ps(in1, in2), halfMask.vec);

- fehg = _mm_shuffle_ps(in2, in2, _MM_SHUFFLE(2,3,0,1));

- Iv = _mm_and_ps(_mm_mul_ps(in1, fehg), halfMask.vec);

- Rs = _mm_hadd_ps(_mm_hadd_ps(Rv, zv),zv);

- Ivm = _mm_xor_ps( negMask.vec, Iv );

- Is = _mm_hadd_ps(_mm_hadd_ps(Ivm, zv),zv);

- _mm_store_ss( &Im, Is );

- _mm_store_ss( &Re, Rs );

- Rsum += Re;

- Isum += Im;

- }

-

- result[0] = lv_cmake(Rsum,Isum);

- return;

-}

-

-#endif /*LV_HAVE_SSE3*/

-

-

-#endif /*INCLUDED_volk_32fc_x2_conjugate_dot_prod_32fc_u_H*/

-

-

-

-#ifndef INCLUDED_volk_32fc_x2_dot_prod_32fc_u_H

-#define INCLUDED_volk_32fc_x2_dot_prod_32fc_u_H

-

-#include <volk/volk_common.h>

-#include <volk/volk_complex.h>

-#include <stdio.h>

-#include <string.h>

-

-

-#ifdef LV_HAVE_GENERIC

-

-

-static inline void volk_32fc_x2_dot_prod_32fc_u_generic(lv_32fc_t* result, const lv_32fc_t* input, const lv_32fc_t* taps, unsigned int num_points) {

-

- float * res = (float*) result;

- float * in = (float*) input;

- float * tp = (float*) taps;

- unsigned int n_2_ccomplex_blocks = num_points/2;

- unsigned int isodd = num_points &1;

-

-

-

- float sum0[2] = {0,0};

- float sum1[2] = {0,0};

- unsigned int i = 0;

-

-

- for(i = 0; i < n_2_ccomplex_blocks; ++i) {

-

-

- sum0[0] += in[0] * tp[0] - in[1] * tp[1];

- sum0[1] += in[0] * tp[1] + in[1] * tp[0];

- sum1[0] += in[2] * tp[2] - in[3] * tp[3];

- sum1[1] += in[2] * tp[3] + in[3] * tp[2];

-

-

- in += 4;

- tp += 4;

-

- }

-

-

- res[0] = sum0[0] + sum1[0];

- res[1] = sum0[1] + sum1[1];

-

-

-

- for(i = 0; i < isodd; ++i) {

-

-

- *result += input[num_points - 1] * taps[num_points - 1];

-

- }

-

-}

-

-#endif /*LV_HAVE_GENERIC*/

-

-#ifdef LV_HAVE_SSE3

-

-#include <pmmintrin.h>

-

-static inline void volk_32fc_x2_dot_prod_32fc_u_sse3(lv_32fc_t* result, const lv_32fc_t* input, const lv_32fc_t* taps, unsigned int num_points) {

-

-

- lv_32fc_t dotProduct;

- memset(&dotProduct, 0x0, 2*sizeof(float));

-

- unsigned int number = 0;

- const unsigned int halfPoints = num_points/2;

-

- __m128 x, y, yl, yh, z, tmp1, tmp2, dotProdVal;

-

- const lv_32fc_t* a = input;

- const lv_32fc_t* b = taps;

-

- dotProdVal = _mm_setzero_ps();

-

- for(;number < halfPoints; number++){

-

- x = _mm_loadu_ps((float*)a); // Load the ar + ai, br + bi as ar,ai,br,bi

- y = _mm_loadu_ps((float*)b); // Load the cr + ci, dr + di as cr,ci,dr,di

-

- yl = _mm_moveldup_ps(y); // Load yl with cr,cr,dr,dr

- yh = _mm_movehdup_ps(y); // Load yh with ci,ci,di,di

-

- tmp1 = _mm_mul_ps(x,yl); // tmp1 = ar*cr,ai*cr,br*dr,bi*dr

-

- x = _mm_shuffle_ps(x,x,0xB1); // Re-arrange x to be ai,ar,bi,br

-

- tmp2 = _mm_mul_ps(x,yh); // tmp2 = ai*ci,ar*ci,bi*di,br*di

-

- z = _mm_addsub_ps(tmp1,tmp2); // ar*cr-ai*ci, ai*cr+ar*ci, br*dr-bi*di, bi*dr+br*di

-

- dotProdVal = _mm_add_ps(dotProdVal, z); // Add the complex multiplication results together

-

- a += 2;

- b += 2;

- }

-

- __VOLK_ATTR_ALIGNED(16) lv_32fc_t dotProductVector[2];

-

- _mm_storeu_ps((float*)dotProductVector,dotProdVal); // Store the results back into the dot product vector

-

- dotProduct += ( dotProductVector[0] + dotProductVector[1] );

-

- if(num_points % 1 != 0) {

- dotProduct += (*a) * (*b);

- }

-

- *result = dotProduct;

-}

-

-#endif /*LV_HAVE_SSE3*/

-

-#endif /*INCLUDED_volk_32fc_x2_dot_prod_32fc_u_H*/

-#ifndef INCLUDED_volk_32fc_x2_multiply_32fc_u_H

-#define INCLUDED_volk_32fc_x2_multiply_32fc_u_H

-

-#include <inttypes.h>

-#include <stdio.h>

-#include <volk/volk_complex.h>

-#include <float.h>

-

-#ifdef LV_HAVE_SSE3

-#include <pmmintrin.h>

- /*!

- \brief Multiplies the two input complex vectors and stores their results in the third vector

- \param cVector The vector where the results will be stored

- \param aVector One of the vectors to be multiplied

- \param bVector One of the vectors to be multiplied

- \param num_points The number of complex values in aVector and bVector to be multiplied together and stored into cVector

- */

-static inline void volk_32fc_x2_multiply_32fc_u_sse3(lv_32fc_t* cVector, const lv_32fc_t* aVector, const lv_32fc_t* bVector, unsigned int num_points){

- unsigned int number = 0;

- const unsigned int halfPoints = num_points / 2;

-

- __m128 x, y, yl, yh, z, tmp1, tmp2;

- lv_32fc_t* c = cVector;

- const lv_32fc_t* a = aVector;

- const lv_32fc_t* b = bVector;

-

- for(;number < halfPoints; number++){

-

- x = _mm_loadu_ps((float*)a); // Load the ar + ai, br + bi as ar,ai,br,bi

- y = _mm_loadu_ps((float*)b); // Load the cr + ci, dr + di as cr,ci,dr,di

-

- yl = _mm_moveldup_ps(y); // Load yl with cr,cr,dr,dr

- yh = _mm_movehdup_ps(y); // Load yh with ci,ci,di,di

-

- tmp1 = _mm_mul_ps(x,yl); // tmp1 = ar*cr,ai*cr,br*dr,bi*dr

-

- x = _mm_shuffle_ps(x,x,0xB1); // Re-arrange x to be ai,ar,bi,br

-

- tmp2 = _mm_mul_ps(x,yh); // tmp2 = ai*ci,ar*ci,bi*di,br*di

-

- z = _mm_addsub_ps(tmp1,tmp2); // ar*cr-ai*ci, ai*cr+ar*ci, br*dr-bi*di, bi*dr+br*di

-

- _mm_storeu_ps((float*)c,z); // Store the results back into the C container

-

- a += 2;

- b += 2;

- c += 2;

- }

-

- if((num_points % 2) != 0) {

- *c = (*a) * (*b);

- }

-}

-#endif /* LV_HAVE_SSE */

-

-#ifdef LV_HAVE_GENERIC

- /*!

- \brief Multiplies the two input complex vectors and stores their results in the third vector

- \param cVector The vector where the results will be stored

- \param aVector One of the vectors to be multiplied

- \param bVector One of the vectors to be multiplied

- \param num_points The number of complex values in aVector and bVector to be multiplied together and stored into cVector

- */

-static inline void volk_32fc_x2_multiply_32fc_u_generic(lv_32fc_t* cVector, const lv_32fc_t* aVector, const lv_32fc_t* bVector, unsigned int num_points){

- lv_32fc_t* cPtr = cVector;

- const lv_32fc_t* aPtr = aVector;

- const lv_32fc_t* bPtr= bVector;

- unsigned int number = 0;

-

- for(number = 0; number < num_points; number++){

- *cPtr++ = (*aPtr++) * (*bPtr++);

- }

-}

-#endif /* LV_HAVE_GENERIC */

-

-

-#endif /* INCLUDED_volk_32fc_x2_multiply_32fc_u_H */

-#ifndef INCLUDED_volk_32fc_x2_multiply_conjugate_32fc_a_H

-#define INCLUDED_volk_32fc_x2_multiply_conjugate_32fc_a_H

-

-#include <inttypes.h>

-#include <stdio.h>

-#include <volk/volk_complex.h>

-#include <float.h>

-

-#ifdef LV_HAVE_SSE3

-#include <pmmintrin.h>

- /*!

- \brief Multiplies vector a by the conjugate of vector b and stores the results in the third vector

- \param cVector The vector where the results will be stored

- \param aVector First vector to be multiplied

- \param bVector Second vector that is conjugated before being multiplied

- \param num_points The number of complex values in aVector and bVector to be multiplied together and stored into cVector

- */

-static inline void volk_32fc_x2_multiply_conjugate_32fc_a_sse3(lv_32fc_t* cVector, const lv_32fc_t* aVector, const lv_32fc_t* bVector, unsigned int num_points){

- unsigned int number = 0;

- const unsigned int halfPoints = num_points / 2;

-

- __m128 x, y, yl, yh, z, tmp1, tmp2;

- lv_32fc_t* c = cVector;

- const lv_32fc_t* a = aVector;

- const lv_32fc_t* b = bVector;

-

- __m128 conjugator = _mm_setr_ps(0, -0.f, 0, -0.f);

-

- for(;number < halfPoints; number++){

-

- x = _mm_load_ps((float*)a); // Load the ar + ai, br + bi as ar,ai,br,bi

- y = _mm_load_ps((float*)b); // Load the cr + ci, dr + di as cr,ci,dr,di

-

- y = _mm_xor_ps(y, conjugator); // conjugate y

-

- yl = _mm_moveldup_ps(y); // Load yl with cr,cr,dr,dr

- yh = _mm_movehdup_ps(y); // Load yh with ci,ci,di,di

-

- tmp1 = _mm_mul_ps(x,yl); // tmp1 = ar*cr,ai*cr,br*dr,bi*dr

-

- x = _mm_shuffle_ps(x,x,0xB1); // Re-arrange x to be ai,ar,bi,br

-

- tmp2 = _mm_mul_ps(x,yh); // tmp2 = ai*ci,ar*ci,bi*di,br*di

-

- z = _mm_addsub_ps(tmp1,tmp2); // ar*cr-ai*ci, ai*cr+ar*ci, br*dr-bi*di, bi*dr+br*di

-

- _mm_store_ps((float*)c,z); // Store the results back into the C container

-

- a += 2;

- b += 2;

- c += 2;

- }

-

- if((num_points % 2) != 0) {

- *c = (*a) * lv_conj(*b);

- }

-}

-#endif /* LV_HAVE_SSE */

-

-#ifdef LV_HAVE_GENERIC

- /*!

- \brief Multiplies vector a by the conjugate of vector b and stores the results in the third vector

- \param cVector The vector where the results will be stored

- \param aVector First vector to be multiplied

- \param bVector Second vector that is conjugated before being multiplied

- \param num_points The number of complex values in aVector and bVector to be multiplied together and stored into cVector

- */

-static inline void volk_32fc_x2_multiply_conjugate_32fc_a_generic(lv_32fc_t* cVector, const lv_32fc_t* aVector, const lv_32fc_t* bVector, unsigned int num_points){

- lv_32fc_t* cPtr = cVector;

- const lv_32fc_t* aPtr = aVector;

- const lv_32fc_t* bPtr= bVector;

- unsigned int number = 0;

-

- for(number = 0; number < num_points; number++){

- *cPtr++ = (*aPtr++) * lv_conj(*bPtr++);

- }

-}

-#endif /* LV_HAVE_GENERIC */

-

-

-#endif /* INCLUDED_volk_32fc_x2_multiply_conjugate_32fc_a_H */

-#ifndef INCLUDED_volk_32fc_x2_multiply_conjugate_32fc_u_H

-#define INCLUDED_volk_32fc_x2_multiply_conjugate_32fc_u_H

-

-#include <inttypes.h>

-#include <stdio.h>

-#include <volk/volk_complex.h>

-#include <float.h>

-

-#ifdef LV_HAVE_SSE3

-#include <pmmintrin.h>

- /*!

- \brief Multiplies vector a by the conjugate of vector b and stores the results in the third vector

- \param cVector The vector where the results will be stored

- \param aVector First vector to be multiplied

- \param bVector Second vector that is conjugated before being multiplied

- \param num_points The number of complex values in aVector and bVector to be multiplied together and stored into cVector

- */

-static inline void volk_32fc_x2_multiply_conjugate_32fc_u_sse3(lv_32fc_t* cVector, const lv_32fc_t* aVector, const lv_32fc_t* bVector, unsigned int num_points){

- unsigned int number = 0;

- const unsigned int halfPoints = num_points / 2;

-

- __m128 x, y, yl, yh, z, tmp1, tmp2;

- lv_32fc_t* c = cVector;

- const lv_32fc_t* a = aVector;

- const lv_32fc_t* b = bVector;

-

- __m128 conjugator = _mm_setr_ps(0, -0.f, 0, -0.f);

-

- for(;number < halfPoints; number++){

-

- x = _mm_loadu_ps((float*)a); // Load the ar + ai, br + bi as ar,ai,br,bi

- y = _mm_loadu_ps((float*)b); // Load the cr + ci, dr + di as cr,ci,dr,di

-

- y = _mm_xor_ps(y, conjugator); // conjugate y

-

- yl = _mm_moveldup_ps(y); // Load yl with cr,cr,dr,dr

- yh = _mm_movehdup_ps(y); // Load yh with ci,ci,di,di

-

- tmp1 = _mm_mul_ps(x,yl); // tmp1 = ar*cr,ai*cr,br*dr,bi*dr

-

- x = _mm_shuffle_ps(x,x,0xB1); // Re-arrange x to be ai,ar,bi,br

-

- tmp2 = _mm_mul_ps(x,yh); // tmp2 = ai*ci,ar*ci,bi*di,br*di

-

- z = _mm_addsub_ps(tmp1,tmp2); // ar*cr-ai*ci, ai*cr+ar*ci, br*dr-bi*di, bi*dr+br*di

-

- _mm_storeu_ps((float*)c,z); // Store the results back into the C container

-

- a += 2;

- b += 2;

- c += 2;

- }

-

- if((num_points % 2) != 0) {

- *c = (*a) * lv_conj(*b);

- }

-}

-#endif /* LV_HAVE_SSE */

-

-#ifdef LV_HAVE_GENERIC

- /*!

- \brief Multiplies vector a by the conjugate of vector b and stores the results in the third vector

- \param cVector The vector where the results will be stored

- \param aVector First vector to be multiplied

- \param bVector Second vector that is conjugated before being multiplied

- \param num_points The number of complex values in aVector and bVector to be multiplied together and stored into cVector

- */

-static inline void volk_32fc_x2_multiply_conjugate_32fc_u_generic(lv_32fc_t* cVector, const lv_32fc_t* aVector, const lv_32fc_t* bVector, unsigned int num_points){

- lv_32fc_t* cPtr = cVector;

- const lv_32fc_t* aPtr = aVector;

- const lv_32fc_t* bPtr= bVector;

- unsigned int number = 0;

-

- for(number = 0; number < num_points; number++){

- *cPtr++ = (*aPtr++) * lv_conj(*bPtr++);

- }

-}

-#endif /* LV_HAVE_GENERIC */

-

-

-#endif /* INCLUDED_volk_32fc_x2_multiply_conjugate_32fc_u_H */

-#ifndef INCLUDED_volk_32i_s32f_convert_32f_a_H

-#define INCLUDED_volk_32i_s32f_convert_32f_a_H

-

-#include <inttypes.h>

-#include <stdio.h>

-

-#ifdef LV_HAVE_SSE2

-#include <emmintrin.h>

-

- /*!

- \brief Converts the input 32 bit integer data into floating point data, and divides the each floating point output data point by the scalar value

- \param inputVector The 32 bit input data buffer

- \param outputVector The floating point output data buffer

- \param scalar The value divided against each point in the output buffer

- \param num_points The number of data values to be converted

- */

-static inline void volk_32i_s32f_convert_32f_a_sse2(float* outputVector, const int32_t* inputVector, const float scalar, unsigned int num_points){

- unsigned int number = 0;

- const unsigned int quarterPoints = num_points / 4;

-

- float* outputVectorPtr = outputVector;

- const float iScalar = 1.0 / scalar;

- __m128 invScalar = _mm_set_ps1(iScalar);

- int32_t* inputPtr = (int32_t*)inputVector;

- __m128i inputVal;

- __m128 ret;

-

- for(;number < quarterPoints; number++){

-

- // Load the 4 values

- inputVal = _mm_load_si128((__m128i*)inputPtr);

-

- ret = _mm_cvtepi32_ps(inputVal);

- ret = _mm_mul_ps(ret, invScalar);

-

- _mm_store_ps(outputVectorPtr, ret);

-

- outputVectorPtr += 4;

- inputPtr += 4;

- }

-

- number = quarterPoints * 4;

- for(; number < num_points; number++){

- outputVector[number] =((float)(inputVector[number])) * iScalar;

- }

-}

-#endif /* LV_HAVE_SSE2 */

-

-

-#ifdef LV_HAVE_GENERIC

- /*!

- \brief Converts the input 32 bit integer data into floating point data, and divides the each floating point output data point by the scalar value

- \param inputVector The 32 bit input data buffer

- \param outputVector The floating point output data buffer

- \param scalar The value divided against each point in the output buffer

- \param num_points The number of data values to be converted

- */

-static inline void volk_32i_s32f_convert_32f_a_generic(float* outputVector, const int32_t* inputVector, const float scalar, unsigned int num_points){

- float* outputVectorPtr = outputVector;

- const int32_t* inputVectorPtr = inputVector;

- unsigned int number = 0;

- const float iScalar = 1.0 / scalar;

-

- for(number = 0; number < num_points; number++){

- *outputVectorPtr++ = ((float)(*inputVectorPtr++)) * iScalar;

- }

-}

-#endif /* LV_HAVE_GENERIC */

-

-

-

-

-#endif /* INCLUDED_volk_32i_s32f_convert_32f_a_H */

-#ifndef INCLUDED_volk_32i_s32f_convert_32f_u_H

-#define INCLUDED_volk_32i_s32f_convert_32f_u_H

-

-#include <inttypes.h>

-#include <stdio.h>

-

-#ifdef LV_HAVE_SSE2

-#include <emmintrin.h>

-

- /*!

- \brief Converts the input 32 bit integer data into floating point data, and divides the each floating point output data point by the scalar value

- \param inputVector The 32 bit input data buffer

- \param outputVector The floating point output data buffer

- \param scalar The value divided against each point in the output buffer

- \param num_points The number of data values to be converted

- \note Output buffer does NOT need to be properly aligned

- */

-static inline void volk_32i_s32f_convert_32f_u_sse2(float* outputVector, const int32_t* inputVector, const float scalar, unsigned int num_points){

- unsigned int number = 0;

- const unsigned int quarterPoints = num_points / 4;

-

- float* outputVectorPtr = outputVector;

- const float iScalar = 1.0 / scalar;

- __m128 invScalar = _mm_set_ps1(iScalar);

- int32_t* inputPtr = (int32_t*)inputVector;

- __m128i inputVal;

- __m128 ret;

-

- for(;number < quarterPoints; number++){

-

- // Load the 4 values

- inputVal = _mm_loadu_si128((__m128i*)inputPtr);

-

- ret = _mm_cvtepi32_ps(inputVal);

- ret = _mm_mul_ps(ret, invScalar);

-

- _mm_storeu_ps(outputVectorPtr, ret);

-

- outputVectorPtr += 4;

- inputPtr += 4;

- }

-

- number = quarterPoints * 4;

- for(; number < num_points; number++){

- outputVector[number] =((float)(inputVector[number])) * iScalar;

- }

-}

-#endif /* LV_HAVE_SSE2 */

-

-

-#ifdef LV_HAVE_GENERIC

- /*!

- \brief Converts the input 32 bit integer data into floating point data, and divides the each floating point output data point by the scalar value

- \param inputVector The 32 bit input data buffer

- \param outputVector The floating point output data buffer

- \param scalar The value divided against each point in the output buffer

- \param num_points The number of data values to be converted

- \note Output buffer does NOT need to be properly aligned

- */

-static inline void volk_32i_s32f_convert_32f_u_generic(float* outputVector, const int32_t* inputVector, const float scalar, unsigned int num_points){

- float* outputVectorPtr = outputVector;

- const int32_t* inputVectorPtr = inputVector;

- unsigned int number = 0;

- const float iScalar = 1.0 / scalar;

-

- for(number = 0; number < num_points; number++){

- *outputVectorPtr++ = ((float)(*inputVectorPtr++)) * iScalar;

- }

-}

-#endif /* LV_HAVE_GENERIC */

-

-

-

-

-#endif /* INCLUDED_volk_32i_s32f_convert_32f_u_H */

-#ifndef INCLUDED_volk_32u_byteswap_u_H

-#define INCLUDED_volk_32u_byteswap_u_H

-

-#include <inttypes.h>

-#include <stdio.h>

-

-#ifdef LV_HAVE_SSE2

-#include <emmintrin.h>

-

-/*!

- \brief Byteswaps (in-place) an aligned vector of int32_t's.

- \param intsToSwap The vector of data to byte swap

- \param numDataPoints The number of data points

-*/

-static inline void volk_32u_byteswap_u_sse2(uint32_t* intsToSwap, unsigned int num_points){

- unsigned int number = 0;

-

- uint32_t* inputPtr = intsToSwap;

- __m128i input, byte1, byte2, byte3, byte4, output;

- __m128i byte2mask = _mm_set1_epi32(0x00FF0000);

- __m128i byte3mask = _mm_set1_epi32(0x0000FF00);

-

- const uint64_t quarterPoints = num_points / 4;

- for(;number < quarterPoints; number++){

- // Load the 32t values, increment inputPtr later since we're doing it in-place.

- input = _mm_loadu_si128((__m128i*)inputPtr);

- // Do the four shifts

- byte1 = _mm_slli_epi32(input, 24);

- byte2 = _mm_slli_epi32(input, 8);

- byte3 = _mm_srli_epi32(input, 8);

- byte4 = _mm_srli_epi32(input, 24);

- // Or bytes together

- output = _mm_or_si128(byte1, byte4);

- byte2 = _mm_and_si128(byte2, byte2mask);

- output = _mm_or_si128(output, byte2);

- byte3 = _mm_and_si128(byte3, byte3mask);

- output = _mm_or_si128(output, byte3);

- // Store the results

- _mm_storeu_si128((__m128i*)inputPtr, output);

- inputPtr += 4;

- }

-

- // Byteswap any remaining points:

- number = quarterPoints*4;

- for(; number < num_points; number++){

- uint32_t outputVal = *inputPtr;

- outputVal = (((outputVal >> 24) & 0xff) | ((outputVal >> 8) & 0x0000ff00) | ((outputVal << 8) & 0x00ff0000) | ((outputVal << 24) & 0xff000000));

- *inputPtr = outputVal;

- inputPtr++;

- }

-}

-#endif /* LV_HAVE_SSE2 */

-

-#ifdef LV_HAVE_GENERIC

-/*!

- \brief Byteswaps (in-place) an aligned vector of int32_t's.

- \param intsToSwap The vector of data to byte swap

- \param numDataPoints The number of data points

-*/

-static inline void volk_32u_byteswap_u_generic(uint32_t* intsToSwap, unsigned int num_points){

- uint32_t* inputPtr = intsToSwap;

-

- unsigned int point;

- for(point = 0; point < num_points; point++){

- uint32_t output = *inputPtr;

- output = (((output >> 24) & 0xff) | ((output >> 8) & 0x0000ff00) | ((output << 8) & 0x00ff0000) | ((output << 24) & 0xff000000));

-

- *inputPtr = output;

- inputPtr++;

- }

-}

-#endif /* LV_HAVE_GENERIC */

-

-

-

-

-#endif /* INCLUDED_volk_32u_byteswap_u_H */

-#ifndef INCLUDED_volk_64f_convert_32f_a_H

-#define INCLUDED_volk_64f_convert_32f_a_H

-

-#include <inttypes.h>

-#include <stdio.h>

-

-#ifdef LV_HAVE_SSE2

-#include <emmintrin.h>

- /*!

- \brief Converts the double values into float values

- \param dVector The converted float vector values

- \param fVector The double vector values to be converted

- \param num_points The number of points in the two vectors to be converted

- */

-static inline void volk_64f_convert_32f_a_sse2(float* outputVector, const double* inputVector, unsigned int num_points){

- unsigned int number = 0;

-

- const unsigned int quarterPoints = num_points / 4;

-

- const double* inputVectorPtr = (const double*)inputVector;

- float* outputVectorPtr = outputVector;

- __m128 ret, ret2;

- __m128d inputVal1, inputVal2;

-

- for(;number < quarterPoints; number++){

- inputVal1 = _mm_load_pd(inputVectorPtr); inputVectorPtr += 2;

- inputVal2 = _mm_load_pd(inputVectorPtr); inputVectorPtr += 2;

-

- ret = _mm_cvtpd_ps(inputVal1);

- ret2 = _mm_cvtpd_ps(inputVal2);

-

- ret = _mm_movelh_ps(ret, ret2);

-

- _mm_store_ps(outputVectorPtr, ret);

- outputVectorPtr += 4;

- }

-

- number = quarterPoints * 4;

- for(; number < num_points; number++){

- outputVector[number] = (float)(inputVector[number]);

- }

-}

-#endif /* LV_HAVE_SSE2 */

-

-

-#ifdef LV_HAVE_GENERIC

-/*!

- \brief Converts the double values into float values

- \param dVector The converted float vector values

- \param fVector The double vector values to be converted

- \param num_points The number of points in the two vectors to be converted

-*/

-static inline void volk_64f_convert_32f_a_generic(float* outputVector, const double* inputVector, unsigned int num_points){

- float* outputVectorPtr = outputVector;

- const double* inputVectorPtr = inputVector;

- unsigned int number = 0;

-

- for(number = 0; number < num_points; number++){

- *outputVectorPtr++ = ((float)(*inputVectorPtr++));

- }

-}

-#endif /* LV_HAVE_GENERIC */

-

-

-

-

-#endif /* INCLUDED_volk_64f_convert_32f_a_H */

-#ifndef INCLUDED_volk_64f_convert_32f_u_H

-#define INCLUDED_volk_64f_convert_32f_u_H

-

-#include <inttypes.h>

-#include <stdio.h>

-

-#ifdef LV_HAVE_SSE2

-#include <emmintrin.h>

- /*!

- \brief Converts the double values into float values

- \param dVector The converted float vector values

- \param fVector The double vector values to be converted

- \param num_points The number of points in the two vectors to be converted

- */

-static inline void volk_64f_convert_32f_u_sse2(float* outputVector, const double* inputVector, unsigned int num_points){

- unsigned int number = 0;

-

- const unsigned int quarterPoints = num_points / 4;

-

- const double* inputVectorPtr = (const double*)inputVector;

- float* outputVectorPtr = outputVector;

- __m128 ret, ret2;

- __m128d inputVal1, inputVal2;

-

- for(;number < quarterPoints; number++){

- inputVal1 = _mm_loadu_pd(inputVectorPtr); inputVectorPtr += 2;

- inputVal2 = _mm_loadu_pd(inputVectorPtr); inputVectorPtr += 2;

-

- ret = _mm_cvtpd_ps(inputVal1);

- ret2 = _mm_cvtpd_ps(inputVal2);

-

- ret = _mm_movelh_ps(ret, ret2);

-

- _mm_storeu_ps(outputVectorPtr, ret);

- outputVectorPtr += 4;

- }

-

- number = quarterPoints * 4;

- for(; number < num_points; number++){

- outputVector[number] = (float)(inputVector[number]);

- }

-}

-#endif /* LV_HAVE_SSE2 */

-

-

-#ifdef LV_HAVE_GENERIC

-/*!

- \brief Converts the double values into float values

- \param dVector The converted float vector values

- \param fVector The double vector values to be converted

- \param num_points The number of points in the two vectors to be converted

-*/

-static inline void volk_64f_convert_32f_u_generic(float* outputVector, const double* inputVector, unsigned int num_points){

- float* outputVectorPtr = outputVector;

- const double* inputVectorPtr = inputVector;

- unsigned int number = 0;

-

- for(number = 0; number < num_points; number++){

- *outputVectorPtr++ = ((float)(*inputVectorPtr++));

- }

-}

-#endif /* LV_HAVE_GENERIC */

-

-

-

-

-#endif /* INCLUDED_volk_64f_convert_32f_u_H */

-#ifndef INCLUDED_volk_64u_byteswap_u_H

-#define INCLUDED_volk_64u_byteswap_u_H

-

-#include <inttypes.h>

-#include <stdio.h>

-

-#ifdef LV_HAVE_SSE2

-#include <emmintrin.h>

-

-/*!

- \brief Byteswaps (in-place) an aligned vector of int64_t's.

- \param intsToSwap The vector of data to byte swap

- \param numDataPoints The number of data points

-*/

-static inline void volk_64u_byteswap_u_sse2(uint64_t* intsToSwap, unsigned int num_points){

- uint32_t* inputPtr = (uint32_t*)intsToSwap;

- __m128i input, byte1, byte2, byte3, byte4, output;

- __m128i byte2mask = _mm_set1_epi32(0x00FF0000);

- __m128i byte3mask = _mm_set1_epi32(0x0000FF00);

- uint64_t number = 0;

- const unsigned int halfPoints = num_points / 2;

- for(;number < halfPoints; number++){

- // Load the 32t values, increment inputPtr later since we're doing it in-place.

- input = _mm_loadu_si128((__m128i*)inputPtr);

-

- // Do the four shifts

- byte1 = _mm_slli_epi32(input, 24);

- byte2 = _mm_slli_epi32(input, 8);

- byte3 = _mm_srli_epi32(input, 8);

- byte4 = _mm_srli_epi32(input, 24);

- // Or bytes together

- output = _mm_or_si128(byte1, byte4);

- byte2 = _mm_and_si128(byte2, byte2mask);

- output = _mm_or_si128(output, byte2);

- byte3 = _mm_and_si128(byte3, byte3mask);

- output = _mm_or_si128(output, byte3);

-

- // Reorder the two words

- output = _mm_shuffle_epi32(output, _MM_SHUFFLE(2, 3, 0, 1));

-

- // Store the results

- _mm_storeu_si128((__m128i*)inputPtr, output);

- inputPtr += 4;

- }

-

- // Byteswap any remaining points:

- number = halfPoints*2;

- for(; number < num_points; number++){

- uint32_t output1 = *inputPtr;

- uint32_t output2 = inputPtr[1];

-

- output1 = (((output1 >> 24) & 0xff) | ((output1 >> 8) & 0x0000ff00) | ((output1 << 8) & 0x00ff0000) | ((output1 << 24) & 0xff000000));

-

- output2 = (((output2 >> 24) & 0xff) | ((output2 >> 8) & 0x0000ff00) | ((output2 << 8) & 0x00ff0000) | ((output2 << 24) & 0xff000000));

-

- *inputPtr++ = output2;

- *inputPtr++ = output1;

- }

-}

-#endif /* LV_HAVE_SSE2 */

-

-#ifdef LV_HAVE_GENERIC

-/*!

- \brief Byteswaps (in-place) an aligned vector of int64_t's.

- \param intsToSwap The vector of data to byte swap

- \param numDataPoints The number of data points

-*/

-static inline void volk_64u_byteswap_u_generic(uint64_t* intsToSwap, unsigned int num_points){

- uint32_t* inputPtr = (uint32_t*)intsToSwap;

- unsigned int point;

- for(point = 0; point < num_points; point++){

- uint32_t output1 = *inputPtr;

- uint32_t output2 = inputPtr[1];

-

- output1 = (((output1 >> 24) & 0xff) | ((output1 >> 8) & 0x0000ff00) | ((output1 << 8) & 0x00ff0000) | ((output1 << 24) & 0xff000000));

-

- output2 = (((output2 >> 24) & 0xff) | ((output2 >> 8) & 0x0000ff00) | ((output2 << 8) & 0x00ff0000) | ((output2 << 24) & 0xff000000));

-

- *inputPtr++ = output2;

- *inputPtr++ = output1;

- }

-}

-#endif /* LV_HAVE_GENERIC */

-

-

-

-

-#endif /* INCLUDED_volk_64u_byteswap_u_H */

-#ifndef INCLUDED_volk_8i_convert_16i_u_H

-#define INCLUDED_volk_8i_convert_16i_u_H

-

-#include <inttypes.h>

-#include <stdio.h>

-

-#ifdef LV_HAVE_SSE4_1

-#include <smmintrin.h>

-

- /*!

- \brief Converts the input 8 bit integer data into 16 bit integer data

- \param inputVector The 8 bit input data buffer

- \param outputVector The 16 bit output data buffer

- \param num_points The number of data values to be converted

- \note Input and output buffers do NOT need to be properly aligned

- */

-static inline void volk_8i_convert_16i_u_sse4_1(int16_t* outputVector, const int8_t* inputVector, unsigned int num_points){

- unsigned int number = 0;

- const unsigned int sixteenthPoints = num_points / 16;

-

- const __m128i* inputVectorPtr = (const __m128i*)inputVector;

- __m128i* outputVectorPtr = (__m128i*)outputVector;

- __m128i inputVal;

- __m128i ret;

-

- for(;number < sixteenthPoints; number++){

- inputVal = _mm_loadu_si128(inputVectorPtr);

- ret = _mm_cvtepi8_epi16(inputVal);

- ret = _mm_slli_epi16(ret, 8); // Multiply by 256

- _mm_storeu_si128(outputVectorPtr, ret);

-

- outputVectorPtr++;

-

- inputVal = _mm_srli_si128(inputVal, 8);

- ret = _mm_cvtepi8_epi16(inputVal);

- ret = _mm_slli_epi16(ret, 8); // Multiply by 256

- _mm_storeu_si128(outputVectorPtr, ret);

-

- outputVectorPtr++;

-

- inputVectorPtr++;

- }

-

- number = sixteenthPoints * 16;

- for(; number < num_points; number++){

- outputVector[number] = (int16_t)(inputVector[number])*256;

- }

-}

-#endif /* LV_HAVE_SSE4_1 */

-

-#ifdef LV_HAVE_GENERIC

- /*!

- \brief Converts the input 8 bit integer data into 16 bit integer data

- \param inputVector The 8 bit input data buffer

- \param outputVector The 16 bit output data buffer

- \param num_points The number of data values to be converted

- \note Input and output buffers do NOT need to be properly aligned

- */

-static inline void volk_8i_convert_16i_u_generic(int16_t* outputVector, const int8_t* inputVector, unsigned int num_points){

- int16_t* outputVectorPtr = outputVector;

- const int8_t* inputVectorPtr = inputVector;

- unsigned int number = 0;

-

- for(number = 0; number < num_points; number++){

- *outputVectorPtr++ = ((int16_t)(*inputVectorPtr++)) * 256;

- }

-}

-#endif /* LV_HAVE_GENERIC */

-

-

-

-

-#endif /* INCLUDED_VOLK_8s_CONVERT_16s_UNALIGNED8_H */

-#ifndef INCLUDED_volk_8i_s32f_convert_32f_u_H

-#define INCLUDED_volk_8i_s32f_convert_32f_u_H

-

-#include <inttypes.h>

-#include <stdio.h>

-

-#ifdef LV_HAVE_SSE4_1

-#include <smmintrin.h>

-

- /*!

- \brief Converts the input 8 bit integer data into floating point data, and divides the each floating point output data point by the scalar value

- \param inputVector The 8 bit input data buffer

- \param outputVector The floating point output data buffer

- \param scalar The value divided against each point in the output buffer

- \param num_points The number of data values to be converted

- \note Output buffer does NOT need to be properly aligned

- */

-static inline void volk_8i_s32f_convert_32f_u_sse4_1(float* outputVector, const int8_t* inputVector, const float scalar, unsigned int num_points){

- unsigned int number = 0;

- const unsigned int sixteenthPoints = num_points / 16;

-

- float* outputVectorPtr = outputVector;

- const float iScalar = 1.0 / scalar;

- __m128 invScalar = _mm_set_ps1( iScalar );

- const int8_t* inputVectorPtr = inputVector;

- __m128 ret;

- __m128i inputVal;

- __m128i interimVal;

-

- for(;number < sixteenthPoints; number++){

- inputVal = _mm_loadu_si128((__m128i*)inputVectorPtr);

-

- interimVal = _mm_cvtepi8_epi32(inputVal);

- ret = _mm_cvtepi32_ps(interimVal);

- ret = _mm_mul_ps(ret, invScalar);

- _mm_storeu_ps(outputVectorPtr, ret);

- outputVectorPtr += 4;

-

- inputVal = _mm_srli_si128(inputVal, 4);

- interimVal = _mm_cvtepi8_epi32(inputVal);

- ret = _mm_cvtepi32_ps(interimVal);

- ret = _mm_mul_ps(ret, invScalar);

- _mm_storeu_ps(outputVectorPtr, ret);

- outputVectorPtr += 4;

-

- inputVal = _mm_srli_si128(inputVal, 4);

- interimVal = _mm_cvtepi8_epi32(inputVal);

- ret = _mm_cvtepi32_ps(interimVal);

- ret = _mm_mul_ps(ret, invScalar);

- _mm_storeu_ps(outputVectorPtr, ret);

- outputVectorPtr += 4;

-

- inputVal = _mm_srli_si128(inputVal, 4);

- interimVal = _mm_cvtepi8_epi32(inputVal);

- ret = _mm_cvtepi32_ps(interimVal);

- ret = _mm_mul_ps(ret, invScalar);

- _mm_storeu_ps(outputVectorPtr, ret);

- outputVectorPtr += 4;

-

- inputVectorPtr += 16;

- }

-

- number = sixteenthPoints * 16;

- for(; number < num_points; number++){

- outputVector[number] = (float)(inputVector[number]) * iScalar;

- }

-}

-#endif /* LV_HAVE_SSE4_1 */

-

-#ifdef LV_HAVE_GENERIC

- /*!

- \brief Converts the input 8 bit integer data into floating point data, and divides the each floating point output data point by the scalar value

- \param inputVector The 8 bit input data buffer

- \param outputVector The floating point output data buffer

- \param scalar The value divided against each point in the output buffer

- \param num_points The number of data values to be converted

- \note Output buffer does NOT need to be properly aligned

- */

-static inline void volk_8i_s32f_convert_32f_u_generic(float* outputVector, const int8_t* inputVector, const float scalar, unsigned int num_points){

- float* outputVectorPtr = outputVector;

- const int8_t* inputVectorPtr = inputVector;

- unsigned int number = 0;

- const float iScalar = 1.0 / scalar;

-

- for(number = 0; number < num_points; number++){

- *outputVectorPtr++ = ((float)(*inputVectorPtr++)) * iScalar;

- }

-}

-#endif /* LV_HAVE_GENERIC */

-

-

-

-

-#endif /* INCLUDED_VOLK_8s_CONVERT_32f_UNALIGNED8_H */

-struct volk_arch_pref {

- char name[128];

- char arch[32];

-};

-VOLK_API void get_config_path(char *);

-VOLK_API int load_preferences(struct volk_arch_pref **);

-static inline void volk_16i_32fc_dot_prod_32fc_a_generic(lv_32fc_t* result, const short* input, const lv_32fc_t * taps, unsigned int num_points) {

-static inline void volk_16i_branch_4_state_8_a_generic(short* target, short* src0, char** permuters, short* cntl2, short* cntl3, short* scalars) {

-static inline void volk_16i_convert_8i_u_generic(int8_t* outputVector, const int16_t* inputVector, unsigned int num_points){

-static inline void volk_16i_max_star_16i_a_generic(short* target, short* src0, unsigned int num_points) {

-static inline void volk_16i_max_star_horizontal_16i_a_generic(int16_t* target, int16_t* src0, unsigned int num_points) {

-static inline void volk_16i_permute_and_scalar_add_a_generic(short* target, short* src0, short* permute_indexes, short* cntl0, short* cntl1, short* cntl2, short* cntl3, short* scalars, unsigned int num_points) {

-static inline void volk_16i_s32f_convert_32f_u_generic(float* outputVector, const int16_t* inputVector, const float scalar, unsigned int num_points){

-static inline void volk_16i_x4_quad_max_star_16i_a_generic(short* target, short* src0, short* src1, short* src2, short* src3, unsigned int num_points) {

-static inline void volk_16i_x5_add_quad_16i_x4_a_generic(short* target0, short* target1, short* target2, short* target3, short* src0, short* src1, short* src2, short* src3, short* src4, unsigned int num_points) {

-static inline void volk_16ic_deinterleave_16i_x2_a_generic(int16_t* iBuffer, int16_t* qBuffer, const lv_16sc_t* complexVector, unsigned int num_points){

-static inline void volk_16ic_deinterleave_16i_x2_a_orc(int16_t* iBuffer, int16_t* qBuffer, const lv_16sc_t* complexVector, unsigned int num_points){

-static inline void volk_16ic_deinterleave_real_16i_a_generic(int16_t* iBuffer, const lv_16sc_t* complexVector, unsigned int num_points){

-static inline void volk_16ic_deinterleave_real_8i_a_generic(int8_t* iBuffer, const lv_16sc_t* complexVector, unsigned int num_points){

-static inline void volk_16ic_deinterleave_real_8i_a_orc(int8_t* iBuffer, const lv_16sc_t* complexVector, unsigned int num_points){

-static inline void volk_16ic_magnitude_16i_a_generic(int16_t* magnitudeVector, const lv_16sc_t* complexVector, unsigned int num_points){

-static inline void volk_16ic_magnitude_16i_a_orc(int16_t* magnitudeVector, const lv_16sc_t* complexVector, unsigned int num_points){

-static inline void volk_16ic_s32f_deinterleave_32f_x2_a_generic(float* iBuffer, float* qBuffer, const lv_16sc_t* complexVector, const float scalar, unsigned int num_points){

-static inline void volk_16ic_s32f_deinterleave_32f_x2_a_orc(float* iBuffer, float* qBuffer, const lv_16sc_t* complexVector, const float scalar, unsigned int num_points){

-static inline void volk_16ic_s32f_deinterleave_real_32f_a_generic(float* iBuffer, const lv_16sc_t* complexVector, const float scalar, unsigned int num_points){

-static inline void volk_16ic_s32f_magnitude_32f_a_generic(float* magnitudeVector, const lv_16sc_t* complexVector, const float scalar, unsigned int num_points){

-static inline void volk_16ic_s32f_magnitude_32f_a_orc(float* magnitudeVector, const lv_16sc_t* complexVector, const float scalar, unsigned int num_points){

-static inline void volk_16u_byteswap_a_orc(uint16_t* intsToSwap, unsigned int num_points){

-static inline void volk_32f_accumulator_s32f_a_generic(float* result, const float* inputBuffer, unsigned int num_points){

-static inline void volk_32f_index_max_16u_a_generic(unsigned int* target, const float* src0, unsigned int num_points) {

-static inline void volk_32f_s32f_32f_fm_detect_32f_a_generic(float* outputVector, const float* inputVector, const float bound, float* saveValue, unsigned int num_points){

-static inline void volk_32f_s32f_calc_spectral_noise_floor_32f_a_generic(float* noiseFloorAmplitude, const float* realDataPoints, const float spectralExclusionValue, const unsigned int num_points){

-static inline void volk_32f_s32f_convert_16i_u_generic(int16_t* outputVector, const float* inputVector, const float scalar, unsigned int num_points){

-static inline void volk_32f_s32f_convert_8i_u_generic(int8_t* outputVector, const float* inputVector, const float scalar, unsigned int num_points){

-static inline void volk_32f_s32f_multiply_32f_a_orc(float* cVector, const float* aVector, const float scalar, unsigned int num_points){

-static inline void volk_32f_s32f_normalize_a_generic(float* vecBuffer, const float scalar, unsigned int num_points){

-static inline void volk_32f_s32f_normalize_a_orc(float* vecBuffer, const float scalar, unsigned int num_points){

-static inline void volk_32f_s32f_power_32f_a_generic(float* cVector, const float* aVector, const float power, unsigned int num_points){

-static inline void volk_32f_s32f_stddev_32f_a_generic(float* stddev, const float* inputBuffer, const float mean, unsigned int num_points){

-static inline void volk_32f_sqrt_32f_a_generic(float* cVector, const float* aVector, unsigned int num_points){

-static inline void volk_32f_sqrt_32f_a_orc(float* cVector, const float* aVector, unsigned int num_points){

-static inline void volk_32f_stddev_and_mean_32f_x2_a_generic(float* stddev, float* mean, const float* inputBuffer, unsigned int num_points){

-static inline void volk_32f_x2_add_32f_a_orc(float* cVector, const float* aVector, const float* bVector, unsigned int num_points){

-static inline void volk_32f_x2_divide_32f_a_generic(float* cVector, const float* aVector, const float* bVector, unsigned int num_points){

-static inline void volk_32f_x2_divide_32f_a_orc(float* cVector, const float* aVector, const float* bVector, unsigned int num_points){

-static inline void volk_32f_x2_dot_prod_16i_a_generic(int16_t* result, const float* input, const float* taps, unsigned int num_points) {