Cog/Audio/Output/OutputCoreAudio.m

//
//  OutputCoreAudio.m
//  Cog
//
//  Created by Vincent Spader on 8/2/05.
//  Copyright 2005 Vincent Spader. All rights reserved.
//

#import "OutputCoreAudio.h"
#import "OutputNode.h"

#import "Logging.h"

extern void scale_by_volume(float * buffer, size_t count, float volume);

static NSString *CogPlaybackDidBeginNotficiation = @"CogPlaybackDidBeginNotficiation";

@implementation OutputCoreAudio

static void fillBuffers(AudioBufferList *ioData, float * inbuffer, size_t count, size_t offset)
{
    const size_t channels = ioData->mNumberBuffers;
    for (int i = 0; i < channels; ++i)
    {
        const size_t maxCount = (ioData->mBuffers[i].mDataByteSize / sizeof(float)) - offset;
        float * output = ((float *)ioData->mBuffers[i].mData) + offset;
        const float * input = inbuffer + i;
        for (size_t j = 0, k = (count > maxCount) ? maxCount : count; j < k; ++j)
        {
            *output = *input;
            output++;
            input += channels;
        }
        ioData->mBuffers[i].mNumberChannels = 1;
    }
}

static void clearBuffers(AudioBufferList *ioData, size_t count, size_t offset)
{
    for (int i = 0; i < ioData->mNumberBuffers; ++i)
    {
        memset(ioData->mBuffers[i].mData + offset * sizeof(float), 0, count * sizeof(float));
        ioData->mBuffers[i].mNumberChannels = 1;
    }
}

static void scaleBuffersByVolume(AudioBufferList *ioData, float volume)
{
    if (volume != 1.0)
    {
        for (int i = 0; i < ioData->mNumberBuffers; ++i)
        {
            scale_by_volume((float*)ioData->mBuffers[i].mData, ioData->mBuffers[i].mDataByteSize / sizeof(float), volume);
        }
    }
}

static OSStatus renderCallback( void *inRefCon, AudioUnitRenderActionFlags *ioActionFlags, const AudioTimeStamp *inTimeStamp, UInt32 inBusNumber, UInt32 inNumberFrames, AudioBufferList *ioData )
{
    OutputCoreAudio * _self = (__bridge OutputCoreAudio *) inRefCon;
    
    const int channels = _self->deviceFormat.mChannelsPerFrame;
    const int bytesPerPacket = channels * sizeof(float);
    
    int amountToRead, amountRead = 0;

    amountToRead = inNumberFrames * bytesPerPacket;
    
    if (_self->stopping == YES || [_self->outputController shouldContinue] == NO)
    {
        // Chain is dead, fill out the serial number pointer forever with silence
        clearBuffers(ioData, amountToRead / bytesPerPacket, 0);
        atomic_fetch_add(&_self->bytesRendered, amountToRead);
        _self->stopping = YES;
        return 0;
    }
    
    if ([[_self->outputController buffer] isEmpty] && ![_self->outputController chainQueueHasTracks])
    {
        // Hit end of last track, pad with silence until queue event stops us
        clearBuffers(ioData, amountToRead / bytesPerPacket, 0);
        atomic_fetch_add(&_self->bytesRendered, amountToRead);
        return 0;
    }
    
    if (_self->savedSize) {
        int readBytes = (int) _self->savedSize;

        const int streamchannels = _self->streamFormat.mChannelsPerFrame;
        const int streamBytesPerPacket = streamchannels * sizeof(float);

        int samplesToRead = readBytes / streamBytesPerPacket;
        
        if (samplesToRead > (amountToRead / bytesPerPacket))
            samplesToRead = amountToRead / bytesPerPacket;
        
        readBytes = samplesToRead * streamBytesPerPacket;
        
        atomic_fetch_sub(&_self->bytesBuffered, readBytes);
        
        float downmixBuffer[samplesToRead * channels];
        [_self->downmixer process:_self->savedBuffer frameCount:samplesToRead output:downmixBuffer];
        fillBuffers(ioData, downmixBuffer, samplesToRead, 0);
        amountRead += samplesToRead * bytesPerPacket;
        [_self->outputController incrementAmountPlayed:samplesToRead * bytesPerPacket];
        atomic_fetch_add(&_self->bytesRendered, samplesToRead * bytesPerPacket);
        [_self->writeSemaphore signal];

        if (_self->savedSize > readBytes) {
            _self->savedSize -= readBytes;
            memmove(_self->savedBuffer, _self->savedBuffer + readBytes, _self->savedSize);
        }
        else {
            _self->savedSize = 0;
        }
    }
    
    while (amountRead < amountToRead && [_self->outputController shouldContinue])
    {
        void * readPtr;
        int toRead = 0;
        do {
            toRead = [[_self->outputController buffer] lengthAvailableToReadReturningPointer:&readPtr];
            if (toRead && *((uint8_t*)readPtr) == 0xFF) {
                size_t toSkip = 0;
                while (toRead && *((uint8_t*)readPtr) == 0xFF) {
                    toSkip++;
                    readPtr++;
                    toRead--;
                }
                [[_self->outputController buffer] didReadLength:(int)toSkip];
                toRead = 0;
            }
        }
        while (!toRead);

        int bytesRead = 0;

        int32_t chunkId = -1;

        if (toRead >= 4) {
            memcpy(&chunkId, readPtr, 4);
            readPtr += 4;
            toRead -= 4;
            bytesRead += 4;
        }

        if (chunkId == 1 && toRead >= sizeof(AudioStreamBasicDescription)) {
            AudioStreamBasicDescription inf;
            memcpy(&inf, readPtr, sizeof(inf));
            readPtr += sizeof(inf);
            toRead -= sizeof(inf);
            bytesRead += sizeof(inf);
            
            if (!_self->streamFormatSetup || memcmp(&inf, &_self->streamFormat, sizeof(inf)) != 0) {
                _self->streamFormatSetup = YES;
                _self->streamFormat = inf;
                _self->downmixer = [[DownmixProcessor alloc] initWithInputFormat:inf andOutputFormat:_self->deviceFormat];
            }
            
            if (toRead >= 4) {
                memcpy(&chunkId, readPtr, 4);
                readPtr += 4;
                toRead -= 4;
                bytesRead += 4;
            }
            else chunkId = -1;
        }

        const int streamchannels = _self->streamFormat.mChannelsPerFrame;
        const int streamBytesPerPacket = streamchannels * sizeof(float);

        if (chunkId == 0 && toRead >= 4) {
            memcpy(&chunkId, readPtr, 4);
            readPtr += 4;
            bytesRead += 4;
            toRead = chunkId;
        }

        if (toRead) {
            size_t samplesToRead = toRead / streamBytesPerPacket;
            size_t saveBytes = 0;
            
            if (samplesToRead * bytesPerPacket > (amountToRead - amountRead)) {
                size_t shortToRead = (amountToRead - amountRead) / bytesPerPacket;
                saveBytes = (samplesToRead - shortToRead) * streamBytesPerPacket;
                samplesToRead = shortToRead;
            }
            float downmixBuffer[samplesToRead * channels];
            [_self->downmixer process:readPtr frameCount:samplesToRead output:downmixBuffer];
            fillBuffers(ioData, downmixBuffer, samplesToRead, amountRead / bytesPerPacket);
            amountRead += samplesToRead * bytesPerPacket;
            bytesRead += toRead;
            
            if (saveBytes) {
                if (!_self->savedBuffer || _self->savedMaxSize < saveBytes) {
                    _self->savedBuffer = realloc(_self->savedBuffer, _self->savedMaxSize = saveBytes * 3);
                }
                _self->savedSize = saveBytes;
                memcpy(_self->savedBuffer, readPtr + toRead - saveBytes, saveBytes);
            }
            
            atomic_fetch_sub(&_self->bytesBuffered, toRead - saveBytes);
            
            [[_self->outputController buffer] didReadLength:bytesRead];
            [_self->outputController incrementAmountPlayed:samplesToRead * bytesPerPacket];
            atomic_fetch_add(&_self->bytesRendered, samplesToRead * bytesPerPacket);
            [_self->writeSemaphore signal];
        }
        else
            [[_self->outputController buffer] didReadLength:bytesRead];
    }
    
    float volumeScale = 1.0;
    long sustained = atomic_load_explicit(&_self->bytesHdcdSustained, memory_order_relaxed);
    if (sustained) {
        if (sustained < amountRead) {
            atomic_store(&_self->bytesHdcdSustained, 0);
        }
        else {
            atomic_fetch_sub(&_self->bytesHdcdSustained, amountRead);
        }
        volumeScale = 0.5;
    }

    scaleBuffersByVolume(ioData, _self->volume * volumeScale);
    
    return 0;
};

- (id)initWithController:(OutputNode *)c
{
	self = [super init];
	if (self)
	{
		outputController = c;
        _au = nil;
        _eq = NULL;
        _bufferSize = 0;
        volume = 1.0;
        outputDeviceID = -1;
        listenerapplied = NO;
        running = NO;
        started = NO;
        stopNext = NO;
        
        streamFormatSetup = NO;

        downmixer = nil;
        
        savedBuffer = NULL;
        savedSize = 0;
        savedMaxSize = 0;
        
        atomic_init(&bytesBuffered, 0);
        atomic_init(&bytesRendered, 0);
        atomic_init(&bytesHdcdSustained, 0);
        
        writeSemaphore = [[Semaphore alloc] init];
        readSemaphore = [[Semaphore alloc] init];
        
#ifdef OUTPUT_LOG
        _logFile = fopen("/tmp/CogAudioLog.raw", "wb");
#endif
    }
	
	return self;
}

static OSStatus
default_device_changed(AudioObjectID inObjectID, UInt32 inNumberAddresses, const AudioObjectPropertyAddress *inAddresses, void *inUserData)
{
    OutputCoreAudio *this = (__bridge OutputCoreAudio *) inUserData;
    return [this setOutputDeviceByID:-1];
}

- (void)observeValueForKeyPath:(NSString *)keyPath ofObject:(id)object change:(NSDictionary *)change context:(void *)context
{
	if ([keyPath isEqualToString:@"values.outputDevice"]) {

		NSDictionary *device = [[[NSUserDefaultsController sharedUserDefaultsController] defaults] objectForKey:@"outputDevice"];

		[self setOutputDeviceWithDeviceDict:device];
	}
    else if ([keyPath isEqualToString:@"values.GraphicEQenable"]) {
        BOOL enabled = [[[[NSUserDefaultsController sharedUserDefaultsController] defaults] objectForKey:@"GraphicEQenable"] boolValue];
        
        [self setEqualizerEnabled:enabled];
    }
}

- (void)signalEndOfStream
{
    [outputController resetAmountPlayed];
    [outputController endOfInputPlayed];
}

- (void)threadEntry:(id)arg
{
    running = YES;
    started = NO;
    stopNext = NO;
    size_t eventCount = 0;
    atomic_store(&bytesRendered, 0);
    NSMutableArray *delayedEvents = [[NSMutableArray alloc] init];
    BOOL delayedEventsPopped = YES;
    while (!stopping) {
        if (++eventCount == 128) {
            [self updateDeviceFormat];
            eventCount = 0;
        }
        
        if ([outputController shouldReset]) {
            [[outputController buffer] empty];
            atomic_store(&bytesBuffered, 0);
            [outputController setShouldReset:NO];
            [delayedEvents removeAllObjects];
            delayedEventsPopped = YES;
        }

        while ([delayedEvents count]) {
            size_t localBytesRendered = atomic_load_explicit(&bytesRendered, memory_order_relaxed);
            if (localBytesRendered >= [[delayedEvents objectAtIndex:0] longValue]) {
                if ([outputController chainQueueHasTracks])
                    delayedEventsPopped = YES;
                [self signalEndOfStream];
                [delayedEvents removeObjectAtIndex:0];
            }
            else break;
        }
        
        if (stopping)
            break;
        
        void *writePtr;
        BOOL wrapped = NO;
        int toWrite = [[outputController buffer] lengthAvailableToWriteReturningPointer:&writePtr bufferWrapped:&wrapped];
        int bytesWritten = 0;
        if (toWrite >= 4 + sizeof(AudioStreamBasicDescription)) {
            if ([outputController formatChanged]) {
                int32_t chunkId = 1; // ASBD
                memcpy(writePtr, &chunkId, 4);

                writePtr += 4;
                toWrite -= 4;
                bytesWritten += 4;
                
                AudioStreamBasicDescription inf = [outputController nodeFormat];
                
                outerStreamFormat = inf;

                memcpy(writePtr, &inf, sizeof(inf));
                
                writePtr += sizeof(inf);
                toWrite -= sizeof(inf);
                bytesWritten += sizeof(inf);
            }
        }
        [[outputController buffer] didWriteLength:bytesWritten];
        
        toWrite = [[outputController buffer] lengthAvailableToWriteReturningPointer:&writePtr bufferWrapped:&wrapped];
        int bytesRead = 0;
        bytesWritten = 0;
        if (toWrite >= 4 + 4 + 512 * outerStreamFormat.mBytesPerPacket) {
            uint8_t buffer[512 * outerStreamFormat.mBytesPerPacket];

            bytesRead = [outputController readData:buffer amount:(int)sizeof(buffer)];
            
            while (bytesRead < sizeof(buffer) && ![outputController endOfStream]) {
                int bytesRead2 = [outputController readData:buffer + bytesRead amount:(int)(sizeof(buffer) - bytesRead)];
                bytesRead += bytesRead2;
            }
           
            int32_t chunkId = 0; // audio data
            memcpy(writePtr, &chunkId, 4);
            writePtr += 4;
            toWrite -= 4;
            bytesWritten += 4;
            
            chunkId = bytesRead;
            memcpy(writePtr, &chunkId, 4);
            writePtr += 4;
            toWrite -= 4;
            bytesWritten += 4;
            
            memcpy(writePtr, buffer, bytesRead);
            writePtr += bytesRead;
            toWrite -= bytesRead;
            bytesWritten += bytesRead;
            
            atomic_fetch_add(&bytesBuffered, bytesRead);
            
            [[outputController buffer] didWriteLength:bytesWritten];
        }
        else if (wrapped && toWrite > 0) {
            memset(writePtr, 0xFF, toWrite);
            [[outputController buffer] didWriteLength:toWrite];
        }
        else if (toWrite) {
            [[outputController buffer] didWriteLength:0];
            toWrite = 0;
        }
        if (bytesRead) {
            [readSemaphore signal];
            continue;
        }
        else if ([outputController shouldContinue] == NO)
            break;
        else if (!toWrite) {
            if (!started) {
                started = YES;
                if (!paused) {
                    NSError *err;
                    [_au startHardwareAndReturnError:&err];
                }
            }
        }
        else {
            // End of input possibly reached
            if (delayedEventsPopped && [outputController endOfStream] == YES)
            {
                long _bytesBuffered = atomic_load_explicit(&bytesBuffered, memory_order_relaxed) * deviceFormat.mBytesPerPacket / outerStreamFormat.mBytesPerPacket;
                _bytesBuffered += atomic_load_explicit(&bytesRendered, memory_order_relaxed);
                if ([outputController chainQueueHasTracks])
                {
                    if (_bytesBuffered < CHUNK_SIZE / 2)
                        _bytesBuffered = 0;
                    else
                        _bytesBuffered -= CHUNK_SIZE / 2;
                }
                else {
                    stopNext = YES;
                    break;
                }
                [delayedEvents addObject:[NSNumber numberWithLong:_bytesBuffered]];
                delayedEventsPopped = NO;
                if (!started) {
                    started = YES;
                    if (!paused) {
                        NSError *err;
                        [_au startHardwareAndReturnError:&err];
                    }
                }
            }
        }
        [readSemaphore signal];
        [writeSemaphore timedWait:5000];
    }
    stopped = YES;
    if (!stopInvoked)
        [self stop];
}

- (OSStatus)setOutputDeviceByID:(AudioDeviceID)deviceID
{
	OSStatus err;
    BOOL defaultDevice = NO;
    AudioObjectPropertyAddress theAddress = {
        .mSelector = kAudioHardwarePropertyDefaultOutputDevice,
        .mScope = kAudioObjectPropertyScopeGlobal,
        .mElement = kAudioObjectPropertyElementMaster
    };

	if (deviceID == -1) {
        defaultDevice = YES;
		UInt32 size = sizeof(AudioDeviceID);
        err = AudioObjectGetPropertyData(kAudioObjectSystemObject, &theAddress, 0, NULL, &size, &deviceID);
								
		if (err != noErr) {
			DLog(@"THERE'S NO DEFAULT OUTPUT DEVICE");
			
			return err;
		}
	}

    if (_au) {
        AudioObjectPropertyAddress defaultDeviceAddress = theAddress;

        if (listenerapplied && !defaultDevice) {
            AudioObjectRemovePropertyListener(kAudioObjectSystemObject, &defaultDeviceAddress, default_device_changed, (__bridge void * _Nullable)(self));
            listenerapplied = NO;
        }

        if (outputDeviceID != deviceID) {
            DLog(@"Device: %i\n", deviceID);
            outputDeviceID = deviceID;
            
            NSError *nserr;
            [_au setDeviceID:outputDeviceID error:&nserr];
            if (nserr != nil) {
                return (OSErr)[nserr code];
            }
        }
        
        if (!listenerapplied && defaultDevice) {
            AudioObjectAddPropertyListener(kAudioObjectSystemObject, &defaultDeviceAddress, default_device_changed, (__bridge void * _Nullable)(self));
            listenerapplied = YES;
        }
    }
    else {
        err = noErr;
    }
	
	if (err != noErr) {
		DLog(@"No output device with ID %d could be found.", deviceID);

		return err;
	}
	
	return err;
}

- (BOOL)setOutputDeviceWithDeviceDict:(NSDictionary *)deviceDict
{
	NSNumber *deviceIDNum = [deviceDict objectForKey:@"deviceID"];
	AudioDeviceID outputDeviceID = [deviceIDNum unsignedIntValue] ?: -1;
	
	__block OSStatus err = [self setOutputDeviceByID:outputDeviceID];
	
	if (err != noErr) {
		// Try matching by name.
		NSString *userDeviceName = deviceDict[@"name"];
		
		[self enumerateAudioOutputsUsingBlock:
		 ^(NSString *deviceName, AudioDeviceID deviceID, AudioDeviceID systemDefaultID, BOOL *stop) {
            if ([deviceName isEqualToString:userDeviceName]) {
                err = [self setOutputDeviceByID:deviceID];

#if 0
                // Disable. Would cause loop by triggering `-observeValueForKeyPath:ofObject:change:context:` above.
                // Update `outputDevice`, in case the ID has changed.
                NSDictionary *deviceInfo = @{
                    @"name": deviceName,
                    @"deviceID": @(deviceID),
                };
                [[NSUserDefaults standardUserDefaults] setObject:deviceInfo forKey:@"outputDevice"];
#endif
				
				DLog(@"Found output device: \"%@\" (%d).", deviceName, deviceID);
				
                *stop = YES;
            }
		}];
	}
	
	if (err != noErr) {

		ALog(@"No output device could be found, your random error code is %d. Have a nice day!", err);
		
		return NO;
	}
	
	return YES;
}

// The following is largely a copy pasta of -awakeFromNib from "OutputsArrayController.m".
// TODO: Share the code. (How to do this across xcodeproj?)
- (void)enumerateAudioOutputsUsingBlock:(void (NS_NOESCAPE ^ _Nonnull)(NSString *deviceName, AudioDeviceID deviceID, AudioDeviceID systemDefaultID, BOOL *stop))block
{
	UInt32 propsize;
	AudioObjectPropertyAddress theAddress = {
		.mSelector = kAudioHardwarePropertyDevices,
		.mScope = kAudioObjectPropertyScopeGlobal,
		.mElement = kAudioObjectPropertyElementMaster
	};
	
	__Verify_noErr(AudioObjectGetPropertyDataSize(kAudioObjectSystemObject, &theAddress, 0, NULL, &propsize));
	UInt32 nDevices = propsize / (UInt32)sizeof(AudioDeviceID);
	AudioDeviceID *devids = malloc(propsize);
	__Verify_noErr(AudioObjectGetPropertyData(kAudioObjectSystemObject, &theAddress, 0, NULL, &propsize, devids));
	
	theAddress.mSelector = kAudioHardwarePropertyDefaultOutputDevice;
	AudioDeviceID systemDefault;
	propsize = sizeof(systemDefault);
	__Verify_noErr(AudioObjectGetPropertyData(kAudioObjectSystemObject, &theAddress, 0, NULL, &propsize, &systemDefault));
	
	theAddress.mScope = kAudioDevicePropertyScopeOutput;
	
	for (UInt32 i = 0; i < nDevices; ++i) {
		CFStringRef name = NULL;
		propsize = sizeof(name);
		theAddress.mSelector = kAudioDevicePropertyDeviceNameCFString;
		__Verify_noErr(AudioObjectGetPropertyData(devids[i], &theAddress, 0, NULL, &propsize, &name));
		
		propsize = 0;
		theAddress.mSelector = kAudioDevicePropertyStreamConfiguration;
		__Verify_noErr(AudioObjectGetPropertyDataSize(devids[i], &theAddress, 0, NULL, &propsize));
		
        if (propsize < sizeof(UInt32)) {
            CFRelease(name);
            continue;
        }
		
		AudioBufferList * bufferList = (AudioBufferList *) malloc(propsize);
		__Verify_noErr(AudioObjectGetPropertyData(devids[i], &theAddress, 0, NULL, &propsize, bufferList));
		UInt32 bufferCount = bufferList->mNumberBuffers;
		free(bufferList);
		
        if (!bufferCount) {
            CFRelease(name);
            continue;
        }
            
		BOOL stop = NO;
		block([NSString stringWithString:(__bridge NSString *)name],
			  devids[i],
			  systemDefault,
			  &stop);
		
		CFRelease(name);
		
		if (stop) {
			break;
		}
	}
	
	free(devids);
}

- (BOOL)updateDeviceFormat
{
    AVAudioFormat *format = _au.outputBusses[0].format;
    
    if (!_deviceFormat || ![_deviceFormat isEqual:format])
    {
        NSError *err;
        AVAudioFormat *renderFormat;

        [outputController incrementAmountPlayed:atomic_load_explicit(&bytesBuffered, memory_order_relaxed)];
        [[outputController buffer] empty];
        atomic_store(&bytesBuffered, 0);

        _deviceFormat = format;
        deviceFormat = *(format.streamDescription);

        ///Seems some 3rd party devices return incorrect stuff...or I just don't like noninterleaved data.
        deviceFormat.mFormatFlags &= ~kLinearPCMFormatFlagIsNonInterleaved;
    //    deviceFormat.mFormatFlags &= ~kLinearPCMFormatFlagIsFloat;
    //    deviceFormat.mFormatFlags = kLinearPCMFormatFlagIsSignedInteger;
        // We don't want more than 8 channels
        if (deviceFormat.mChannelsPerFrame > 8) {
            deviceFormat.mChannelsPerFrame = 8;
        }
        deviceFormat.mBytesPerFrame = deviceFormat.mChannelsPerFrame*(deviceFormat.mBitsPerChannel/8);
        deviceFormat.mBytesPerPacket = deviceFormat.mBytesPerFrame * deviceFormat.mFramesPerPacket;

        /* Set the channel layout for the audio queue */
        AudioChannelLayoutTag tag = 0;
        switch (deviceFormat.mChannelsPerFrame) {
        case 1:
            tag = kAudioChannelLayoutTag_Mono;
            break;
        case 2:
            tag = kAudioChannelLayoutTag_Stereo;
            break;
        case 3:
            tag = kAudioChannelLayoutTag_DVD_4;
            break;
        case 4:
            tag = kAudioChannelLayoutTag_Quadraphonic;
            break;
        case 5:
            tag = kAudioChannelLayoutTag_MPEG_5_0_A;
            break;
        case 6:
            tag = kAudioChannelLayoutTag_MPEG_5_1_A;
            break;
        case 7:
            tag = kAudioChannelLayoutTag_MPEG_6_1_A;
            break;
        case 8:
            tag = kAudioChannelLayoutTag_MPEG_7_1_A;
            break;
        }

        renderFormat = [[AVAudioFormat alloc] initWithStreamDescription:&deviceFormat channelLayout:[[AVAudioChannelLayout alloc] initWithLayoutTag:tag]];
        [_au.inputBusses[0] setFormat:renderFormat error:&err];
        if (err != nil)
            return NO;
        
        [outputController setFormat:&deviceFormat];
        
        AudioStreamBasicDescription asbd = deviceFormat;
        
        asbd.mFormatFlags &= ~kAudioFormatFlagIsPacked;
        
        AudioUnitSetProperty (_eq, kAudioUnitProperty_StreamFormat,
                              kAudioUnitScope_Input, 0, &asbd, sizeof (asbd));
        
        AudioUnitSetProperty (_eq, kAudioUnitProperty_StreamFormat,
                              kAudioUnitScope_Output, 0, &asbd, sizeof (asbd));
        AudioUnitReset (_eq, kAudioUnitScope_Input, 0);
        AudioUnitReset (_eq, kAudioUnitScope_Output, 0);
        
        AudioUnitReset (_eq, kAudioUnitScope_Global, 0);
        
        eqEnabled = [[[[NSUserDefaultsController sharedUserDefaultsController] defaults] objectForKey:@"GraphicEQenable"] boolValue];
    }
    
    return YES;
}

- (BOOL)setup
{
	if (_au)
		[self stop];
    
    stopInvoked = NO;
    running = NO;
    stopping = NO;
    stopped = NO;
    paused = NO;
    stopNext = NO;
    outputDeviceID = -1;

    streamFormatSetup = NO;
    
    savedBuffer = NULL;
    savedSize = 0;
    savedMaxSize = 0;
	
    AudioComponentDescription desc;
    NSError *err;
	
	desc.componentType = kAudioUnitType_Output;
	desc.componentSubType = kAudioUnitSubType_HALOutput;
	desc.componentManufacturer = kAudioUnitManufacturer_Apple;
	desc.componentFlags = 0;
	desc.componentFlagsMask = 0;
	
    _au = [[AUAudioUnit alloc] initWithComponentDescription:desc error:&err];
    if (err != nil)
        return NO;

    // Setup the output device before mucking with settings
    NSDictionary *device = [[[NSUserDefaultsController sharedUserDefaultsController] defaults] objectForKey:@"outputDevice"];
    if (device) {
        BOOL ok = [self setOutputDeviceWithDeviceDict:device];
        if (!ok) {
            //Ruh roh.
            [self setOutputDeviceWithDeviceDict:nil];
            
            [[[NSUserDefaultsController sharedUserDefaultsController] defaults] removeObjectForKey:@"outputDevice"];
        }
    }
    else {
        [self setOutputDeviceWithDeviceDict:nil];
    }

    _deviceFormat = nil;
        
    AudioComponent comp = NULL;
    
    desc.componentType = kAudioUnitType_Effect;
    desc.componentSubType = kAudioUnitSubType_GraphicEQ;
    
    comp = AudioComponentFindNext(comp, &desc);
    if (!comp)
        return NO;
    
    OSStatus _err = AudioComponentInstanceNew(comp, &_eq);
    if (err)
        return NO;

    [self updateDeviceFormat];
    
    __block AudioUnit eq = _eq;
    __block AudioStreamBasicDescription *format = &deviceFormat;
    __block BOOL *eqEnabled = &self->eqEnabled;
    __block void *refCon = (__bridge void *)self;
    
#ifdef OUTPUT_LOG
    __block FILE *logFile = _logFile;
#endif

    _au.outputProvider = ^AUAudioUnitStatus(AudioUnitRenderActionFlags * _Nonnull actionFlags, const AudioTimeStamp * _Nonnull timestamp, AUAudioFrameCount frameCount, NSInteger inputBusNumber, AudioBufferList * _Nonnull inputData)
    {
        // This expects multiple buffers, so:
        int i;
        const int channels = format->mChannelsPerFrame;
        const int channelsminusone = channels - 1;
        float buffers[frameCount * format->mChannelsPerFrame];
        uint8_t bufferlistbuffer[sizeof(AudioBufferList) + sizeof(AudioBuffer) * channelsminusone];
        AudioBufferList * ioData = (AudioBufferList *)(bufferlistbuffer);
        
        ioData->mNumberBuffers = channels;
        
        memset(buffers, 0, sizeof(buffers));
        
        for (i = 0; i < channels; ++i) {
            ioData->mBuffers[i].mNumberChannels = 1;
            ioData->mBuffers[i].mData = buffers + frameCount * i;
            ioData->mBuffers[i].mDataByteSize = frameCount * sizeof(float);
        }
        
        OSStatus ret;
        
        if (*eqEnabled)
            ret = AudioUnitRender(eq, actionFlags, timestamp, (UInt32) inputBusNumber, frameCount, ioData);
        else
            ret = renderCallback(refCon, actionFlags, timestamp, (UInt32) inputBusNumber, frameCount, ioData);
        
        if (ret)
            return ret;
        
        for (i = 0; i < channels; ++i) {
            float * outBuffer = ((float*)inputData->mBuffers[0].mData) + i;
            const float * inBuffer = ((float*)ioData->mBuffers[i].mData);
            const int frameCount = ioData->mBuffers[i].mDataByteSize / sizeof(float);
            for (int j = 0; j < frameCount; ++j) {
                *outBuffer = *inBuffer;
                inBuffer++;
                outBuffer += channels;
            }
        }
        
#ifdef OUTPUT_LOG
        if (logFile) {
            fwrite(inputData->mBuffers[0].mData, 1, inputData->mBuffers[0].mDataByteSize, logFile);
        }
#endif
        
        inputData->mBuffers[0].mNumberChannels = channels;
        
        return 0;
    };
    
    [_au setMaximumFramesToRender:512];

    UInt32 value;
    UInt32 size = sizeof(value);

    value = CHUNK_SIZE;
    AudioUnitSetProperty (_eq, kAudioUnitProperty_MaximumFramesPerSlice,
                          kAudioUnitScope_Global, 0, &value, size);
                          
    value = 127;
    AudioUnitSetProperty (_eq, kAudioUnitProperty_RenderQuality,
                          kAudioUnitScope_Global, 0, &value, size);

    AURenderCallbackStruct callbackStruct;
    callbackStruct.inputProcRefCon = (__bridge void *)self;
    callbackStruct.inputProc = renderCallback;
    AudioUnitSetProperty (_eq, kAudioUnitProperty_SetRenderCallback,
                          kAudioUnitScope_Input, 0, &callbackStruct, sizeof(callbackStruct));

    AudioUnitReset (_eq, kAudioUnitScope_Input, 0);
    AudioUnitReset (_eq, kAudioUnitScope_Output, 0);
    
    AudioUnitReset (_eq, kAudioUnitScope_Global, 0);

    _err = AudioUnitInitialize(_eq);
    if (_err)
        return NO;
    
    [self setEqualizerEnabled:[[[[NSUserDefaultsController sharedUserDefaultsController] defaults] objectForKey:@"GraphicEQenable"] boolValue]];
    
    [outputController beginEqualizer:_eq];
    
    [_au allocateRenderResourcesAndReturnError:&err];
    
    [[NSUserDefaultsController sharedUserDefaultsController] addObserver:self forKeyPath:@"values.outputDevice" options:0 context:NULL];
    [[NSUserDefaultsController sharedUserDefaultsController] addObserver:self forKeyPath:@"values.GraphicEQenable" options:0 context:NULL];
    observersapplied = YES;
    
	return (err == nil);
}

- (void)setVolume:(double)v
{
    volume = v * 0.01f;
}

- (void)setEqualizerEnabled:(BOOL)enabled
{
    if (enabled && !eqEnabled) {
        if (_eq) {
            AudioUnitReset (_eq, kAudioUnitScope_Input, 0);
            AudioUnitReset (_eq, kAudioUnitScope_Output, 0);
            AudioUnitReset (_eq, kAudioUnitScope_Global, 0);
        }
    }
    
    eqEnabled = enabled;
}

- (void)start
{
    [self threadEntry:nil];
}

- (void)stop
{
    stopInvoked = YES;
    if (observersapplied) {
        observersapplied = NO;
        [[NSUserDefaultsController sharedUserDefaultsController] removeObserver:self forKeyPath:@"values.outputDevice"];
        [[NSUserDefaultsController sharedUserDefaultsController] removeObserver:self forKeyPath:@"values.GraphicEQenable"];
    }
    if (stopNext && started && !paused) {
        while (![[outputController buffer] isEmpty]) {
            [writeSemaphore signal];
            [readSemaphore signal];
            usleep(500);
        }
    }
    if (stopNext) {
        stopNext = NO;
        [self signalEndOfStream];
    }
    stopping = YES;
    paused = NO;
    [writeSemaphore signal];
    [readSemaphore signal];
    if (listenerapplied) {
        AudioObjectPropertyAddress theAddress = {
            .mSelector = kAudioHardwarePropertyDefaultOutputDevice,
            .mScope = kAudioObjectPropertyScopeGlobal,
            .mElement = kAudioObjectPropertyElementMaster
        };
        AudioObjectRemovePropertyListener(kAudioObjectSystemObject, &theAddress, default_device_changed, (__bridge void * _Nullable)(self));
        listenerapplied = NO;
    }
    if (_au) {
        if (started)
            [_au stopHardware];
        _au = nil;
    }
    if (running)
    while (!stopped)
    {
        stopping = YES;
        [readSemaphore signal];
        [writeSemaphore timedWait:5000];
    }
    if (_eq)
    {
        // This takes the EQ and frees it after disposing of any present UIs
        [outputController endEqualizer:_eq];
        _eq = NULL;
    }
#ifdef OUTPUT_LOG
    if (_logFile)
    {
        fclose(_logFile);
        _logFile = NULL;
    }
#endif
    if (savedBuffer)
    {
        free(savedBuffer);
        savedBuffer = NULL;
        savedSize = 0;
        savedMaxSize = 0;
    }
    
    outputController = nil;
}

- (void)dealloc
{
    if (!stopInvoked)
        [self stop];
}

- (void)pause
{
    paused = YES;
    if (started)
        [_au stopHardware];
}

- (void)resume
{
    NSError *err;
    [_au startHardwareAndReturnError:&err];
    paused = NO;
    started = YES;
}

- (void)sustainHDCD
{
    atomic_store(&bytesHdcdSustained, deviceFormat.mSampleRate * 10 * sizeof(float) * 2);
}

@end