Robin Gareus
74c4ca3e52
the rest from `tools/convert_boost.sh`.
* replace boost::function, boost::bind with std::function and std::bind.
This required some manual fixes, notably std::placeholders,
some static_casts<>, and boost::function::clear -> = {}.
670 lines
20 KiB
C++
670 lines
20 KiB
C++
/*
|
|
This software is being provided to you, the licensee, by Ville Pulkki,
|
|
under the following license. By obtaining, using and/or copying this
|
|
software, you agree that you have read, understood, and will comply
|
|
with these terms and conditions: Permission to use, copy, modify and
|
|
distribute, including the right to grant others rights to distribute
|
|
at any tier, this software and its documentation for any purpose and
|
|
without fee or royalty is hereby granted, provided that you agree to
|
|
comply with the following copyright notice and statements, including
|
|
the disclaimer, and that the same appear on ALL copies of the software
|
|
and documentation, including modifications that you make for internal
|
|
use or for distribution:
|
|
|
|
Copyright 1998 by Ville Pulkki, Helsinki University of Technology. All
|
|
rights reserved.
|
|
|
|
The software may be used, distributed, and included to commercial
|
|
products without any charges. When included to a commercial product,
|
|
the method "Vector Base Amplitude Panning" and its developer Ville
|
|
Pulkki must be referred to in documentation.
|
|
|
|
This software is provided "as is", and Ville Pulkki or Helsinki
|
|
University of Technology make no representations or warranties,
|
|
expressed or implied. By way of example, but not limitation, Helsinki
|
|
University of Technology or Ville Pulkki make no representations or
|
|
warranties of merchantability or fitness for any particular purpose or
|
|
that the use of the licensed software or documentation will not
|
|
infringe any third party patents, copyrights, trademarks or other
|
|
rights. The name of Ville Pulkki or Helsinki University of Technology
|
|
may not be used in advertising or publicity pertaining to distribution
|
|
of the software.
|
|
*/
|
|
|
|
#include <algorithm>
|
|
#include <cmath>
|
|
#include <stdlib.h>
|
|
|
|
#include "pbd/cartesian.h"
|
|
|
|
#include "vbap_speakers.h"
|
|
|
|
using namespace ARDOUR;
|
|
using namespace PBD;
|
|
using namespace std;
|
|
|
|
const double VBAPSpeakers::MIN_VOL_P_SIDE_LGTH = 0.01;
|
|
|
|
VBAPSpeakers::VBAPSpeakers (std::shared_ptr<Speakers> s)
|
|
: _dimension (2)
|
|
, _parent (s)
|
|
{
|
|
_parent->Changed.connect_same_thread (speaker_connection, std::bind (&VBAPSpeakers::update, this));
|
|
update ();
|
|
}
|
|
|
|
VBAPSpeakers::~VBAPSpeakers ()
|
|
{
|
|
}
|
|
|
|
void
|
|
VBAPSpeakers::update ()
|
|
{
|
|
int dim = 2;
|
|
|
|
_speakers = _parent->speakers ();
|
|
|
|
for (vector<Speaker>::const_iterator i = _speakers.begin (); i != _speakers.end (); ++i) {
|
|
if ((*i).angles ().ele != 0.0) {
|
|
dim = 3;
|
|
break;
|
|
}
|
|
}
|
|
|
|
_dimension = dim;
|
|
|
|
if (_speakers.size () < 2) {
|
|
/* nothing to be done with less than two speakers */
|
|
return;
|
|
}
|
|
|
|
if (_dimension == 3) {
|
|
ls_triplet_chain* ls_triplets = 0;
|
|
choose_speaker_triplets (&ls_triplets);
|
|
if (ls_triplets) {
|
|
calculate_3x3_matrixes (ls_triplets);
|
|
free (ls_triplets);
|
|
}
|
|
} else {
|
|
choose_speaker_pairs ();
|
|
}
|
|
}
|
|
|
|
void
|
|
VBAPSpeakers::choose_speaker_triplets (struct ls_triplet_chain** ls_triplets)
|
|
{
|
|
/* Selects the loudspeaker triplets, and
|
|
* calculates the inversion matrices for each selected triplet.
|
|
* A line (connection) is drawn between each loudspeaker. The lines
|
|
* denote the sides of the triangles. The triangles should not be
|
|
* intersecting. All crossing connections are searched and the
|
|
* longer connection is erased. This yields non-intesecting triangles,
|
|
* which can be used in panning.
|
|
*/
|
|
|
|
#if 0 // DEVEL/DEBUG
|
|
for (vector<Speaker>::iterator i = _speakers.begin(); i != _speakers.end(); ++i) {
|
|
cout << "Speaker " << (*i).id << " @ "
|
|
<< (*i).coords().x << ", " << (*i).coords().y << ", " << (*i).coords().z
|
|
<< " azimuth " << (*i).angles().azi
|
|
<< " elevation " << (*i).angles().ele
|
|
<< " distance " << (*i).angles().length
|
|
<< endl;
|
|
}
|
|
#endif
|
|
|
|
int i, j, k, l, table_size;
|
|
int n_speakers = _speakers.size ();
|
|
|
|
if (n_speakers < 3) {
|
|
fprintf (stderr, "VBAP: at least 3 speakers need to be defined.");
|
|
return;
|
|
}
|
|
|
|
/* variable length arrays arrived in C99, became optional in C11, and
|
|
* are only planned for C++14. Use alloca which is functionally
|
|
* identical (but uglier to read).
|
|
*/
|
|
int* connections = (int*)alloca (sizeof (int) * n_speakers * n_speakers);
|
|
float* distance_table = (float*)alloca (sizeof (float) * ((n_speakers * (n_speakers - 1)) / 2));
|
|
int* distance_table_i = (int*)alloca (sizeof (int) * ((n_speakers * (n_speakers - 1)) / 2));
|
|
int* distance_table_j = (int*)alloca (sizeof (int) * ((n_speakers * (n_speakers - 1)) / 2));
|
|
float distance;
|
|
|
|
struct ls_triplet_chain *trip_ptr, *prev, *tmp_ptr;
|
|
|
|
for (i = 0; i < n_speakers * n_speakers; i++) {
|
|
connections[i] = 0;
|
|
}
|
|
|
|
for (i = 0; i < n_speakers; i++) {
|
|
for (j = i + 1; j < n_speakers; j++) {
|
|
for (k = j + 1; k < n_speakers; k++) {
|
|
if (vol_p_side_lgth (i, j, k, _speakers) > MIN_VOL_P_SIDE_LGTH) {
|
|
connections[(i * n_speakers) + j] = 1;
|
|
connections[(j * n_speakers) + i] = 1;
|
|
connections[(i * n_speakers) + k] = 1;
|
|
connections[(k * n_speakers) + i] = 1;
|
|
connections[(j * n_speakers) + k] = 1;
|
|
connections[(k * n_speakers) + j] = 1;
|
|
add_ldsp_triplet (i, j, k, ls_triplets);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/*calculate distancies between all speakers and sorting them*/
|
|
table_size = (((n_speakers - 1) * (n_speakers)) / 2);
|
|
for (i = 0; i < table_size; i++) {
|
|
distance_table[i] = 100000.0;
|
|
}
|
|
|
|
for (i = 0; i < n_speakers; i++) {
|
|
for (j = i + 1; j < n_speakers; j++) {
|
|
if (connections[(i * n_speakers) + j] == 1) {
|
|
distance = fabs (vec_angle (_speakers[i].coords (), _speakers[j].coords ()));
|
|
k = 0;
|
|
while (distance_table[k] < distance) {
|
|
k++;
|
|
}
|
|
for (l = table_size - 1; l > k; l--) {
|
|
distance_table[l] = distance_table[l - 1];
|
|
distance_table_i[l] = distance_table_i[l - 1];
|
|
distance_table_j[l] = distance_table_j[l - 1];
|
|
}
|
|
distance_table[k] = distance;
|
|
distance_table_i[k] = i;
|
|
distance_table_j[k] = j;
|
|
} else
|
|
table_size--;
|
|
}
|
|
}
|
|
|
|
/* disconnecting connections which are crossing shorter ones,
|
|
* starting from shortest one and removing all that cross it,
|
|
* and proceeding to next shortest */
|
|
for (i = 0; i < table_size; i++) {
|
|
int fst_ls = distance_table_i[i];
|
|
int sec_ls = distance_table_j[i];
|
|
if (connections[(fst_ls * n_speakers) + sec_ls] == 1) {
|
|
for (j = 0; j < n_speakers; j++) {
|
|
for (k = j + 1; k < n_speakers; k++) {
|
|
if ((j != fst_ls) && (k != sec_ls) && (k != fst_ls) && (j != sec_ls)) {
|
|
if (lines_intersect (fst_ls, sec_ls, j, k) == 1) {
|
|
connections[(j * n_speakers) + k] = 0;
|
|
connections[(k * n_speakers) + j] = 0;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/* remove triangles which had crossing sides
|
|
* with smaller triangles or include loudspeakers*/
|
|
trip_ptr = *ls_triplets;
|
|
prev = 0;
|
|
while (trip_ptr != 0) {
|
|
i = trip_ptr->ls_nos[0];
|
|
j = trip_ptr->ls_nos[1];
|
|
k = trip_ptr->ls_nos[2];
|
|
if (connections[(i * n_speakers) + j] == 0 ||
|
|
connections[(i * n_speakers) + k] == 0 ||
|
|
connections[(j * n_speakers) + k] == 0 ||
|
|
any_ls_inside_triplet (i, j, k) == 1) {
|
|
if (prev != 0) {
|
|
prev->next = trip_ptr->next;
|
|
tmp_ptr = trip_ptr;
|
|
trip_ptr = trip_ptr->next;
|
|
free (tmp_ptr);
|
|
} else {
|
|
*ls_triplets = trip_ptr->next;
|
|
tmp_ptr = trip_ptr;
|
|
trip_ptr = trip_ptr->next;
|
|
free (tmp_ptr);
|
|
}
|
|
} else {
|
|
prev = trip_ptr;
|
|
trip_ptr = trip_ptr->next;
|
|
}
|
|
}
|
|
}
|
|
|
|
int
|
|
VBAPSpeakers::any_ls_inside_triplet (int a, int b, int c)
|
|
{
|
|
/* returns 1 if there is loudspeaker(s) inside given ls triplet */
|
|
float invdet;
|
|
const CartesianVector* lp1;
|
|
const CartesianVector* lp2;
|
|
const CartesianVector* lp3;
|
|
float invmx[9];
|
|
int i, j;
|
|
float tmp;
|
|
bool any_ls_inside;
|
|
bool this_inside;
|
|
int n_speakers = _speakers.size ();
|
|
|
|
lp1 = &(_speakers[a].coords ());
|
|
lp2 = &(_speakers[b].coords ());
|
|
lp3 = &(_speakers[c].coords ());
|
|
|
|
/* matrix inversion */
|
|
invdet = 1.0 / ( lp1->x * ((lp2->y * lp3->z) - (lp2->z * lp3->y))
|
|
- lp1->y * ((lp2->x * lp3->z) - (lp2->z * lp3->x))
|
|
+ lp1->z * ((lp2->x * lp3->y) - (lp2->y * lp3->x)));
|
|
|
|
invmx[0] = ((lp2->y * lp3->z) - (lp2->z * lp3->y)) * invdet;
|
|
invmx[3] = ((lp1->y * lp3->z) - (lp1->z * lp3->y)) * -invdet;
|
|
invmx[6] = ((lp1->y * lp2->z) - (lp1->z * lp2->y)) * invdet;
|
|
invmx[1] = ((lp2->x * lp3->z) - (lp2->z * lp3->x)) * -invdet;
|
|
invmx[4] = ((lp1->x * lp3->z) - (lp1->z * lp3->x)) * invdet;
|
|
invmx[7] = ((lp1->x * lp2->z) - (lp1->z * lp2->x)) * -invdet;
|
|
invmx[2] = ((lp2->x * lp3->y) - (lp2->y * lp3->x)) * invdet;
|
|
invmx[5] = ((lp1->x * lp3->y) - (lp1->y * lp3->x)) * -invdet;
|
|
invmx[8] = ((lp1->x * lp2->y) - (lp1->y * lp2->x)) * invdet;
|
|
|
|
any_ls_inside = false;
|
|
for (i = 0; i < n_speakers; i++) {
|
|
if (i != a && i != b && i != c) {
|
|
this_inside = true;
|
|
for (j = 0; j < 3; j++) {
|
|
tmp = _speakers[i].coords ().x * invmx[0 + j * 3];
|
|
tmp += _speakers[i].coords ().y * invmx[1 + j * 3];
|
|
tmp += _speakers[i].coords ().z * invmx[2 + j * 3];
|
|
if (tmp < -0.001) {
|
|
this_inside = false;
|
|
}
|
|
}
|
|
if (this_inside) {
|
|
any_ls_inside = true;
|
|
}
|
|
}
|
|
}
|
|
|
|
return any_ls_inside;
|
|
}
|
|
|
|
void
|
|
VBAPSpeakers::add_ldsp_triplet (int i, int j, int k, struct ls_triplet_chain** ls_triplets)
|
|
{
|
|
/* adds i,j,k triplet to triplet chain*/
|
|
|
|
struct ls_triplet_chain *trip_ptr, *prev;
|
|
trip_ptr = *ls_triplets;
|
|
prev = 0;
|
|
|
|
while (trip_ptr != 0) {
|
|
prev = trip_ptr;
|
|
trip_ptr = trip_ptr->next;
|
|
}
|
|
|
|
trip_ptr = (struct ls_triplet_chain*)malloc (sizeof (struct ls_triplet_chain));
|
|
|
|
if (prev == 0) {
|
|
*ls_triplets = trip_ptr;
|
|
} else {
|
|
prev->next = trip_ptr;
|
|
}
|
|
|
|
trip_ptr->next = 0;
|
|
trip_ptr->ls_nos[0] = i;
|
|
trip_ptr->ls_nos[1] = j;
|
|
trip_ptr->ls_nos[2] = k;
|
|
}
|
|
|
|
double
|
|
VBAPSpeakers::vec_angle (CartesianVector v1, CartesianVector v2)
|
|
{
|
|
double inner = ((v1.x * v2.x + v1.y * v2.y + v1.z * v2.z) /
|
|
(vec_length (v1) * vec_length (v2)));
|
|
|
|
if (inner > 1.0) {
|
|
inner = 1.0;
|
|
}
|
|
|
|
if (inner < -1.0) {
|
|
inner = -1.0;
|
|
}
|
|
|
|
return fabs (acos (inner));
|
|
}
|
|
|
|
double
|
|
VBAPSpeakers::vec_length (CartesianVector v1)
|
|
{
|
|
double rv = sqrt (v1.x * v1.x + v1.y * v1.y + v1.z * v1.z);
|
|
if (rv > 1e-14)
|
|
return rv;
|
|
return 0;
|
|
}
|
|
|
|
double
|
|
VBAPSpeakers::vec_prod (CartesianVector v1, CartesianVector v2)
|
|
{
|
|
return (v1.x * v2.x + v1.y * v2.y + v1.z * v2.z);
|
|
}
|
|
|
|
double
|
|
VBAPSpeakers::vol_p_side_lgth (int i, int j, int k, const vector<Speaker>& speakers)
|
|
{
|
|
/* calculate volume of the parallelepiped defined by the loudspeaker
|
|
* direction vectors and divide it with total length of the triangle sides.
|
|
* This is used when removing too narrow triangles. */
|
|
|
|
double volper, lgth;
|
|
CartesianVector xprod;
|
|
cross_prod (speakers[i].coords (), speakers[j].coords (), &xprod);
|
|
volper = fabs (vec_prod (xprod, speakers[k].coords ()));
|
|
lgth = (fabs (vec_angle (speakers[i].coords (), speakers[j].coords ())) + fabs (vec_angle (speakers[i].coords (), speakers[k].coords ())) + fabs (vec_angle (speakers[j].coords (), speakers[k].coords ())));
|
|
if (lgth > 0.00001) {
|
|
return volper / lgth;
|
|
} else {
|
|
return 0.0;
|
|
}
|
|
}
|
|
|
|
void
|
|
VBAPSpeakers::cross_prod (CartesianVector v1, CartesianVector v2, CartesianVector* res)
|
|
{
|
|
double length;
|
|
|
|
res->x = (v1.y * v2.z) - (v1.z * v2.y);
|
|
res->y = (v1.z * v2.x) - (v1.x * v2.z);
|
|
res->z = (v1.x * v2.y) - (v1.y * v2.x);
|
|
|
|
length = vec_length (*res);
|
|
if (length > 0) {
|
|
res->x /= length;
|
|
res->y /= length;
|
|
res->z /= length;
|
|
} else {
|
|
res->x = 0;
|
|
res->y = 0;
|
|
res->z = 0;
|
|
}
|
|
}
|
|
|
|
int
|
|
VBAPSpeakers::lines_intersect (int i, int j, int k, int l)
|
|
{
|
|
/* checks if two lines intersect on 3D sphere
|
|
* see theory in paper Pulkki, V. Lokki, T. "Creating Auditory Displays
|
|
* with Multiple Loudspeakers Using VBAP: A Case Study with
|
|
* DIVA Project" in International Conference on
|
|
* Auditory Displays -98. E-mail Ville.Pulkki@hut.fi
|
|
* if you want to have that paper.
|
|
*/
|
|
|
|
CartesianVector v1;
|
|
CartesianVector v2;
|
|
CartesianVector v3, neg_v3;
|
|
|
|
float dist_ij, dist_kl, dist_iv3, dist_jv3, dist_inv3, dist_jnv3;
|
|
float dist_kv3, dist_lv3, dist_knv3, dist_lnv3;
|
|
|
|
cross_prod (_speakers[i].coords (), _speakers[j].coords (), &v1);
|
|
cross_prod (_speakers[k].coords (), _speakers[l].coords (), &v2);
|
|
cross_prod (v1, v2, &v3);
|
|
|
|
neg_v3.x = 0.0 - v3.x;
|
|
neg_v3.y = 0.0 - v3.y;
|
|
neg_v3.z = 0.0 - v3.z;
|
|
|
|
dist_ij = (vec_angle (_speakers[i].coords (), _speakers[j].coords ()));
|
|
dist_kl = (vec_angle (_speakers[k].coords (), _speakers[l].coords ()));
|
|
dist_iv3 = (vec_angle (_speakers[i].coords (), v3));
|
|
dist_jv3 = (vec_angle (v3, _speakers[j].coords ()));
|
|
dist_inv3 = (vec_angle (_speakers[i].coords (), neg_v3));
|
|
dist_jnv3 = (vec_angle (neg_v3, _speakers[j].coords ()));
|
|
dist_kv3 = (vec_angle (_speakers[k].coords (), v3));
|
|
dist_lv3 = (vec_angle (v3, _speakers[l].coords ()));
|
|
dist_knv3 = (vec_angle (_speakers[k].coords (), neg_v3));
|
|
dist_lnv3 = (vec_angle (neg_v3, _speakers[l].coords ()));
|
|
|
|
/* if one of loudspeakers is close to crossing point, don't do anything*/
|
|
if (fabsf (dist_iv3) <= 0.01 || fabsf (dist_jv3) <= 0.01 ||
|
|
fabsf (dist_kv3) <= 0.01 || fabsf (dist_lv3) <= 0.01 ||
|
|
fabsf (dist_inv3) <= 0.01 || fabsf (dist_jnv3) <= 0.01 ||
|
|
fabsf (dist_knv3) <= 0.01 || fabsf (dist_lnv3) <= 0.01) {
|
|
return (0);
|
|
}
|
|
|
|
/* if crossing point is on line between both loudspeakers return 1 */
|
|
if (((fabsf (dist_ij - (dist_iv3 + dist_jv3)) <= 0.01) &&
|
|
(fabsf (dist_kl - (dist_kv3 + dist_lv3)) <= 0.01)) ||
|
|
((fabsf (dist_ij - (dist_inv3 + dist_jnv3)) <= 0.01) &&
|
|
(fabsf (dist_kl - (dist_knv3 + dist_lnv3)) <= 0.01))) {
|
|
return (1);
|
|
} else {
|
|
return (0);
|
|
}
|
|
}
|
|
|
|
void
|
|
VBAPSpeakers::calculate_3x3_matrixes (struct ls_triplet_chain* ls_triplets)
|
|
{
|
|
/* Calculates the inverse matrices for 3D */
|
|
float invdet;
|
|
const CartesianVector* lp1;
|
|
const CartesianVector* lp2;
|
|
const CartesianVector* lp3;
|
|
float* invmx;
|
|
struct ls_triplet_chain* tr_ptr = ls_triplets;
|
|
int triplet_count = 0;
|
|
int triplet;
|
|
|
|
assert (tr_ptr);
|
|
|
|
/* counting triplet amount */
|
|
|
|
while (tr_ptr != 0) {
|
|
triplet_count++;
|
|
tr_ptr = tr_ptr->next;
|
|
}
|
|
|
|
#if 0 // DEVEL/DEBUG
|
|
cerr << "@@@ VBAP triplets generate " << triplet_count << " of speaker tuples\n";
|
|
#endif
|
|
|
|
triplet = 0;
|
|
|
|
_matrices.clear ();
|
|
_speaker_tuples.clear ();
|
|
|
|
for (int n = 0; n < triplet_count; ++n) {
|
|
_matrices.push_back (threeDmatrix ());
|
|
_speaker_tuples.push_back (tmatrix ());
|
|
}
|
|
|
|
tr_ptr = ls_triplets;
|
|
while (tr_ptr != 0) {
|
|
lp1 = &(_speakers[tr_ptr->ls_nos[0]].coords ());
|
|
lp2 = &(_speakers[tr_ptr->ls_nos[1]].coords ());
|
|
lp3 = &(_speakers[tr_ptr->ls_nos[2]].coords ());
|
|
|
|
/* matrix inversion */
|
|
invmx = tr_ptr->inv_mx;
|
|
invdet = 1.0 / ( lp1->x * ((lp2->y * lp3->z) - (lp2->z * lp3->y))
|
|
- lp1->y * ((lp2->x * lp3->z) - (lp2->z * lp3->x))
|
|
+ lp1->z * ((lp2->x * lp3->y) - (lp2->y * lp3->x)));
|
|
|
|
invmx[0] = ((lp2->y * lp3->z) - (lp2->z * lp3->y)) * invdet;
|
|
invmx[3] = ((lp1->y * lp3->z) - (lp1->z * lp3->y)) * -invdet;
|
|
invmx[6] = ((lp1->y * lp2->z) - (lp1->z * lp2->y)) * invdet;
|
|
invmx[1] = ((lp2->x * lp3->z) - (lp2->z * lp3->x)) * -invdet;
|
|
invmx[4] = ((lp1->x * lp3->z) - (lp1->z * lp3->x)) * invdet;
|
|
invmx[7] = ((lp1->x * lp2->z) - (lp1->z * lp2->x)) * -invdet;
|
|
invmx[2] = ((lp2->x * lp3->y) - (lp2->y * lp3->x)) * invdet;
|
|
invmx[5] = ((lp1->x * lp3->y) - (lp1->y * lp3->x)) * -invdet;
|
|
invmx[8] = ((lp1->x * lp2->y) - (lp1->y * lp2->x)) * invdet;
|
|
|
|
/* copy the matrix */
|
|
|
|
_matrices[triplet][0] = invmx[0];
|
|
_matrices[triplet][1] = invmx[1];
|
|
_matrices[triplet][2] = invmx[2];
|
|
_matrices[triplet][3] = invmx[3];
|
|
_matrices[triplet][4] = invmx[4];
|
|
_matrices[triplet][5] = invmx[5];
|
|
_matrices[triplet][6] = invmx[6];
|
|
_matrices[triplet][7] = invmx[7];
|
|
_matrices[triplet][8] = invmx[8];
|
|
|
|
_speaker_tuples[triplet][0] = tr_ptr->ls_nos[0];
|
|
_speaker_tuples[triplet][1] = tr_ptr->ls_nos[1];
|
|
_speaker_tuples[triplet][2] = tr_ptr->ls_nos[2];
|
|
|
|
#if 0 // DEVEL/DEBUG
|
|
cerr << "Triplet[" << triplet << "] = "
|
|
<< tr_ptr->ls_nos[0] << " + "
|
|
<< tr_ptr->ls_nos[1] << " + "
|
|
<< tr_ptr->ls_nos[2] << endl;
|
|
#endif
|
|
|
|
triplet++;
|
|
|
|
tr_ptr = tr_ptr->next;
|
|
}
|
|
}
|
|
|
|
void
|
|
VBAPSpeakers::choose_speaker_pairs ()
|
|
{
|
|
/* selects the loudspeaker pairs, calculates the inversion
|
|
* matrices and stores the data to a global array
|
|
*/
|
|
const int n_speakers = _speakers.size ();
|
|
|
|
if (n_speakers < 2) {
|
|
fprintf (stderr, "VBAP: at least 2 speakers need to be defined.");
|
|
return;
|
|
}
|
|
|
|
const double AZIMUTH_DELTA_THRESHOLD_DEGREES = (180.0 / M_PI) * (M_PI - 0.175);
|
|
/* variable length arrays arrived in C99, became optional in C11, and
|
|
* are only planned for C++14. Use alloca which is functionally
|
|
* identical (but uglier to read).
|
|
*/
|
|
int* sorted_speakers = (int*)alloca (sizeof (int) * n_speakers);
|
|
bool* exists = (bool*)alloca (sizeof (bool) * n_speakers);
|
|
double* inverse_matrix = (double*)alloca (sizeof (double) * n_speakers * 4);
|
|
int expected_pairs = 0;
|
|
int pair;
|
|
int speaker;
|
|
|
|
for (speaker = 0; speaker < n_speakers; ++speaker) {
|
|
exists[speaker] = false;
|
|
}
|
|
|
|
/* sort loudspeakers according their aximuth angle */
|
|
#ifdef __clang_analyzer__
|
|
// sort_2D_lss() assigns values to all of sorted_speakers
|
|
// "uninitialized value"
|
|
memset (sorted_speakers, 0, sizeof (*sorted_speakers));
|
|
#endif
|
|
sort_2D_lss (sorted_speakers);
|
|
|
|
/* adjacent loudspeakers are the loudspeaker pairs to be used.*/
|
|
for (speaker = 0; speaker < n_speakers - 1; speaker++) {
|
|
if ((_speakers[sorted_speakers[speaker + 1]].angles ().azi -
|
|
_speakers[sorted_speakers[speaker]].angles ().azi) <= AZIMUTH_DELTA_THRESHOLD_DEGREES) {
|
|
if (calc_2D_inv_tmatrix (_speakers[sorted_speakers[speaker]].angles ().azi,
|
|
_speakers[sorted_speakers[speaker + 1]].angles ().azi,
|
|
&inverse_matrix[4 * speaker]) != 0) {
|
|
exists[speaker] = true;
|
|
expected_pairs++;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (((6.283 - _speakers[sorted_speakers[n_speakers - 1]].angles ().azi) + _speakers[sorted_speakers[0]].angles ().azi) <= AZIMUTH_DELTA_THRESHOLD_DEGREES) {
|
|
if (calc_2D_inv_tmatrix (_speakers[sorted_speakers[n_speakers - 1]].angles ().azi,
|
|
_speakers[sorted_speakers[0]].angles ().azi,
|
|
&inverse_matrix[4 * (n_speakers - 1)]) != 0) {
|
|
exists[n_speakers - 1] = true;
|
|
expected_pairs++;
|
|
}
|
|
}
|
|
|
|
pair = 0;
|
|
|
|
_matrices.clear ();
|
|
_speaker_tuples.clear ();
|
|
|
|
for (int n = 0; n < expected_pairs; ++n) {
|
|
_matrices.push_back (twoDmatrix ());
|
|
_speaker_tuples.push_back (tmatrix ());
|
|
}
|
|
|
|
for (speaker = 0; speaker < n_speakers - 1; speaker++) {
|
|
if (exists[speaker]) {
|
|
_matrices[pair][0] = inverse_matrix[(speaker * 4) + 0];
|
|
_matrices[pair][1] = inverse_matrix[(speaker * 4) + 1];
|
|
_matrices[pair][2] = inverse_matrix[(speaker * 4) + 2];
|
|
_matrices[pair][3] = inverse_matrix[(speaker * 4) + 3];
|
|
|
|
_speaker_tuples[pair][0] = sorted_speakers[speaker];
|
|
_speaker_tuples[pair][1] = sorted_speakers[speaker + 1];
|
|
|
|
pair++;
|
|
}
|
|
}
|
|
|
|
if (exists[n_speakers - 1]) {
|
|
_matrices[pair][0] = inverse_matrix[(speaker * 4) + 0];
|
|
_matrices[pair][1] = inverse_matrix[(speaker * 4) + 1];
|
|
_matrices[pair][2] = inverse_matrix[(speaker * 4) + 2];
|
|
_matrices[pair][3] = inverse_matrix[(speaker * 4) + 3];
|
|
|
|
_speaker_tuples[pair][0] = sorted_speakers[n_speakers - 1];
|
|
_speaker_tuples[pair][1] = sorted_speakers[0];
|
|
}
|
|
}
|
|
|
|
void
|
|
VBAPSpeakers::sort_2D_lss (int* sorted_speakers)
|
|
{
|
|
vector<Speaker> tmp = _speakers;
|
|
vector<Speaker>::iterator s;
|
|
azimuth_sorter sorter;
|
|
unsigned int n;
|
|
|
|
sort (tmp.begin (), tmp.end (), sorter);
|
|
|
|
for (n = 0, s = tmp.begin (); s != tmp.end (); ++s, ++n) {
|
|
sorted_speakers[n] = (*s).id;
|
|
}
|
|
assert (n == _speakers.size ());
|
|
}
|
|
|
|
int
|
|
VBAPSpeakers::calc_2D_inv_tmatrix (double azi1, double azi2, double* inverse_matrix)
|
|
{
|
|
double x1, x2, x3, x4;
|
|
double det;
|
|
|
|
x1 = cos (azi1 * (M_PI / 180.0));
|
|
x2 = sin (azi1 * (M_PI / 180.0));
|
|
x3 = cos (azi2 * (M_PI / 180.0));
|
|
x4 = sin (azi2 * (M_PI / 180.0));
|
|
det = (x1 * x4) - (x3 * x2);
|
|
|
|
if (fabs (det) <= 0.001) {
|
|
inverse_matrix[0] = 0.0;
|
|
inverse_matrix[1] = 0.0;
|
|
inverse_matrix[2] = 0.0;
|
|
inverse_matrix[3] = 0.0;
|
|
|
|
return 0;
|
|
|
|
} else {
|
|
inverse_matrix[0] = x4 / det;
|
|
inverse_matrix[1] = -x3 / det;
|
|
inverse_matrix[2] = -x2 / det;
|
|
inverse_matrix[3] = x1 / det;
|
|
|
|
return 1;
|
|
}
|
|
}
|