jpeg2moro 0.0.1

data/History.txt

@@ -0,0 +1,4 @@
+=== 0.0.1 2010-11-22
+
+* 1 major enhancement:
+  * Initial release

data/Manifest.txt

@@ -0,0 +1,13 @@
+History.txt
+Manifest.txt
+README.rdoc
+Rakefile
+bin/jpeg2moro
+lib/jpeg2moro.rb
+script/console
+script/destroy
+script/generate
+spec/jpeg2moro_spec.rb
+spec/spec.opts
+spec/spec_helper.rb
+tasks/rspec.rake

data/README.rdoc

@@ -0,0 +1,64 @@
+= jpeg2moro
+
+* http://github.com/2moro/jpeg2moro
+
+== DESCRIPTION:
+
+JPEG2moro is a method of encoding arbitrary data (including an alpha channel) within the JPEG Application Segment APP10.
+
+== FEATURES/PROBLEMS:
+
+* converts image files to jpeg2moro format
+
+== SYNOPSIS:
+
+  # command line
+
+  # create a jpeg with transparency from a png file (creates image.jpg)
+  > ruby/scripts/jpeg2moro source.png
+
+  # specify alpha channel bit depth (1 bit) and output file output.jpg
+  > ruby/scripts/jpeg2moro source.png -a 1 -o output.jpg
+
+  # programmatically read from file
+
+  jpeg = JPEG2moro.new("source.png")
+  jpeg.save("output.jpg", :alpha_depth => 8)
+
+  # programmatically read from string
+
+  jpeg = JPEG2moro.with_data(File.read("source.png"))
+  jpeg.save("output.jpg", :alpha_depth => 8)
+
+== REQUIREMENTS:
+
+* rmagick
+
+== INSTALL:
+
+* sudo gem install jpeg2moro
+
+== LICENSE:
+
+(The MIT License)
+
+Copyright (c) 2010 2moro mobile
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+'Software'), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/Rakefile

@@ -0,0 +1,24 @@
+require 'rubygems'
+gem 'hoe', '>= 2.1.0'
+require 'hoe'
+#require 'fileutils'
+#require './lib/jpeg2moro'
+
+Hoe.plugin :newgem
+# Hoe.plugin :website
+# Hoe.plugin :cucumberfeatures
+
+# Generate all the Rake tasks
+# Run 'rake -T' to see list of generated tasks (from gem root directory)
+$hoe = Hoe.spec 'jpeg2moro' do
+  self.developer '2moro mobile', 'support@2moro.com.au'
+  self.rubyforge_name       = self.name # TODO this is default value
+  self.extra_deps           = [['rmagick','>= 2.13.1']]
+end
+
+require 'newgem/tasks'
+#Dir['tasks/**/*.rake'].each { |t| load t }
+
+# TODO - want other tests/tasks run by default? Add them to the list
+# remove_task :default
+# task :default => [:spec, :features]

data/bin/jpeg2moro

@@ -0,0 +1,102 @@
+#!/usr/bin/env ruby
+#
+
+$:.unshift File.join(File.dirname(__FILE__), '..', 'lib')
+
+require 'jpeg2moro'
+require 'getoptlong'
+
+ARG_SPEC = [ [ '--help', '-h', GetoptLong::NO_ARGUMENT ],
+             [ '--test', '-n', GetoptLong::NO_ARGUMENT ],
+             [ '--output', '-o', GetoptLong::REQUIRED_ARGUMENT ],
+             [ '--debug', '-d', GetoptLong::NO_ARGUMENT ],
+             [ '--alpha-depth', '-a', GetoptLong::REQUIRED_ARGUMENT ],
+             [ '--quality', '-q', GetoptLong::REQUIRED_ARGUMENT ],
+             [ '--verbose', '-v', GetoptLong::NO_ARGUMENT ]
+           ]
+
+private
+
+# parse command line arguments
+def command_line_options
+  opts = GetoptLong.new(*ARG_SPEC)
+  options = {}
+  opts.each do |opt,arg|
+    opt[0,2] = ''
+    opt = opt.gsub(/-/, '_').to_sym
+    case opt
+    when :help
+      puts usage
+      exit 0
+    else
+      options[opt] = arg ? arg : true
+    end
+  end
+  options
+end
+
+def usage
+  usage = <<EOM
+jpeg2moro - converts image files to jpeg2moro format
+usage: jpeg2moro [OPTIONS] source_file [source_file ...]
+
+options:
+  --help, -h:         this help message
+  --output, -o:       specify output filename
+  --debug, -d:        turn on debugging output and file dumping
+  --alpha-depth, -a:  set depth for alpha channel, default #{JPEG2moro::DEFAULT_ALPHA_DEPTH}
+  --quality, -q:      jpeg compression level (0-100), default #{JPEG2moro::DEFAULT_QUALITY}
+  --verbose, -v:      verbose mode
+
+EOM
+end
+
+def output_filename(input)
+  file = File.basename(input)
+  file = file.sub(/\.[^.]+$/, '')
+  file + ".jpg"
+end
+
+begin
+  opts = command_line_options
+  input_files = ARGV
+
+  #opts[:input] = params.pop if !opts[:input] && $stdin.tty?
+
+  JPEG2moro.debug = opts[:debug]
+
+  if input_files.length == 0
+    puts usage
+  elsif opts[:output] && input_files.length > 1
+    puts "ERROR: output file option can only be used with one input file"
+    puts usage
+    exit 1
+  end
+
+  output_opts = {}
+  [:alpha_depth, :quality].each do |i|
+    output_opts[i] = opts[i] if opts[i]
+  end
+
+  # convert input files to jpeg2moro format
+  input_files.each do |input_file|
+    unless File.exist?(input_file)
+      puts "error: '#{input_file}' file not found"
+      next
+    end
+
+    output_file = opts[:output] || output_filename(input_file)
+    if output_file == input_file
+      puts "error: input file '#{input_file}' would overwrite itself, skipping"
+      next
+    end
+
+    jpeg = JPEG2moro.new(input_file)
+    jpeg.save(output_file, output_opts)
+
+    if opts[:verbose]
+      puts "%s -> %s" % [File.basename(input_file), File.basename(output_file)]
+    end
+  end
+
+end

data/lib/jpeg2moro.rb

@@ -0,0 +1,201 @@
+
+require 'rubygems'
+require 'zlib'
+gem 'rmagick'
+require 'RMagick'
+include Magick
+
+class JPEG2moro
+  DEBUG = 1
+  VERSION = "0.0.1"
+
+  DEFAULT_ALPHA_DEPTH = 8
+  DEFAULT_QUALITY = 70
+
+  class << self
+    attr_accessor :debug
+  end
+
+  def initialize(options = {})
+    if options.kind_of?(Hash) 
+      @file = options[:file]
+      @data = options[:data]
+    else
+      @file = options
+    end
+
+    @data = File.read(@file) if @file
+    debug "read %d bytes" % [@data.length]
+  end
+
+  def self.with_data(data)
+    return JPEG2moro.new(:data => data)
+  end
+
+  def to_s
+    @data
+  end
+
+  # save output_file with the given options
+  def save(output_file, options = {})
+    output = convert(options)
+    File.open(output_file, "w") { |f| f.print output }
+  end
+
+  private
+
+  # convert data to jpeg2moro format
+  def convert(options = {})
+    @convert_options = options.clone
+    @convert_options[:alpha_depth] ||= DEFAULT_ALPHA_DEPTH
+
+    # convert image data to jpg format
+    img = Image.from_blob(@data).first
+    jpeg_data = img.to_blob { |i|
+      i.quality =  (options[:quality] || DEFAULT_QUALITY).to_i
+      i.format = 'jpg'
+    }
+    # insert alpha channel into jpeg data
+    insert_opacity_header(jpeg_data)
+
+    # return jpeg2moro object (contains alpha channel)
+    return JPEG2moro.new(:data => jpeg_data)
+  end
+
+  def debug(msg)
+    puts msg if self.class.debug
+  end
+
+  def debug_dump(data, filename)
+    if self.class.debug
+      File.open(filename, "w") { |f| f.print data }
+    end
+  end
+
+  def standalone_marker(marker)
+    (marker >= 0xd0 && marker <= 0xd7) ||  # RST
+      marker == 0xd8 || marker == 0xd9  || # SOI/EOI
+      marker == 0x01  # TEM
+  end
+
+  # find position to insert opacity information
+  # (just before SOS or EOI marker)
+  def insert_position(jpeg_data)
+    # parse jpeg data
+    data = jpeg_data
+    pos = 0
+    while pos < data.length
+      marker1 = data[pos]
+      marker2 = data[pos + 1]
+
+      return -1 if marker1 != 0xff  # parse error
+      if marker2 == 0xff
+        # packed marker
+        pos += 1
+        next
+      end
+
+      if marker2 == 0xda || marker2 == 0xd9
+        # SOS (start of scan) or EOI (end of image)
+        # insert before this marker
+        debug "found insert position: %d (marker %x)" % [pos, marker2]
+        return pos
+      end
+
+      pos += 2
+      next if standalone_marker(marker2)
+
+      mlength = data[pos, 2].unpack('C2').reverse.pack('C2').unpack('S').first
+      pos += mlength
+
+      debug "marker: %x, length: %d" % [marker2,  mlength]
+    end
+  end
+
+  # create a 'chunk' named name, with the given data.
+  # (4 bytes)  Length
+  # (4 bytes)  Chunk type  (e.g. "ALPH" for alpha channel)
+  # (length bytes) Chunk data
+  def chunk(name, data)
+    raise "chunk name must be four characters long" unless name.length == 4
+    [data.length].pack("N") + name + data  # TODO: not sure if this is unsigned
+  end
+
+  # create one or more app10 application segments containing the given data.
+  # if data exceeds the maximum length of the app segment, it is split into multiple
+  # segments.  returns array of app10 segments.
+  # (2 bytes) APP10 marker  (0xFFE9)
+  # (2 bytes) Length of segment (including 2 byte length parameter)
+  # (length - 2 bytes) Chunk data
+  def app10_segments(data)
+    i = 0
+    len = data.length
+    ret = []
+    while i < len
+      seglen = len - i > 65535 ? 65535 : len - i
+      segdata = data[i, seglen]
+      debug "segment data length: " + segdata.length.to_s
+
+      mlength = segdata.length + 2 
+      header = [0xff, 0xe9].pack("C*")  # APP10 marker
+      header += [mlength].pack("S").unpack("C*").reverse.pack("C*")
+      header += segdata
+      ret.push header
+      i += seglen
+    end
+    ret
+  end
+
+  # create opacity header
+  def create_opacity_header
+    img = Image.from_blob(@data).first  # original image data
+    bit_depth = @convert_options[:alpha_depth]
+    bit_depth = bit_depth.to_i
+
+    unless [1,8,16].include?(bit_depth)
+      raise "unsupported alpha bit depth: " + @convert_options[:alpha_depth].to_s
+    end
+
+    debug "using bit depth: %d" % [bit_depth]
+
+    img.set_channel_depth(AlphaChannel, bit_depth)
+    alpha = img.separate(OpacityChannel)
+    #alpha.set_channel_depth(DefaultChannels, 1)
+    #alpha.display
+    storage = bit_depth == 16 ? ShortPixel : CharPixel
+    data = alpha.export_pixels_to_str(0, 0, alpha.columns, alpha.rows,
+                                      "A", storage)
+
+    debug_dump(alpha.to_blob, "alpha.png")
+
+    if bit_depth == 1
+      # pack into bit string
+      data = data.unpack('C*').map { |i| i == 0xff ? 1 : 0 }.join
+      data = [data].pack("B*")
+    end
+
+    debug_dump(data, "pixel.dat")
+
+    deflated = Zlib::Deflate.deflate(data, 9)
+    #deflated = deflated[2..-5]  # strip header/footer?
+    debug "deflated size: %d bytes" % [deflated.length]
+
+    debug_dump(deflated, "compressed.dat")
+    
+    # create alpha chunk, pack into app10 segment(s)
+    alpha_data = [bit_depth].pack("C") + deflated
+    alpha_chunk = chunk("ALPH", alpha_data)
+    segments = app10_segments(alpha_chunk)
+    header = segments.join
+
+    debug_dump(header, "header.dat")
+
+    header
+  end
+
+  def insert_opacity_header(jpeg_data)
+    offset = insert_position(jpeg_data)
+    header = create_opacity_header
+    jpeg_data.insert(offset, header)
+  end
+end

data/script/console

@@ -0,0 +1,10 @@
+#!/usr/bin/env ruby
+# File: script/console
+irb = RUBY_PLATFORM =~ /(:?mswin|mingw)/ ? 'irb.bat' : 'irb'
+
+libs =  " -r irb/completion"
+# Perhaps use a console_lib to store any extra methods I may want available in the cosole
+# libs << " -r #{File.dirname(__FILE__) + '/../lib/console_lib/console_logger.rb'}"
+libs <<  " -r #{File.dirname(__FILE__) + '/../lib/jpeg2moro.rb'}"
+puts "Loading jpeg2moro gem"
+exec "#{irb} #{libs} --simple-prompt"

data/script/destroy

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+APP_ROOT = File.expand_path(File.join(File.dirname(__FILE__), '..'))
+
+begin
+  require 'rubigen'
+rescue LoadError
+  require 'rubygems'
+  require 'rubigen'
+end
+require 'rubigen/scripts/destroy'
+
+ARGV.shift if ['--help', '-h'].include?(ARGV[0])
+RubiGen::Base.use_component_sources! [:rubygems, :newgem, :newgem_theme, :test_unit]
+RubiGen::Scripts::Destroy.new.run(ARGV)

data/script/generate

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+APP_ROOT = File.expand_path(File.join(File.dirname(__FILE__), '..'))
+
+begin
+  require 'rubigen'
+rescue LoadError
+  require 'rubygems'
+  require 'rubigen'
+end
+require 'rubigen/scripts/generate'
+
+ARGV.shift if ['--help', '-h'].include?(ARGV[0])
+RubiGen::Base.use_component_sources! [:rubygems, :newgem, :newgem_theme, :test_unit]
+RubiGen::Scripts::Generate.new.run(ARGV)

data/spec/jpeg2moro_spec.rb

@@ -0,0 +1,11 @@
+require File.dirname(__FILE__) + '/spec_helper.rb'
+
+# Time to add your specs!
+# http://rspec.info/
+describe "Place your specs here" do
+  
+  it "find this spec in spec directory" do
+    # violated "Be sure to write your specs"
+  end
+  
+end

data/spec/spec.opts

@@ -0,0 +1 @@
+--colour

data/spec/spec_helper.rb

@@ -0,0 +1,8 @@
+begin
+  require 'rubygems' unless ENV['NO_RUBYGEMS']
+  gem 'rspec'
+  require 'rspec'
+end
+
+$:.unshift(File.dirname(__FILE__) + '/../lib')
+require 'jpeg2moro'

data/tasks/rspec.rake

@@ -0,0 +1,16 @@
+begin
+  require 'rubygems' unless ENV['NO_RUBYGEMS']
+  require 'rspec'
+rescue LoadError
+  puts <<-EOS
+To use rspec for testing you must install rspec gem:
+    gem install rspec
+EOS
+  exit(0)
+end
+
+desc "Run the specs under spec/models"
+RSpec::Core::RakeTask.new do |t|
+#  t.rspec_opts = ['--options', "spec/spec.opts"]
+  t.pattern = 'spec/**/*_spec.rb'
+end

metadata

@@ -0,0 +1,129 @@
+--- !ruby/object:Gem::Specification 
+name: jpeg2moro
+version: !ruby/object:Gem::Version 
+  hash: 29
+  prerelease: false
+  segments: 
+  - 0
+  - 0
+  - 1
+  version: 0.0.1
+platform: ruby
+authors: 
+- 2moro mobile
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-11-23 00:00:00 +10:30
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: rmagick
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 57
+        segments: 
+        - 2
+        - 13
+        - 1
+        version: 2.13.1
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: rubyforge
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 7
+        segments: 
+        - 2
+        - 0
+        - 4
+        version: 2.0.4
+  type: :development
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: hoe
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 19
+        segments: 
+        - 2
+        - 7
+        - 0
+        version: 2.7.0
+  type: :development
+  version_requirements: *id003
+description: JPEG2moro is a method of encoding arbitrary data (including an alpha channel) within the JPEG Application Segment APP10.
+email: 
+- support@2moro.com.au
+executables: 
+- jpeg2moro
+extensions: []
+
+extra_rdoc_files: 
+- History.txt
+- Manifest.txt
+files: 
+- History.txt
+- Manifest.txt
+- README.rdoc
+- Rakefile
+- bin/jpeg2moro
+- lib/jpeg2moro.rb
+- script/console
+- script/destroy
+- script/generate
+- spec/jpeg2moro_spec.rb
+- spec/spec.opts
+- spec/spec_helper.rb
+- tasks/rspec.rake
+has_rdoc: true
+homepage: http://github.com/2moro/jpeg2moro
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --main
+- README.rdoc
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: jpeg2moro
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: JPEG2moro is a method of encoding arbitrary data (including an alpha channel) within the JPEG Application Segment APP10.
+test_files: []
+