bench9000 0.1

data/vendor/psd.rb/lib/psd/header.rb

@@ -0,0 +1,69 @@
+class PSD
+  # Describes the Header for the PSD file, which is the first section of the file.
+  class Header < BinData::Record
+    endian :big
+
+    string  :sig, read_length: 4
+    uint16  :version
+
+    # Reserved bytes
+    skip    length: 6
+
+    uint16  :channels
+    uint32  :rows
+    uint32  :cols
+    uint16  :depth
+    uint16  :mode
+
+    uint32  :color_data_len
+    skip    length: :color_data_len
+
+    # All of the color modes are stored internally as a short from 0-15.
+    # This is a mapping of that value to a human-readable name.
+    MODES = [
+      'Bitmap',
+      'GrayScale',
+      'IndexedColor',
+      'RGBColor',
+      'CMYKColor',
+      'HSLColor',
+      'HSBColor',
+      'Multichannel',
+      'Duotone',
+      'LabColor',
+      'Gray16',
+      'RGB48',
+      'Lab48',
+      'CMYK64',
+      'DeepMultichannel',
+      'Duotone16'
+    ]
+
+    # Get the human-readable color mode name.
+    def mode_name
+      if mode >= 0 && mode <= 15
+        MODES[mode]
+      else
+        "(#{mode})"
+      end
+    end
+
+    # Width of the entire document in pixels.
+    def width
+      cols
+    end
+
+    # Height of the entire document in pixels.
+    def height
+      rows
+    end
+
+    def rgb?
+      mode == 3
+    end
+
+    def cmyk?
+      mode == 4
+    end
+  end
+end

data/vendor/psd.rb/lib/psd/helpers.rb

@@ -0,0 +1,51 @@
+class PSD
+  # Various helper methods that make accessing PSD data easier since it's
+  # split up among various sections.
+  module Helpers
+    # Width of the entire PSD document, in pixels.
+    def width
+      header.cols
+    end
+
+    # Height of the entire PSD document, in pixels.
+    def height
+      header.rows
+    end
+
+    # All of the layers in this document, including section divider layers.
+    def layers
+      layer_mask.layers
+    end
+
+    # All of the layers, but filters out the section dividers.
+    def actual_layers
+      layers.delete_if { |l| l.folder? || l.folder_end? }
+    end
+
+    # All of the folders in the document.
+    def folders
+      layers.select { |l| l.folder? }
+    end
+
+    # Constructs a tree of the current document for easy traversal and data access.
+    def tree
+      @root ||= PSD::Node::Root.new(self)
+    end
+
+    def resource(id)
+      @resources[id].nil? ? nil : @resources[id].data
+    end
+
+    def layer_comps
+      resource(:layer_comps).to_a
+    end
+
+    def guides
+      resource(:guides).to_a
+    end
+
+    def slices
+      resource(:slices).to_a
+    end
+  end
+end

data/vendor/psd.rb/lib/psd/image.rb

@@ -0,0 +1,123 @@
+class PSD
+  # Parses the full preview image at the end of the PSD document.
+  class Image
+    include ImageFormat::RAW
+    include ImageFormat::RLE
+    include ImageMode::CMYK
+    include ImageMode::Greyscale
+    include ImageMode::RGB
+    include Export::PNG
+
+    attr_reader :pixel_data, :opacity, :has_mask
+    alias :has_mask? :has_mask
+
+    # All of the possible compression formats Photoshop uses.
+    COMPRESSIONS = [
+      'Raw',
+      'RLE',
+      'ZIP',
+      'ZIPPrediction'
+    ].freeze
+
+    # Store a reference to the file and the header. We also do a few simple calculations
+    # to figure out the number of pixels in the image and the length of each channel.
+    def initialize(file, header)
+      @file = file
+      @header = header
+
+      @num_pixels = width * height
+      @num_pixels *= 2 if depth == 16
+
+      calculate_length
+      @channel_data = []
+      @pixel_data = []
+      @opacity = 1.0
+      @has_mask = false
+
+      @start_pos = @file.tell
+      @end_pos = @start_pos + @length
+
+      PSD.logger.debug "Image: #{width}x#{height}, length = #{@length}, mode = #{@header.mode_name}, position = #{@start_pos}"
+
+      # Each color channel is represented by a unique ID
+      @channels_info = [
+        {id: 0},
+        {id: 1},
+        {id: 2}
+      ]
+
+      @channels_info << {id: -1} if channels == 4
+    end
+
+    # Begins parsing the image by first figuring out the compression format used, and then
+    # by reading the image data.
+    def parse
+      @compression = parse_compression!
+
+      # ZIP not implemented
+      if [2, 3].include?(@compression)
+        PSD.logger.debug "Warning: ZIP image compression not supported yet. Skipping."
+        @file.seek @end_pos and return
+      end
+
+      PSD.logger.debug "Compression: id = #{@compression}, name = #{COMPRESSIONS[@compression]}"
+
+      parse_image_data!
+
+      return self
+    end
+
+    # We delegate a few useful methods to the header.
+    [:height, :width, :channels, :depth, :mode].each do |attribute|
+      define_method attribute do
+        @header.send(attribute)
+      end
+    end
+
+    private
+
+    def calculate_length
+      @length = case depth
+      when 1 then (width + 7) / 8 * height
+      when 16 then width * height * 2
+      else width * height
+      end
+
+      @channel_length = @length
+      @length *= channels
+    end
+
+    def parse_compression!
+      @file.read_short
+    end
+
+    def parse_image_data!
+      case @compression
+      when 0 then parse_raw!
+      when 1 then parse_rle!
+      when 2, 3 then parse_zip!
+      else @file.seek(@end_pos)
+      end
+
+      process_image_data
+    end
+
+    def process_image_data
+      case mode
+      when 1 then combine_greyscale_channel
+      when 3 then combine_rgb_channel
+      when 4 then combine_cmyk_channel
+      end
+
+      @channel_data = nil
+    end
+
+    def pixel_step
+      depth == 8 ? 1 : 2
+    end
+
+    def pixel(i)
+      @pixel_data[i]
+    end
+  end
+end

data/vendor/psd.rb/lib/psd/image_exports/png.rb

@@ -0,0 +1,31 @@
+class PSD::Image
+  module Export
+    # PNG image export. This is the default export format.
+    module PNG
+      # Load the image pixels into a PNG file and return a reference to the
+      # data.
+      def to_png
+        return @png if @png
+
+        PSD.logger.debug "Beginning PNG export"
+        @png = ChunkyPNG::Canvas.new(width.to_i, height.to_i, ChunkyPNG::Color::TRANSPARENT)
+
+        i = 0
+        height.times do |y|
+          width.times do |x|
+            @png[x, y] = @pixel_data[i]
+            i += 1
+          end
+        end
+
+        @png
+      end
+      alias :export :to_png
+
+      # Saves the PNG data to disk.
+      def save_as_png(file)
+        to_png.save(file, :fast_rgba)
+      end
+    end
+  end
+end

data/vendor/psd.rb/lib/psd/image_formats/layer_raw.rb

@@ -0,0 +1,21 @@
+class PSD
+  module ImageFormat
+    module LayerRAW
+      private
+
+      # Since we're parsing on a per-channel basis, we need to modify the behavior
+      # of the RAW encoding parser a bit. This version is aware of the current
+      # channel data position, since layers that have RAW encoding often use RLE
+      # encoded alpha channels.
+      def parse_raw!
+        PSD.logger.debug "Attempting to parse RAW encoded channel..."
+
+        (@chan_pos...(@chan_pos + @ch_info[:length] - 2)).each do |i|
+          @channel_data[i] = @file.read(1).bytes.to_a[0]
+        end
+
+        @chan_pos += @ch_info[:length] - 2
+      end
+    end
+  end
+end

data/vendor/psd.rb/lib/psd/image_formats/layer_rle.rb

@@ -0,0 +1,24 @@
+class PSD
+  module ImageFormat
+    # Some method overrides for layer images.
+    module LayerRLE
+      private
+
+      def parse_byte_counts!
+        byte_counts = []
+        height.times do
+          byte_counts << @file.read_short
+        end
+
+        return byte_counts
+      end
+
+      def parse_channel_data!
+        @line_index = 0
+
+        PSD.logger.debug "Parsing RLE channel ##{@ch_info[:id]}: file position = #{@file.tell}, image position = #{@chan_pos}, line = #{@line_index}"
+        decode_rle_channel
+      end
+    end
+  end
+end

data/vendor/psd.rb/lib/psd/image_formats/raw.rb

@@ -0,0 +1,12 @@
+class PSD
+  module ImageFormat
+    # Parses a RAW uncompressed image
+    module RAW
+      private
+
+      def parse_raw!
+        @channel_data = @file.read(@length).bytes.to_a
+      end
+    end
+  end
+end

data/vendor/psd.rb/lib/psd/image_formats/rle.rb

@@ -0,0 +1,63 @@
+class PSD
+  module ImageFormat
+    # Parses an RLE compressed image
+    module RLE
+      private
+
+      def parse_rle!
+        @byte_counts = parse_byte_counts!
+        parse_channel_data!
+      end
+
+      def parse_byte_counts!
+        byte_counts = []
+        (channels * height).times do |i|
+          byte_counts << @file.read_short
+        end
+
+        return byte_counts
+      end
+
+      def parse_channel_data!
+        @chan_pos = 0
+        @line_index = 0
+
+        channels.times do |i|
+          PSD.logger.debug "Parsing RLE channel ##{i}: file position = #{@file.tell}, image position = #{@chan_pos}, line = #{@line_index}"
+          decode_rle_channel
+          @line_index += height
+        end
+      end
+
+      def decode_rle_channel
+        height.times do |j|
+          byte_count = @byte_counts[@line_index + j]
+          finish = @file.tell + byte_count
+
+          while @file.tell < finish
+            len = @file.read(1).bytes.to_a[0]
+
+            if len < 128
+              len += 1
+              (@chan_pos...@chan_pos+len).each do |k|
+                @channel_data[k] = @file.read(1).bytes.to_a[0]
+              end
+
+              @chan_pos += len
+            elsif len > 128
+              len ^= 0xff
+              len += 2
+
+              val = @file.read(1).bytes.to_a[0]
+              (@chan_pos...@chan_pos+len).each do |k|
+                @channel_data[k] = val
+              end
+
+              @chan_pos += len
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/vendor/psd.rb/lib/psd/image_modes/cmyk.rb

@@ -0,0 +1,31 @@
+class PSD
+  module ImageMode
+    module CMYK
+      private
+
+      def combine_cmyk_channel
+        (0...@num_pixels).step(pixel_step) do |i|
+          c = m = y = k = 0
+          a = 255
+
+          @channels_info.each_with_index do |chan, index|
+            next if chan[:id] == -2
+
+            val = @channel_data[i + (@channel_length * index)]
+
+            case chan[:id]
+            when -1 then a = val
+            when 0 then c = val
+            when 1 then m = val
+            when 2 then y = val
+            when 3 then k = val
+            end
+          end
+
+          rgb = PSD::Color.cmyk_to_rgb(255 - c, 255 - m, 255 - y, 255 - k)
+          @pixel_data.push ChunkyPNG::Color.rgba(*rgb.values, a)
+        end
+      end
+    end
+  end
+end

data/vendor/psd.rb/lib/psd/image_modes/greyscale.rb

@@ -0,0 +1,22 @@
+class PSD
+  module ImageMode
+    module Greyscale
+      private
+
+      def combine_greyscale_channel
+        if channels == 2
+          (0...@num_pixels).step(pixel_step) do |i|
+            grey = @channel_data[i]
+            alpha = @channel_data[@channel_length + i]
+
+            @pixel_data.push ChunkyPNG::Color.grayscale_alpha(grey, alpha)
+          end
+        else
+          (0...@num_pixels).step(pixel_step) do |i|
+            @pixel_data.push ChunkyPNG::Color.grayscale(@channel_data[i])
+          end
+        end
+      end
+    end
+  end
+end