/*

  Simple DirectMedia Layer

  Copyright (C) 1997-2016 Sam Lantinga <slouken@libsdl.org>

  This software is provided 'as-is', without any express or implied

  warranty.  In no event will the authors be held liable for any damages

  arising from the use of this software.

  Permission is granted to anyone to use this software for any purpose,

  including commercial applications, and to alter it and redistribute it

  freely, subject to the following restrictions:

  1. The origin of this software must not be misrepresented; you must not

     claim that you wrote the original software. If you use this software

     in a product, an acknowledgment in the product documentation would be

     appreciated but is not required.

  2. Altered source versions must be plainly marked as such, and must not be

     misrepresented as being the original software.

  3. This notice may not be removed or altered from any source distribution.

*/

#include "../../SDL_internal.h"

#if SDL_AUDIO_DRIVER_COREAUDIO

/* !!! FIXME: clean out some of the macro salsa in here. */

#include "SDL_audio.h"

#include "../SDL_audio_c.h"

#include "../SDL_sysaudio.h"

#include "SDL_coreaudio.h"

#include "SDL_assert.h"

#define DEBUG_COREAUDIO 0

#define CHECK_RESULT(msg) \

    if (result != noErr) { \

        SDL_SetError("CoreAudio error (%s): %d", msg, (int) result); \

        return 0; \

    }

#if MACOSX_COREAUDIO

static const AudioObjectPropertyAddress devlist_address = {

    kAudioHardwarePropertyDevices,

    kAudioObjectPropertyScopeGlobal,

    kAudioObjectPropertyElementMaster

};

typedef void (*addDevFn)(const char *name, const int iscapture, AudioDeviceID devId, void *data);

typedef struct AudioDeviceList

{

    AudioDeviceID devid;

    SDL_bool alive;

    struct AudioDeviceList *next;

} AudioDeviceList;

static AudioDeviceList *output_devs = NULL;

static AudioDeviceList *capture_devs = NULL;

static SDL_bool

add_to_internal_dev_list(const int iscapture, AudioDeviceID devId)

{

    AudioDeviceList *item = (AudioDeviceList *) SDL_malloc(sizeof (AudioDeviceList));

    if (item == NULL) {

        return SDL_FALSE;

    }

    item->devid = devId;

    item->alive = SDL_TRUE;

    item->next = iscapture ? capture_devs : output_devs;

    if (iscapture) {

        capture_devs = item;

    } else {

        output_devs = item;

    }

    return SDL_TRUE;

}

static void

addToDevList(const char *name, const int iscapture, AudioDeviceID devId, void *data)

{

    if (add_to_internal_dev_list(iscapture, devId)) {

        SDL_AddAudioDevice(iscapture, name, (void *) ((size_t) devId));

    }

}

static void

build_device_list(int iscapture, addDevFn addfn, void *addfndata)

{

    OSStatus result = noErr;

    UInt32 size = 0;

    AudioDeviceID *devs = NULL;

    UInt32 i = 0;

    UInt32 max = 0;

    result = AudioObjectGetPropertyDataSize(kAudioObjectSystemObject,

                                            &devlist_address, 0, NULL, &size);

    if (result != kAudioHardwareNoError)

        return;

    devs = (AudioDeviceID *) alloca(size);

    if (devs == NULL)

        return;

    result = AudioObjectGetPropertyData(kAudioObjectSystemObject,

                                        &devlist_address, 0, NULL, &size, devs);

    if (result != kAudioHardwareNoError)

        return;

    max = size / sizeof (AudioDeviceID);

    for (i = 0; i < max; i++) {

        CFStringRef cfstr = NULL;

        char *ptr = NULL;

        AudioDeviceID dev = devs[i];

        AudioBufferList *buflist = NULL;

        int usable = 0;

        CFIndex len = 0;

        const AudioObjectPropertyAddress addr = {

            kAudioDevicePropertyStreamConfiguration,

            iscapture ? kAudioDevicePropertyScopeInput : kAudioDevicePropertyScopeOutput,

            kAudioObjectPropertyElementMaster

        };

        const AudioObjectPropertyAddress nameaddr = {

            kAudioObjectPropertyName,

            iscapture ? kAudioDevicePropertyScopeInput : kAudioDevicePropertyScopeOutput,

            kAudioObjectPropertyElementMaster

        };

        result = AudioObjectGetPropertyDataSize(dev, &addr, 0, NULL, &size);

        if (result != noErr)

            continue;

        buflist = (AudioBufferList *) SDL_malloc(size);

        if (buflist == NULL)

            continue;

        result = AudioObjectGetPropertyData(dev, &addr, 0, NULL,

                                            &size, buflist);

        if (result == noErr) {

            UInt32 j;

            for (j = 0; j < buflist->mNumberBuffers; j++) {

                if (buflist->mBuffers[j].mNumberChannels > 0) {

                    usable = 1;

                    break;

                }

            }

        }

        SDL_free(buflist);

        if (!usable)

            continue;

        size = sizeof (CFStringRef);

        result = AudioObjectGetPropertyData(dev, &nameaddr, 0, NULL, &size, &cfstr);

        if (result != kAudioHardwareNoError)

            continue;

        len = CFStringGetMaximumSizeForEncoding(CFStringGetLength(cfstr),

                                                kCFStringEncodingUTF8);

        ptr = (char *) SDL_malloc(len + 1);

        usable = ((ptr != NULL) &&

                  (CFStringGetCString

                   (cfstr, ptr, len + 1, kCFStringEncodingUTF8)));

        CFRelease(cfstr);

        if (usable) {

            len = strlen(ptr);

            /* Some devices have whitespace at the end...trim it. */

            while ((len > 0) && (ptr[len - 1] == ' ')) {

                len--;

            }

            usable = (len > 0);

        }

        if (usable) {

            ptr[len] = '\0';

#if DEBUG_COREAUDIO

            printf("COREAUDIO: Found %s device #%d: '%s' (devid %d)\n",

                   ((iscapture) ? "capture" : "output"),

                   (int) i, ptr, (int) dev);

#endif

            addfn(ptr, iscapture, dev, addfndata);

        }

        SDL_free(ptr);  /* addfn() would have copied the string. */

    }

}

static void

free_audio_device_list(AudioDeviceList **list)

{

    AudioDeviceList *item = *list;

    while (item) {

        AudioDeviceList *next = item->next;

        SDL_free(item);

        item = next;

    }

    *list = NULL;

}

static void

COREAUDIO_DetectDevices(void)

{

    build_device_list(SDL_TRUE, addToDevList, NULL);

    build_device_list(SDL_FALSE, addToDevList, NULL);

}

static void

build_device_change_list(const char *name, const int iscapture, AudioDeviceID devId, void *data)

{

    AudioDeviceList **list = (AudioDeviceList **) data;

    AudioDeviceList *item;

    for (item = *list; item != NULL; item = item->next) {

        if (item->devid == devId) {

            item->alive = SDL_TRUE;

            return;

        }

    }

    add_to_internal_dev_list(iscapture, devId);  /* new device, add it. */

    SDL_AddAudioDevice(iscapture, name, (void *) ((size_t) devId));

}

static void

reprocess_device_list(const int iscapture, AudioDeviceList **list)

{

    AudioDeviceList *item;

    AudioDeviceList *prev = NULL;

    for (item = *list; item != NULL; item = item->next) {

        item->alive = SDL_FALSE;

    }

    build_device_list(iscapture, build_device_change_list, list);

    /* free items in the list that aren't still alive. */

    item = *list;

    while (item != NULL) {

        AudioDeviceList *next = item->next;

        if (item->alive) {

            prev = item;

        } else {

            SDL_RemoveAudioDevice(iscapture, (void *) ((size_t) item->devid));

            if (prev) {

                prev->next = item->next;

            } else {

                *list = item->next;

            }

            SDL_free(item);

        }

        item = next;

    }

}

/* this is called when the system's list of available audio devices changes. */

static OSStatus

device_list_changed(AudioObjectID systemObj, UInt32 num_addr, const AudioObjectPropertyAddress *addrs, void *data)

{

    reprocess_device_list(SDL_TRUE, &capture_devs);

    reprocess_device_list(SDL_FALSE, &output_devs);

    return 0;

}

#endif

static int open_playback_devices = 0;

static int open_capture_devices = 0;

static void update_audio_session()

{

#if !MACOSX_COREAUDIO

    /* !!! FIXME: move this to AVAudioSession. This is deprecated, and the new version is available as of (ancient!) iOS 3.0 */

    UInt32 category;

    if (open_playback_devices && open_capture_devices) {

        category = kAudioSessionCategory_PlayAndRecord;

    } else if (open_capture_devices) {

        category = kAudioSessionCategory_RecordAudio;

    } else {  /* nothing open, or just playing audio. */

        category = kAudioSessionCategory_AmbientSound;

    }

    AudioSessionSetProperty(kAudioSessionProperty_AudioCategory, sizeof (UInt32), &category);

#endif

}

/* The CoreAudio callback */

static OSStatus

outputCallback(void *inRefCon,

               AudioUnitRenderActionFlags * ioActionFlags,

               const AudioTimeStamp * inTimeStamp,

               UInt32 inBusNumber, UInt32 inNumberFrames,

               AudioBufferList * ioData)

{

    SDL_AudioDevice *this = (SDL_AudioDevice *) inRefCon;

    AudioBuffer *abuf;

    UInt32 remaining, len;

    void *ptr;

    UInt32 i;

    /* Only do anything if audio is enabled and not paused */

    if (!SDL_AtomicGet(&this->enabled) || SDL_AtomicGet(&this->paused)) {

        for (i = 0; i < ioData->mNumberBuffers; i++) {

            abuf = &ioData->mBuffers[i];

            SDL_memset(abuf->mData, this->spec.silence, abuf->mDataByteSize);

        }

        return 0;

    }

    /* No SDL conversion should be needed here, ever, since we accept

       any input format in OpenAudio, and leave the conversion to CoreAudio.

     */

    /*

       SDL_assert(!this->convert.needed);

       SDL_assert(this->spec.channels == ioData->mNumberChannels);

     */

    for (i = 0; i < ioData->mNumberBuffers; i++) {

        abuf = &ioData->mBuffers[i];

        remaining = abuf->mDataByteSize;

        ptr = abuf->mData;

        while (remaining > 0) {

            if (this->hidden->bufferOffset >= this->hidden->bufferSize) {

                /* Generate the data */

                SDL_LockMutex(this->mixer_lock);

                (*this->spec.callback)(this->spec.userdata,

                            this->hidden->buffer, this->hidden->bufferSize);

                SDL_UnlockMutex(this->mixer_lock);

                this->hidden->bufferOffset = 0;

            }

            len = this->hidden->bufferSize - this->hidden->bufferOffset;

            if (len > remaining)

                len = remaining;

            SDL_memcpy(ptr, (char *)this->hidden->buffer +

                       this->hidden->bufferOffset, len);

            ptr = (char *)ptr + len;

            remaining -= len;

            this->hidden->bufferOffset += len;

        }

    }

    return noErr;

}

static OSStatus

inputCallback(void *inRefCon,

              AudioUnitRenderActionFlags *ioActionFlags,

              const AudioTimeStamp *inTimeStamp,

              UInt32 inBusNumber, UInt32 inNumberFrames,

              AudioBufferList *ioData)

{

    SDL_AudioDevice *this = (SDL_AudioDevice *) inRefCon;

    if (!SDL_AtomicGet(&this->enabled) || SDL_AtomicGet(&this->paused)) {

        return noErr;  /* just drop this if we're not accepting input. */

    }

    const OSStatus err = AudioUnitRender(this->hidden->audioUnit, ioActionFlags, inTimeStamp, inBusNumber, inNumberFrames, &this->hidden->captureBufferList);

    SDL_assert(this->hidden->captureBufferList.mNumberBuffers == 1);

    if (err == noErr) {

        const AudioBuffer *abuf = &this->hidden->captureBufferList.mBuffers[0];

        UInt32 remaining = abuf->mDataByteSize;

        const Uint8 *ptr = (const Uint8 *) abuf->mData;

        /* No SDL conversion should be needed here, ever, since we accept

           any input format in OpenAudio, and leave the conversion to CoreAudio.

         */

        while (remaining > 0) {

            UInt32 len = this->hidden->bufferSize - this->hidden->bufferOffset;

            if (len > remaining)

                len = remaining;

            SDL_memcpy((char *)this->hidden->buffer + this->hidden->bufferOffset, ptr, len);

            ptr += len;

            remaining -= len;

            this->hidden->bufferOffset += len;

            if (this->hidden->bufferOffset >= this->hidden->bufferSize) {

                SDL_LockMutex(this->mixer_lock);

                (*this->spec.callback)(this->spec.userdata,

                            this->hidden->buffer, this->hidden->bufferSize);

                SDL_UnlockMutex(this->mixer_lock);

                this->hidden->bufferOffset = 0;

            }

        }

    }

    return noErr;

}

#if MACOSX_COREAUDIO

static const AudioObjectPropertyAddress alive_address =

{

    kAudioDevicePropertyDeviceIsAlive,

    kAudioObjectPropertyScopeGlobal,

    kAudioObjectPropertyElementMaster

};

static OSStatus

device_unplugged(AudioObjectID devid, UInt32 num_addr, const AudioObjectPropertyAddress *addrs, void *data)

{

    SDL_AudioDevice *this = (SDL_AudioDevice *) data;

    SDL_bool dead = SDL_FALSE;

    UInt32 isAlive = 1;

    UInt32 size = sizeof (isAlive);

    OSStatus error;

    if (!SDL_AtomicGet(&this->enabled)) {

        return 0;  /* already known to be dead. */

    }

    error = AudioObjectGetPropertyData(this->hidden->deviceID, &alive_address,

                                       0, NULL, &size, &isAlive);

    if (error == kAudioHardwareBadDeviceError) {

        dead = SDL_TRUE;  /* device was unplugged. */

    } else if ((error == kAudioHardwareNoError) && (!isAlive)) {

        dead = SDL_TRUE;  /* device died in some other way. */

    }

    if (dead) {

        SDL_OpenedAudioDeviceDisconnected(this);

    }

    return 0;

}

#endif

static void

COREAUDIO_CloseDevice(_THIS)

{

    const int iscapture = this->iscapture;

    if (this->hidden->audioUnitOpened) {

        #if MACOSX_COREAUDIO

        /* Unregister our disconnect callback. */

        AudioObjectRemovePropertyListener(this->hidden->deviceID, &alive_address, device_unplugged, this);

        #endif

        AURenderCallbackStruct callback;

        const AudioUnitElement output_bus = 0;

        const AudioUnitElement input_bus = 1;

        const AudioUnitElement bus = ((iscapture) ? input_bus : output_bus);

        /* stop processing the audio unit */

        AudioOutputUnitStop(this->hidden->audioUnit);

        /* Remove the input callback */

        SDL_zero(callback);

        AudioUnitSetProperty(this->hidden->audioUnit,

                             iscapture ? kAudioOutputUnitProperty_SetInputCallback : kAudioUnitProperty_SetRenderCallback,

                             kAudioUnitScope_Global, bus, &callback, sizeof(callback));

        AudioComponentInstanceDispose(this->hidden->audioUnit);

    }

    SDL_free(this->hidden->captureBufferList.mBuffers[0].mData);

    SDL_free(this->hidden->buffer);

    SDL_free(this->hidden);

    if (iscapture) {

        open_capture_devices--;

    } else {

        open_playback_devices--;

    }

    update_audio_session();

}

#if MACOSX_COREAUDIO

static int

prepare_device(_THIS, void *handle, int iscapture)

{

    AudioDeviceID devid = (AudioDeviceID) ((size_t) handle);

    OSStatus result = noErr;

    UInt32 size = 0;

    UInt32 alive = 0;

    pid_t pid = 0;

    AudioObjectPropertyAddress addr = {

        0,

        kAudioObjectPropertyScopeGlobal,

        kAudioObjectPropertyElementMaster

    };