phocoder-rails 0.0.33

data/lib/generators/phocoder_rails/templates/model.rb

@@ -0,0 +1,20 @@
+class <%= name.classify %> < ActiveRecord::Base
+
+  acts_as_phocodable :thumbnail_class => "<%= name.classify %>Thumbnail", 
+    :thumbnails => [
+      {:label=>"small",:width=>100,:height=>100 },
+      {:label=>"medium",:width=>400,:height=>400, 
+        :frame=>{ :width=>20, :bottom=>50, :color=>'003' }, 
+        :annotations=>[
+                        {:text=>"Annotation Testing",:pointsize=>30,:fill_color=>'fff',:gravity=>"South",:y=>10},
+                        {:text=>"Howdy!",:pointsize=>10,:fill_color=>'ccc',:gravity=>"North",:y=>5}
+                      ] 
+      }
+    ],
+    
+    :videos => [ {:label => 'mp4',:video_codec=>"h264" }, #, :thumbnails=>{ :number=>1, :start_at_first_frame=>1 } 
+                 {:label => 'webm', :video_codec=>"vp8" },
+                 {:label => 'ogv', :video_codec=>"theora" }
+    ]
+
+end

data/lib/generators/phocoder_rails/templates/model_migration.rb

@@ -0,0 +1,56 @@
+class Create<%= name.classify.pluralize %> < ActiveRecord::Migration
+  def self.up
+    
+    create_table :<%= name.pluralize %> do |t|
+      t.string   "filename"
+      t.string   "content_type"
+      t.integer  "duration_in_ms"
+      t.integer  "width"
+      t.integer  "height"
+      t.integer  "file_size"
+      t.string   "upload_host"
+      t.datetime "created_at"
+      t.datetime "updated_at"
+      t.datetime "taken_at"
+      t.float    "lat"
+      t.float    "lng"
+      t.string   "encodable_status"
+      
+      t.timestamps
+    end
+    
+    add_index :<%= name.pluralize %>, :id
+    
+    
+    create_table :<%= name.singularize %>_thumbnails do |t|
+      t.string   "filename"
+      t.string   "content_type"
+      t.integer  "duration_in_ms"
+      t.integer  "width"
+      t.integer  "height"
+      t.integer  "file_size"
+      t.string   "upload_host"
+      t.datetime "created_at"
+      t.datetime "updated_at"
+      t.datetime "taken_at"
+      t.float    "lat"
+      t.float    "lng"
+      t.string   "encodable_status"
+      
+      t.string   "thumbnail"
+      t.integer  "parent_id"
+      t.string   "parent_type"
+      
+      t.timestamps
+    end
+    
+    add_index :<%= name.singularize %>_thumbnails, :id
+    add_index :<%= name.singularize %>_thumbnails, :parent_id
+    
+  end
+
+  def self.down
+    drop_table :<%= name.pluralize %>
+    drop_table :<%= name.singularize %>_thumbnails
+  end
+end

data/lib/generators/phocoder_rails/templates/model_thumbnail.rb

@@ -0,0 +1,5 @@
+class <%= name.classify %>Thumbnail < ActiveRecord::Base
+
+  acts_as_phocodable :parent_class => "<%= name.classify %>" 
+
+end

data/lib/generators/phocoder_rails/templates/model_update_migration.rb

@@ -0,0 +1,64 @@
+class Make<%= name.classify.pluralize %>Encodable < ActiveRecord::Migration
+  def self.up
+    
+    
+    add_column :<%= name.pluralize %>, :filename, :string
+    add_column :<%= name.pluralize %>, :content_type, :string
+    add_column :<%= name.pluralize %>, :duration_in_ms, :integer
+    add_column :<%= name.pluralize %>, :width, :integer
+    add_column :<%= name.pluralize %>, :height, :integer
+    add_column :<%= name.pluralize %>, :file_size, :integer
+    add_column :<%= name.pluralize %>, :upload_host, :string
+    add_column :<%= name.pluralize %>, :taken_at, :datetime
+    add_column :<%= name.pluralize %>, :lat, :float
+    add_column :<%= name.pluralize %>, :lng, :float
+    add_column :<%= name.pluralize %>, :encodable_status, :string
+      
+    
+    
+    create_table :<%= name.singularize %>_thumbnails do |t|
+      t.string   "filename"
+      t.string   "content_type"
+      t.integer  "duration_in_ms"
+      t.integer  "width"
+      t.integer  "height"
+      t.integer  "file_size"
+      t.string   "upload_host"
+      t.datetime "created_at"
+      t.datetime "updated_at"
+      t.datetime "taken_at"
+      t.float    "lat"
+      t.float    "lng"
+      t.string   "encodable_status"
+      
+      t.string   "thumbnail"
+      t.integer  "parent_id"
+      t.string   "parent_type"
+      
+      t.timestamps
+    end
+    
+    add_index :<%= name.singularize %>_thumbnails, :id
+    add_index :<%= name.singularize %>_thumbnails, :parent_id
+    
+  end
+
+  def self.down
+    
+    remove_column :<%= name.pluralize %>, :filename
+    remove_column :<%= name.pluralize %>, :content_type
+    remove_column :<%= name.pluralize %>, :duration_in_ms
+    remove_column :<%= name.pluralize %>, :width
+    remove_column :<%= name.pluralize %>, :height
+    remove_column :<%= name.pluralize %>, :file_size
+    remove_column :<%= name.pluralize %>, :upload_host
+    remove_column :<%= name.pluralize %>, :created_at
+    remove_column :<%= name.pluralize %>, :updated_at
+    remove_column :<%= name.pluralize %>, :taken_at
+    remove_column :<%= name.pluralize %>, :lat
+    remove_column :<%= name.pluralize %>, :lng
+    remove_column :<%= name.pluralize %>, :encodable_status
+    
+    drop_table :<%= name.singularize %>_thumbnails
+  end
+end

data/lib/generators/phocoder_rails/templates/phocodable.yml

@@ -0,0 +1,28 @@
+development:
+  phocoder_api_key: asdf
+  zencoder_api_key: asdf
+  base_url: http://your.host.test.com
+  storeage_mode : s3
+  s3_bucket_name: bucket.name
+  s3_access_key_id: asdf
+  s3_secret_access_key: asdf
+  
+test:
+  phocoder_api_key: asdf
+  zencoder_api_key: asdf
+  phocoder_url: http://photoapi.chaos.webapeel.com
+  base_url: http://your.host.test.com
+  storeage_mode : local
+  s3_bucket_name: bucket.name
+  s3_access_key_id: asdf
+  s3_secret_access_key: asdf
+
+production:
+  phocoder_api_key: asdf
+  zencoder_api_key: asdf
+  base_url: http://your.host.test.com
+  storeage_mode : s3
+  processing_mode : resque
+  s3_bucket_name: bucket.name
+  s3_access_key_id: asdf
+  s3_secret_access_key: asdf

data/lib/generators/phocoder_rails/templates/views/_form.html.erb.tt

@@ -0,0 +1,23 @@
+<%%= form_for( @<%= file_name.singularize %>, :html => { :multipart => true } ) do |f| %>
+
+  <%% if @<%= file_name.singularize %>.errors.any? %>
+    <div id="error_explanation">
+      <h2><%%= pluralize(@<%= file_name.singularize %>.errors.count, "error") %> prohibited this encodable from being saved:</h2>
+      <ul>
+      <%% @<%= file_name.singularize %>.errors.full_messages.each do |msg| %>
+        <li><%%= msg %></li>
+      <%% end %>
+      </ul>
+    </div>
+  <%% end %>
+
+  <div class="field">
+  	<%%= f.label :file, "Upload image file" %>
+  	<%%= f.file_field :file %>
+  </div>
+  
+  <div class="actions">
+    <%%= f.submit %>
+  </div>
+  
+<%% end %>

data/lib/generators/phocoder_rails/templates/views/index.html.erb.tt

@@ -0,0 +1,26 @@
+<h1>Listing <%= file_name %></h1>
+
+<table>
+  <tr>
+    <th>Filename</th>
+    <th></th>
+    <th></th>
+
+  </tr>
+
+<%% @<%= file_name %>.each do |<%= file_name.singularize %>| %>
+  <tr>
+    <td>
+    	<%%= phocoder_thumbnail <%= file_name.singularize %>,"small",false %><br/>
+		<%%= <%= file_name.singularize %>.filename %>
+	</td>
+    <td><%%= link_to 'Show', <%= file_name.singularize %> %></td>
+    
+    <td><%%= link_to 'Destroy', <%= file_name.singularize %>, :confirm => 'Are you sure?', :method => :delete %></td>
+  </tr>
+<%% end %>
+</table>
+
+<br />
+
+<%%= link_to 'New <%= file_name.singularize %>', new_<%= file_name.singularize %>_path %>

data/lib/generators/phocoder_rails/templates/views/new.html.erb.tt

@@ -0,0 +1,5 @@
+<h1>New <%= file_name.singularize %></h1>
+
+<%%= render 'form' %>
+
+<%%= link_to 'Back', <%= file_name %>_path %>

data/lib/generators/phocoder_rails/templates/views/show.html.erb.tt

@@ -0,0 +1,12 @@
+<p id="notice"><%%= notice %></p>
+
+<p>
+  <b>Filename:</b>
+  <%%= @<%= file_name.singularize %>.filename %>
+</p>
+
+<%%= phocoder_thumbnail @<%= file_name.singularize %>,"medium" %>
+
+<br/>
+
+<%%= link_to 'Back', <%= file_name %>_path %>

data/lib/phocoder_rails.rb

@@ -0,0 +1,12 @@
+module PhocoderRails
+  require 'phocoder_rails/engine' if defined?(Rails)
+  
+  require 'active_record'
+  #require 'action_pack'
+  #require 'active_support'
+  require 'aws/s3'
+  
+  require 'phocoder_rails/acts_as_phocodable'
+  require 'phocoder_rails/errors'
+  #require 'phocoder_rails/base'
+end

data/lib/phocoder_rails/acts_as_phocodable.rb

@@ -0,0 +1,1153 @@
+module ActsAsPhocodable
+  
+  require 'phocoder'
+  require 'zencoder'
+  require 'open-uri'
+  # Storeage mode controls how uploads are handled.
+  # Valid options are:
+  #     offline : For development mode with no net connection.  No processing.
+  #     local : To store images locally but use Phocoder for processing.
+  #     s3 : Store image in S3 and use Phocoder for processing.
+  # Set this options either in evnironment.rb or
+  # in environments/development.rb etc...
+  
+  mattr_accessor :storeage_mode
+  self.storeage_mode = "local"
+  
+  
+  # Processing mode controls when images get sent to phocoder
+  # Valid options are:
+  #   automatic : Send to phocoder as soon as the file is stored.
+  #               With 'local' storage mode, this submits the job
+  #               to phocoder while the user is still waiting.
+  #  delayed : Handle storage/phocoding in a background process.
+  #  spawn : Use the Spawn library to fork a new process to store/phocode.
+  mattr_accessor :processing_mode
+  self.processing_mode = "automatic"
+  
+  # This is used as the base address for phocoder notifications.
+  # When storeage_mode == "local" this is also used to point
+  # phocoder at the file.  
+  # It should only be the host.domain portion of the URL
+  # no path components.
+  mattr_accessor :base_url
+  self.base_url = "http://your-domain.com"
+  
+  # The bucket for storing s3 files
+  mattr_accessor :s3_bucket_name
+  self.s3_bucket_name = "your-bucket"
+  
+  # The access_key_id for storing s3 files
+  mattr_accessor :s3_access_key_id
+  self.s3_access_key_id = "your-access-key-id"
+  
+  # The secret_access_key for storing s3 files
+  mattr_accessor :s3_secret_access_key
+  self.s3_secret_access_key = "your-secret-access-key"
+  
+  # The javascript library to use for updates
+  # either 'prototype' or 'jquery'
+  mattr_accessor :javascript_library
+  self.javascript_library = 'prototype'
+  
+  # The local directory where files should be stored
+  mattr_accessor :local_base_dir
+  self.local_base_dir = '/tmp'
+  
+  # The config file that tells phocoder where to find
+  # config options.
+  mattr_accessor :config_file
+  self.config_file = "config/phocodable.yml"
+  
+  
+  # The list of image content types that are considered web safe
+  # These can be displayed directly, skipping processing if in offline mode
+  mattr_accessor :web_safe_image_types
+  self.web_safe_image_types = [
+    'image/jpeg',
+    'image/jpg',
+    'image/gif',
+    'image/png',
+    'image/x-png',
+    'image/jpg',
+    'application/png',
+    'application/x-png'
+  ]
+  
+  # The list of image content types that are not considered web safe
+  # These can not be displayed directly
+  mattr_accessor :other_image_types
+  self.other_image_types = [
+    'image/pjpeg',
+    'image/x-ms-bmp',
+    'image/bmp',
+    'image/x-bmp',
+    'image/x-bitmap',
+    'image/x-xbitmap',
+    'image/x-win-bitmap',
+    'image/x-windows-bmp',
+    'image/ms-bmp',
+    'application/bmp',
+    'application/x-bmp',
+    'application/x-win-bitmap',
+    'application/preview',
+    'image/jp_',
+    'application/jpg',
+    'application/x-jpg',
+    'image/pipeg',
+    'image/vnd.swiftview-jpeg',
+    'image/x-xbitmap',
+    'image/gi_',
+    'image/x-citrix-pjpeg',
+    'image/x-nikon-nef',
+    'image/tiff',
+    'image/x-olympus-orf',
+    'image/x-dcraw'
+  ]
+  
+  # The list of content types that will trigger image handling.
+  def image_types
+    web_safe_image_types + other_image_types
+  end
+
+  
+  # The list of content types that will trigger video handling.
+  mattr_accessor :video_types
+  self.video_types = [
+   'application/x-flash-video',
+   'video/avi',
+   'video/mp4',
+   'video/ogg',
+   'video/quicktime',
+   'video/3gp',
+   'video/3gpp',
+   'video/vnd.objectvideo',
+   'video/x-ms-wmv',
+   'video/x-ms-asf',
+   'video/x-ms-wvx',
+   'video/x-ms-wm',
+   'video/x-ms-wmx'
+  ]
+  
+  # Mapping for generating a file extension 
+  # based on the codec passed in for zencoder
+  mattr_accessor :video_extensions
+  self.video_extensions = {
+    "h264" => "mp4",
+    "vp6" => "vp6",
+    "vp8" => "webm",
+    "theora" => "ogv",
+    "mpeg4" => "mpg",
+    "wmv" => "wmv"
+  }
+  
+  # TODO : This needs to be fixed.
+  # It currently matches anything with an 'x' in it
+  mattr_accessor :label_size_regex
+  self.label_size_regex = /(\d*)x(\d*)(pad|crop|stretch|preserve)?/ # 
+  
+  mattr_accessor :size_string_regex
+  self.size_string_regex = /(\d*)x(\d*)([!>]?)/
+  
+  def image?(content_type)
+    image_types.include?(content_type)
+  end
+  
+  def web_safe?(content_type)
+    web_safe_image_types.include?(content_type)
+  end
+  
+  def video?(content_type)
+    video_types.include?(content_type)
+  end
+  
+  
+  #def self.storeage_mode
+  #  @@storeage_mode
+  #end
+  
+  
+  def acts_as_phocodable(options = { })
+    
+    include InstanceMethods
+    include Spawn
+    attr_reader :saved_file
+    attr_accessor :phocoding
+    after_save :save_local_file
+    before_destroy :cleanup #:remove_local_file,:destroy_thumbnails,:remove_s3_file
+    
+    include ActiveSupport::Callbacks
+
+    define_callbacks :local_file_saved, :file_saved, :file_ready, :phocode_hdr, :phocode_composite, :phocode_tone_mapping
+    
+    #cattr_accessor :phocoder_options
+    #self.phocoder_options = options
+    
+    cattr_accessor :phocoder_thumbnails
+    self.phocoder_thumbnails = options[:thumbnails] ||= []
+    
+    cattr_accessor :zencoder_videos
+    self.zencoder_videos = options[:videos] ||= []
+    
+    cattr_accessor :thumbnail_class
+    self.thumbnail_class = options[:thumbnail_class] ? options[:thumbnail_class].constantize : self
+    
+    cattr_accessor :parent_class
+    self.parent_class = options[:parent_class] ? options[:parent_class].constantize : self
+    
+    has_many   :thumbnails, :class_name => "::#{self.thumbnail_class.name}",:as => :parent 
+    if self.thumbnail_class != self.parent_class
+      #we have to do this to get the poster for videos covered
+      belongs_to  :parent, :polymorphic => true
+    else
+      belongs_to  :parent, :class_name => "::#{self.parent_class.name}" ,:foreign_key => "parent_id"
+    end
+    
+    
+    has_many :encodable_jobs, :as => :encodable 
+    
+    scope :top_level, where({:parent_id=>nil}) if respond_to?(:parent_id)
+    scope :top_level, where({}) if !respond_to?(:parent_id)
+    # we can't just call this next scope 'parents' because that is already
+    # taken and returns an array of parent classes of the ruby object
+    scope :parent_items, where({:parent_id=>nil}) if respond_to?(:parent_id)
+    scope :parent_items, where({}) if !respond_to?(:parent_id)
+    
+    scope :thumbnails, where("#{base_class.table_name}.parent_id is not null")
+    
+    #just a writer, the reader is below
+    cattr_accessor :phocodable_configuration
+    read_phocodable_configuration
+  end
+  
+  def config
+    return phocodable_configuration if !phocodable_configuration.blank?
+    self.read_phocodable_configuration
+  end
+  
+  def validates_phocodable
+    validates_presence_of :content_type, :filename, :if=>lambda{ parent_id.blank? }
+  end
+  
+  def update_from_phocoder(params)
+    Rails.logger.debug "tying to call update from phocoder for params = #{params.to_json}"
+    if !params[:output].blank?
+      Rails.logger.debug "find_by_phocoder_output_id #{params[:output][:id]}"
+      iu = find_by_phocoder_output_id params[:output][:id]
+      Rails.logger.debug "the item = #{iu}"
+      img_params = params[:output]
+      iu.filename = File.basename(params[:output][:url]) #if iu.filename.blank?
+      if ActsAsPhocodable.storeage_mode == "local"
+        iu.save_url(params[:output][:url])
+      end
+    else
+      iu = find_by_phocoder_input_id params[:input][:id]
+      img_params = params[:input]
+    end
+    [:file_size,:width,:height,:taken_at,:lat,:lng].each do |att|
+      setter = att.to_s + "="
+      if iu.respond_to? setter and !img_params[att].blank?
+        iu.send setter, img_params[att]
+      end
+    end
+    
+    #iu.file_size = img_params[:file_size]
+    #iu.width = img_params[:width]
+    #iu.height = img_params[:height]
+    iu.phocoder_status = "ready"
+    iu.save
+    iu
+  end
+  
+  
+  # Updating from zencoder is a two pass operation.
+  # This method gets called for each output when it's ready.
+  # Once all outputs are ready, we call parent.check_zencoder_details
+  def update_from_zencoder(params)
+    Rails.logger.debug "tying to call update from zencoder for params = #{params}"
+    iu = find_by_zencoder_output_id params[:output][:id]
+    if params[:output][:url].match /%2F(.*)\?/
+      iu.filename = $1
+    else
+      iu.filename = File.basename(params[:output][:url].match(/(.*)\??/)[1])
+    end
+    #iu.filename = File.basename(params[:output][:url].match(/(.*)\??/)[1]) if iu.filename.blank?
+    if ActsAsPhocodable.storeage_mode == "local"
+      iu.save_url(params[:output][:url])
+    end
+    iu.zencoder_status = "ready"
+    iu.save
+    iu.parent.check_zencoder_details
+  end
+  
+  def thumbnail_attributes_for(thumbnail_name = "small")
+    atts = self.phocoder_thumbnails.select{|atts| atts[:label] == thumbnail_name }.first
+    if atts.blank?
+      atts = create_atts_from_size_string(thumbnail_name)
+    end
+    if atts.blank?
+      raise ThumbnailAttributesNotFoundError.new("No thumbnail attributes were found for label '#{thumbnail_name}'")
+    end
+    atts
+  end
+  
+  def create_label_from_size_string(size_string)
+    if size_string.match ActsAsPhocodable.size_string_regex
+      size_string = size_string.gsub("!","crop")
+      size_string = size_string.gsub(">","preserve")
+    end
+    size_string
+  end
+  
+  def create_atts_from_size_string(label_string)
+    match = label_string.match ActsAsPhocodable.label_size_regex
+    return nil if match.blank?
+    atts = {}
+    if !match[1].blank?
+      atts[:width] = match[1]
+    end
+    if !match[2].blank?
+      atts[:height] = match[2]
+    end
+    if !match[3].blank?
+      atts[:aspect_mode] = match[3]
+    end
+    atts[:label] = label_string
+    #atts[:label] = "#{atts[:width]}x#{atts[:height]}"
+    #atts[:label] += "_#{atts[:aspect_mode]}" if atts[:aspect_mode]
+    atts
+  end
+  
+  
+  
+  def read_phocodable_configuration
+    config_path =  File.join(::Rails.root.to_s, ActsAsPhocodable.config_file)
+    puts "looking for a config in #{config_path}"
+    self.phocodable_configuration =  YAML.load(ERB.new(File.read(config_path)).result)[::Rails.env.to_s].symbolize_keys
+    self.apply_phocodable_configuration
+  end
+  
+  def apply_phocodable_configuration
+    if self.phocodable_configuration[:base_url]
+      ActsAsPhocodable.base_url = phocodable_configuration[:base_url]
+    end
+    if self.phocodable_configuration[:storeage_mode]
+      ActsAsPhocodable.storeage_mode = phocodable_configuration[:storeage_mode]
+    end
+    if self.phocodable_configuration[:processing_mode]
+      ActsAsPhocodable.processing_mode = phocodable_configuration[:processing_mode]
+    end
+    if self.phocodable_configuration[:s3_bucket_name]
+      ActsAsPhocodable.s3_bucket_name = phocodable_configuration[:s3_bucket_name]
+    end
+    if self.phocodable_configuration[:s3_access_key_id]
+      ActsAsPhocodable.s3_access_key_id = phocodable_configuration[:s3_access_key_id]
+    end
+    if self.phocodable_configuration[:s3_secret_access_key]
+      ActsAsPhocodable.s3_secret_access_key = phocodable_configuration[:s3_secret_access_key]
+    end
+    if self.phocodable_configuration[:javascript_library]
+      ActsAsPhocodable.javascript_library = phocodable_configuration[:javascript_library]
+    end
+    if self.phocodable_configuration[:local_base_dir]
+      ActsAsPhocodable.local_base_dir = phocodable_configuration[:local_base_dir]
+    end
+    
+    
+    if self.phocodable_configuration[:phocoder_url]
+      ::Phocoder.base_url = phocodable_configuration[:phocoder_url]
+    end
+    if self.phocodable_configuration[:phocoder_api_key]
+      ::Phocoder.api_key = phocodable_configuration[:phocoder_api_key]
+    end
+    if self.phocodable_configuration[:zencoder_api_key]
+      ::Zencoder.api_key = phocodable_configuration[:zencoder_api_key]
+    end
+    if ActsAsPhocodable.storeage_mode == "s3"
+      self.establish_aws_connection
+    end
+  end
+  
+  def establish_aws_connection
+    AWS::S3::Base.establish_connection!(
+                                        :access_key_id     => ActsAsPhocodable.s3_access_key_id,
+                                        :secret_access_key => ActsAsPhocodable.s3_secret_access_key
+    )
+  end
+  
+  
+  
+  
+  
+  
+  module InstanceMethods
+    
+    
+    
+    def image?
+      self.class.image?(content_type)
+    end
+    
+    def web_safe?
+      self.class.web_safe?(content_type)
+    end
+    
+    def video?
+      self.class.video?(content_type)
+    end
+    
+    def encode
+      if image?
+        phocode
+      elsif video?
+        zencode
+      end
+    end
+    
+    def recode
+      reload #make sure that we have current thumbs
+      destroy_thumbnails
+      reload
+      encode
+    end
+    
+    def ready?
+      if ActsAsPhocodable.storeage_mode == "offline"
+        true
+      #elsif image?
+      #  return phocoder_status=='ready'
+      #elsif video?
+      #  return zencoder_status=='ready'  
+      #else
+      #  return false
+      else
+        return encodable_status == "ready"
+      end
+    end
+    
+    def error?
+      if ActsAsPhocodable.storeage_mode == "offline"
+        false
+      #elsif image?
+      #  return phocoder_status=='failed'
+      #elsif video?
+      #  return zencoder_status=='failed'
+      #else
+      #  true
+      else
+        return encodable_status == "ready"
+      end
+    end
+    
+    def create_thumbnails_from_response(response_thumbs,job_id)
+      new_thumbs = []
+      response_thumbs.each do |thumb_params|
+        puts "creating a thumb for #{thumb_params["label"]}"
+        # we do this the long way around just in case some of these
+        # atts are attr_protected
+        thumb = nil
+        if respond_to?(:parent_id) and !self.parent_id.blank? 
+          Rails.logger.debug "trying to create a thumb from the parent "
+          thumb = self.parent.thumbnails.new()
+          self.parent.thumbnails << thumb
+        else
+          Rails.logger.debug "trying to create a thumb from myself "
+          thumb = self.thumbnails.new()
+          self.thumbnails << thumb
+        end
+        
+        
+        thumb.thumbnail = thumb_params["label"]
+        thumb.filename = thumb_params["filename"]
+        thumb.width = thumb_params["width"]
+        thumb.height = thumb_params["height"]
+        tjob = thumb.encodable_jobs.new
+        
+        tjob.phocoder_output_id = thumb_params["id"]
+        tjob.phocoder_job_id = job_id
+        #thumb.parent_id = self.id
+        tjob.phocoder_status  =  "phocoding"
+        thumb.encodable_jobs << tjob
+        thumb.encodable_status = "phocoding"
+        thumb.save
+        new_thumbs << thumb
+        Rails.logger.debug "    thumb.errors = #{thumb.errors.to_json}"
+        puts "    thumb.errors = #{thumb.errors.to_json}"
+      end
+      new_thumbs
+    end
+    
+    def clear_phocoding
+      phocoding = false
+    end
+    
+    def dedupe_input_thumbs(input_thumbs)
+      needed_thumbs = []
+      input_thumbs.each do |it|
+        t = thumbnails.find_by_thumbnail(it[:label])
+        if t.blank?
+          needed_thumbs << it 
+        end
+      end
+      needed_thumbs
+    end
+    
+    def phocode(input_thumbs = self.parent_class.phocoder_thumbnails)
+      puts " input_thumbs.count = #{input_thumbs.size}"
+      input_thumbs = dedupe_input_thumbs(input_thumbs)
+      puts " after dedupe input_thumbs.count = #{input_thumbs.size}"
+      #if self.thumbnails.count >= self.class.phocoder_thumbnails.size
+      #  raise "This item already has thumbnails!"
+      #  return
+      #end
+      
+      return if input_thumbs.size == 0
+      # We do this because sometimes save will get called more than once
+      # during a single request
+      return if phocoding
+      phocoding = true
+      
+      Rails.logger.debug "trying to phocode for #{Phocoder.base_url} "
+      Rails.logger.debug "callback url = #{callback_url}"
+      response = Phocoder::Job.create(phocoder_params(input_thumbs))
+      Rails.logger.debug "the phocode response = #{response.to_json}" if Rails.env != "test"
+      puts "the phocode response = #{response.to_json}" if Rails.env != "test"
+      job = self.encodable_jobs.new
+      job.phocoder_input_id = response.body["job"]["inputs"].first["id"]
+      job.phocoder_job_id = response.body["job"]["id"]
+      job.phocoder_status = "phocoding"
+      self.encodable_jobs << job
+      self.encodable_status = "phocoding" unless self.encodable_status == "ready" # the unless clause allows new thumbs to be created on the fly without jacking with the status
+      self.save #false need to do save(false) here if we're calling phocode on after_save
+      response_thumbs = response.body["job"]["thumbnails"]
+      Rails.logger.debug "trying to decode #{response_thumbs.size} response_thumbs = #{response_thumbs.to_json}"
+      puts "trying to decode #{response_thumbs.size} response_thumbs = #{response_thumbs.to_json}"
+      create_thumbnails_from_response(response_thumbs,response.body["job"]["id"])
+    end
+    
+    def phocode_hdr
+      #if self.thumbnails.count >= self.class.phocoder_thumbnails.size
+      #  raise "This item already has thumbnails!"
+      #  return
+      #end
+      
+      # We do this because sometimes save will get called more than once
+      # during a single request
+      return if phocoding
+      phocoding = true
+      run_callbacks :phocode_hdr do
+        Rails.logger.debug "trying to phocode for #{Phocoder.base_url} "
+        Rails.logger.debug "callback url = #{callback_url}"
+        response = Phocoder::Job.create(phocoder_hdr_params)
+        Rails.logger.debug "the response from phocode_hdr = #{response.body.to_json}"
+        job = self.encodable_jobs.new
+        job.phocoder_output_id = response.body["job"]["hdr"]["id"]
+        job.phocoder_job_id = response.body["job"]["id"]
+        job.phocoder_status = "phocoding"
+        self.encodable_jobs << job
+        self.encodable_status = "phocoding"
+        self.save #false need to do save(false) here if we're calling phocode on after_save
+      end
+     
+    end
+    
+    
+    def phocode_tone_mapping
+      #if self.thumbnails.count >= self.class.phocoder_thumbnails.size
+      #  raise "This item already has thumbnails!"
+      #  return
+      #end
+      
+      # We do this because sometimes save will get called more than once
+      # during a single request
+      return if phocoding
+      phocoding = true
+      run_callbacks :phocode_tone_mapping do
+        destroy_thumbnails
+        Rails.logger.debug "trying to phocode for #{Phocoder.base_url} "
+        Rails.logger.debug "callback url = #{callback_url}"
+        response = Phocoder::Job.create(phocoder_tone_mapping_params)
+        Rails.logger.debug "tone_mapping response = #{response.body.to_json}"
+        puts "tone_mapping response = #{response.body.to_json}"
+        job = self.encodable_jobs.new
+        job.phocoder_output_id = response.body["job"]["tone_mapping"]["id"]
+        job.phocoder_job_id = response.body["job"]["id"]
+        job.phocoder_status = "phocoding"
+        self.encodable_jobs << job
+        self.encodable_status = "phocoding"
+        self.save #false need to do save(false) here if we're calling phocode on after_save
+        response_thumbs = response.body["job"]["thumbnails"]
+        Rails.logger.debug "trying to decode #{response_thumbs.size} response_thumbs = #{response_thumbs.to_json}"
+        create_thumbnails_from_response(response_thumbs,response.body["job"]["id"])
+      end
+    end
+    
+    
+    def phocode_composite
+      #if self.thumbnails.count >= self.class.phocoder_thumbnails.size
+      #  raise "This item already has thumbnails!"
+      #  return
+      #end
+      
+      # We do this because sometimes save will get called more than once
+      # during a single request
+      return if phocoding
+      phocoding = true
+      run_callbacks :phocode_composite do
+        destroy_thumbnails
+        Rails.logger.debug "trying to phocode for #{Phocoder.base_url} "
+        Rails.logger.debug "callback url = #{callback_url}"
+        response = Phocoder::Job.create(phocoder_composite_params)
+        Rails.logger.debug "composite response = #{response.body.to_json}"
+        puts "composite response = #{response.body.to_json}"
+        job = self.encodable_jobs.new
+        job.phocoder_output_id = response.body["job"]["composite"]["id"]
+        job.phocoder_job_id = response.body["job"]["id"]
+        job.phocoder_status = "phocoding"
+        self.encodable_jobs << job
+        self.encodable_status = "phocoding"
+        self.save #false need to do save(false) here if we're calling phocode on after_save
+        response_thumbs = response.body["job"]["thumbnails"]
+        Rails.logger.debug "trying to decode #{response_thumbs.size} response_thumbs = #{response_thumbs.to_json}"
+        puts "trying to decode #{response_thumbs.size} response_thumbs = #{response_thumbs.to_json}"
+        create_thumbnails_from_response(response_thumbs,response.body["job"]["id"])
+      end
+    end
+    
+    
+    def zencode
+      # We do this because sometimes save will get called more than once
+      # during a single request
+      return if @zencoding
+      @zencoding = true
+      
+      Rails.logger.debug "trying to zencode!!!!!"
+      Rails.logger.debug "callback url = #{callback_url}"
+      response = Zencoder::Job.create(zencoder_params)
+      Rails.logger.debug "response from Zencoder = #{response.body.to_json}"
+      job = self.encodable_jobs.new
+      job.zencoder_job_id = response.body["id"]
+      self.encodable_jobs << job
+      
+      response.body["outputs"].each do |output_params|
+        thumb = self.thumbnails.new()
+        thumb.thumbnail = output_params["label"]
+        
+        tjob = thumb.encodable_jobs.new
+        tjob.zencoder_output_id = output_params["id"]
+        tjob.zencoder_url = output_params["url"]
+        tjob.zencoder_job_id = response.body["id"]
+        tjob.zencoder_status  =  "zencoding"
+        thumb.encodable_jobs << tjob
+        
+        self.thumbnails << thumb
+        thumb.encodable_status = "zencoding"
+        thumb.save
+        puts "    thumb.errors = #{thumb.errors.to_json}"
+      end
+      
+      self.save
+    end
+    
+    def phocoder_extension
+      if self.content_type.blank?
+        ".jpg"
+      else
+        self.content_type.match(/png/) ? ".png" : ".jpg"
+      end
+    end
+    
+    def phocoder_params(input_thumbs = self.parent_class.phocoder_thumbnails)
+      {:input => {:url => self.public_url, :notifications=>[{:url=>callback_url }] },
+        :thumbnails => phocoder_thumbnail_params(input_thumbs)
+      }
+    end
+    
+    def phocoder_thumbnail_params(input_thumbs = self.parent_class.phocoder_thumbnails)
+      input_thumbs.map{|thumb|
+        thumb_filename = thumb[:label] + "_" + File.basename(self.filename,File.extname(self.filename)) + phocoder_extension 
+        base_url = ActsAsPhocodable.storeage_mode == "s3" ? "s3://#{self.s3_bucket_name}/#{self.thumbnail_resource_dir}/" : ""
+        th = thumb.clone
+        th[:base_url] = base_url  if !base_url.blank?
+        th.merge({
+          :filename=>thumb_filename,
+          :notifications=>[{:url=>thumbnail_callback_url }]
+        })
+      }
+    end
+    
+    
+    def phocoder_hdr_params
+      { }
+    end
+    
+    def phocoder_tone_mapping_params
+      { }
+    end
+    
+    def phocoder_composite_params
+      { }
+    end
+    
+    def zencoder_params
+      base_url = ActsAsPhocodable.storeage_mode == "s3" ? "s3://#{self.s3_bucket_name}/#{self.thumbnail_resource_dir}/" : ""
+      params = {:input =>  self.public_url ,
+        :outputs => self.class.zencoder_videos.map{|video|
+          vid_filename = self.new_zencoder_filename( video[:video_codec] )
+          vid = video.clone
+          if vid[:thumbnails] and vid[:thumbnails].is_a? Array
+            vid[:thumbnails].each do |thumb|
+              thumb[:base_url] = base_url if !base_url.blank?
+            end
+          elsif vid[:thumbnails]
+            vid[:thumbnails][:base_url] = base_url  if !base_url.blank?
+          end        
+          
+          vid[:base_url] = base_url  if !base_url.blank?
+          vid.merge({
+            :filename=>vid_filename,
+            :public=>1,
+            :notifications=>[{:url=>zencoder_thumbnail_callback_url }]
+          })
+        }
+      }
+      params[:outputs][0][:thumbnails] = { :number=>1, :start_at_first_frame=>1,:public=>1 }
+      params[:outputs][0][:thumbnails][:base_url] = base_url  if !base_url.blank?
+      Rails.logger.debug "for zencoder the params = #{params.to_json}"
+      #puts "for zencoder the params = #{params.to_json}"
+      params
+    end
+   
+    def new_zencoder_filename(format)
+      filename + "." + self.class.video_extensions[format]
+    end
+    
+    
+    def check_zencoder_details
+      # we don't get a lot of info from zencoder, so we have to ask for details
+      shouldCheck = true
+      thumbnails.each do |t|
+        if t.encodable_status != 'ready'
+          shouldCheck = false
+        end
+      end
+      
+      return  if !shouldCheck
+      
+      details = Zencoder::Job.details(self.encodable_jobs.last.zencoder_job_id)
+      
+      #puts "in check_zencoder_details the details.body = #{details.body.to_json}"
+      
+      if details.body["job"]["state"] != 'finished'
+        self.encodable_jobs.last.zencoder_status = details.body["job"]["state"]
+        save
+        return
+      end
+      
+      self.encodable_jobs.last.zencoder_status = self.encodable_status = "ready"
+      self.width = details.body["job"]["input_media_file"]["width"]
+      self.height = details.body["job"]["input_media_file"]["height"]
+      self.duration_in_ms = details.body["job"]["input_media_file"]["duration_in_ms"]
+      self.file_size = details.body["job"]["input_media_file"]["file_size_bytes"]
+      self.save
+      
+      #puts "the output files = #{details.body["job"]["output_media_files"]}"
+      
+      update_zencoder_outputs(details)
+            
+      # Now create the image thumb
+      create_zencoder_image_thumb(details)
+      
+    end
+    
+    
+    def update_zencoder_outputs(details)
+      details.body["job"]["output_media_files"].each do |output|
+        #puts "updating for output = #{output.to_json}"
+        job = EncodableJob.find_by_zencoder_output_id output["id"]
+        thumb = job.encodable
+        thumb.width = output["width"]
+        thumb.height = output["height"]
+        thumb.file_size = output["file_size_bytes"]
+        thumb.duration_in_ms = output["duration_in_ms"]
+        thumb.save
+      end
+    end
+    
+    def create_zencoder_image_thumb(details)
+      
+      # for now we should only have one thumbnail
+      output = details.body["job"]["thumbnails"].first
+      return if output.blank?
+      thumb = thumbnails.new
+      thumb.thumbnail = "poster"
+      thumb.width = output["width"]
+      thumb.height = output["height"]
+      thumb.file_size = output["file_size_bytes"]
+      thumb.filename = "frame_0000.png" #File.basename(output["url"])
+      thumb.content_type = "image/png"
+      if ActsAsPhocodable.storeage_mode == "local"
+        thumb.save_url(output["url"])
+      end
+      thumb.save
+      #now get thumbnails for the poster
+      thumb.phocode 
+    end
+    
+    def phocodable_config
+      puts "looking for config!"
+      self.class.config
+    end
+    
+    def phocodable?
+      true
+    end
+    
+    def save_url(url)
+      Rails.logger.debug "We are about to download : #{url} to #{local_dir} - #{local_path}"
+      FileUtils.mkdir_p(local_dir) if !File.exists?(local_dir)
+      FileUtils.touch local_path
+      writeOut = open(local_path, "wb")
+      writeOut.write(open(url).read)
+      writeOut.close
+    end
+    
+    def destroy_thumbnails
+      if self.class.phocoder_thumbnails.size == 0 and self.class.zencoder_videos.size == 0 
+        puts "we're skipping destory_thumbnails since we don't do any processing "
+        return
+      end
+      #puts "calling destory thumbnails for #{self.thumbnails.count} - #{self.thumbnails.size}"
+      self.thumbnails.each do |thumb|
+        thumb.destroy
+      end
+      #puts "calling destory thumbnails for #{self.thumbnails.count}"
+    end
+    
+    def create_atts_from_size_string(label_string)
+      self.class.create_atts_from_size_string(label_string)
+    end
+    
+    def thumbnail_attributes_for(thumbnail_name)
+      self.class.thumbnail_attributes_for(thumbnail_name)
+    end
+    
+    def thumbnail_for(thumbnail_hash_or_name)
+      thumbnail_name = thumbnail_hash_or_name.is_a?(Hash) ? thumbnail_hash_or_name[:label] : thumbnail_hash_or_name 
+      if thumbnail_name and thumbnail_name.match ActsAsPhocodable.size_string_regex
+        thumbnail_name = self.class.create_label_from_size_string(thumbnail_name)
+      end
+      if thumbnail_name.blank? and thumbnail_hash_or_name.is_a?(Hash)
+        thumbnail_name = "#{thumbnail_hash_or_name[:width]}x#{thumbnail_hash_or_name[:height]}"
+        puts "thumbnail_name = #{thumbnail_name}"
+        thumbnail_hash_or_name[:label] = thumbnail_name
+      end
+      thumb = thumbnails.find_by_thumbnail(thumbnail_name)
+      if thumb.blank? and ActsAsPhocodable.storeage_mode == "offline"
+        thumb = self
+      elsif thumb.blank? and thumbnail_hash_or_name.is_a? Hash
+        thumb = self.phocode([thumbnail_hash_or_name]).first
+      elsif thumb.blank? and thumbnail_hash_or_name.is_a?(String) and thumbnail_hash_or_name.match ActsAsPhocodable.label_size_regex
+        atts = create_atts_from_size_string(thumbnail_name)
+        thumb = self.phocode([atts]).first
+      end
+      if thumb.blank?
+        raise ThumbnailNotFoundError.new("No thumbnail was found for label '#{thumbnail_name}'")
+      end
+      thumb
+      #a dirty hack for now to keep things working.  
+      #Remove this!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+      #Go back to just returning the thumb
+      #thumb.blank? ? self : thumb
+    end
+    
+    def get_thumbnail(thumbnail_name)
+      thumbnail_for(thumbnail_name)
+    end
+    
+    def file=(new_file)
+      return if new_file.nil?
+      Rails.logger.debug "we got a new file of class = #{new_file.class}"
+      cleanup
+      if new_file.is_a? File
+        self.filename = File.basename new_file.path
+        self.content_type = MIME::Types.type_for(self.filename).first.content_type
+        self.file_size = new_file.size
+      else
+        self.filename = new_file.original_filename
+        self.content_type = new_file.content_type  
+        self.file_size = new_file.size
+      end
+      
+      if new_file.respond_to? :tempfile
+        @saved_file = new_file.tempfile
+      else
+        @saved_file = new_file
+      end
+    end
+    
+    #compatability method for attachment_fu
+    def uploaded_data=(data)
+      self.file = data
+    end
+    
+    def save_local_file
+      return if @saved_file.blank?
+      puts "saving the local file!!!!!!"
+      Rails.logger.debug "==================================================================================================="
+      Rails.logger.debug "about to save the local file"
+      run_callbacks :file_saved do
+        run_callbacks :local_file_saved do
+          FileUtils.mkdir_p local_dir
+          FileUtils.cp @saved_file.path, local_path
+          FileUtils.chmod 0755, local_path
+          self.encodable_status = "local"
+          if self.respond_to? :upload_host      
+            self.upload_host = %x{hostname}.strip
+          end
+          @saved_file = nil
+          @saved_a_new_file = true
+          self.save
+        end
+        if ActsAsPhocodable.storeage_mode == "s3" and ActsAsPhocodable.processing_mode == "automatic"
+          self.save_s3_file
+        end
+        if ActsAsPhocodable.storeage_mode == "s3" and ActsAsPhocodable.processing_mode == "spawn"
+          spawn do # :method => :thread # <-- I think that should be set at the config/environment level
+            Rails.logger.debug "------------beginning of spawn block"
+            puts               "------------beginning of spawn block"
+            self.save_s3_file
+            Rails.logger.debug "------------end of spawn block"
+            puts               "------------end of spawn block"
+          end
+        end
+        if ActsAsPhocodable.storeage_mode == "local" and ActsAsPhocodable.processing_mode == "automatic" 
+          self.encode
+        end
+        
+      end
+    end
+    
+    def fire_ready_callback
+      run_callbacks :file_ready do
+      end
+    end
+    
+    
+    def cleanup
+      #puts "calling cleanup!"
+      destroy_thumbnails
+      remove_local_file
+      if ActsAsPhocodable.storeage_mode == "s3"
+        remove_s3_file
+      end
+    end
+    
+    def remove_local_file
+      if local_path and File.exists? local_path
+        FileUtils.rm local_path
+        if Dir.glob(File.join(local_dir,"*")).size == 0
+          FileUtils.rmdir local_dir 
+        end
+      end
+    end
+    
+    def path_id
+      
+      #puts "parent_id = #{parent_id}"
+      #puts "parent = #{parent}"
+      if respond_to?(:parent_id)
+        parent_id.blank? ? id : parent.path_id
+      else
+        id
+      end
+    end
+    
+    def resource_dir
+      File.join(self.class.table_name, path_id.to_s )
+    end
+    
+    def thumbnail_resource_dir
+      File.join(self.thumbnail_class.table_name, path_id.to_s )
+    end
+    
+    def local_dir
+      File.join(ActsAsPhocodable.local_base_dir,resource_dir)
+    end
+    
+    def local_path
+      filename.blank? ? nil : File.join(local_dir,filename)
+    end
+    
+    def local_url
+      filename.blank? ? nil : File.join("/",resource_dir,filename)
+    end
+    
+    # This should generate a fully qualified http://something-something
+    # type of a reference.  Depending on storeage_mode/base_url settings.
+    def public_url
+      puts "our base_url = #{base_url} and our local_url = #{local_url}"
+      if ActsAsPhocodable.storeage_mode == "local" or ActsAsPhocodable.storeage_mode == "offline" 
+        base_url + local_url
+      else
+        s3_url
+      end
+    end
+    
+    def public_filename
+      public_url
+    end
+    
+    
+    def callback_url
+      self.base_url + self.notification_callback_path
+    end
+    
+    def zencoder_callback_url
+      self.base_url + self.zencoder_notification_callback_path
+    end
+    
+    def thumbnail_callback_url
+      self.base_url + self.thumbnail_notification_callback_path
+    end
+    
+    def zencoder_thumbnail_callback_url
+      self.base_url + self.zencoder_thumbnail_notification_callback_path
+    end
+    
+    def notification_callback_path
+      "/phocoder/phocoder_notifications/#{self.class.name}/#{self.id}.json"
+    end
+  
+    def zencoder_notification_callback_path
+      "/phocoder/zencoder_notifications/#{self.class.name}/#{self.id}.json"
+    end
+      
+    def thumbnail_notification_callback_path
+      "/phocoder/phocoder_notifications/#{self.thumbnail_class.name}/#{self.id}.json"
+    end
+  
+    def zencoder_thumbnail_notification_callback_path
+      "/phocoder/zencoder_notifications/#{self.thumbnail_class.name}/#{self.id}.json"
+    end
+    
+    def base_url
+      self.class.base_url
+    end
+    
+    def s3_key
+      filename.blank? ? nil : File.join(resource_dir,filename)
+    end
+    
+    def s3_url
+      "http://#{s3_bucket_name}.s3.amazonaws.com/#{s3_key}"
+    end
+    
+    def s3_bucket_name
+      self.class.s3_bucket_name
+    end
+    
+    def save_s3_file
+      #I don't think we need this return check anymore.  
+      #return if !@saved_a_new_file
+      #@saved_a_new_file = false
+      AWS::S3::S3Object.store(
+                              s3_key, 
+                              open(local_path), 
+      s3_bucket_name,
+      :access => :public_read
+      )
+      self.encodable_status = "s3"
+      self.save
+      obj_data = AWS::S3::S3Object.find(s3_key,s3_bucket_name)
+      Rails.logger.debug "----------------------------------------------------------------------------------------------------"
+      if obj_data.size == file_size # it made it into s3 safely
+        Rails.logger.debug " we are about to remove local file!"
+        remove_local_file
+      else
+        msg = "The file was not saved to S3 sucessfully.  Orig size: #{file_size} - S3 size: #{obj_data.size}"
+        Rails.logger.debug msg
+        raise ActsAsPhocodable::Error.new msg
+      end
+      self.encode
+    end
+    
+    
+    def remove_s3_file
+      #puts "trying to delete #{s3_key} #{s3_bucket_name}"
+      #if ActsAsPhocodable.storeage_mode == "s3"
+        AWS::S3::S3Object.delete s3_key, s3_bucket_name
+      #end
+    rescue Exception => e
+      #this probably means that the file never made it to S3
+    end
+    
+    # Sanitizes a filename.
+    def filename=(new_name)
+      write_attribute :filename, sanitize_filename(new_name)
+    end
+    
+    def sanitize_filename(filename)
+      return unless filename
+      filename.strip.tap do |name|
+        # NOTE: File.basename doesn't work right with Windows paths on Unix
+        # get only the filename, not the whole path
+        name.gsub! /^.*(\\|\/)/, ''
+        
+        # Finally, replace all non alphanumeric, underscore or periods with underscore
+        name.gsub! /[^A-Za-z0-9\.\-]/, '_'
+      end
+    end
+    
+    # Calculate the width for the target thumbnail atts
+    def calc_width(thumbnail_atts)   
+      tw = thumbnail_atts[:width].blank? ? 100000 : thumbnail_atts[:width].to_f
+      th = thumbnail_atts[:height].blank? ? 100000 : thumbnail_atts[:height].to_f
+      w =  width.to_f
+      h =  height.to_f
+      if w <= tw and h <= th
+        w.round
+      elsif w > h
+        if (h * ( tw / w )).round < tw
+          tw .round
+        else
+         (h * ( tw / w )).round
+        end
+      else
+        if (w * ( th / h )).round < tw
+         (w * ( th / h )).round
+        else
+          tw.round
+        end
+      end
+    end #end calc_width
+    
+    
+    def calc_height(thumbnail_atts)
+      tw = thumbnail_atts[:width].blank? ? 100000 : thumbnail_atts[:width].to_f
+      th = thumbnail_atts[:height].blank? ? 100000 : thumbnail_atts[:height].to_f
+      w =  width.to_f
+      h =  height.to_f
+      if w <= tw and h <= th
+        h.round
+      elsif w > h
+        if (h * ( tw / w )).round < th
+         (h * ( tw / w )).round
+        else
+          th.round
+        end
+      else
+        if (w * ( th / h )).round < tw
+          th.round
+        else
+         (h * ( tw / w )).round
+        end
+      end
+    end #end calc_height
+    
+    
+    
+  end#module InstanceMethods
+    
+end
+ActiveRecord::Base.extend ActsAsPhocodable