Пример #1
0
void AmbisonicsMeter::setNumberOfLoudspeakers(long aNumberOfChannels)
{
    Planewaves::setNumberOfLoudspeakers(aNumberOfChannels);
    m_vectors->setNumberOfLoudspeakers(aNumberOfChannels);
    m_number_of_outputs		= 0;
    
    if(m_loudspeakers_amplitudes)
        cicm_free(m_loudspeakers_amplitudes);
    if(m_loudspeakers_peaks)
        cicm_free(m_loudspeakers_peaks);
    if(m_loudspeakers_energies)
        cicm_free(m_loudspeakers_energies);
    if(m_loudspeakers_angles_mapped)
        cicm_free(m_loudspeakers_angles_mapped);
    if(m_loudspeakers_angles_width)
        cicm_free(m_loudspeakers_angles_width);
    
    cicm_malloc_vec_d(m_loudspeakers_amplitudes, m_number_of_loudspeakers);
    cicm_malloc_vec_d(m_loudspeakers_peaks, m_number_of_loudspeakers);
    cicm_malloc_vec_d(m_loudspeakers_energies, m_number_of_loudspeakers);
    cicm_malloc_vec_d(m_loudspeakers_angles_mapped, m_number_of_loudspeakers);
    cicm_malloc_vec_d(m_loudspeakers_angles_width, m_number_of_loudspeakers);
    
    for(int i = 0; i < m_number_of_loudspeakers; i++)
    {
        m_loudspeakers_amplitudes[i] = 0.;
        m_loudspeakers_peaks[i] = 0.;
        m_loudspeakers_energies[i] = -90;
    }
    
    double curAngle, prevAngle, nextAngle, prevPortion, nextPortion;
	for(int i = 0; i < m_number_of_loudspeakers; i++)
	{
		curAngle = m_angles_of_loudspeakers_double[i];
		if (i != 0)
            prevAngle = m_angles_of_loudspeakers_double[i-1];
		else
            prevAngle = m_angles_of_loudspeakers_double[m_number_of_loudspeakers-1];
		if (i != m_number_of_loudspeakers-1)
            nextAngle = m_angles_of_loudspeakers_double[i+1];
		else
            nextAngle = m_angles_of_loudspeakers_double[0];
		
		prevPortion = (curAngle - prevAngle);
		nextPortion = (nextAngle - curAngle);
		
		if (nextPortion < 0.)
            nextPortion += CICM_2PI;
		if (prevPortion < 0.)
            prevPortion += CICM_2PI;
		
		m_loudspeakers_angles_width[i] = (prevPortion + nextPortion)*0.5;
		m_loudspeakers_angles_mapped[i] = (curAngle - prevPortion*0.5) + m_loudspeakers_angles_width[i]*0.5;
	}
}
Пример #2
0
AmbisonicWider::AmbisonicWider(long anOrder, long aVectorSize) : Ambisonic(anOrder, aVectorSize)
{
    m_number_of_inputs = m_number_of_harmonics + 1;

	m_wider_matrix = new cicm_vector_double[m_number_of_harmonics];
	for(int i = 0; i < m_number_of_harmonics; i++)
	{
		cicm_malloc_vec_d(m_wider_matrix[i], NUMBEROFLINEARPOINTS);
	}
	cicm_malloc_vec_f(m_harmonics_vector_float, m_number_of_harmonics);
	cicm_malloc_vec_d(m_harmonics_vector_double, m_number_of_harmonics);
	m_index_vector = NULL;
	m_vector_float = NULL;
    m_vector_double = NULL;
	computeWidenVector();
	setWidenValue(1.);
}
Пример #3
0
AmbisonicsDecoder::AmbisonicsDecoder(long anOrder, long aNumberOfLoudspeakers, long aVectorSize) : Ambisonic(anOrder, aVectorSize)
{
    cicm_malloc_vec_f(m_vector_float_input, m_number_of_harmonics);
    cicm_malloc_vec_d(m_vector_double_input, m_number_of_harmonics);
    
    m_decoder_matrix_float  = NULL;
    m_decoder_matrix_double = NULL;
    m_vector_float_output   = NULL;
    m_vector_double_output  = NULL;
    m_number_of_loudspeakers = 0;
    setNumberOfLoudspeakers(aNumberOfLoudspeakers);
}
Пример #4
0
void AmbisonicWider::setVectorSize(long aVectorSize)
{
	Ambisonic::setVectorSize(aVectorSize);
	if(m_index_vector)
		free(m_index_vector);
	if(m_vector_double)
		cicm_free(m_vector_double);
	if(m_vector_float)
		cicm_free(m_vector_float);
	m_index_vector = new int[m_vector_size];
	cicm_malloc_vec_f(m_vector_float, m_vector_size);
	cicm_malloc_vec_d(m_vector_double, m_vector_size);
}
Пример #5
0
void AmbisonicsDecoder::setNumberOfLoudspeakers(long aNumberOfLoudspeakers)
{
    m_number_of_outputs		= Tools::clip_min(aNumberOfLoudspeakers, m_number_of_harmonics);
    if(m_number_of_loudspeakers != m_number_of_outputs)
    {
        if(m_decoder_matrix_float)
            cicm_free(m_decoder_matrix_float);
        if(m_decoder_matrix_double)
            cicm_free(m_decoder_matrix_double);
        if(m_vector_float_output)
            cicm_free(m_vector_float_output);
        if(m_vector_double_output)
            cicm_free(m_vector_double_output);
        
        m_number_of_loudspeakers = m_number_of_outputs;
        
        cicm_malloc_mat_f(m_decoder_matrix_float, m_number_of_outputs, m_number_of_harmonics);
        cicm_malloc_mat_d(m_decoder_matrix_double, m_number_of_outputs, m_number_of_harmonics);
        cicm_malloc_vec_f(m_vector_float_output, m_number_of_outputs);
        cicm_malloc_vec_d(m_vector_double_output, m_number_of_outputs);
        computeMatrix();
    }
}