X-Git-Url: http://gitweb.michael.orlitzky.com/?a=blobdiff_plain;f=src%2Fwebsites%2Fredtube.rb;h=4de8772e9f27a8f695f231b16bbd7e00a934536e;hb=ebba6d4d52735ca1833127e1966b79073cdc698b;hp=39ca90137a7f367f3c3d571b2c6261415b9c33c2;hpb=4427ec884bf38dd94256a59260613e1dff3e984a;p=dead%2Fwhatever-dl.git

diff --git a/src/websites/redtube.rb b/src/websites/redtube.rb
index 39ca901..4de8772 100644
--- a/src/websites/redtube.rb
+++ b/src/websites/redtube.rb
@@ -14,123 +14,64 @@
 # GNU General Public License for more details.
 #
 # http://www.fsf.org/licensing/licenses/gpl.html
-#
-# 
-# NOTE:
-#
-# All credit belongs to whomever reverse-engineered the Redtube
-# Flash applet in the first place. I took the algorithm from this
-# script:
-#
-# http://userscripts.org/scripts/review/8691
-#
-# and merely cleaned it up a bit while porting it to Ruby.
-#
 
-# The Redtube class needs the extra string methods..
-require 'src/string'
 require 'src/website'
+require 'cgi'
+
 
-# This class handles the algorithm magic needed to get
-# the URL from a Redtube video id.
 class Redtube < Website
 
   VALID_REDTUBE_URL_REGEX = /^(http:\/\/)?(www\.)?redtube\.com\/(\d+)$/
-  
+
   def self.owns_url?(url)
     return url =~ VALID_REDTUBE_URL_REGEX
   end
 
 
-  # The only public method. This calls the other parts
-  # of the algorithm and, with any luck, we wind up with
-  # the URL to the video.
   def get_video_url()
-    # First, parse the video ID out of the URL.
-    video_id = parse_video_id()
-    
-    padded_id = video_id.to_s.pad_left('0', 7)
-
-    video_dir = self.get_video_dir(video_id)
-    file_name = self.get_file_name(padded_id)
-
-    # This mess is actually the only directory out of
-    # which they serve videos.
-    return 'http://dl.redtube.com/_videos_t4vn23s9jc5498tgj49icfj4678/' +
-           "#{video_dir}/#{file_name}"
+    page_data = self.get_page_data(@url)
+    begin
+      # We prefer to parse the HTML5 version because it can come in a
+      # nicer container format.
+      return parse_html5_src(page_data)
+    rescue StandardError => e
+      return self.parse_hashlink(page_data)
+    end
   end
 
-  
-  protected
 
-  VIDEO_FILE_EXTENSION = '.flv'
+  protected;
 
   def parse_video_id()
     return /\d+/.match(@url)[0]
   end
 
-  
-  # Not sure what they're thinking with this one.
-  def get_video_dir(video_id)
-    return (video_id.to_f / 1000.0).floor.to_s.pad_left('0', 7)
-  end
 
+  def parse_html5_src(page_data)
+    html5_src_regex = /\"<source src='([^']+?)'/
 
-  # The first part of the algorithmic magic. Multiply each 
-  # digit of the padded video id by the index of the
-  # following digit, and sum them up.
-  def int_magic(padded_video_id)
-    ret = 0
+    matches = html5_src_regex.match(page_data)
 
-    0.upto(6) do |a|
-      ret += padded_video_id[a,1].to_i * (a+1)
+    if matches.nil? or matches.length < 2
+      raise StandardError.new("Could not parse the HTML5 source src.")
+    else
+      return matches[1]
     end
-  
-    return ret
+
   end
 
 
-  # Part 2 of the magic. Sum the digits of the result
-  # of the first magic.
-  def more_magic(file_string)
-    magic = self.int_magic(file_string).to_s
-    
-    ret = 0
-    
-    0.upto(magic.length - 1) do |a|
-      ret += magic[a,1].to_i
-    end
+  def parse_hashlink(page_data)
+    hashlink_regex = /hashlink=([^&]+)&/
 
-    return ret
-  end
+    matches = hashlink_regex.match(page_data)
 
+    if matches.nil? or matches.length < 2
+      raise StandardError.new("Could not parse the 'hashlink' Flash variable.")
+    end
 
-  # Complete fricking mystery
-  def get_file_name(file_string)
-    map = ['R', '1', '5', '3', '4', '2', 'O', '7', 'K', '9', 'H', 'B', 'C', 'D', 'X', 'F', 'G', 'A', 'I', 'J', '8', 'L', 'M', 'Z', '6', 'P', 'Q', '0', 'S', 'T', 'U', 'V', 'W', 'E', 'Y', 'N']
+    # The hashlink variable /is/ the video URL, but it's encoded.
+    return CGI::unescape(matches[1])
+  end
 
-    # The stupid variable names I copied from the
-    # source script. Considering myself disclaimed.
-    my_int = self.more_magic(file_string)
-    new_char = '0' + my_int.to_s
-    
-    if my_int >= 10 then
-      new_char = my_int.to_s
-    end
-    
-    file_name =  map[file_string[3] - 48 + my_int + 3]
-    file_name += new_char[1,1]
-    file_name += map[file_string[0] - 48 + my_int + 2]
-    file_name += map[file_string[2] - 48 + my_int + 1]
-    file_name += map[file_string[5] - 48 + my_int + 6]
-    file_name += map[file_string[1] - 48 + my_int + 5]
-    file_name += new_char[0,1]
-    file_name += map[file_string[4] - 48 + my_int + 7]
-    file_name += map[file_string[6] - 48 + my_int + 4]
-    file_name += VIDEO_FILE_EXTENSION
-    
-    return file_name
-  end 
-
-  
 end