//
// EqualizerWindowController.m
// Cog
//
// Created by Christopher Snowhill on 2/13/22.
//
#import "EqualizerWindowController.h"
#import "json.h"
#import "Logging.h"
static const NSString *equalizerGenre = @"";
static const NSString *equalizerDefaultGenre = @"Flat";
static NSArray *equalizer_presets_processed = nil;
static NSDictionary *equalizer_presets_by_name = nil;
static json_value *equalizer_presets = NULL;
static NSString *_cog_equalizer_type = @"Cog EQ library file v1.0";
static NSArray *_cog_equalizer_items() {
return @[@"name", @"hz32", @"hz64", @"hz128", @"hz256", @"hz512", @"hz1000", @"hz2000", @"hz4000", @"hz8000", @"hz16000", @"preamp"];
}
static NSArray *_cog_equalizer_band_settings() {
return @[@"eqPreamp", @"eq20Hz", @"eq25Hz", @"eq31p5Hz", @"eq40Hz", @"eq50Hz", @"eq63Hz", @"eq80Hz", @"eq100Hz", @"eq125Hz", @"eq160Hz", @"eq200Hz", @"eq250Hz", @"eq315Hz", @"eq400Hz", @"eq500Hz", @"eq630Hz", @"eq800Hz", @"eq1kHz", @"eq1p2kHz", @"eq1p6kHz", @"eq2kHz", @"eq2p5kHz", @"eq3p1kHz", @"eq4kHz", @"eq5kHz", @"eq6p3kHz", @"eq8kHz", @"eq10kHz", @"eq12kHz", @"eq16kHz", @"eq20kHz"];
}
static const float cog_equalizer_bands[10] = { 32, 64, 128, 256, 512, 1000, 2000, 4000, 8000, 16000 };
static NSArray *cog_equalizer_items = nil;
static NSArray *cog_equalizer_band_settings = nil;
static NSString *cog_equalizer_extra_genres = @"altGenres";
static const float apple_equalizer_bands[31] = { 20, 25, 31.5, 40, 50, 63, 80, 100, 125, 160, 200, 250, 315, 400, 500, 630, 800, 1000, 1200, 1600, 2000, 2500, 3100, 4000, 5000, 6300, 8000, 10000, 12000, 16000, 20000 };
static inline float interpolatePoint(const NSDictionary *preset, float freqTarget) {
if(!cog_equalizer_items)
cog_equalizer_items = _cog_equalizer_items();
// predict extra bands! lpc was too broken, quadra was broken, let's try simple linear steps
if(freqTarget < cog_equalizer_bands[0]) {
float work[14];
float work_freq[14];
for(unsigned int i = 0; i < 10; ++i) {
work[9 - i] = [[preset objectForKey:[cog_equalizer_items objectAtIndex:1 + i]] floatValue];
work_freq[9 - i] = cog_equalizer_bands[i];
}
for(unsigned int i = 10; i < 14; ++i) {
work[i] = work[i - 1] + (work[i - 1] - work[i - 2]) * 1.05;
work_freq[i] = work_freq[i - 1] + (work_freq[i - 1] - work_freq[i - 2]) * 1.05;
}
for(unsigned int i = 0; i < 13; ++i) {
if(freqTarget >= work_freq[13 - i] &&
freqTarget < work_freq[12 - i]) {
float freqLow = work_freq[13 - i];
float freqHigh = work_freq[12 - i];
float valueLow = work[13 - i];
float valueHigh = work[12 - i];
float delta = (freqTarget - freqLow) / (freqHigh - freqLow);
return valueLow + (valueHigh - valueLow) * delta;
}
}
return work[13];
} else if(freqTarget > cog_equalizer_bands[9]) {
float work[14];
float work_freq[14];
for(unsigned int i = 0; i < 10; ++i) {
work[i] = [[preset objectForKey:[cog_equalizer_items objectAtIndex:1 + i]] floatValue];
work_freq[i] = cog_equalizer_bands[i];
}
for(unsigned int i = 10; i < 14; ++i) {
work[i] = work[i - 1] + (work[i - 1] - work[i - 2]) * 1.05;
work_freq[i] = work_freq[i - 1] + (work_freq[i - 1] - work_freq[i - 2]) * 1.05;
}
for(unsigned int i = 0; i < 13; ++i) {
if(freqTarget >= work_freq[i] &&
freqTarget < work_freq[i + 1]) {
float freqLow = work_freq[i];
float freqHigh = work_freq[i + 1];
float valueLow = work[i];
float valueHigh = work[i + 1];
float delta = (freqTarget - freqLow) / (freqHigh - freqLow);
return valueLow + (valueHigh - valueLow) * delta;
}
}
return work[13];
}
// Pick the extremes
if(freqTarget == cog_equalizer_bands[0])
return [[preset objectForKey:[cog_equalizer_items objectAtIndex:1]] floatValue];
else if(freqTarget == cog_equalizer_bands[9])
return [[preset objectForKey:[cog_equalizer_items objectAtIndex:10]] floatValue];
// interpolation time! linear is fine for this
for(size_t i = 0; i < 9; ++i) {
if(freqTarget >= cog_equalizer_bands[i] &&
freqTarget < cog_equalizer_bands[i + 1]) {
float freqLow = cog_equalizer_bands[i];
float freqHigh = cog_equalizer_bands[i + 1];
float valueLow = [[preset objectForKey:[cog_equalizer_items objectAtIndex:i + 1]] floatValue];
float valueHigh = [[preset objectForKey:[cog_equalizer_items objectAtIndex:i + 2]] floatValue];
float delta = (freqTarget - freqLow) / (freqHigh - freqLow);
return valueLow + (valueHigh - valueLow) * delta;
}
}
return 0.0;
}
static void interpolateBands(float *out, const NSDictionary *preset) {
for(size_t i = 0; i < 31; ++i) {
out[i] = interpolatePoint(preset, apple_equalizer_bands[i]);
}
}
static float getPreamp(const NSDictionary *preset) {
return [[preset objectForKey:[cog_equalizer_items objectAtIndex:11]] floatValue];
}
static void loadPresets() {
if([equalizer_presets_processed count]) return;
NSURL *url = [[NSBundle mainBundle] URLForResource:@"Cog.q1" withExtension:@"json"];
NSFileHandle *fileHandle = [NSFileHandle fileHandleForReadingAtPath:[url path]];
if(fileHandle) {
NSError *err;
NSData *data;
if(@available(macOS 10.15, *)) {
data = [fileHandle readDataToEndOfFileAndReturnError:&err];
} else {
data = [fileHandle readDataToEndOfFile];
err = nil;
}
if(!err && data) {
equalizer_presets = json_parse(data.bytes, data.length);
if(equalizer_presets->type == json_object &&
equalizer_presets->u.object.length == 2 &&
strncmp(equalizer_presets->u.object.values[0].name, "type", equalizer_presets->u.object.values[0].name_length) == 0 &&
equalizer_presets->u.object.values[0].value->type == json_string &&
strncmp(equalizer_presets->u.object.values[0].value->u.string.ptr, [_cog_equalizer_type UTF8String], equalizer_presets -> u.object.values[0].value->u.string.length) == 0 &&
strncmp(equalizer_presets->u.object.values[1].name, "presets", equalizer_presets->u.object.values[1].name_length) == 0 &&
equalizer_presets->u.object.values[1].value->type == json_array) {
// Got the array of presets
NSMutableArray *array = [[NSMutableArray alloc] init];
NSMutableDictionary *dict = [[NSMutableDictionary alloc] init];
size_t count = equalizer_presets->u.object.values[1].value->u.array.length;
json_value **values = equalizer_presets->u.object.values[1].value->u.array.values;
cog_equalizer_items = _cog_equalizer_items();
const size_t cog_object_minimum = [cog_equalizer_items count];
for(size_t i = 0; i < count; ++i) {
if(values[i]->type == json_object) {
NSMutableArray<NSString *> *extraGenres = [[NSMutableArray alloc] init];
size_t object_items = values[i]->u.object.length;
json_object_entry *object_entry = values[i]->u.object.values;
size_t requiredItemsPresent = 0;
if(object_items >= cog_object_minimum) {
NSMutableDictionary *equalizerItem = [[NSMutableDictionary alloc] init];
for(size_t j = 0; j < object_items; ++j) {
NSString *key = [NSString stringWithUTF8String:object_entry[j].name];
NSInteger index = [cog_equalizer_items indexOfObject:key];
if(index != NSNotFound) {
if(index == 0 && object_entry[j].value->type == json_string) {
NSString *name = [NSString stringWithUTF8String:object_entry[j].value->u.string.ptr];
[equalizerItem setObject:name forKey:key];
++requiredItemsPresent;
} else if(object_entry[j].value->type == json_integer) {
int64_t value = object_entry[j].value->u.integer;
float floatValue = ((value <= 401 && value >= 1) ? ((float)(value - 201) / 10.0) : 0.0);
[equalizerItem setObject:@(floatValue) forKey:key];
++requiredItemsPresent;
}
} else if([key isEqualToString:cog_equalizer_extra_genres]) {
// Process alternate genre matches
if(object_entry[j].value->type == json_array) {
size_t value_count = object_entry[j].value->u.array.length;
json_value **values = object_entry[j].value->u.array.values;
for(size_t k = 0; k < value_count; ++k) {
if(values[k]->type == json_string) {
[extraGenres addObject:[NSString stringWithUTF8String:values[i]->u.string.ptr]];
}
}
}
}
}
if(requiredItemsPresent == cog_object_minimum) {
// Add the base item
NSDictionary *outItem = [NSDictionary dictionaryWithDictionary:equalizerItem];
[array addObject:outItem];
[dict setObject:outItem forKey:[outItem objectForKey:@"name"]];
// Add the alternate genres, if any
for(NSString *genre in extraGenres) {
[dict setObject:outItem forKey:genre];
}
}
}
}
}
equalizer_presets_processed = [NSArray arrayWithArray:array];
equalizer_presets_by_name = [NSDictionary dictionaryWithDictionary:dict];
}
}
[fileHandle closeFile];
json_value_free(equalizer_presets);
equalizer_presets = NULL;
}
}
void equalizerApplyGenre(AudioUnit au, const NSString *genre) {
equalizerGenre = genre;
if([[NSUserDefaults standardUserDefaults] boolForKey:@"GraphicEQtrackgenre"]) {
loadPresets();
NSDictionary *preset = [equalizer_presets_by_name objectForKey:genre];
if(!preset) {
// Find a match
if(genre && ![genre isEqualToString:@""]) {
NSUInteger matchLength = 0;
NSString *lowerCaseGenre = [genre lowercaseString];
for(NSString *key in [equalizer_presets_by_name allKeys]) {
NSString *lowerCaseKey = [key lowercaseString];
if([lowerCaseGenre containsString:lowerCaseKey]) {
if([key length] > matchLength) {
matchLength = [key length];
preset = [equalizer_presets_by_name objectForKey:key];
}
}
}
}
if(!preset) {
preset = [equalizer_presets_by_name objectForKey:equalizerDefaultGenre];
}
}
if(preset) {
NSInteger index = [equalizer_presets_processed indexOfObject:preset];
[[NSUserDefaults standardUserDefaults] setInteger:index forKey:@"GraphicEQpreset"];
equalizerApplyPreset(au, preset);
}
}
}
void equalizerLoadPreset(AudioUnit au) {
NSInteger index = [[NSUserDefaults standardUserDefaults] integerForKey:@"GraphicEQpreset"];
if(index >= 0 && index < [equalizer_presets_processed count]) {
NSDictionary *preset = [equalizer_presets_processed objectAtIndex:index];
equalizerApplyPreset(au, preset);
} else if(au) {
@synchronized(cog_equalizer_band_settings) {
if(!cog_equalizer_band_settings)
cog_equalizer_band_settings = _cog_equalizer_band_settings();
}
AudioUnitSetParameter(au, kGraphicEQParam_NumberOfBands, kAudioUnitScope_Global, 0, 1, 0);
for(NSInteger i = 1; i < [cog_equalizer_band_settings count]; ++i) {
float value = [[NSUserDefaults standardUserDefaults] floatForKey:[cog_equalizer_band_settings objectAtIndex:i]];
AudioUnitSetParameter(au, (int)(i - 1), kAudioUnitScope_Global, 0, value, 0);
}
}
}
void equalizerApplyPreset(AudioUnit au, const NSDictionary *preset) {
if(au && preset) {
@synchronized(cog_equalizer_band_settings) {
if(!cog_equalizer_band_settings)
cog_equalizer_band_settings = _cog_equalizer_band_settings();
}
AudioUnitParameterValue paramValue = 0;
if(AudioUnitGetParameter(au, kGraphicEQParam_NumberOfBands, kAudioUnitScope_Global, 0, ¶mValue))
return;
float presetValues[31];
interpolateBands(presetValues, preset);
float preamp = getPreamp(preset);
[[NSUserDefaults standardUserDefaults] setFloat:preamp forKey:[cog_equalizer_band_settings objectAtIndex:0]];
AudioUnitSetParameter(au, kGraphicEQParam_NumberOfBands, kAudioUnitScope_Global, 0, 1, 0);
for(unsigned int i = 0; i < 31; ++i) {
[[NSUserDefaults standardUserDefaults] setFloat:presetValues[i] forKey:[cog_equalizer_band_settings objectAtIndex:i + 1]];
AudioUnitSetParameter(au, i, kAudioUnitScope_Global, 0, presetValues[i], 0);
}
}
}
@implementation EqPresetBehaviorArrayController
- (void)awakeFromNib {
[self removeObjects:[self arrangedObjects]];
loadPresets();
for(NSDictionary *preset in equalizer_presets_processed) {
[self addObject:@{ @"name": [preset objectForKey:@"name"], @"preference": [preset objectForKey:@"name"] }];
}
[self addObject:@{ @"name": @"Custom", @"preference": @"Custom" }];
}
@end
@implementation EqualizerSlider
- (void)awakeFromNib {
[self setTrackFillColor:[NSColor systemGrayColor]];
}
@end
@interface EqualizerWindowController ()
@end
@implementation EqualizerWindowController
+ (void)initialize {
@synchronized(cog_equalizer_band_settings) {
if(!cog_equalizer_band_settings)
cog_equalizer_band_settings = _cog_equalizer_band_settings();
}
}
- (id)init {
return [super initWithWindowNibName:@"Equalizer"];
}
- (void)windowDidLoad {
[super windowDidLoad];
[self changePreset:presetSelector];
[self handleMouseEvents];
}
- (void)setEQ:(AudioUnit)au {
self->au = au;
}
- (IBAction)toggleWindow:(id)sender {
if([[self window] isVisible])
[[self window] orderOut:self];
else
[self showWindow:self];
}
- (IBAction)toggleEnable:(id)sender {
}
- (IBAction)toggleTracking:(id)sender {
equalizerApplyGenre(au, equalizerGenre);
[self changePreset:presetSelector];
}
- (IBAction)flattenEQ:(id)sender {
NSDictionary *preset = [equalizer_presets_by_name objectForKey:equalizerDefaultGenre];
NSInteger index = [equalizer_presets_processed indexOfObject:preset];
[presetSelector selectItemAtIndex:index];
[[NSUserDefaults standardUserDefaults] setInteger:index forKey:@"GraphicEQpreset"];
[self changePreset:presetSelector];
}
- (EqualizerSlider *)sliderForIndex:(NSInteger)index {
switch(index) {
case 0:
return eqPreamp;
case 1:
return eq20Hz;
case 2:
return eq25Hz;
case 3:
return eq31p5Hz;
case 4:
return eq40Hz;
case 5:
return eq50Hz;
case 6:
return eq63Hz;
case 7:
return eq80Hz;
case 8:
return eq100Hz;
case 9:
return eq125Hz;
case 10:
return eq160Hz;
case 11:
return eq200Hz;
case 12:
return eq250Hz;
case 13:
return eq315Hz;
case 14:
return eq400Hz;
case 15:
return eq500Hz;
case 16:
return eq630Hz;
case 17:
return eq800Hz;
case 18:
return eq1kHz;
case 19:
return eq1p2kHz;
case 20:
return eq1p6kHz;
case 21:
return eq2kHz;
case 22:
return eq2p5kHz;
case 23:
return eq3p1kHz;
case 24:
return eq4kHz;
case 25:
return eq5kHz;
case 26:
return eq6p3kHz;
case 27:
return eq8kHz;
case 28:
return eq10kHz;
case 29:
return eq12kHz;
case 30:
return eq16kHz;
case 31:
return eq20kHz;
default:
return nil;
}
}
- (IBAction)levelPreamp:(id)sender {
float preamp = [eqPreamp floatValue];
float maxValue = 0.0;
for(NSInteger i = 1; i < [cog_equalizer_band_settings count]; ++i) {
float value = [[self sliderForIndex:i] floatValue];
if(value > maxValue) maxValue = value;
}
if(maxValue > 0.0 && preamp != -maxValue) {
[presetSelector selectItemAtIndex:[equalizer_presets_processed count]];
[[NSUserDefaults standardUserDefaults] setInteger:[equalizer_presets_processed count] forKey:@"GraphicEQpreset"];
[eqPreamp setFloatValue:-maxValue];
[[NSUserDefaults standardUserDefaults] setFloat:-maxValue forKey:[cog_equalizer_band_settings objectAtIndex:0]];
}
}
- (IBAction)adjustSlider:(id)sender {
NSInteger tag = [sender tag];
NSInteger count = [equalizer_presets_processed count];
if([[NSUserDefaults standardUserDefaults] integerForKey:@"GraphicEQpreset"] != count) {
[[NSUserDefaults standardUserDefaults] setInteger:count forKey:@"GraphicEQpreset"];
[presetSelector selectItemAtIndex:count];
}
if(tag == 0) {
float preamp = [eqPreamp floatValue];
[[NSUserDefaults standardUserDefaults] setFloat:preamp forKey:[cog_equalizer_band_settings objectAtIndex:0]];
} else if(tag < [cog_equalizer_band_settings count]) {
float value = [sender floatValue];
[[NSUserDefaults standardUserDefaults] setFloat:value forKey:[cog_equalizer_band_settings objectAtIndex:tag]];
if(au)
AudioUnitSetParameter(au, (int)(tag - 1), kAudioUnitScope_Global, 0, value, 0);
}
}
- (void)changePreset:(id)sender {
NSInteger index = [sender indexOfSelectedItem];
if(index >= 0 && index < [equalizer_presets_processed count]) {
NSDictionary *preset = [equalizer_presets_processed objectAtIndex:index];
equalizerApplyPreset(au, preset);
}
}
- (void)handleMouseEvents {
[NSEvent addLocalMonitorForEventsMatchingMask:NSEventMaskRightMouseDown | NSEventMaskRightMouseDragged
handler:^NSEvent *_Nullable(NSEvent *_Nonnull theEvent) {
if([theEvent window] == [self window]) {
NSPoint event_location = [theEvent locationInWindow];
NSPoint local_point = [self.window.contentView convertPoint:event_location fromView:nil];
for(NSInteger i = 0; i < [cog_equalizer_band_settings count]; ++i) {
NSSlider *slider = [self sliderForIndex:i];
if(NSPointInRect(local_point, [slider frame])) {
float sliderPosition = (MAX(MIN(local_point.y, 344.0), 40.0) - 40.0) / 152.0 - 1.0;
[slider setFloatValue:sliderPosition * 20.0];
[self adjustSlider:slider];
break;
}
}
}
return theEvent;
}];
}
@end