//Multiply this with b
Matrix*
Matrix::multiplyMatrix(Matrix* b)
{
if(col!=b->getRowCnt())
{
return NULL;
}
Matrix* res=new Matrix(row,b->getColCnt());
gsl_matrix_set_zero (res->matrix);
gsl_matrix_float* resmatrix=gsl_matrix_float_alloc(row,b->getColCnt());
convertToFloat(resmatrix,res->matrix,row,b->getColCnt());
gsl_matrix_float* cmatrix=gsl_matrix_float_alloc(row,col);
convertToFloat(cmatrix,matrix,row,col);
gsl_matrix_float* bmatrix=gsl_matrix_float_alloc(b->getRowCnt(),b->getColCnt());
convertToFloat(bmatrix,b->matrix,b->getRowCnt(),b->getColCnt());
gsl_blas_sgemm (CblasNoTrans, CblasNoTrans, 1, cmatrix, bmatrix, 0, resmatrix);
convertFromFloat(resmatrix,res->matrix,row,b->getColCnt());
gsl_matrix_float_free(resmatrix);
gsl_matrix_float_free(cmatrix);
gsl_matrix_float_free(bmatrix);
return res;
}
int
Matrix::multiplyWithMatrix(Matrix* b)
{
if(col!=b->getRowCnt())
{
return -1;
}
gsl_matrix* res=gsl_matrix_alloc(row,b->getColCnt());
gsl_matrix_set_zero(res);
gsl_matrix_float* resmatrix=gsl_matrix_float_alloc(row,b->getColCnt());
convertToFloat(resmatrix,res,row,b->getColCnt());
gsl_matrix_float* cmatrix=gsl_matrix_float_alloc(row,col);
convertToFloat(cmatrix,matrix,row,col);
gsl_matrix_float* bmatrix=gsl_matrix_float_alloc(b->getRowCnt(),b->getColCnt());
convertToFloat(bmatrix,b->matrix,b->getRowCnt(),b->getColCnt());
gsl_blas_sgemm(CblasNoTrans, CblasNoTrans, 1, cmatrix, bmatrix, 0, resmatrix);
convertFromFloat(resmatrix,res,row,b->getColCnt());
gsl_matrix_float_free(resmatrix);
gsl_matrix_float_free(cmatrix);
gsl_matrix_float_free(bmatrix);
gsl_matrix_memcpy(matrix, res);
gsl_matrix_free(res);
return 0;
}
void
JackLayer::read(AudioBuffer &buffer)
{
for (unsigned i = 0; i < in_ringbuffers_.size(); ++i) {
const size_t incomingSamples = jack_ringbuffer_read_space(in_ringbuffers_[i]) / sizeof(captureFloatBuffer_[0]);
if (!incomingSamples)
continue;
captureFloatBuffer_.resize(incomingSamples);
buffer.resize(incomingSamples);
// write to output
const size_t from_ringbuffer = jack_ringbuffer_read_space(in_ringbuffers_[i]);
const size_t expected_bytes = std::min(incomingSamples * sizeof(captureFloatBuffer_[0]), from_ringbuffer);
// FIXME: while we have samples to write AND while we have space to write them
const size_t read_bytes = jack_ringbuffer_read(in_ringbuffers_[i],
(char *) captureFloatBuffer_.data(), expected_bytes);
if (read_bytes < expected_bytes) {
RING_WARN("Dropped %zu bytes", expected_bytes - read_bytes);
break;
}
/* Write the data one frame at a time. This is
* inefficient, but makes things simpler. */
// FIXME: this is braindead, we should write blocks of samples at a time
// convert a vector of samples from 1 channel to a float vector
convertFromFloat(captureFloatBuffer_, *buffer.getChannel(i));
}
}
// creates a radially-varying heightfield
static void
setRadial
(
byte_t * grid,
int bytesPerElement,
PHY_ScalarType type,
float phase = 0.0
)
{
btAssert(grid);
btAssert(bytesPerElement > 0);
// min/max
float period = 0.5 / s_gridSpacing;
float floor = 0.0;
float min_r = 3.0 * sqrt(s_gridSpacing);
float magnitude = 50.0 * sqrt(s_gridSpacing);
// pick a base_phase such that phase = 0 results in max height
// (this way, if you create a heightfield with phase = 0,
// you can rely on the min/max heights that result)
float base_phase = (0.5 * SIMD_PI) - (period * min_r);
phase += base_phase;
// center of grid
float cx = 0.5 * s_gridSize * s_gridSpacing;
float cy = cx; // assume square grid
byte_t * p = grid;
for (int i = 0; i < s_gridSize; ++i) {
float x = i * s_gridSpacing;
for (int j = 0; j < s_gridSize; ++j) {
float y = j * s_gridSpacing;
float dx = x - cx;
float dy = y - cy;
float r = sqrt((dx * dx) + (dy * dy));
float z = period;
if (r < min_r) {
r = min_r;
}
z = (1.0 / r) * sin(period * r + phase);
if (z > period) {
z = period;
} else if (z < -period) {
z = -period;
}
z = floor + magnitude * z;
convertFromFloat(p, z, type);
p += bytesPerElement;
}
}
}
static void
updateHeight
(
byte_t * p,
float new_val,
PHY_ScalarType type
)
{
float old_val = convertToFloat(p, type);
if (!old_val) {
convertFromFloat(p, new_val, type);
}
}
// creates a random, fractal heightfield
static void
setFractal
(
byte_t * grid,
int bytesPerElement,
PHY_ScalarType type,
int step
)
{
btAssert(grid);
btAssert(bytesPerElement > 0);
btAssert(step > 0);
btAssert(step < s_gridSize);
int newStep = step / 2;
// std::cerr << "Computing grid with step = " << step << ": before\n";
// dumpGrid(grid, bytesPerElement, type, step + 1);
// special case: starting (must set four corners)
if (s_gridSize - 1 == step) {
// pick a non-zero (possibly negative) base elevation for testing
float base = randomHeight(step / 2);
convertFromFloat(grid, base, type);
convertFromFloat(grid + step * bytesPerElement, base, type);
convertFromFloat(grid + step * s_gridSize * bytesPerElement, base, type);
convertFromFloat(grid + (step * s_gridSize + step) * bytesPerElement, base, type);
}
// determine elevation of each corner
float c00 = convertToFloat(grid, type);
float c01 = convertToFloat(grid + step * bytesPerElement, type);
float c10 = convertToFloat(grid + (step * s_gridSize) * bytesPerElement, type);
float c11 = convertToFloat(grid + (step * s_gridSize + step) * bytesPerElement, type);
// set top middle
updateHeight(grid + newStep * bytesPerElement, 0.5 * (c00 + c01) + randomHeight(step), type);
// set left middle
updateHeight(grid + (newStep * s_gridSize) * bytesPerElement, 0.5 * (c00 + c10) + randomHeight(step), type);
// set right middle
updateHeight(grid + (newStep * s_gridSize + step) * bytesPerElement, 0.5 * (c01 + c11) + randomHeight(step), type);
// set bottom middle
updateHeight(grid + (step * s_gridSize + newStep) * bytesPerElement, 0.5 * (c10 + c11) + randomHeight(step), type);
// set middle
updateHeight(grid + (newStep * s_gridSize + newStep) * bytesPerElement, 0.25 * (c00 + c01 + c10 + c11) + randomHeight(step), type);
// std::cerr << "Computing grid with step = " << step << ": after\n";
// dumpGrid(grid, bytesPerElement, type, step + 1);
// terminate?
if (newStep < 2) {
return;
}
// recurse
setFractal(grid, bytesPerElement, type, newStep);
setFractal(grid + newStep * bytesPerElement, bytesPerElement, type, newStep);
setFractal(grid + (newStep * s_gridSize) * bytesPerElement, bytesPerElement, type, newStep);
setFractal(grid + ((newStep * s_gridSize) + newStep) * bytesPerElement, bytesPerElement, type, newStep);
}
