VuoAudioFile.c

Go to the documentation of this file.

 
#include "VuoAudioFile.h"
#include "VuoUrlFetch.h"
#include "VuoOsStatus.h"
#include "VuoEventLoop.h"
 
#include <dispatch/dispatch.h>
 
#include <AudioToolbox/AudioToolbox.h>
//#include <CoreServices/CoreServices.h>
//#include <CoreAudio/CoreAudioTypes.h>
//#include <AudioToolbox/AudioFile.h>
//#include <AudioToolbox/AudioFormat.h>
 
#include "module.h"
 
#include "VuoApp.h"
 
#ifdef VUO_COMPILER
VuoModuleMetadata({
                     "title" : "VuoAudioFile",
                     "dependencies" : [
                         "VuoAudioSamples",
                         "VuoInteger",
                         "VuoLoopType",
                         "VuoOsStatus",
                         "VuoReal",
                         "VuoText",
                         "VuoUrlFetch",
                         "VuoList_VuoAudioSamples",
                         "AudioToolbox.framework",
                         "CoreFoundation.framework"
                     ]
                 });
#endif
 
typedef struct VuoAudioFileInternal
{
    ExtAudioFileRef audioFile;                          
    dispatch_queue_t audioFileQueue;                    
    AudioStreamBasicDescription inputFormat;            
    AudioStreamBasicDescription outputFormat;           
    SInt64 totalFrameCount;                             
    SInt64 headerFrames;                                
 
    bool playing;                                       
    VuoLoopType loop;                                   
 
    void (*decodedChannels)(VuoList_VuoAudioSamples);   
    void (*finishedPlayback)(void);                     
    dispatch_source_t playbackTimer;                    
    dispatch_semaphore_t playbackTimerCanceled;         
} *VuoAudioFileInternal;
 
static void VuoAudioFile_decodeChannels(VuoAudioFileInternal afi)
{
    if (!afi->playing)
        return;
 
    VuoInteger bufferSize = sizeof(float) * afi->outputFormat.mChannelsPerFrame * VuoAudioSamples_bufferSize;
    float *buffer = (float*)malloc(bufferSize);
    bzero(buffer, bufferSize);
 
    dispatch_sync(afi->audioFileQueue, ^{
        VuoInteger framesRemaining = VuoAudioSamples_bufferSize;
        float *subBuffer = buffer;
 
        while (framesRemaining)
        {
            AudioBufferList bufferList;
            bufferList.mNumberBuffers = 1;
            bufferList.mBuffers[0].mNumberChannels = afi->outputFormat.mChannelsPerFrame;
            bufferList.mBuffers[0].mDataByteSize = sizeof(float) * afi->outputFormat.mChannelsPerFrame * framesRemaining;
            bufferList.mBuffers[0].mData = (void *)subBuffer;
 
            UInt32 numFrames = framesRemaining;
            OSStatus err = ExtAudioFileRead(afi->audioFile, &numFrames, &bufferList);
            if (err != noErr)
            {
                free(buffer);
                char *errStr = VuoOsStatus_getText(err);
                VUserLog("Error reading samples: %s", errStr);
                free(errStr);
                afi->playing = false;
                if (afi->finishedPlayback)
                    afi->finishedPlayback();
                return;
            }
 
            if (!numFrames)
            {
//              VLog("didn't get any more frames; breaking");
                break;
            }
 
            framesRemaining -= numFrames;
            subBuffer += numFrames * afi->outputFormat.mChannelsPerFrame;
        }
 
        if (framesRemaining)
        {
//          VLog("couldn't get all the frames; stopping playback");
 
            // even if LoopType is looping, still fire the finishedPlaybac event to let
            // user know one cycle is complete
            if (afi->finishedPlayback)
                afi->finishedPlayback();
 
            switch(afi->loop)
            {
                case VuoLoopType_Loop:
                {
                    const SInt64 targetFrame = 0;
 
                    OSStatus err = ExtAudioFileSeek(afi->audioFile, targetFrame + afi->headerFrames);
 
                    if (err != noErr)
                    {
                        char *errStr = VuoOsStatus_getText(err);
                        VUserLog("Error seeking to sample: %s", errStr);
                        free(errStr);
                        afi->playing = false;
                        break;
                    }
 
                    break;
                }
 
                default:
                    afi->playing = false;
                    break;
            }
        }
    });
 
    VuoList_VuoAudioSamples channels = VuoListCreate_VuoAudioSamples();
 
    for (VuoInteger channel = 0; channel < afi->outputFormat.mChannelsPerFrame; ++channel)
    {
        VuoAudioSamples samples = VuoAudioSamples_alloc(VuoAudioSamples_bufferSize);
        samples.samplesPerSecond = VuoAudioSamples_sampleRate;  
 
        for (VuoInteger sample = 0; sample < VuoAudioSamples_bufferSize; ++sample)
            samples.samples[sample] = buffer[sample*afi->outputFormat.mChannelsPerFrame + channel];
 
        VuoListAppendValue_VuoAudioSamples(channels, samples);
    }
    free(buffer);
 
    dispatch_sync(afi->audioFileQueue, ^{
                      if (afi->decodedChannels)
                          afi->decodedChannels(channels);
                      else
                      {
                          VuoRetain(channels);
                          VuoRelease(channels);
                      }
                  });
}
 
void VuoAudioFile_free(void *af)
{
    VuoAudioFileInternal afi = (VuoAudioFileInternal)af;
 
    if (afi->playbackTimer)
    {
        dispatch_source_cancel(afi->playbackTimer);
        dispatch_release(afi->playbackTimer);
    }
 
    if (afi->playbackTimerCanceled)
    {
        dispatch_semaphore_wait(afi->playbackTimerCanceled, DISPATCH_TIME_FOREVER);
        dispatch_release(afi->playbackTimerCanceled);
    }
 
    if (afi->audioFileQueue)
        dispatch_release(afi->audioFileQueue);
 
    if (afi->audioFile)
        ExtAudioFileDispose(afi->audioFile);
 
    free(afi);
}
 
VuoAudioFile VuoAudioFile_make(VuoText url)
{
    if (VuoText_isEmpty(url))
        return NULL;
 
    VuoAudioFileInternal afi = calloc(1, sizeof(struct VuoAudioFileInternal));
    VuoRegister(afi, VuoAudioFile_free);
 
    afi->playing = false;
    afi->loop = VuoLoopType_None;
    afi->decodedChannels = NULL;
    afi->finishedPlayback = NULL;
 
    {
        VuoText normalizedURL = VuoUrl_normalize(url, VuoUrlNormalize_default);
        VuoRetain(normalizedURL);
        CFStringRef urlCFS = CFStringCreateWithCString(NULL, normalizedURL, kCFStringEncodingUTF8);
        CFURLRef url = CFURLCreateWithString(NULL, urlCFS, NULL);
        if (!url)
        {
            VUserLog("Couldn't open '%s': Invalid URL.", normalizedURL);
            VuoRelease(normalizedURL);
            CFRelease(urlCFS);
            goto fail;
        }
 
        // https://b33p.net/kosada/node/7971
        VuoApp_init(false);
 
        OSStatus err = ExtAudioFileOpenURL(url, &afi->audioFile);
        CFRelease(urlCFS);
        CFRelease(url);
        if (err != noErr)
        {
            char *errStr = VuoOsStatus_getText(err);
            VUserLog("Couldn't open '%s': %s", normalizedURL, errStr);
            free(errStr);
            VuoRelease(normalizedURL);
            goto fail;
        }
        VuoRelease(normalizedURL);
    }
 
    {
        UInt32 size = sizeof(afi->inputFormat);
        OSStatus err = ExtAudioFileGetProperty(afi->audioFile, kExtAudioFileProperty_FileDataFormat, &size, &afi->inputFormat);
        if (err != noErr)
        {
            char *errStr = VuoOsStatus_getText(err);
            VUserLog("Error getting file format for '%s': %s", url, errStr);
            free(errStr);
            goto fail;
        }
    }
 
    {
        UInt32 size = sizeof(afi->totalFrameCount);
        OSStatus err = ExtAudioFileGetProperty(afi->audioFile, kExtAudioFileProperty_FileLengthFrames, &size, &afi->totalFrameCount);
        if (err != noErr)
        {
            char *errStr = VuoOsStatus_getText(err);
            VUserLog("Error getting frame count for '%s': %s", url, errStr);
            free(errStr);
            goto fail;
        }
    }
 
    {
        afi->outputFormat = afi->inputFormat;
        afi->outputFormat.mFormatID = kAudioFormatLinearPCM;
        afi->outputFormat.mSampleRate = VuoAudioSamples_sampleRate; 
        afi->outputFormat.mFormatFlags = kAudioFormatFlagIsFloat;
        afi->outputFormat.mBytesPerFrame = sizeof(float) * afi->outputFormat.mChannelsPerFrame;
        afi->outputFormat.mBitsPerChannel = sizeof(float) * 8;
        afi->outputFormat.mFramesPerPacket = 1;
        afi->outputFormat.mBytesPerPacket = afi->outputFormat.mBytesPerFrame * afi->outputFormat.mFramesPerPacket;
        UInt32 size = sizeof(afi->outputFormat);
        OSStatus err = ExtAudioFileSetProperty(afi->audioFile, kExtAudioFileProperty_ClientDataFormat, size, &afi->outputFormat);
        if (err != noErr)
        {
            char *errStr = VuoOsStatus_getText(err);
            VUserLog("Error setting output format for '%s': %s", url, errStr);
            free(errStr);
            goto fail;
        }
    }
 
    {
        AudioConverterRef ac;
        UInt32 size = sizeof(AudioConverterRef);
        bzero(&ac, size);
        OSStatus err = ExtAudioFileGetProperty(afi->audioFile, kExtAudioFileProperty_AudioConverter, &size, &ac);
        if (err != noErr)
        {
            char *errStr = VuoOsStatus_getText(err);
            VUserLog("Error getting audio converter info for '%s': %s", url, errStr);
            free(errStr);
        }
        else
        {
            AudioConverterPrimeInfo pi;
            UInt32 size = sizeof(AudioConverterPrimeInfo);
            bzero(&pi, size);
            OSStatus err = AudioConverterGetProperty(ac, kAudioConverterPrimeInfo, &size, &pi);
            if (err != noErr)
            {
                if (err != kAudioFormatUnsupportedPropertyError)
                {
                    char *errStr = VuoOsStatus_getText(err);
                    VUserLog("Error getting header info for '%s': %s", url, errStr);
                    free(errStr);
                }
            }
            else
                afi->headerFrames = pi.leadingFrames;
        }
    }
 
    afi->audioFileQueue = dispatch_queue_create("org.vuo.audiofile", VuoEventLoop_getDispatchInteractiveAttribute());
    dispatch_queue_t q = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_HIGH, 0);
    afi->playbackTimer = dispatch_source_create(DISPATCH_SOURCE_TYPE_TIMER, 0, DISPATCH_TIMER_STRICT, q);
    afi->playbackTimerCanceled = dispatch_semaphore_create(0);
 
    uint64_t nanoseconds = (float)VuoAudioSamples_bufferSize/VuoAudioSamples_sampleRate * NSEC_PER_SEC; 
    dispatch_source_set_timer(afi->playbackTimer, dispatch_time(DISPATCH_TIME_NOW, nanoseconds), nanoseconds, 0);
    dispatch_source_set_event_handler(afi->playbackTimer, ^{
                                          VuoAudioFile_decodeChannels(afi);
                                      });
    dispatch_source_set_cancel_handler(afi->playbackTimer, ^{
                                           dispatch_semaphore_signal(afi->playbackTimerCanceled);
                                       });
 
    // Seek past the header.
    VuoAudioFile_setTime((VuoAudioFile)afi, 0);
 
    dispatch_resume(afi->playbackTimer);
 
    return (VuoAudioFile)afi;
 
fail:
    VuoRetain(afi);
    VuoRelease(afi);
    return NULL;
}
 
bool VuoAudioFile_getInfo(VuoText url, VuoReal *duration, VuoInteger *channelCount, VuoReal *sampleRate)
{
    VuoAudioFileInternal afi = VuoAudioFile_make(url);
    if (!afi)
        return false;
    VuoRetain(afi);
 
    *duration = (float)afi->totalFrameCount / afi->inputFormat.mSampleRate;
    *channelCount = afi->inputFormat.mChannelsPerFrame;
    *sampleRate = afi->inputFormat.mSampleRate;
 
    VuoRelease(afi);
 
    return true;
}
 
void VuoAudioFile_enableTriggers(VuoAudioFile af, void (*decodedChannels)(VuoList_VuoAudioSamples), void (*finishedPlayback)(void))
{
    if (!af)
        return;
    VuoAudioFileInternal afi = (VuoAudioFileInternal)af;
    dispatch_sync(afi->audioFileQueue, ^{
                      afi->decodedChannels = decodedChannels;
                      afi->finishedPlayback = finishedPlayback;
                  });
}
 
void VuoAudioFile_disableTriggers(VuoAudioFile af)
{
    if (!af)
        return;
    VuoAudioFileInternal afi = (VuoAudioFileInternal)af;
    dispatch_sync(afi->audioFileQueue, ^{
                      afi->decodedChannels = NULL;
                      afi->finishedPlayback = NULL;
                  });
}
 
void VuoAudioFile_setLoopType(VuoAudioFile af, VuoLoopType loop)
{
    if (!af)
        return;
    VuoAudioFileInternal afi = (VuoAudioFileInternal)af;
    afi->loop = loop;
}
 
void VuoAudioFile_setTime(VuoAudioFile af, VuoReal time)
{
    if (!af)
        return;
    VuoAudioFileInternal afi = (VuoAudioFileInternal)af;
    dispatch_sync(afi->audioFileQueue, ^{
                      SInt64 targetFrame = time * afi->inputFormat.mSampleRate;
//                    VLog("seeking to frame %lld (of %lld)", targetFrame, afi->totalFrameCount);
                      OSStatus err = ExtAudioFileSeek(afi->audioFile, targetFrame + afi->headerFrames);
                      if (err != noErr)
                      {
                          char *errStr = VuoOsStatus_getText(err);
                          VUserLog("Error seeking to sample: %s", errStr);
                          free(errStr);
                          return;
                      }
                  });
}
 
void VuoAudioFile_play(VuoAudioFile af)
{
    if (!af)
        return;
    VuoAudioFileInternal afi = (VuoAudioFileInternal)af;
    afi->playing = true;
}
 
void VuoAudioFile_pause(VuoAudioFile af)
{
    if (!af)
        return;
    VuoAudioFileInternal afi = (VuoAudioFileInternal)af;
    afi->playing = false;
}
 
bool VuoAudioFile_isPlaying(VuoAudioFile af)
{
    if (!af)
        return false;
    VuoAudioFileInternal afi = (VuoAudioFileInternal)af;
    return afi->playing;
}