bench9000 0.1

data/vendor/psd.rb/lib/psd/channel_image.rb

@@ -0,0 +1,115 @@
+require_relative 'image'
+
+class PSD
+  # Represents an image for a single layer, which differs slightly in format from
+  # the full size preview image.
+  class ChannelImage < Image
+    include ImageFormat::LayerRLE
+    include ImageFormat::LayerRAW
+
+    attr_reader :width, :height, :mask_data
+    
+    def initialize(file, header, layer)
+      @layer = layer
+
+      @width = @layer.width
+      @height = @layer.height
+
+      super(file, header)
+
+      @channels_info = @layer.channels_info
+      @has_mask = @layer.mask.width * @layer.mask.height > 0
+      @opacity = @layer.opacity / 255.0
+      @mask_data = []
+    end
+
+    def skip
+      PSD.logger.debug "Skipping channel image data. Layer = #{@layer.name}"
+      @channels_info.each do |ch|
+        @file.seek ch[:length], IO::SEEK_CUR
+      end
+    end
+
+    def channels
+      @layer.channels
+    end
+
+    def parse
+      PSD.logger.debug "Layer = #{@layer.name}, Size = #{width}x#{height}"
+      PSD.logger.debug @channels_info
+
+      @chan_pos = 0
+      @channels_info.each do |ch_info|
+        @ch_info = ch_info
+        if ch_info[:length] <= 0
+          parse_compression! and next
+        end
+
+        # If the ID of this current channel is -2, then we assume the dimensions
+        # of the layer mask.
+        if ch_info[:id] == -2
+          @width = @layer.mask.width
+          @height = @layer.mask.height
+        else
+          @width = @layer.width
+          @height = @layer.height
+        end
+
+        @length = @width * @height
+
+        start = @file.tell
+
+        PSD.logger.debug "Channel ##{ch_info[:id]}, length = #{ch_info[:length]}"
+        parse_image_data!
+
+        finish = @file.tell
+
+        if finish != start + ch_info[:length]
+          PSD.logger.error "Read incorrect number of bytes for channel ##{ch_info[:id]}. Expected = #{ch_info[:length]}, Actual = #{finish - start}"
+          @file.seek start + ch_info[:length]
+        end
+      end
+
+      if @channel_data.length != (@length * @channels_info.length)
+        PSD.logger.error "#{@channel_data.length} read; expected #{@length}"
+      end
+
+      @width = @layer.width
+      @height = @layer.height
+
+      parse_user_mask
+      process_image_data
+    end
+
+    def parse_image_data!
+      @compression = parse_compression!
+
+      case @compression
+      when 0 then parse_raw!
+      when 1 then parse_rle!
+      when 2, 3 then parse_zip!
+      else
+        PSD.logger.error "Unknown image compression: #{@compression}. Attempting to skip."
+        @file.seek(@end_pos)
+      end
+    end
+
+    def parse_user_mask
+      return unless has_mask?
+
+      channel = @channels_info.select { |c| c[:id] == -2 }.first
+      index = @channels_info.index { |c| c[:id] == -2 }
+      return if channel.nil?
+
+      start = @channel_length * index
+      length = @layer.mask.width * @layer.mask.height
+      PSD.logger.debug "Copying user mask: #{length} bytes at #{start}"
+
+      @mask_data = @channel_data[start, length]
+
+      if @mask_data.length != length
+        PSD.logger.error "Mask length is incorrect. Expected = #{length}, Actual = #{@mask_data.length}"
+      end
+    end
+  end
+end

data/vendor/psd.rb/lib/psd/color.rb

@@ -0,0 +1,125 @@
+class PSD
+  # Various color conversion methods. All color values are stored in the PSD
+  # document in the color space as defined by the user instead of a normalized
+  # value of some kind. This means that we have to do all the conversion ourselves
+  # for each color space.
+  module Color
+    extend self
+
+      # This is a relic of libpsd that will likely go away in a future version. It
+      # stored the entire color value in a 32-bit address space for speed.
+    def color_space_to_argb(color_space, color_component)
+      color = case color_space
+      when 0
+        rgb_to_color *color_component
+      when 1
+        hsb_to_color color_component[0], 
+          color_component[1] / 100.0, color_component[2] / 100.0
+      when 2
+        cmyk_to_color color_component[0] / 100.0,
+          color_component[1] / 100.0, color_component[2] / 100.0,
+          color_component[3] / 100.0
+      when 7
+        lab_to_color *color_component
+      else
+        0x00FFFFFF
+      end
+
+      color_to_argb(color)
+    end
+
+    def color_to_argb(color)
+      [
+        (color) >> 24,
+        ((color) & 0x00FF0000) >> 16,
+        ((color) & 0x0000FF00) >> 8,
+        (color) & 0x000000FF
+      ]
+    end
+
+    def rgb_to_color(*args)
+      argb_to_color(255, *args)
+    end
+
+    def argb_to_color(a, r, g, b)
+      (a << 24) | (r << 16) | (g << 8) | b
+    end
+
+    def hsb_to_color(*args)
+      ahsb_to_color(255, *args)
+    end
+
+    def ahsb_to_color(alpha, hue, saturation, brightness)
+      if saturation == 0.0
+        b = g = r = (255 * brightness).to_i
+      else
+        if brightness <= 0.5
+          m2 = brightness * (1 + saturation)
+        else
+          m2 = brightness + saturation - brightness * saturation
+        end
+
+        m1 = 2 * brightness - m2
+        r = hue_to_color(hue + 120, m1, m2)
+        g = hue_to_color(hue, m1, m2)
+        b = hue_to_color(hue - 120, m1, m2)
+      end
+
+      argb_to_color alpha, r, g, b
+    end
+
+    def hue_to_color(hue, m1, m2)
+      hue = (hue % 360).to_i
+      if hue < 60
+        v = m1 + (m2 - m1) * hue / 60
+      elsif hue < 180
+        v = m2
+      elsif hue < 240
+        v = m1 + (m2 - m1) * (240 - hue) / 60
+      else
+        v = m1
+      end
+
+      (v * 255).to_i
+    end
+
+    def cmyk_to_color(c, m, y, k)
+      r = 1 - (c * (1 - k) + k) * 255
+      g = 1 - (m * (1 - k) + k) * 255
+      b = 1 - (y * (1 - k) + k) * 255
+
+      r = [0, r, 255].sort[1]
+      g = [0, g, 255].sort[1]
+      b = [0, b, 255].sort[1]
+
+      rgb_to_color r, g, b
+    end
+
+    def lab_to_color(*args)
+      alab_to_color(255, *args)
+    end
+
+    def alab_to_color(alpha, l, a, b)
+      xyz = lab_to_xyz(l, a, b)
+      axyz_to_color alpha, xyz[:x], xyz[:y], xyz[:z]
+    end
+
+    def lab_to_xyz(l, a, b)
+      y = (l + 16) / 116
+      x = y + (a / 500)
+      z = y - (b / 200)
+
+      x, y, z = [x, y, z].map do |n|
+        n**3 > 0.008856 ? n**3 : (n - 16 / 116) / 7.787
+      end
+    end
+
+    def cmyk_to_rgb(c, m, y, k)
+      Hash[{
+        r: (65535 - (c * (255 - k) + (k << 8))) >> 8,
+        g: (65535 - (m * (255 - k) + (k << 8))) >> 8,
+        b: (65535 - (y * (255 - k) + (k << 8))) >> 8
+      }.map { |k, v| [k, Util.clamp(v, 0, 255)] }]
+    end
+  end
+end

data/vendor/psd.rb/lib/psd/descriptor.rb

@@ -0,0 +1,200 @@
+class PSD
+  # A descriptor is a block of data that describes a complex data structure of some kind.
+  # It was added sometime around Photoshop 5.0 and it superceded a few legacy things such
+  # as layer names and type data.
+  class Descriptor
+    # Store a reference to our file and initialize our data structure.
+    def initialize(file)
+      @file = file
+      @data = {}
+    end
+
+    # Parse the descriptor. Descriptors always start with a class identifier, followed by
+    # a variable number of items in the descriptor. We return the Hash that represents
+    # the full data structure.
+    def parse
+      PSD.logger.debug "Descriptor: pos = #{@file.tell}"
+
+      @data[:class] = parse_class
+      num_items = @file.read_int
+
+      PSD.logger.debug "Class = #{@data[:class]}, Item count = #{num_items}"
+
+      num_items.times do |i|
+        id, value = parse_key_item
+        @data[id] = value
+      end
+
+      @data
+    end
+
+    private
+
+    def parse_class
+      {
+        name: @file.read_unicode_string,
+        id: parse_id
+      }
+    end
+
+    def parse_id
+      len = @file.read_int
+      len == 0 ? @file.read_string(4) : @file.read_string(len)
+    end
+
+    def parse_key_item
+      id = parse_id
+      PSD.logger.debug "Key = #{id}"
+
+      value = parse_item
+
+      return id, value
+    end
+
+    def parse_item(type = nil)
+      type = @file.read_string(4) if type.nil?
+      PSD.logger.debug "Type = #{type}"
+
+      value = case type
+      when 'bool'         then parse_boolean
+      when 'type', 'GlbC' then parse_class
+      when 'Objc', 'GlbO' then Descriptor.new(@file).parse
+      when 'doub'         then parse_double
+      when 'enum'         then parse_enum
+      when 'alis'         then parse_alias
+      when 'Pth'          then parse_file_path
+      when 'long'         then parse_integer
+      when 'comp'         then parse_large_integer
+      when 'VlLs'         then parse_list
+      when 'ObAr'         then parse_object_array
+      when 'tdta'         then parse_raw_data
+      when 'obj '         then parse_reference
+      when 'TEXT'         then @file.read_unicode_string
+      when 'UntF'         then parse_unit_double
+      when 'UnFl'         then parse_unit_float
+      end
+
+      return value
+    end
+
+    def parse_boolean;  @file.read_boolean; end
+    def parse_double;   @file.read_double; end
+    def parse_integer;  @file.read_int; end
+    def parse_large_integer; @file.read_longlong; end
+    def parse_identifier; @file.read_int; end
+    def parse_index; @file.read_int; end
+    def parse_offset; @file.read_int; end
+    def parse_property; parse_id; end
+
+    # Discard the first ID becasue it's the same as the key
+    # parsed from the Key/Item. Also, YOLO.
+    def parse_enum
+      parse_id
+      parse_id
+    end
+
+    def parse_alias
+      len = @file.read_int
+      @file.read_string len
+    end
+
+    def parse_file_path
+      len = @file.read_int
+
+      # Little-endian, because fuck the world.
+      sig = @file.read_string(4)
+      path_size = @file.read('l<')
+      num_chars = @file.read('l<')
+
+      path = @file.read_unicode_string(num_chars)
+
+      {sig: sig, path: path}
+    end
+
+    def parse_list
+      count = @file.read_int
+      items = []
+
+      count.times do |i|
+        items << parse_item
+      end
+
+      return items
+    end
+
+    def parse_object_array
+      raise NotImplementedError.new("Object array not implemented yet")
+      count = @file.read_int
+      items_in_obj = @file.read_int
+      wat = @file.read_short
+      
+      puts count
+      puts items_in_obj
+      puts wat
+
+      obj = {}
+      count.times do |i|
+        item = []
+        name = @file.read_string(@file.read_int)
+        puts name
+        obj[name] = parse_list
+      end
+
+      return obj
+    end
+
+    def parse_raw_data
+      len = @file.read_int
+      @file.read(len)
+    end
+
+    def parse_reference
+      form = @file.read_string(4)
+      klass = parse_class
+
+      case form
+      when 'Clss' then nil
+      when 'Enmr' then parse_enum
+      when 'Idnt' then parse_identifier
+      when 'indx' then parse_index
+      when 'name' then @file.read_unicode_string
+      when 'rele' then parse_offset
+      when 'prop' then parse_property
+      end
+    end
+
+    def parse_unit_double
+      unit_id = @file.read_string(4)
+      unit = case unit_id
+      when '#Ang' then 'Angle'
+      when '#Rsl' then 'Density'
+      when '#Rlt' then 'Distance'
+      when '#Nne' then 'None'
+      when '#Prc' then 'Percent'
+      when '#Pxl' then 'Pixels'
+      when '#Mlm' then 'Millimeters'
+      when '#Pnt' then 'Points'
+      end
+
+      value = @file.read_double
+      {id: unit_id, unit: unit, value: value}
+    end
+
+    def parse_unit_float
+      unit_id = @file.read_string(4)
+      unit = case unit_id
+      when '#Ang' then 'Angle'
+      when '#Rsl' then 'Density'
+      when '#Rlt' then 'Distance'
+      when '#Nne' then 'None'
+      when '#Prc' then 'Percent'
+      when '#Pxl' then 'Pixels'
+      when '#Mlm' then 'Millimeters'
+      when '#Pnt' then 'Points'
+      end
+
+      value = @file.read_float
+      {id: unit_id, unit: unit, value: value}
+    end
+  end
+end

data/vendor/psd.rb/lib/psd/file.rb

@@ -0,0 +1,104 @@
+class PSD
+  # An extension of the built-in Ruby File class that adds numerous helpers for
+  # reading/writing binary data.
+  class File < ::File
+    # All of the formats and their pack codes that we want to be able to convert into
+    # methods for easy reading/writing.
+    FORMATS = {
+      ulonglong: {
+        length: 8,
+        code: 'Q>'
+      },
+      longlong: {
+        length: 8,
+        code: 'q>'
+      },
+      double: {
+        length: 8,
+        code: 'G'
+      },
+      float: {
+        length: 4,
+        code: 'F'
+      },
+      uint: {
+        length: 4,
+        code: 'L>'
+      },
+      int: {
+        length: 4,
+        code: 'l>'
+      },
+      ushort: {
+        length: 2,
+        code: 'S>'
+      },
+      short: {
+        length: 2,
+        code: 's>'
+      }
+    }
+
+    FORMATS.each do |format, info|
+      define_method "read_#{format}" do
+        read(info[:length]).unpack(info[:code])[0]
+      end
+
+      define_method "write_#{format}" do |val|
+        write [val].pack(info[:code])
+      end
+    end
+
+    # Adobe's lovely signed 32-bit fixed-point number with 8bits.24bits
+    #   http://www.adobe.com/devnet-apps/photoshop/fileformatashtml/PhotoshopFileFormats.htm#50577409_17587
+    def read_path_number
+      read(1).unpack('c*')[0].to_f +
+        (read(3).unpack('B*')[0].to_i(2).to_f / (2 ** 24)).to_f # pre-decimal point
+    end
+
+    def write_path_number(num)
+      write [num.to_i].pack('C')
+
+      # Now for the fun part.
+      # We first convert the decimal to be a whole number representing a
+      # fraction with the denominator of 2^24
+      # Next, we write that number as a 24-bit integer to the file
+      binary_numerator = ((num - num.to_i).abs * 2 ** 24).to_i
+      write [binary_numerator >> 16].pack('C')
+      write [binary_numerator >> 8].pack('C')
+      write [binary_numerator >> 0].pack('C')
+    end
+
+    # Reads a string of the given length and converts it to UTF-8 from the internally used MacRoman encoding.
+    def read_string(length=nil)
+      length = @file.read(1).bytes.to_a[0] if length.nil?
+      read(length).delete("\000")
+    end
+
+    def read_byte
+      read(1).bytes.to_a[0]
+    end
+
+    # Reads a unicode string, which is double the length of a normal string and encoded as UTF-16.
+    def read_unicode_string(length=nil)
+      length ||= read_int if length.nil?
+      !length.nil? && length > 0 ? read(length * 2).encode('UTF-8', 'UTF-16BE').delete("\000") : ''
+    end
+
+    # Reads a boolean value.
+    def read_boolean
+      read_byte != 0
+    end
+
+    # Reads a 32-bit color space value.
+    def read_space_color
+      color_space = read_short
+      color_component = []
+      4.times do |i|
+        color_component.push(read_short >> 8)
+      end
+
+      Color.color_space_to_argb(color_space, color_component)
+    end
+  end
+end