dhun 0.5.0

data/ext/extconf.rb

@@ -0,0 +1,15 @@
+# Loads mkmf which is used to make makefiles for Ruby extensions
+require 'mkmf'
+
+# Give it a name
+extension_name = 'dhun_ext'
+
+# The destination
+dir_config(extension_name)
+
+# Config changes
+$LDFLAGS << " -framework AudioToolbox -framework CoreServices"
+$CFLAGS << " -std=c99"
+
+# Do the work
+create_makefile(extension_name)

data/ext/player.c

@@ -0,0 +1,187 @@
+#include "dhun.h"
+
+AQPlayerState aqData;
+
+static void HandleOutputBuffer (void                *aqData,
+                                AudioQueueRef       inAQ,
+                                AudioQueueBufferRef inBuffer) {
+  AQPlayerState *pAqData = (AQPlayerState *) aqData;
+
+  if (pAqData->mIsRunning == 0) return;
+  UInt32 numBytesReadFromFile;
+  UInt32 numPackets = pAqData->mNumPacketsToRead;
+
+  AudioFileReadPackets (pAqData->mAudioFile,
+                        false,
+                        &numBytesReadFromFile,
+                        pAqData->mPacketDescs,
+                        pAqData->mCurrentPacket,
+                        &numPackets,
+                        inBuffer->mAudioData);
+  if (numPackets > 0) {
+    inBuffer->mAudioDataByteSize = numBytesReadFromFile;
+    AudioQueueEnqueueBuffer (pAqData->mQueue,
+                             inBuffer,
+                             (pAqData->mPacketDescs ? numPackets : 0),
+                             pAqData->mPacketDescs);
+    pAqData->mCurrentPacket += numPackets;
+  } else {
+    AudioQueueStop (pAqData->mQueue,
+                    false);
+    //printf("Play Stopped!\n");
+    pAqData->mIsRunning = false;
+  }
+}
+
+void DeriveBufferSize (AudioStreamBasicDescription *ASBDesc,
+                       UInt32                      maxPacketSize,
+                       Float64                     seconds,
+                       UInt32                      *outBufferSize,
+                       UInt32                      *outNumPacketsToRead) {
+  static const int maxBufferSize = 0x50000;
+  static const int minBufferSize = 0x4000;
+
+  if (ASBDesc->mFramesPerPacket != 0) {
+    Float64 numPacketsForTime =
+      ASBDesc->mSampleRate / ASBDesc->mFramesPerPacket * seconds;
+
+    *outBufferSize = numPacketsForTime * maxPacketSize;
+  } else {
+    *outBufferSize =
+      maxBufferSize > maxPacketSize ?
+      maxBufferSize : maxPacketSize;
+  }
+
+  if (
+      *outBufferSize > maxBufferSize &&
+      *outBufferSize > maxPacketSize
+      )
+    *outBufferSize = maxBufferSize;
+  else {
+    if (*outBufferSize < minBufferSize)
+      *outBufferSize = minBufferSize;
+  }
+
+  *outNumPacketsToRead = *outBufferSize / maxPacketSize;
+}
+
+void playFile(const char* filePath) {
+
+  CFURLRef audioFileURL = CFURLCreateFromFileSystemRepresentation(NULL,
+                                                                  (UInt8*) filePath,
+                                                                  strlen (filePath),
+                                                                  false);
+
+
+  OSStatus result = AudioFileOpenURL(audioFileURL,
+                                     fsRdPerm,
+                                     0,
+                                     &aqData.mAudioFile);
+
+  CFRelease (audioFileURL);
+
+  UInt32 dataFormatSize = sizeof (aqData.mDataFormat);
+
+  AudioFileGetProperty(aqData.mAudioFile,
+                       kAudioFilePropertyDataFormat,
+                       &dataFormatSize,
+                       &aqData.mDataFormat);
+
+  AudioQueueNewOutput(&aqData.mDataFormat,
+                      HandleOutputBuffer,
+                      &aqData,
+                      CFRunLoopGetCurrent(),
+                      kCFRunLoopCommonModes,
+                      0,
+                      &aqData.mQueue);
+
+  UInt32 maxPacketSize;
+  UInt32 propertySize = sizeof (maxPacketSize);
+  AudioFileGetProperty(aqData.mAudioFile,
+                       kAudioFilePropertyPacketSizeUpperBound,
+                       &propertySize,
+                       &maxPacketSize);
+
+
+  DeriveBufferSize(&aqData.mDataFormat,
+                   maxPacketSize,
+                   0.5,
+                   &aqData.bufferByteSize,
+                   &aqData.mNumPacketsToRead);
+
+  bool isFormatVBR = (aqData.mDataFormat.mBytesPerPacket == 0 ||
+                      aqData.mDataFormat.mFramesPerPacket == 0);
+
+  if (isFormatVBR) {
+    // LOG("%s\n","VBR");
+    aqData.mPacketDescs =
+      (AudioStreamPacketDescription*)
+      malloc (aqData.mNumPacketsToRead * sizeof (AudioStreamPacketDescription));
+  } else {
+    aqData.mPacketDescs = NULL;
+  }
+
+  UInt32 cookieSize = sizeof (UInt32);
+  bool couldNotGetProperty =
+    AudioFileGetPropertyInfo (aqData.mAudioFile,
+                              kAudioFilePropertyMagicCookieData,
+                              &cookieSize,
+                              NULL);
+
+  if (!couldNotGetProperty && cookieSize) {
+    char* magicCookie = (char *) malloc (cookieSize);
+
+    AudioFileGetProperty (aqData.mAudioFile,
+                          kAudioFilePropertyMagicCookieData,
+                          &cookieSize,
+                          magicCookie);
+
+    AudioQueueSetProperty (aqData.mQueue,
+                           kAudioQueueProperty_MagicCookie,
+                           magicCookie,
+                           cookieSize);
+
+    free (magicCookie);
+  }
+
+  aqData.mCurrentPacket = 0;
+  aqData.mIsRunning = true;
+
+  //LOG("%d\n", aqData.mNumPacketsToRead);
+  for (int i = 0; i < kNumberBuffers; ++i) {
+    AudioQueueAllocateBuffer (aqData.mQueue,
+                              aqData.bufferByteSize,
+                              &aqData.mBuffers[i]);
+
+    HandleOutputBuffer (&aqData,
+                        aqData.mQueue,
+                        aqData.mBuffers[i]);
+  }
+
+  Float32 gain = 1.0;
+  // Optionally, allow user to override gain setting here
+  AudioQueueSetParameter (aqData.mQueue,
+                          kAudioQueueParam_Volume,
+                          gain);
+
+
+  //LOG("%s\n","Starting play");
+
+
+  // IMPORTANT NOTE : This value must be set
+  // Before the call to HandleOutputBuffer
+  //a qData.mIsRunning = true;
+
+  AudioQueueStart (aqData.mQueue,
+                   NULL);
+
+}
+
+
+void free_aqData() {
+  AudioQueueDispose (aqData.mQueue, true);
+
+  AudioFileClose (aqData.mAudioFile);
+
+  free (aqData.mPacketDescs);
+}

data/ext/query.c

@@ -0,0 +1,102 @@
+#include "dhun.h"
+
+SearchResults queryResults;
+
+void notificationCallback(CFNotificationCenterRef  center,
+                          void                    *observer,
+                          CFStringRef              name,
+                          const void              *object,
+                          CFDictionaryRef          userInfo) {
+  //CFDictionaryRef attributes;
+  //CFArrayRef      attributeNames;
+  CFTypeRef         attrValue = NULL;
+  CFIndex         idx, count;
+  MDItemRef       itemRef = NULL;
+  MDQueryRef      queryRef = (MDQueryRef)object;
+  CFStringRef      attrName = NULL;
+  CFStringEncoding  encoding = CFStringGetSystemEncoding();
+
+  if (CFStringCompare(name, kMDQueryDidFinishNotification, 0)
+      == kCFCompareEqualTo) { // gathered results
+    // disable updates, process results, and reenable updates
+    MDQueryDisableUpdates(queryRef);
+    count = MDQueryGetResultCount(queryRef);
+    if (count > 0) {
+      queryResults.size=count;
+      queryResults.files = (char**) malloc(count*sizeof(char*));
+      for (idx = 0; idx < count; idx++) {
+        itemRef = (MDItemRef)MDQueryGetResultAtIndex(queryRef, idx);
+        //attributeNames = MDItemCopyAttributeNames(itemRef);
+        //attributes = MDItemCopyAttributes(itemRef, attributeNames);
+        attrName = CFStringCreateWithCString(NULL,
+                                             "kMDItemPath", encoding);
+        attrValue = MDItemCopyAttribute(itemRef, attrName);
+        const char* convertedString =  CFStringGetCStringPtr((CFStringRef)attrValue, encoding);
+        queryResults.files[idx] = malloc(strlen(convertedString)+1);
+        strcpy(queryResults.files[idx],convertedString);
+        //CFShow(attrValue);
+        //CFRelease(attributes);
+        //CFRelease(attributeNames);
+      }
+      //printf("%ld results total\n", count);
+    }
+    MDQueryEnableUpdates(queryRef);
+  } else if (CFStringCompare(name, kMDQueryDidUpdateNotification, 0)
+             == kCFCompareEqualTo) { // live update
+    CFShow(name), CFShow(object), CFShow(userInfo);
+  }
+  // ignore kMDQueryProgressNotification
+}
+
+int getFilesForQuery(const char* queryStr)
+{
+  int                     i;
+  CFStringRef             rawQuery = NULL;
+  MDQueryRef              queryRef;
+  Boolean                 result;
+  CFNotificationCenterRef localCenter;
+  MDQueryBatchingParams   batchingParams;
+  //char* query;
+  //asprintf(&query,QUERY_TEMPLATE,queryStr,queryStr,queryStr);
+  //printf("Querying for %s\n", query);
+  rawQuery = CFStringCreateWithCString(kCFAllocatorDefault,
+                                       queryStr,
+                                       CFStringGetSystemEncoding());
+
+  queryRef = MDQueryCreate(kCFAllocatorDefault, rawQuery, NULL, NULL);
+  if (queryRef == NULL)
+    goto out;
+
+  if (!(localCenter = CFNotificationCenterGetLocalCenter())) {
+    fprintf(stderr, "failed to access local notification center\n");
+    goto out;
+  }
+
+  CFNotificationCenterAddObserver(localCenter,          // process-local center
+                                  NULL,                 // observer
+                                  notificationCallback, // to process query finish/update notifications
+                                  NULL,                 // observe all notifications
+                                  (void *)queryRef,     // observe notifications for this object
+                                  CFNotificationSuspensionBehaviorDeliverImmediately);
+
+  // maximum number of results that can accumulate and the maximum number
+  // of milliseconds that can pass before various notifications are sent
+  batchingParams.first_max_num    = 1000; // first progress notification
+  batchingParams.first_max_ms     = 1000;
+  batchingParams.progress_max_num = 1000; // additional progress notifications
+  batchingParams.progress_max_ms  = 1000;
+  batchingParams.update_max_num   = 1;    // update notification
+  batchingParams.update_max_ms    = 1000;
+  MDQuerySetBatchingParameters(queryRef, batchingParams);
+
+  // go execute the query
+  MDQueryExecute(queryRef, kMDQuerySynchronous);
+
+ out:
+  CFRelease(rawQuery);
+  if (queryRef)
+    CFRelease(queryRef);
+
+  //  free(query);
+  return 0;
+}

data/lib/dhun.rb

@@ -0,0 +1,13 @@
+module Dhun
+  VERSION = '0.5.0'
+  
+  autoload :Runner, 'dhun/runner'
+  autoload :Controller, 'dhun/controller'
+  autoload :Server, 'dhun/server'
+  autoload :DhunServer, 'dhun/dhun_server'
+  autoload :DhunClient, 'dhun/dhun_client'
+  autoload :Handler, 'dhun/handler'
+  autoload :Player, 'dhun/player'
+  autoload :Query, 'dhun/query'
+  autoload :Result, 'dhun/result'
+end

data/lib/dhun/command.rb

@@ -0,0 +1,15 @@
+require 'json'
+module Dhun
+  class Command
+    attr_reader :commands, :arguments
+    
+    def initialize(command,arguments)
+      @command = command
+      @arguments = arguments
+    end
+    
+    def to_json
+      { "command" => @command, "arguments" => @arguments }.to_json
+    end
+  end
+end

data/lib/dhun/controller.rb

@@ -0,0 +1,116 @@
+require 'json'
+module Dhun
+  class Controller
+
+    attr_accessor :options
+    
+    def initialize(options)
+      @options = options
+    end
+
+    def start
+      server = Server.new(@options)
+      if DhunClient.is_dhun_server_running?(@options[:socket])
+        puts "Dhun is already running"
+      else
+        server.start
+      end
+    end
+    
+    def stop
+      send_command("stop")
+    end
+    
+    def query(*args)
+      q = Query.new(args.join(' '))
+      if q.is_valid?
+        files = q.execute_spotlight_query
+        puts(files.empty? ? "No Results Found" : "#{files.size} Results\n" + files.join("\n"))
+      else
+        puts "Invalid Query Syntax. Run dhun -h to see right syntax"
+      end
+    end
+
+    def play(*args)
+      resp = get_json_response("play", args)
+      return unless resp
+      # Process response
+      case resp.success?
+      when true
+        puts resp[:message]
+        # Print list of files
+        print_list resp[:files]
+      else
+        puts resp[:message]
+      end
+    end
+
+    def enqueue(*args)
+      resp = get_json_response("enqueue",args)
+      return unless resp
+      # Process response
+      case resp.success?
+      when true
+        puts resp[:message]
+        # Print list of files
+        print_list resp[:files]
+      else
+        puts resp[:message]
+      end
+    end
+
+    def status
+      resp = get_json_response("status")
+      return unless resp
+      puts resp[:message]
+      if resp.success?
+        now_playing = resp[:now_playing]
+        queue = resp[:queue]
+        puts "Now playing #{now_playing}" if now_playing
+        if queue.empty? 
+          puts "Queue is empty" 
+        else 
+          print_list(queue)
+        end
+      end
+    end
+
+    def next(*args)
+      resp = get_json_response("next")
+      puts resp[:message] if resp
+    end
+
+    def pause
+      resp = get_json_response("pause")
+      puts resp[:message] if resp
+    end
+
+    def resume
+      resp = get_json_response("resume")
+      puts resp[:message] if resp
+    end
+
+
+    protected
+    def send_command(command,arguments=[])
+      cmd = { "command" => command, "arguments" => arguments }.to_json
+      client = DhunClient.new(@options)
+      resp = client.send(cmd)
+    end
+
+    def get_json_response(command,*args)
+      begin 
+         resp = send_command(command,args)
+         return Result.from_json_str(resp)
+      rescue 
+        puts "Invalid Response From Server"
+        puts $!
+        return nil
+      end
+    end
+
+    def print_list(list)
+      list.each { |item| puts item }
+    end
+  end
+end