typedef struct MySofa { /* contains data of one SOFA file */
struct MYSOFA_EASY *easy;
- int n_samples; /* length of one impulse response (IR) */
+ int ir_samples; /* length of one impulse response (IR) */
+ int n_samples; /* ir_samples to next power of 2 */
float *lir, *rir; /* IRs (time-domain) */
int max_delay;
} MySofa;
if (mysofa->DataSamplingRate.elements != 1)
return AVERROR(EINVAL);
*samplingrate = mysofa->DataSamplingRate.values[0];
- s->sofa.n_samples = mysofa->N;
+ s->sofa.ir_samples = mysofa->N;
+ s->sofa.n_samples = 1 << (32 - ff_clz(s->sofa.ir_samples));
license = mysofa_getAttribute(mysofa->attributes, (char *)"License");
if (license)
av_log(ctx, AV_LOG_INFO, "SOFA license: %s\n", license);
int *n_clippings = &td->n_clippings[jobnr];
float *ringbuffer = td->ringbuffer[jobnr];
float *temp_src = td->temp_src[jobnr];
- const int n_samples = s->sofa.n_samples; /* length of one IR */
+ const int ir_samples = s->sofa.ir_samples; /* length of one IR */
+ const int n_samples = s->sofa.n_samples;
const float *src = (const float *)in->data[0]; /* get pointer to audio input buffer */
float *dst = (float *)out->data[0]; /* get pointer to audio output buffer */
const int in_channels = s->n_conv; /* number of input channels */
/* LFE is an input channel but requires no convolution */
/* apply gain to LFE signal and add to output buffer */
*dst += *(buffer[s->lfe_channel] + wr) * s->gain_lfe;
- temp_ir += FFALIGN(n_samples, 32);
+ temp_ir += n_samples;
continue;
}
}
/* multiply signal and IR, and add up the results */
- dst[0] += s->fdsp->scalarproduct_float(temp_ir, temp_src, n_samples);
- temp_ir += FFALIGN(n_samples, 32);
+ dst[0] += s->fdsp->scalarproduct_float(temp_ir, temp_src, FFALIGN(ir_samples, 32));
+ temp_ir += n_samples;
}
/* clippings counter */
{
struct SOFAlizerContext *s = ctx->priv;
int n_samples;
+ int ir_samples;
int n_conv = s->n_conv; /* no. channels to convolve */
int n_fft;
float delay_l; /* broadband delay for each IR */
}
n_samples = s->sofa.n_samples;
+ ir_samples = s->sofa.ir_samples;
- s->data_ir[0] = av_calloc(FFALIGN(n_samples, 32), sizeof(float) * s->n_conv);
- s->data_ir[1] = av_calloc(FFALIGN(n_samples, 32), sizeof(float) * s->n_conv);
+ s->data_ir[0] = av_calloc(n_samples, sizeof(float) * s->n_conv);
+ s->data_ir[1] = av_calloc(n_samples, sizeof(float) * s->n_conv);
s->delay[0] = av_calloc(s->n_conv, sizeof(int));
s->delay[1] = av_calloc(s->n_conv, sizeof(int));
}
/* get temporary IR for L and R channel */
- data_ir_l = av_calloc(n_conv * FFALIGN(n_samples, 32), sizeof(*data_ir_l));
- data_ir_r = av_calloc(n_conv * FFALIGN(n_samples, 32), sizeof(*data_ir_r));
+ data_ir_l = av_calloc(n_conv * n_samples, sizeof(*data_ir_l));
+ data_ir_r = av_calloc(n_conv * n_samples, sizeof(*data_ir_r));
if (!data_ir_r || !data_ir_l) {
ret = AVERROR(ENOMEM);
goto fail;
}
if (s->type == TIME_DOMAIN) {
- s->temp_src[0] = av_calloc(FFALIGN(n_samples, 32), sizeof(float));
- s->temp_src[1] = av_calloc(FFALIGN(n_samples, 32), sizeof(float));
+ s->temp_src[0] = av_calloc(n_samples, sizeof(float));
+ s->temp_src[1] = av_calloc(n_samples, sizeof(float));
if (!s->temp_src[0] || !s->temp_src[1]) {
ret = AVERROR(ENOMEM);
goto fail;
/* get id of IR closest to desired position */
mysofa_getfilter_float(s->sofa.easy, coordinates[0], coordinates[1], coordinates[2],
- data_ir_l + FFALIGN(n_samples, 32) * i,
- data_ir_r + FFALIGN(n_samples, 32) * i,
+ data_ir_l + n_samples * i,
+ data_ir_r + n_samples * i,
&delay_l, &delay_r);
s->delay[0][i] = delay_l * sample_rate;
/* get size of ringbuffer (longest IR plus max. delay) */
/* then choose next power of 2 for performance optimization */
- n_current = s->sofa.n_samples + s->sofa.max_delay;
+ n_current = n_samples + s->sofa.max_delay;
/* length of longest IR plus max. delay */
n_max = FFMAX(n_max, n_current);
for (i = 0; i < s->n_conv; i++) {
float *lir, *rir;
- offset = i * FFALIGN(n_samples, 32); /* no. samples already written */
+ offset = i * n_samples; /* no. samples already written */
lir = data_ir_l + offset;
rir = data_ir_r + offset;
if (s->type == TIME_DOMAIN) {
- for (j = 0; j < n_samples; j++) {
+ for (j = 0; j < ir_samples; j++) {
/* load reversed IRs of the specified source position
* sample-by-sample for left and right ear; and apply gain */
- s->data_ir[0][offset + j] = lir[n_samples - 1 - j] * gain_lin;
- s->data_ir[1][offset + j] = rir[n_samples - 1 - j] * gain_lin;
+ s->data_ir[0][offset + j] = lir[ir_samples - 1 - j] * gain_lin;
+ s->data_ir[1][offset + j] = rir[ir_samples - 1 - j] * gain_lin;
}
} else {
memset(fft_in_l, 0, n_fft * sizeof(*fft_in_l));
memset(fft_in_r, 0, n_fft * sizeof(*fft_in_r));
offset = i * n_fft; /* no. samples already written */
- for (j = 0; j < n_samples; j++) {
+ for (j = 0; j < ir_samples; j++) {
/* load non-reversed IRs of the specified source position
* sample-by-sample and apply gain,
* L channel is loaded to real part, R channel to imag part,