musicbeeipc 2.0.0.1

data/lib/pack.rb

@@ -0,0 +1,282 @@
+#----------------------------------------------------------#
+#- MusicBeeIPCSDK Rb v2.0.0                               -#
+#- Copyright © Kerli Low 2014                             -#
+#- This file is licensed under the                        -#
+#- BSD 2-Clause License                                   -#
+#- See LICENSE_MusicBeeIPCSDK for more information.       -#
+#----------------------------------------------------------#
+
+require_relative "constants.rb"
+require_relative "structs.rb"
+
+
+class MusicBeeIPC
+  private
+  
+  # ----------------------------------------------------------------------------
+  # All strings are encoded in UTF-16 little endian
+  # ----------------------------------------------------------------------------
+
+  # -Int32: 32 bit integer
+  # -Int32: 32 bit integer
+  # -...
+  def pack_i(*int32s)
+    cds = COPYDATASTRUCT.new
+    cds[:dwData] = 0
+    
+    num = int32s.length
+    
+    cds[:cbData] = MBIPC_SIZEOFINT * num
+    
+    data = int32s.pack("l" + num.to_s)
+    
+    cds[:lpData] = FFI::MemoryPointer.from_string(data)
+    
+    return cds.to_ptr.address
+  end
+
+  # -Int32:  Byte count of string
+  # -byte[]: String data
+  # -Int32:  Byte count of string
+  # -byte[]: String data
+  # -...
+  def pack_s(*strings)
+    cds = COPYDATASTRUCT.new
+    cds[:dwData] = 0
+    
+    num = strings.length
+    
+    cds[:cbData] = MBIPC_SIZEOFINT * num
+    
+    encoded = strings.map do |s|
+      e = s.encode("UTF-16LE").force_encoding("BINARY")
+      cds[:cbData] += e.length
+      e
+    end
+    
+    data = ""
+    encoded.each { |e| data += [e.length].pack("l") + e }
+    
+    cds[:lpData] = FFI::MemoryPointer.from_string(data)
+    
+    return cds.to_ptr.address
+  end
+
+  # -Int32:  Byte count of string
+  # -byte[]: String data
+  # -Int32:  32 bit integer
+  # -Int32:  32 bit integer
+  # -...
+  def pack_si(string_1, *int32s)
+    cds = COPYDATASTRUCT.new
+    cds[:dwData] = 0
+    
+    encoded = string_1.encode("UTF-16LE").force_encoding("BINARY")
+    byte_count = encoded.length
+    
+    num = int32s.length
+    
+    cds[:cbData] = MBIPC_SIZEOFINT * (num + 1) + byte_count
+    
+    data = [byte_count].pack("l") + encoded +
+           int32s.pack("l" + int32s.length.to_s)
+    
+    cds[:lpData] = FFI::MemoryPointer.from_string(data)
+    
+    return cds.to_ptr.address
+  end
+
+  # -Int32:  Byte count of string
+  # -byte[]: String data
+  # -Int32:  bool
+  # -Int32:  bool
+  # -...
+  def pack_sb(string_1, *bools)
+    cds = COPYDATASTRUCT.new
+    cds[:dwData] = 0
+    
+    encoded = string_1.encode("UTF-16LE").force_encoding("BINARY")
+    byte_count = encoded.length
+    
+    bools_i = bools.map { |b| b ? 1 : 0 }
+    
+    num = bools_i.length
+    
+    cds[:cbData] = MBIPC_SIZEOFINT * (num + 1) + byte_count
+    
+    data = [byte_count].pack("l") + encoded +
+           bools_i.pack("l" + bools_i.length.to_s)
+    
+    cds[:lpData] = FFI::MemoryPointer.from_string(data)
+    
+    return cds.to_ptr.address
+  end
+
+  # -Int32:  Byte count of string
+  # -byte[]: String data
+  # -double: 64-bit floating-point value
+  # -double: 64-bit floating-point value
+  # -...
+  def pack_sd(string_1, *doubles)
+    cds = COPYDATASTRUCT.new
+    cds[:dwData] = 0
+    
+    encoded = string_1.encode("UTF-16LE").force_encoding("BINARY")
+    byte_count = encoded.length
+    
+    num = doubles.length
+    
+    cds[:cbData] = MBIPC_SIZEOFDOUBLE * num + MBIPC_SIZEOFINT + byte_count
+    
+    data = [byte_count].pack("l") + encoded +
+           doubles.pack("d" + doubles.length.to_s)
+    
+    cds[:lpData] = FFI::MemoryPointer.from_string(data)
+    
+    return cds.to_ptr.address
+  end
+
+  # -Int32:  Byte count of string
+  # -byte[]: String data
+  # -Int32:  Number of strings in string array
+  # -Int32:  Byte count of string in string array
+  # -byte[]: String data in string array
+  # -Int32:  Byte count of string in string array
+  # -byte[]: String data in string array
+  # -...
+  def pack_ssa(string_1, strings)
+    cds = COPYDATASTRUCT.new
+    cds[:dwData] = 0
+    
+    encoded_1 = string_1.encode("UTF-16LE").force_encoding("BINARY")
+    byte_count_1 = encoded_1.length
+    
+    num = strings.length
+    
+    cds[:cbData] = MBIPC_SIZEOFINT * (num + 2) + byte_count_1
+    
+    encoded = strings.map do |s|
+      e = s.encode("UTF-16LE").force_encoding("BINARY")
+      cds[:cbData] += e.length
+      e
+    end
+    
+    data = [byte_count_1].pack("l") + encoded_1 + [num].pack("l")
+    encoded.each { |e| data += [e.length].pack("l") + e }
+    
+    cds[:lpData] = FFI::MemoryPointer.from_string(data)
+    
+    return cds.to_ptr.address
+  end
+
+  # -Int32:  Byte count of string
+  # -byte[]: String data
+  # -Int32:  Byte count of string
+  # -byte[]: String data
+  # -Int32:  Number of strings in string array
+  # -Int32:  Byte count of string in string array
+  # -byte[]: String data in string array
+  # -Int32:  Byte count of string in string array
+  # -byte[]: String data in string array
+  # -...
+  def pack_sssa(string_1, string_2, strings)
+    cds = COPYDATASTRUCT.new
+    cds[:dwData] = 0
+    
+    encoded_1 = string_1.encode("UTF-16LE").force_encoding("BINARY")
+    byte_count_1 = encoded_1.length
+    
+    encoded_2 = string_2.encode("UTF-16LE").force_encoding("BINARY")
+    byte_count_2 = encoded_2.length
+    
+    num = strings.length
+    
+    cds[:cbData] = MBIPC_SIZEOFINT * (num + 3) + byte_count_1 + byte_count_2
+    
+    encoded = strings.map do |s|
+      e = s.encode("UTF-16LE").force_encoding("BINARY")
+      cds[:cbData] += e.length
+      e
+    end
+    
+    data = [byte_count_1].pack("l") + encoded_1 +
+           [byte_count_2].pack("l") + encoded_2 + [num].pack("l")
+    encoded.each { |e| data += [e.length].pack("l") + e }
+    
+    cds[:lpData] = FFI::MemoryPointer.from_string(data)
+    
+    return cds.to_ptr.address
+  end
+
+  # -Int32:  Byte count of string
+  # -byte[]: String data
+  # -Int32: 32 bit integer
+  # -Int32:  Byte count of string
+  # -byte[]: String data
+  # -...
+  def pack_sis(string_1, int32_1, string_2)
+    cds = COPYDATASTRUCT.new
+    cds[:dwData] = 0
+    
+    encoded_1 = string_1.encode("UTF-16LE").force_encoding("BINARY")
+    byte_count_1 = encoded_1.length
+    
+    encoded_2 = string_2.encode("UTF-16LE").force_encoding("BINARY")
+    byte_count_2 = encoded_2.length
+    
+    cds[:cbData] = MBIPC_SIZEOFINT * 3 + byte_count_1 + byte_count_2
+    
+    data = [byte_count_1].pack("l") + encoded_1 +
+           [int32_1, byte_count_2].pack("ll") + encoded_2
+    
+    cds[:lpData] = FFI::MemoryPointer.from_string(data)
+    
+    return cds.to_ptr.address
+  end
+
+  # -Int32: Number of integers in integer array
+  # -Int32: 32 bit integer
+  # -Int32: 32 bit integer
+  # -...
+  # -Int32: 32 bit integer
+  def pack_iai(int32s, int32_1)
+    cds = COPYDATASTRUCT.new
+    cds[:dwData] = 0
+    
+    num = int32s.length
+    
+    cds[:cbData] = MBIPC_SIZEOFINT * (num + 2)
+    
+    data = ([num] + int32s + [int32_1]).pack("l" + (num + 2).to_s)
+    
+    cds[:lpData] = FFI::MemoryPointer.from_string(data)
+    
+    return cds.to_ptr.address
+  end
+
+  # -Int32:  Byte count of string
+  # -byte[]: String data
+  # -Int32:  Number of integers in integer array
+  # -Int32:  32 bit integer
+  # -Int32:  32 bit integer
+  # -...
+  # -Int32:  32 bit integer
+  def pack_siai(string_1, int32s, int32_1)
+    cds = COPYDATASTRUCT.new
+    cds[:dwData] = 0
+    
+    encoded = string_1.encode("UTF-16LE").force_encoding("BINARY")
+    byte_count = encoded.length
+    
+    num = int32s.length
+    
+    cds[:cbData] = MBIPC_SIZEOFINT * (num + 3) + byte_count
+    
+    data = [byte_count].pack("l") + encoded +
+           ([num] + int32s + [int32_1]).pack("l" + (num + 2).to_s)
+    
+    cds[:lpData] = FFI::MemoryPointer.from_string(data)
+    
+    return cds.to_ptr.address
+  end
+end

data/lib/structs.rb

@@ -0,0 +1,40 @@
+#----------------------------------------------------------#
+#- MusicBeeIPCSDK Rb v2.0.0                               -#
+#- Copyright © Kerli Low 2014                             -#
+#- This file is licensed under the                        -#
+#- BSD 2-Clause License                                   -#
+#- See LICENSE_MusicBeeIPCSDK for more information.       -#
+#----------------------------------------------------------#
+
+require "ffi"
+
+
+class FloatInt < FFI::Union
+  layout :f, :float,
+         :i, :int
+         
+  def initialize(opts={}, *args)
+    self[:f] = opts[:f] if opts[:f]
+    self[:i] = opts[:i] if opts[:i]
+    super(*args)
+  end
+end
+
+
+class LRUShort < FFI::Union  
+  layout :lr, :long,
+         :low, :ushort,
+         :high, :ushort, 2
+         
+  def initialize(lr=0, *args)
+    self[:lr] = lr
+    super(*args)
+  end
+end
+
+
+class COPYDATASTRUCT < FFI::Struct
+  layout :dwData, :pointer,
+         :cbData, :uint32,
+         :lpData, :pointer
+  end

data/lib/unpack.rb

@@ -0,0 +1,204 @@
+#----------------------------------------------------------#
+#- MusicBeeIPCSDK Rb v2.0.0                               -#
+#- Copyright © Kerli Low 2014                             -#
+#- This file is licensed under the                        -#
+#- BSD 2-Clause License                                   -#
+#- See LICENSE_MusicBeeIPCSDK for more information.       -#
+#----------------------------------------------------------#
+
+require_relative "constants.rb"
+require_relative "structs.rb"
+
+
+class MusicBeeIPC
+  private
+  
+  # ----------------------------------------------------------------------------
+  # All strings are encoded in UTF-16 little endian
+  # ----------------------------------------------------------------------------
+
+  # -Int32:  Byte count of the string
+  # -byte[]: String data
+  # Free lr after use
+  #
+  # @return [String]
+  def unpack_s(lr)
+    string_1 = ""
+    
+    begin
+      mmf = open_mmf(lr)
+      raise "Failed to open MMF." if !mmf
+      
+      view, ptr = map_mmf_view(mmf, lr)
+      raise "Failed to map MMF view." if !view
+    rescue
+      return ""
+    ensure
+      close_mmf(mmf) if mmf
+    end
+    
+    begin
+      byte_count = ptr.read_string(MBIPC_SIZEOFINT).unpack("l")[0]
+      ptr += MBIPC_SIZEOFINT
+      
+      if byte_count > 0
+        string_1 = ptr.read_string(byte_count).force_encoding("UTF-16LE").
+                   encode(__ENCODING__)
+      end
+    rescue
+      return ""
+    ensure
+      unmap_mmf_view(view)
+      close_mmf(mmf)
+    end
+    
+    return string_1
+  end
+
+  # -Int32:  Number of strings
+  # -Int32:  Byte count of 1st string
+  # -byte[]: 1st string data
+  # -Int32:  Byte count of 2nd string
+  # -byte[]: 2nd string data
+  # -...
+  # Free lr after use
+  #
+  # @return [Array<String>]
+  def unpack_sa(lr)
+    begin
+      mmf = open_mmf(lr)
+      raise "Failed to open MMF." if !mmf
+      
+      view, ptr = map_mmf_view(mmf, lr)
+      raise "Failed to map MMF view." if !view
+    rescue
+      return []
+    ensure
+      close_mmf(mmf) if mmf
+    end
+    
+    begin
+      str_count = ptr.read_string(MBIPC_SIZEOFINT).unpack("l")[0]
+      ptr += MBIPC_SIZEOFINT
+      
+      strings = Array.new(str_count)
+      
+      strings.map! do |s|
+        byte_count = ptr.read_string(MBIPC_SIZEOFINT).unpack("l")[0]
+        ptr += MBIPC_SIZEOFINT
+      
+        if byte_count > 0
+          s = ptr.read_string(byte_count).force_encoding("UTF-16LE").
+              encode(__ENCODING__)
+          ptr += byte_count
+          s
+        end
+      end
+    rescue
+      return []
+    ensure
+      unmap_mmf_view(view)
+      close_mmf(mmf)
+    end
+    
+    return strings
+  end
+
+  # -Int32: 1st 32 bit integer
+  # -Int32: 2nd 32 bit integer
+  # Free lr after use
+  #
+  # @return [Array<int>]
+  def unpack_ii(lr)
+    begin
+      mmf = open_mmf(lr)
+      raise "Failed to open MMF." if !mmf
+      
+      view, ptr = map_mmf_view(mmf, lr)
+      raise "Failed to map MMF view." if !view
+    rescue
+      return [-1, -1]
+    ensure
+      close_mmf(mmf) if mmf
+    end
+    
+    begin
+      ints = ptr.read_string(MBIPC_SIZEOFINT * 2).unpack("ll")
+    rescue
+      return [-1, -1]
+    ensure
+      unmap_mmf_view(view)
+      close_mmf(mmf)
+    end
+    
+    return ints
+  end
+
+  # -Int32: Number of integers
+  # -Int32: 1st 32 bit integer
+  # -Int32: 2nd 32 bit integer
+  # -...
+  # Free lr after use
+  #
+  # @return [Array<int>]
+  def unpack_ia(lr)
+    begin
+      mmf = open_mmf(lr)
+      raise "Failed to open MMF." if !mmf
+      
+      view, ptr = map_mmf_view(mmf, lr)
+      raise "Failed to map MMF view." if !view
+    rescue
+      return []
+    ensure
+      close_mmf(mmf) if mmf
+    end
+    
+    begin
+      int_count = ptr.read_string(MBIPC_SIZEOFINT).unpack("l")[0]
+      ptr += MBIPC_SIZEOFINT
+      
+      ints = ptr.read_string(MBIPC_SIZEOFINT * int_count).
+                 unpack("l" + int_count.to_s)
+    rescue
+      return []
+    ensure
+      unmap_mmf_view(view)
+      close_mmf(mmf)
+    end
+    
+    return ints
+  end
+  
+  
+  def open_mmf(lr)
+    return nil if !lr || lr == 0
+    
+    ls = LRUShort.new(lr)
+    
+    name = ("mbipc_mmf_" + ls[:low].to_s + "\0").encode("UTF-16LE")
+
+    # FILE_MAP_READ = 0x0004 = 4
+    # FALSE = 0
+    open_file_mapping(4, 0, name)
+  end
+  
+  def close_mmf(mmf)
+    close_handle(mmf)
+  end
+  
+  def map_mmf_view(mmf, lr)
+    ls = LRUShort.new(lr)
+    
+    # FILE_MAP_READ = 0x0004 = 4
+    view = map_view_of_file(mmf, 4, 0, 0, 0)
+    
+    ptr = FFI::Pointer.new(:char, view + ls[:high] + MBIPC_SIZEOFLONG)
+    
+    return [view, ptr]
+  end
+  
+  def unmap_mmf_view(view)
+    unmap_view_of_file(view)
+  end
+end