kode54
/
cog
2
1
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

HRIR Filter: Replace deprecated Intel-only code 

_mm_malloc and _mm_free are apparently based on intrinsic functions,
and only exist on Intel or older macOS targets. So removing them in
favor of posix_memalign.

Signed-off-by: Christopher Snowhill <kode54@gmail.com>
CQTexperiment
Christopher Snowhill 2022-02-08 00:13:41 -08:00
parent f4f4f80f64
commit 0763b28f38
1 changed files with 53 additions and 44 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

97
Audio/Chain/HeadphoneFilter.m
View File

@ -10,12 +10,21 @@
#import "AudioDecoder.h" #import "AudioDecoder.h"
#import "AudioSource.h" #import "AudioSource.h"
#import <mm_malloc.h>
#import <soxr.h> #import <soxr.h>
#import <stdlib.h>
#import "lpc.h" #import "lpc.h"
#import "util.h" #import "util.h"
// Apparently _mm_malloc is Intel-only on newer macOS targets, so use supported posix_memalign
static void *_memalign_malloc(size_t size, size_t align) {
void *ret = NULL;
if(posix_memalign(&ret, align, size) != 0) {
return NULL;
}
return ret;
}
@implementation HeadphoneFilter @implementation HeadphoneFilter
enum { enum {
@ -264,7 +273,7 @@ static const int8_t speakers_to_hesuvi_14[11][2] = {
} }
fftSize = 2 << pow; fftSize = 2 << pow;
float *deinterleavedImpulseBuffer = (float *)_mm_malloc(fftSize * sizeof(float) * (impulseChannels + 1), 16); float *deinterleavedImpulseBuffer = (float *)_memalign_malloc(fftSize * sizeof(float) * (impulseChannels + 1), 16);
if(!deinterleavedImpulseBuffer) { if(!deinterleavedImpulseBuffer) {
free(impulseBuffer); free(impulseBuffer);
return nil; return nil;
@ -287,54 +296,54 @@ static const int8_t speakers_to_hesuvi_14[11][2] = {
fftSetup = vDSP_create_fftsetup(log2n, FFT_RADIX2); fftSetup = vDSP_create_fftsetup(log2n, FFT_RADIX2);
if(!fftSetup) { if(!fftSetup) {
_mm_free(deinterleavedImpulseBuffer); free(deinterleavedImpulseBuffer);
return nil; return nil;
} }
paddedSignal = (float *)_mm_malloc(sizeof(float) * paddedBufferSize, 16); paddedSignal = (float *)_memalign_malloc(sizeof(float) * paddedBufferSize, 16);
if(!paddedSignal) { if(!paddedSignal) {
_mm_free(deinterleavedImpulseBuffer); free(deinterleavedImpulseBuffer);
return nil; return nil;
} }
signal_fft.realp = (float *)_mm_malloc(sizeof(float) * fftSizeOver2, 16); signal_fft.realp = (float *)_memalign_malloc(sizeof(float) * fftSizeOver2, 16);
signal_fft.imagp = (float *)_mm_malloc(sizeof(float) * fftSizeOver2, 16); signal_fft.imagp = (float *)_memalign_malloc(sizeof(float) * fftSizeOver2, 16);
if(!signal_fft.realp || !signal_fft.imagp) { if(!signal_fft.realp || !signal_fft.imagp) {
_mm_free(deinterleavedImpulseBuffer); free(deinterleavedImpulseBuffer);
return nil; return nil;
} }
input_filtered_signal_per_channel[0].realp = (float *)_mm_malloc(sizeof(float) * fftSizeOver2, 16); input_filtered_signal_per_channel[0].realp = (float *)_memalign_malloc(sizeof(float) * fftSizeOver2, 16);
input_filtered_signal_per_channel[0].imagp = (float *)_mm_malloc(sizeof(float) * fftSizeOver2, 16); input_filtered_signal_per_channel[0].imagp = (float *)_memalign_malloc(sizeof(float) * fftSizeOver2, 16);
if(!input_filtered_signal_per_channel[0].realp || if(!input_filtered_signal_per_channel[0].realp ||
!input_filtered_signal_per_channel[0].imagp) { !input_filtered_signal_per_channel[0].imagp) {
_mm_free(deinterleavedImpulseBuffer); free(deinterleavedImpulseBuffer);
return nil; return nil;
} }
input_filtered_signal_per_channel[1].realp = (float *)_mm_malloc(sizeof(float) * fftSizeOver2, 16); input_filtered_signal_per_channel[1].realp = (float *)_memalign_malloc(sizeof(float) * fftSizeOver2, 16);
input_filtered_signal_per_channel[1].imagp = (float *)_mm_malloc(sizeof(float) * fftSizeOver2, 16); input_filtered_signal_per_channel[1].imagp = (float *)_memalign_malloc(sizeof(float) * fftSizeOver2, 16);
if(!input_filtered_signal_per_channel[1].realp || if(!input_filtered_signal_per_channel[1].realp ||
!input_filtered_signal_per_channel[1].imagp) { !input_filtered_signal_per_channel[1].imagp) {
_mm_free(deinterleavedImpulseBuffer); free(deinterleavedImpulseBuffer);
return nil; return nil;
} }
impulse_responses = (COMPLEX_SPLIT *)calloc(sizeof(COMPLEX_SPLIT), channels * 2); impulse_responses = (COMPLEX_SPLIT *)calloc(sizeof(COMPLEX_SPLIT), channels * 2);
if(!impulse_responses) { if(!impulse_responses) {
_mm_free(deinterleavedImpulseBuffer); free(deinterleavedImpulseBuffer);
return nil; return nil;
} }
for(size_t i = 0; i < channels; ++i) { for(size_t i = 0; i < channels; ++i) {
impulse_responses[i * 2 + 0].realp = (float *)_mm_malloc(sizeof(float) * fftSizeOver2, 16); impulse_responses[i * 2 + 0].realp = (float *)_memalign_malloc(sizeof(float) * fftSizeOver2, 16);
impulse_responses[i * 2 + 0].imagp = (float *)_mm_malloc(sizeof(float) * fftSizeOver2, 16); impulse_responses[i * 2 + 0].imagp = (float *)_memalign_malloc(sizeof(float) * fftSizeOver2, 16);
impulse_responses[i * 2 + 1].realp = (float *)_mm_malloc(sizeof(float) * fftSizeOver2, 16); impulse_responses[i * 2 + 1].realp = (float *)_memalign_malloc(sizeof(float) * fftSizeOver2, 16);
impulse_responses[i * 2 + 1].imagp = (float *)_mm_malloc(sizeof(float) * fftSizeOver2, 16); impulse_responses[i * 2 + 1].imagp = (float *)_memalign_malloc(sizeof(float) * fftSizeOver2, 16);
if(!impulse_responses[i * 2 + 0].realp || !impulse_responses[i * 2 + 0].imagp || if(!impulse_responses[i * 2 + 0].realp || !impulse_responses[i * 2 + 0].imagp ||
!impulse_responses[i * 2 + 1].realp || !impulse_responses[i * 2 + 1].imagp) { !impulse_responses[i * 2 + 1].realp || !impulse_responses[i * 2 + 1].imagp) {
_mm_free(deinterleavedImpulseBuffer); free(deinterleavedImpulseBuffer);
return nil; return nil;
} }
@ -361,7 +370,7 @@ static const int8_t speakers_to_hesuvi_14[11][2] = {
if(impulseChannels == 7) { if(impulseChannels == 7) {
temp = (float *)malloc(sizeof(float) * fftSize); temp = (float *)malloc(sizeof(float) * fftSize);
if(!temp) { if(!temp) {
_mm_free(deinterleavedImpulseBuffer); free(deinterleavedImpulseBuffer);
return nil; return nil;
} }
@ -373,7 +382,7 @@ static const int8_t speakers_to_hesuvi_14[11][2] = {
} else { } else {
temp = (float *)malloc(sizeof(float) * fftSize * 2); temp = (float *)malloc(sizeof(float) * fftSize * 2);
if(!temp) { if(!temp) {
_mm_free(deinterleavedImpulseBuffer); free(deinterleavedImpulseBuffer);
return nil; return nil;
} }
@ -400,20 +409,20 @@ static const int8_t speakers_to_hesuvi_14[11][2] = {
vDSP_fft_zrip(fftSetup, &impulse_responses[i * 2 + 1], 1, log2n, FFT_FORWARD); vDSP_fft_zrip(fftSetup, &impulse_responses[i * 2 + 1], 1, log2n, FFT_FORWARD);
} }
_mm_free(deinterleavedImpulseBuffer); free(deinterleavedImpulseBuffer);
left_result = (float *)_mm_malloc(sizeof(float) * fftSize, 16); left_result = (float *)_memalign_malloc(sizeof(float) * fftSize, 16);
right_result = (float *)_mm_malloc(sizeof(float) * fftSize, 16); right_result = (float *)_memalign_malloc(sizeof(float) * fftSize, 16);
if(!left_result || !right_result) if(!left_result || !right_result)
return nil; return nil;
prevOverlapLeft = (float *)_mm_malloc(sizeof(float) * fftSize, 16); prevOverlapLeft = (float *)_memalign_malloc(sizeof(float) * fftSize, 16);
prevOverlapRight = (float *)_mm_malloc(sizeof(float) * fftSize, 16); prevOverlapRight = (float *)_memalign_malloc(sizeof(float) * fftSize, 16);
if(!prevOverlapLeft || !prevOverlapRight) if(!prevOverlapLeft || !prevOverlapRight)
return nil; return nil;
left_mix_result = (float *)_mm_malloc(sizeof(float) * fftSize, 16); left_mix_result = (float *)_memalign_malloc(sizeof(float) * fftSize, 16);
right_mix_result = (float *)_mm_malloc(sizeof(float) * fftSize, 16); right_mix_result = (float *)_memalign_malloc(sizeof(float) * fftSize, 16);
if(!left_mix_result || !right_mix_result) if(!left_mix_result || !right_mix_result)
return nil; return nil;
@ -426,32 +435,32 @@ static const int8_t speakers_to_hesuvi_14[11][2] = {
- (void)dealloc { - (void)dealloc {
if(fftSetup) vDSP_destroy_fftsetup(fftSetup); if(fftSetup) vDSP_destroy_fftsetup(fftSetup);
_mm_free(paddedSignal); free(paddedSignal);
_mm_free(signal_fft.realp); free(signal_fft.realp);
_mm_free(signal_fft.imagp); free(signal_fft.imagp);
_mm_free(input_filtered_signal_per_channel[0].realp); free(input_filtered_signal_per_channel[0].realp);
_mm_free(input_filtered_signal_per_channel[0].imagp); free(input_filtered_signal_per_channel[0].imagp);
_mm_free(input_filtered_signal_per_channel[1].realp); free(input_filtered_signal_per_channel[1].realp);
_mm_free(input_filtered_signal_per_channel[1].imagp); free(input_filtered_signal_per_channel[1].imagp);
if(impulse_responses) { if(impulse_responses) {
for(size_t i = 0; i < channelCount * 2; ++i) { for(size_t i = 0; i < channelCount * 2; ++i) {
_mm_free(impulse_responses[i].realp); free(impulse_responses[i].realp);
_mm_free(impulse_responses[i].imagp); free(impulse_responses[i].imagp);
} }
free(impulse_responses); free(impulse_responses);
} }
_mm_free(left_result); free(left_result);
_mm_free(right_result); free(right_result);
_mm_free(prevOverlapLeft); free(prevOverlapLeft);
_mm_free(prevOverlapRight); free(prevOverlapRight);
_mm_free(left_mix_result); free(left_mix_result);
_mm_free(right_mix_result); free(right_mix_result);
} }
- (void)process:(const float *)inBuffer sampleCount:(size_t)count toBuffer:(float *)outBuffer { - (void)process:(const float *)inBuffer sampleCount:(size_t)count toBuffer:(float *)outBuffer {