1 /* Copyright (c) 2013 The Chromium OS Authors. All rights reserved. 2 * Use of this source code is governed by a BSD-style license that can be 3 * found in the LICENSE file. 4 */ 5 6 /* Copyright (C) 2011 Google Inc. All rights reserved. 7 * Use of this source code is governed by a BSD-style license that can be 8 * found in the LICENSE.WEBKIT file. 9 */ 10 11 #include <assert.h> 12 #include <stdlib.h> 13 14 #include "drc.h" 15 #include "drc_math.h" 16 17 static void set_default_parameters(struct drc *drc); 18 static void init_data_buffer(struct drc *drc); 19 static void init_emphasis_eq(struct drc *drc); 20 static void init_crossover(struct drc *drc); 21 static void init_kernel(struct drc *drc); 22 static void free_data_buffer(struct drc *drc); 23 static void free_emphasis_eq(struct drc *drc); 24 static void free_kernel(struct drc *drc); 25 drc_new(float sample_rate)26 struct drc *drc_new(float sample_rate) 27 { 28 struct drc *drc = (struct drc *)calloc(1, sizeof(struct drc)); 29 drc->sample_rate = sample_rate; 30 set_default_parameters(drc); 31 return drc; 32 } 33 drc_init(struct drc * drc)34 void drc_init(struct drc *drc) 35 { 36 init_data_buffer(drc); 37 init_emphasis_eq(drc); 38 init_crossover(drc); 39 init_kernel(drc); 40 } 41 drc_free(struct drc * drc)42 void drc_free(struct drc *drc) 43 { 44 free_kernel(drc); 45 free_emphasis_eq(drc); 46 free_data_buffer(drc); 47 free(drc); 48 } 49 50 /* Allocates temporary buffers used during drc_process(). */ init_data_buffer(struct drc * drc)51 static void init_data_buffer(struct drc *drc) 52 { 53 int i; 54 size_t size = sizeof(float) * DRC_PROCESS_MAX_FRAMES; 55 56 for (i = 0; i < DRC_NUM_CHANNELS; i++) { 57 drc->data1[i] = (float *)calloc(1, size); 58 drc->data2[i] = (float *)calloc(1, size); 59 } 60 } 61 62 /* Frees temporary buffers */ free_data_buffer(struct drc * drc)63 static void free_data_buffer(struct drc *drc) 64 { 65 int i; 66 67 for (i = 0; i < DRC_NUM_CHANNELS; i++) { 68 free(drc->data1[i]); 69 free(drc->data2[i]); 70 } 71 } 72 drc_set_param(struct drc * drc,int index,unsigned paramID,float value)73 void drc_set_param(struct drc *drc, int index, unsigned paramID, float value) 74 { 75 assert(paramID < PARAM_LAST); 76 if (paramID < PARAM_LAST) 77 drc->parameters[index][paramID] = value; 78 } 79 drc_get_param(struct drc * drc,int index,unsigned paramID)80 static float drc_get_param(struct drc *drc, int index, unsigned paramID) 81 { 82 assert(paramID < PARAM_LAST); 83 return drc->parameters[index][paramID]; 84 } 85 86 /* Initializes parameters to default values. */ set_default_parameters(struct drc * drc)87 static void set_default_parameters(struct drc *drc) 88 { 89 float nyquist = drc->sample_rate / 2; 90 int i; 91 92 for (i = 0; i < DRC_NUM_KERNELS; i++) { 93 float *param = drc->parameters[i]; 94 param[PARAM_THRESHOLD] = -24; /* dB */ 95 param[PARAM_KNEE] = 30; /* dB */ 96 param[PARAM_RATIO] = 12; /* unit-less */ 97 param[PARAM_ATTACK] = 0.003f; /* seconds */ 98 param[PARAM_RELEASE] = 0.250f; /* seconds */ 99 param[PARAM_PRE_DELAY] = DRC_DEFAULT_PRE_DELAY; /* seconds */ 100 101 /* Release zone values 0 -> 1. */ 102 param[PARAM_RELEASE_ZONE1] = 0.09f; 103 param[PARAM_RELEASE_ZONE2] = 0.16f; 104 param[PARAM_RELEASE_ZONE3] = 0.42f; 105 param[PARAM_RELEASE_ZONE4] = 0.98f; 106 107 /* This is effectively a master volume on the compressed 108 * signal */ 109 param[PARAM_POST_GAIN] = 0; /* dB */ 110 param[PARAM_ENABLED] = 0; 111 } 112 113 drc->parameters[0][PARAM_CROSSOVER_LOWER_FREQ] = 0; 114 drc->parameters[1][PARAM_CROSSOVER_LOWER_FREQ] = 200 / nyquist; 115 drc->parameters[2][PARAM_CROSSOVER_LOWER_FREQ] = 2000 / nyquist; 116 117 /* These parameters has only one copy */ 118 drc->parameters[0][PARAM_FILTER_STAGE_GAIN] = 4.4f; /* dB */ 119 drc->parameters[0][PARAM_FILTER_STAGE_RATIO] = 2; 120 drc->parameters[0][PARAM_FILTER_ANCHOR] = 15000 / nyquist; 121 } 122 123 /* Finds the zero and pole for one stage of the emphasis filter */ emphasis_stage_roots(float gain,float normalized_frequency,float * zero,float * pole)124 static void emphasis_stage_roots(float gain, float normalized_frequency, 125 float *zero, float *pole) 126 { 127 float gk = 1 - gain / 20; 128 float f1 = normalized_frequency * gk; 129 float f2 = normalized_frequency / gk; 130 *zero = expf(-f1 * PI_FLOAT); 131 *pole = expf(-f2 * PI_FLOAT); 132 } 133 134 /* Calculates the biquad coefficients for two emphasis stages. */ emphasis_stage_pair_biquads(float gain,float f1,float f2,struct biquad * emphasis,struct biquad * deemphasis)135 static void emphasis_stage_pair_biquads(float gain, float f1, float f2, 136 struct biquad *emphasis, 137 struct biquad *deemphasis) 138 { 139 float z1, p1; 140 float z2, p2; 141 142 emphasis_stage_roots(gain, f1, &z1, &p1); 143 emphasis_stage_roots(gain, f2, &z2, &p2); 144 145 float b0 = 1; 146 float b1 = -(z1 + z2); 147 float b2 = z1 * z2; 148 float a0 = 1; 149 float a1 = -(p1 + p2); 150 float a2 = p1 * p2; 151 152 /* Gain compensation to make 0dB @ 0Hz */ 153 float alpha = (a0 + a1 + a2) / (b0 + b1 + b2); 154 155 emphasis->b0 = b0 * alpha; 156 emphasis->b1 = b1 * alpha; 157 emphasis->b2 = b2 * alpha; 158 emphasis->a1 = a1; 159 emphasis->a2 = a2; 160 161 float beta = (b0 + b1 + b2) / (a0 + a1 + a2); 162 163 deemphasis->b0 = a0 * beta; 164 deemphasis->b1 = a1 * beta; 165 deemphasis->b2 = a2 * beta; 166 deemphasis->a1 = b1; 167 deemphasis->a2 = b2; 168 } 169 170 /* Initializes the emphasis and deemphasis filter */ init_emphasis_eq(struct drc * drc)171 static void init_emphasis_eq(struct drc *drc) 172 { 173 struct biquad e = { 0.f, 0.f, 0.f, 0.f, 0.f, 0.f, 0.f, 0.f, 0.f }; 174 struct biquad d = { 0.f, 0.f, 0.f, 0.f, 0.f, 0.f, 0.f, 0.f, 0.f }; 175 int i, j; 176 177 float stage_gain = drc_get_param(drc, 0, PARAM_FILTER_STAGE_GAIN); 178 float stage_ratio = drc_get_param(drc, 0, PARAM_FILTER_STAGE_RATIO); 179 float anchor_freq = drc_get_param(drc, 0, PARAM_FILTER_ANCHOR); 180 181 drc->emphasis_eq = eq2_new(); 182 drc->deemphasis_eq = eq2_new(); 183 184 for (i = 0; i < 2; i++) { 185 emphasis_stage_pair_biquads(stage_gain, anchor_freq, 186 anchor_freq / stage_ratio, 187 &e, &d); 188 for (j = 0; j < 2; j++) { 189 eq2_append_biquad_direct(drc->emphasis_eq, j, &e); 190 eq2_append_biquad_direct(drc->deemphasis_eq, j, &d); 191 } 192 anchor_freq /= (stage_ratio * stage_ratio); 193 } 194 } 195 196 /* Frees the emphasis and deemphasis filter */ free_emphasis_eq(struct drc * drc)197 static void free_emphasis_eq(struct drc *drc) 198 { 199 eq2_free(drc->emphasis_eq); 200 eq2_free(drc->deemphasis_eq); 201 } 202 203 /* Initializes the crossover filter */ init_crossover(struct drc * drc)204 static void init_crossover(struct drc *drc) 205 { 206 float freq1 = drc->parameters[1][PARAM_CROSSOVER_LOWER_FREQ]; 207 float freq2 = drc->parameters[2][PARAM_CROSSOVER_LOWER_FREQ]; 208 209 crossover2_init(&drc->xo2, freq1, freq2); 210 } 211 212 /* Initializes the compressor kernels */ init_kernel(struct drc * drc)213 static void init_kernel(struct drc *drc) 214 { 215 int i; 216 217 for (i = 0; i < DRC_NUM_KERNELS; i++) { 218 dk_init(&drc->kernel[i], drc->sample_rate); 219 220 float db_threshold = drc_get_param(drc, i, PARAM_THRESHOLD); 221 float db_knee = drc_get_param(drc, i, PARAM_KNEE); 222 float ratio = drc_get_param(drc, i, PARAM_RATIO); 223 float attack_time = drc_get_param(drc, i, PARAM_ATTACK); 224 float release_time = drc_get_param(drc, i, PARAM_RELEASE); 225 float pre_delay_time = drc_get_param(drc, i, PARAM_PRE_DELAY); 226 float releaseZone1 = drc_get_param(drc, i, PARAM_RELEASE_ZONE1); 227 float releaseZone2 = drc_get_param(drc, i, PARAM_RELEASE_ZONE2); 228 float releaseZone3 = drc_get_param(drc, i, PARAM_RELEASE_ZONE3); 229 float releaseZone4 = drc_get_param(drc, i, PARAM_RELEASE_ZONE4); 230 float db_post_gain = drc_get_param(drc, i, PARAM_POST_GAIN); 231 int enabled = drc_get_param(drc, i, PARAM_ENABLED); 232 233 dk_set_parameters(&drc->kernel[i], 234 db_threshold, 235 db_knee, 236 ratio, 237 attack_time, 238 release_time, 239 pre_delay_time, 240 db_post_gain, 241 releaseZone1, 242 releaseZone2, 243 releaseZone3, 244 releaseZone4 245 ); 246 247 dk_set_enabled(&drc->kernel[i], enabled); 248 } 249 } 250 251 /* Frees the compressor kernels */ free_kernel(struct drc * drc)252 static void free_kernel(struct drc *drc) 253 { 254 int i; 255 for (i = 0; i < DRC_NUM_KERNELS; i++) 256 dk_free(&drc->kernel[i]); 257 } 258 259 // Note gcc 4.9+ with -O2 on aarch64 produces vectorized version of C 260 // that is comparable performance, but twice as large. -O1 and -Os produce 261 // small but slower code (4x slower than Neon). 262 #if defined(__aarch64__) sum3(float * data,const float * data1,const float * data2,int n)263 static void sum3(float *data, const float *data1, const float *data2, int n) 264 { 265 int count = n / 4; 266 int i; 267 268 if (count) { 269 __asm__ __volatile( 270 "1: \n" 271 "ld1 {v0.4s}, [%[data1]], #16 \n" 272 "ld1 {v1.4s}, [%[data2]], #16 \n" 273 "ld1 {v2.4s}, [%[data]] \n" 274 "fadd v0.4s, v0.4s, v1.4s \n" 275 "fadd v0.4s, v0.4s, v2.4s \n" 276 "st1 {v0.4s}, [%[data]], #16 \n" 277 "subs %w[count], %w[count], #1 \n" 278 "b.ne 1b \n" 279 : /* output */ 280 [data]"+r"(data), 281 [data1]"+r"(data1), 282 [data2]"+r"(data2), 283 [count]"+r"(count) 284 : /* input */ 285 : /* clobber */ 286 "v0", "v1", "v2", "memory", "cc" 287 ); 288 } 289 290 n &= 3; 291 for (i = 0; i < n; i++) 292 data[i] += data1[i] + data2[i]; 293 } 294 #elif defined(__ARM_NEON__) sum3(float * data,const float * data1,const float * data2,int n)295 static void sum3(float *data, const float *data1, const float *data2, int n) 296 { 297 int count = n / 4; 298 int i; 299 300 if (count) { 301 __asm__ __volatile( 302 "1: \n" 303 "vld1.32 {q0}, [%[data1]]! \n" 304 "vld1.32 {q1}, [%[data2]]! \n" 305 "vld1.32 {q2}, [%[data]] \n" 306 "vadd.f32 q0, q0, q1 \n" 307 "vadd.f32 q0, q0, q2 \n" 308 "vst1.32 {q0}, [%[data]]! \n" 309 "subs %[count], #1 \n" 310 "bne 1b \n" 311 : /* output */ 312 [data]"+r"(data), 313 [data1]"+r"(data1), 314 [data2]"+r"(data2), 315 [count]"+r"(count) 316 : /* input */ 317 : /* clobber */ 318 "q0", "q1", "q2", "memory", "cc" 319 ); 320 } 321 322 n &= 3; 323 for (i = 0; i < n; i++) 324 data[i] += data1[i] + data2[i]; 325 } 326 #elif defined(__SSE3__) 327 #include <emmintrin.h> sum3(float * data,const float * data1,const float * data2,int n)328 static void sum3(float *data, const float *data1, const float *data2, int n) 329 { 330 __m128 x, y, z; 331 int count = n / 4; 332 int i; 333 334 if (count) { 335 __asm__ __volatile( 336 "1: \n" 337 "lddqu (%[data1]), %[x] \n" 338 "lddqu (%[data2]), %[y] \n" 339 "lddqu (%[data]), %[z] \n" 340 "addps %[x], %[y] \n" 341 "addps %[y], %[z] \n" 342 "movdqu %[z], (%[data]) \n" 343 "add $16, %[data1] \n" 344 "add $16, %[data2] \n" 345 "add $16, %[data] \n" 346 "sub $1, %[count] \n" 347 "jne 1b \n" 348 : /* output */ 349 [data]"+r"(data), 350 [data1]"+r"(data1), 351 [data2]"+r"(data2), 352 [count]"+r"(count), 353 [x]"=x"(x), 354 [y]"=x"(y), 355 [z]"=x"(z) 356 : /* input */ 357 : /* clobber */ 358 "memory", "cc" 359 ); 360 } 361 362 n &= 3; 363 for (i = 0; i < n; i++) 364 data[i] += data1[i] + data2[i]; 365 } 366 #else sum3(float * data,const float * data1,const float * data2,int n)367 static void sum3(float *data, const float *data1, const float *data2, int n) 368 { 369 int i; 370 for (i = 0; i < n; i++) 371 data[i] += data1[i] + data2[i]; 372 } 373 #endif 374 drc_process(struct drc * drc,float ** data,int frames)375 void drc_process(struct drc *drc, float **data, int frames) 376 { 377 int i; 378 float **data1 = drc->data1; 379 float **data2 = drc->data2; 380 381 /* Apply pre-emphasis filter if it is not disabled. */ 382 if (!drc->emphasis_disabled) 383 eq2_process(drc->emphasis_eq, data[0], data[1], frames); 384 385 /* Crossover */ 386 crossover2_process(&drc->xo2, frames, data[0], data[1], 387 data1[0], data1[1], data2[0], data2[1]); 388 389 /* Apply compression to each band of the signal. The processing is 390 * performed in place. 391 */ 392 dk_process(&drc->kernel[0], data, frames); 393 dk_process(&drc->kernel[1], data1, frames); 394 dk_process(&drc->kernel[2], data2, frames); 395 396 /* Sum the three bands of signal */ 397 for (i = 0; i < DRC_NUM_CHANNELS; i++) 398 sum3(data[i], data1[i], data2[i], frames); 399 400 /* Apply de-emphasis filter if emphasis is not disabled. */ 401 if (!drc->emphasis_disabled) 402 eq2_process(drc->deemphasis_eq, data[0], data[1], frames); 403 } 404