void Ambix_directional_loudnessAudioProcessor::processBlock (AudioSampleBuffer& buffer, MidiBuffer& midiMessages)
{
_Sh_transf = Sh_transf; // buffer old values
calcParams(); // calc new transformation matrix
int NumSamples = buffer.getNumSamples();
output_buffer.setSize(buffer.getNumChannels(), NumSamples);
output_buffer.clear();
for (int out = 0; out < std::min(AMBI_CHANNELS,getNumOutputChannels()); out++)
{
for (int in = 0; in < std::min(AMBI_CHANNELS,getNumInputChannels()); in++)
{
if (_Sh_transf(in, out) != 0.f || Sh_transf(in, out) != 0.f)
{
if (_Sh_transf(in, out) == Sh_transf(in, out))
{
output_buffer.addFrom(out, 0, buffer, in, 0, NumSamples, (float)Sh_transf(in, out));
} else {
output_buffer.addFromWithRamp(out, 0, buffer.getReadPointer(in), NumSamples, (float)_Sh_transf(in, out), (float)Sh_transf(in, out));
}
}
}
}
buffer = output_buffer;
}
bool FloppyImageSt::open(const char *fileName)
{
if(!FloppyImage::open(fileName))
return false;
if(!loadImageIntoMemory()) { // load the whole image in memory to avoid later disk access
close();
return false;
}
calcParams(); // calculate the params of this floppy
Debug::out(LOG_DEBUG, "ST Image opened: %s", fileName);
Debug::out(LOG_DEBUG, "ST Image params - %d tracks, %d sides, %d sectors per track", params.tracksNo, params.sidesNo, params.sectorsPerTrack);
return true;
}
void Ambix_mirrorAudioProcessor::processBlock (AudioSampleBuffer& buffer, MidiBuffer& midiMessages)
{
int NumSamples = buffer.getNumSamples();
// save old parameters for interpolation (start ramp)
_gain_factors = gain_factors;
calcParams();
for (int acn = 0; acn < getTotalNumInputChannels(); acn++)
{
buffer.applyGainRamp(acn, 0, NumSamples, _gain_factors.getUnchecked(acn), gain_factors.getUnchecked(acn));
}
}
void Ambix_rotatorAudioProcessor::processBlock (AudioSampleBuffer& buffer, MidiBuffer& midiMessages)
{
if (_new_params)
{
_Sh_transf = Sh_transf; // buffer old values
calcParams(); // calc new transformation matrix
}
int NumSamples = buffer.getNumSamples();
output_buffer.setSize(buffer.getNumChannels(), NumSamples);
output_buffer.clear();
int num_out_ch = jmin(AMBI_CHANNELS,getTotalNumOutputChannels());
int num_in_ch = jmin(AMBI_CHANNELS,getTotalNumInputChannels());
// 0th channel is invariant!
output_buffer.addFrom(0, 0, buffer, 0, 0, NumSamples);
for (int out = 1; out < num_out_ch; out++)
{
int n = (int)sqrtf(out);// order
int in_start = n*n;
int in_end = jmin((n+1)*(n+1), num_in_ch);
for (int in = in_start; in < in_end; in++)
{
if (!_new_params)
{
if (Sh_transf(in, out) != 0.f)
output_buffer.addFrom(out, 0, buffer, in, 0, NumSamples, (float)Sh_transf(in, out));
} else {
if (_Sh_transf(in, out) != 0.f || Sh_transf(in, out) != 0.f)
output_buffer.addFromWithRamp(out, 0, buffer.getReadPointer(in), NumSamples, (float)_Sh_transf(in, out), (float)Sh_transf(in, out));
}
}
}
if (_new_params)
_new_params = false;
buffer = output_buffer;
}
twoLinkArm::ArmParams twoLinkArm::calcParams(double weight, double height, point x0)
{
double h=0.0254*height;
return calcParams(weight,.186*h,.1964*h,x0);
}
void Ambix_wideningAudioProcessor::processBlock (AudioSampleBuffer& buffer, MidiBuffer& midiMessages)
{
// backup old coefficients
memcpy(_cos_coeffs, cos_coeffs, sizeof(float)*AMBI_ORDER*(BESSEL_APPR+1));
memcpy(_sin_coeffs, sin_coeffs, sizeof(float)*AMBI_ORDER*(BESSEL_APPR+1));
// calc new coefficients
calcParams();
//////////////////////
// write to the buffer
if (_buf_write_pos + buffer.getNumSamples() < _buf_size)
{
for (int ch = 0; ch < buffer.getNumChannels(); ch++)
{
// copy straight into buffer
ring_buffer.copyFrom(ch, _buf_write_pos, buffer, ch, 0, buffer.getNumSamples());
}
// update write position
_buf_write_pos += buffer.getNumSamples();
} else { // if buffer reaches end
int samples_to_write1 = _buf_size - _buf_write_pos;
int samples_to_write2 = buffer.getNumSamples() - samples_to_write1;
// std::cout << "spl_write1: " << samples_to_write1 << " spl_write2: " << samples_to_write2 << std::endl;
for (int ch = 0; ch < buffer.getNumChannels(); ch++)
{
// copy until end
ring_buffer.copyFrom(ch, _buf_write_pos, buffer, ch, 0, samples_to_write1);
// start copy to front
ring_buffer.copyFrom(ch, 0, buffer, ch, samples_to_write1, samples_to_write2);
}
// update write position
_buf_write_pos = samples_to_write2;
}
// String debug = String::empty;
/////////////////////////
// compute read positions (tap delay times)
// Q is computed in calcParams() (SampleRate dependent)
for (int i=0; i < BESSEL_APPR*2+1; i++) {
_buf_read_pos[i] = _buf_write_pos - i*Q - buffer.getNumSamples();
if (_buf_read_pos[i] < 0)
_buf_read_pos[i] = _buf_size + _buf_read_pos[i]; // -1 ?
// debug << _buf_read_pos[i] << " ";
}
// std::cout << "read pos: " << debug << std::endl;
/////////////////////////
// do the rotation
buffer.clear();
int fir_length = 2*BESSEL_APPR+1;
if (single_sided)
fir_length = BESSEL_APPR+1;
for (int acn_out = 0; acn_out < getTotalNumOutputChannels(); acn_out++) // iterate over output channels
{
int l_out = 0;
int m_out = 0;
ACNtoLM(acn_out, l_out, m_out);
for (int acn_in = 0; acn_in < getTotalNumInputChannels(); acn_in++) // iterate over input channels
{
int l_in=0; // degree 0, 1, 2, 3, 4, ...
int m_in=0; // order ..., -2, -1, 0 , 1, 2, ...
ACNtoLM(acn_in, l_in, m_in);
if (abs(m_out) == abs (m_in) && l_in == l_out) { // if degree and order match do something
int pos_index = 0; // index of _buf_read_pos
///////////////
// pass through terms (z symmetric, m=0)
if (m_out == 0 && m_in == 0) {
if (!single_sided)
pos_index = BESSEL_APPR;
// read from buffer
if (_buf_read_pos[pos_index] + buffer.getNumSamples() < _buf_size)
{
buffer.copyFrom(acn_out, 0, ring_buffer, acn_out, _buf_read_pos[pos_index], buffer.getNumSamples());
} else {
int samples_to_read1 = _buf_size - _buf_read_pos[pos_index];
int samples_to_read2 = buffer.getNumSamples() - samples_to_read1;
// copy until end
buffer.copyFrom(acn_out, 0, ring_buffer, acn_out, _buf_read_pos[pos_index], samples_to_read1);
// start copy from front
buffer.copyFrom(acn_out, samples_to_read1, ring_buffer, acn_out, 0, samples_to_read2);
}
}
///////////////
// cosine terms
else if (m_in < 0 && m_out < 0) // cosine
{
for (int i=0; i < fir_length; i++) { // ITERATE BESSEL APPR
int j = abs(i-BESSEL_APPR);
if (single_sided)
j=i;
float _coeff = _cos_coeffs[l_in-1][j];
float coeff = cos_coeffs[l_in-1][j];
if (coeff != 0.f) { // skip zero coefficients
// read from buffer
if (_buf_read_pos[i] + buffer.getNumSamples() < _buf_size)
{
if (_coeff != coeff) // interpolate?
buffer.addFromWithRamp(acn_out, 0, ring_buffer.getReadPointer(acn_in, _buf_read_pos[i]), buffer.getNumSamples(), _coeff, coeff);
else
buffer.addFrom(acn_out, 0, ring_buffer, acn_in, _buf_read_pos[i], buffer.getNumSamples(), coeff);
} else {
int samples_to_read1 = _buf_size - _buf_read_pos[i];
int samples_to_read2 = buffer.getNumSamples() - samples_to_read1;
// copy until end
if (_coeff != coeff) // interpolate?
buffer.addFromWithRamp(acn_out, 0, ring_buffer.getReadPointer(acn_in, _buf_read_pos[i]), samples_to_read1, _coeff, coeff);
else
buffer.addFrom(acn_out, 0, ring_buffer, acn_in, _buf_read_pos[i], samples_to_read1, coeff);
// start copy from front
if (_coeff != coeff) // interpolate?
buffer.addFromWithRamp(acn_out, samples_to_read1, ring_buffer.getReadPointer(acn_in, 0), samples_to_read2, _coeff, coeff);
else
buffer.addFrom(acn_out, samples_to_read1, ring_buffer, acn_in, 0, samples_to_read2, coeff);
}
}
} // end iterate BESSEL_APPR
}
///////////////
// -sine terms
else if (m_in < 0 && m_out > 0) // -sine
{
for (int i=0; i < fir_length; i++) { // ITERATE BESSEL APPR
int j = abs(i-BESSEL_APPR);
if (single_sided)
j=i;
float _coeff = -_sin_coeffs[l_in-1][j];
float coeff = -sin_coeffs[l_in-1][j];
if (coeff != 0.f) { // skip zero coefficients
// read from buffer
if (_buf_read_pos[i] + buffer.getNumSamples() < _buf_size)
{
if (_coeff != coeff) // interpolate?
buffer.addFromWithRamp(acn_out, 0, ring_buffer.getReadPointer(acn_in, _buf_read_pos[i]), buffer.getNumSamples(), _coeff, coeff);
else
buffer.addFrom(acn_out, 0, ring_buffer, acn_in, _buf_read_pos[i], buffer.getNumSamples(), coeff);
} else {
int samples_to_read1 = _buf_size - _buf_read_pos[i];
int samples_to_read2 = buffer.getNumSamples() - samples_to_read1;
// copy until end
if (_coeff != coeff) // interpolate?
buffer.addFromWithRamp(acn_out, 0, ring_buffer.getReadPointer(acn_in, _buf_read_pos[i]), samples_to_read1, _coeff, coeff);
else
buffer.addFrom(acn_out, 0, ring_buffer, acn_in, _buf_read_pos[i], samples_to_read1, coeff);
// start copy from front
if (_coeff != coeff) // interpolate?
buffer.addFromWithRamp(acn_out, samples_to_read1, ring_buffer.getReadPointer(acn_in, 0), samples_to_read2, _coeff, coeff);
else
buffer.addFrom(acn_out, samples_to_read1, ring_buffer, acn_in, 0, samples_to_read2, coeff);
}
}
} // end iterate BESSEL_APPR
}
///////////////
// cosine terms
else if (m_in > 0 && m_out > 0) // cosine
{
for (int i=0; i < fir_length; i++) { // ITERATE BESSEL APPR
int j = abs(i-BESSEL_APPR);
if (single_sided)
j=i;
float _coeff = _cos_coeffs[l_in-1][j];
float coeff = cos_coeffs[l_in-1][j];
if (coeff != 0.f) { // skip zero coefficients
// read from buffer
if (_buf_read_pos[i] + buffer.getNumSamples() < _buf_size)
{
if (_coeff != coeff) // interpolate?
buffer.addFromWithRamp(acn_out, 0, ring_buffer.getReadPointer(acn_in, _buf_read_pos[i]), buffer.getNumSamples(), _coeff, coeff);
else
buffer.addFrom(acn_out, 0, ring_buffer, acn_in, _buf_read_pos[i], buffer.getNumSamples(), coeff);
} else {
int samples_to_read1 = _buf_size - _buf_read_pos[i];
int samples_to_read2 = buffer.getNumSamples() - samples_to_read1;
// copy until end
if (_coeff != coeff) // interpolate?
buffer.addFromWithRamp(acn_out, 0, ring_buffer.getReadPointer(acn_in, _buf_read_pos[i]), samples_to_read1, _coeff, coeff);
else
buffer.addFrom(acn_out, 0, ring_buffer, acn_in, _buf_read_pos[i], samples_to_read1, coeff);
// start copy from front
if (_coeff != coeff) // interpolate?
buffer.addFromWithRamp(acn_out, samples_to_read1, ring_buffer.getReadPointer(acn_in, 0), samples_to_read2, _coeff, coeff);
else
buffer.addFrom(acn_out, samples_to_read1, ring_buffer, acn_in, 0, samples_to_read2, coeff);
}
}
} // end iterate BESSEL_APPR
}
///////////////
// sine terms
else if (m_in > 0 && m_out < 0) // sine
{
for (int i=0; i < fir_length; i++) { // ITERATE BESSEL APPR
int j = abs(i-BESSEL_APPR);
if (single_sided)
j=i;
float _coeff = _sin_coeffs[l_in-1][j];
float coeff = sin_coeffs[l_in-1][j];
if (coeff != 0.f) { // skip zero coefficients
// read from buffer
if (_buf_read_pos[i] + buffer.getNumSamples() < _buf_size)
{
if (_coeff != coeff) // interpolate?
buffer.addFromWithRamp(acn_out, 0, ring_buffer.getReadPointer(acn_in, _buf_read_pos[i]), buffer.getNumSamples(), _coeff, coeff);
else
buffer.addFrom(acn_out, 0, ring_buffer, acn_in, _buf_read_pos[i], buffer.getNumSamples(), coeff);
} else {
int samples_to_read1 = _buf_size - _buf_read_pos[i];
int samples_to_read2 = buffer.getNumSamples() - samples_to_read1;
// copy until end
if (_coeff != coeff) // interpolate?
buffer.addFromWithRamp(acn_out, 0, ring_buffer.getReadPointer(acn_in, _buf_read_pos[i]), samples_to_read1, _coeff, coeff);
else
buffer.addFrom(acn_out, 0, ring_buffer, acn_in, _buf_read_pos[i], samples_to_read1, coeff);
// start copy from front
if (_coeff != coeff) // interpolate?
buffer.addFromWithRamp(acn_out, samples_to_read1, ring_buffer.getReadPointer(acn_in, 0), samples_to_read2, _coeff, coeff);
else
buffer.addFrom(acn_out, samples_to_read1, ring_buffer, acn_in, 0, samples_to_read2, coeff);
}
}
} // end iterate BESSEL_APPR
}
}
}
}
}
//==============================================================================
void Ambix_wideningAudioProcessor::prepareToPlay (double sampleRate, int samplesPerBlock)
{
calcParams();
ring_buffer.clear();
}
void Ambix_rotator_zAudioProcessor::processBlock (AudioSampleBuffer& buffer, MidiBuffer& midiMessages)
{
int NumSamples = buffer.getNumSamples();
// resize buffer if necessary
output_buffer.setSize((std::max)(getNumOutputChannels(), getNumInputChannels()), NumSamples);
// clear output buffer
output_buffer.clear();
// save old parameters for interpolation (start ramp)
_cos_z = cos_z;
_sin_z = sin_z;
// calculate new parameters (end ramp)
calcParams();
// iterate over input and output channels for z axis rotation
// this should work for arbitary ambisonics orders!
for (int acn_out = 0; acn_out < getNumOutputChannels(); acn_out++)
{
int l_out = 0;
int m_out = 0;
ACNtoLM(acn_out, l_out, m_out);
for (int acn_in = 0; acn_in < getNumInputChannels(); acn_in++)
{
int l_in=0; // degree 0, 1, 2, 3, 4, ......
int m_in=0; // order ...., -2, -1, 0 , 1, 2, ...
ACNtoLM(acn_in, l_in, m_in);
if (abs(m_out) == abs (m_in) && l_in == l_out) { // if degree and order match do something
if (m_out == 0 && m_in == 0) {
// gain 1 -> no interpolation needed
output_buffer.copyFrom(acn_out, 0, buffer, acn_in, 0, NumSamples);
}
else if (m_in < 0 && m_out < 0)
{
output_buffer.addFromWithRamp(acn_out, 0, buffer.getReadPointer(acn_in), NumSamples, _cos_z[-m_out], cos_z[-m_out]); // interpolation with ramp done by juce
}
else if (m_in < 0 && m_out > 0)
{
output_buffer.addFromWithRamp(acn_out, 0, buffer.getReadPointer(acn_in), NumSamples, -_sin_z[m_out], -sin_z[m_out]);
}
else if (m_in > 0 && m_out > 0)
{
output_buffer.addFromWithRamp(acn_out, 0, buffer.getReadPointer(acn_in), NumSamples, _cos_z[m_out], cos_z[m_out]);
}
else if (m_in > 0 && m_out < 0)
{
output_buffer.addFromWithRamp(acn_out, 0, buffer.getReadPointer(acn_in), NumSamples, _sin_z[m_in], sin_z[m_in]);
}
}
}
}
// return output buffer
buffer = output_buffer;
}
