viddl-rb 0.6 → 0.7

data/plugins/metacafe.rb

@@ -3,59 +3,58 @@
 # Vidoes that have URLs that look like this: http://www.metacafe.com/watch/cb-q78rA_lp9s1_9EJsqKJ5BdIHdDNuHa1l/ cannot be downloaded.
 
 class Metacafe < PluginBase
-	BASE_FILE_URL = "http://v.mccont.com/ItemFiles/%5BFrom%20www.metacafe.com%5D%20"
-	API_BASE = "http://www.metacafe.com/api/"
-	
-	#this will be called by the main app to check whether this plugin is responsible for the url passed
-	def self.matches_provider?(url)
-		url.include?("metacafe.com")
-	end
-	
-	def self.get_urls_and_filenames(url)
-		video_id = get_video_id(url)
-		info_url = API_BASE + "item/#{video_id}" #use the API to get the full video url
-		info_doc = Nokogiri::XML(open(info_url))
-		
-		video_swf_url = get_video_swf_url(info_doc, video_id)
-		
-		#by getting the video swf url we get a http redirect url with all info needed
-		http_response = Net::HTTP.get_response(URI(video_swf_url)) 
-		redirect_url = http_response['location'] 
-		
-		file_info = get_file_info(redirect_url, video_id)
-		key_string = get_file_key(redirect_url)
-		file_url_with_key = file_info[:file_url] + "?__gda__=#{key_string}"
-		escaped_url = CGI::escape(file_url_with_key)
-		
-		[{:url => escaped_url, :name => get_video_name(video_swf_url) + file_info[:extension]}]
-	end
-	
-	def self.get_video_id(url)
-		id = url[/watch\/(\d+)/, 1]
-		unless id
-			puts "ERROR: Can only download videos that has the ID in the URL."
-			exit
-		end
-		id
-	end
+  BASE_FILE_URL = "http://v.mccont.com/ItemFiles/%5BFrom%20www.metacafe.com%5D%20"
+  API_BASE = "http://www.metacafe.com/api/"
+  
+  #this will be called by the main app to check whether this plugin is responsible for the url passed
+  def self.matches_provider?(url)
+    url.include?("metacafe.com")
+  end
+  
+  def self.get_urls_and_filenames(url, options = {})
+    video_id = get_video_id(url)
+    info_url = API_BASE + "item/#{video_id}" #use the API to get the full video url
+    info_doc = Nokogiri::XML(open(info_url))
+    
+    video_swf_url = get_video_swf_url(info_doc, video_id)
+    
+    #by getting the video swf url we get a http redirect url with all info needed
+    http_response = Net::HTTP.get_response(URI(video_swf_url)) 
+    redirect_url = CGI::unescape(http_response['location'])
 
-	def self.get_video_swf_url(info_doc, video_id)
-		video_url = info_doc.xpath("//rss/channel/item/link").text
-		video_url.sub!("watch", "fplayer")
-		video_url.sub!(/\/\z/, ".swf") # remove last '/' and add .swf in it's place
-	end
-		
-	#$1 = file name part 1, $2 = file name part 2, $3 = file extension
-	def self.get_file_info(redirect_url, video_id)
-		redirect_url =~ /mediaURL.+?metacafe\.com%.+?%\d+\.(\d+)\.(\d+)(\.[\d\w]+)/																																				
-		{:file_url => "#{BASE_FILE_URL}#{video_id}\.#{$1}\.#{$2}#{$3}", :extension => $3}
-	end
-																																										
-	def self.get_file_key(redirect_url)
-		redirect_url[/key.+?\%22([\w\d]+?)\%22/, 1]
-	end
-	
-	def self.get_video_name(url)
-		url[/fplayer\/\d+\/([\d\w]+)\.swf/, 1]
-	end
+    file_info = get_file_info(redirect_url, video_id)
+    key_string = get_file_key(redirect_url)
+    file_url_with_key = file_info[:file_url] + "?__gda__=#{key_string}"
+        
+    [{:url => file_url_with_key, :name => get_video_name(video_swf_url) + file_info[:extension]}]
+  end
+  
+  def self.get_video_id(url)
+    id = url[/watch\/(\d+)/, 1]
+    unless id
+      raise CouldNotDownloadVideoError, "Can only download videos that has the ID in the URL."
+    end
+    id
+  end
+
+  def self.get_video_swf_url(info_doc, video_id)
+    video_url = info_doc.xpath("//rss/channel/item/link").text
+    video_url.sub!("watch", "fplayer")
+    video_url.sub!(/\/\z/, ".swf") # remove last '/' and add .swf in it's place
+  end
+    
+  #$1 = file name part 1, $2 = file name part 2, $3 = file extension
+  def self.get_file_info(redirect_url, video_id)
+    redirect_url =~ /mediaURL.+?metacafe\.com%.+?%\d+\.(\d+)\.(\d+)(\.[\d\w]+)/                                                                       
+    {:file_url => "#{BASE_FILE_URL}#{video_id}\.#{$1}\.#{$2}#{$3}", :extension => $3}
+  end
+                                                                                    
+  def self.get_file_key(redirect_url)
+    redirect_url[/key.+?value":"([\w\d]+)"/, 1]
+  end
+  
+  def self.get_video_name(url)
+    name =  url[/fplayer\/\d+\/([\d\w]+)\.swf/, 1]
+    PluginBase.make_filename_safe(name)
+  end
 end

data/plugins/soundcloud.rb

@@ -1,13 +1,13 @@
+require 'rest_client'
 class Soundcloud < PluginBase
-  require 'iconv'
   # this will be called by the main app to check whether this plugin is responsible for the url passed
   def self.matches_provider?(url)
     url.include?("soundcloud.com")
   end
 
   # return the url for original video file and title
-  def self.get_urls_and_filenames(url)
-    doc          = Nokogiri::XML(open(url))
+  def self.get_urls_and_filenames(url, options = {})
+    doc          = Nokogiri::HTML(RestClient.get(url).body)
     download_filename = doc.at("#main-content-inner img[class=waveform]").attributes["src"].value.to_s.match(/\.com\/(.+)\_/)[1]
     download_url = "http://media.soundcloud.com/stream/#{download_filename}"
     file_name    = transliterate("#{doc.at('//h1/em').text.chomp}") + ".mp3"
@@ -18,25 +18,22 @@ class Soundcloud < PluginBase
   def self.transliterate(str)
   # Based on permalink_fu by Rick Olsen
 
-  # Escape str by transliterating to UTF-8 with Iconv
-  s = Iconv.iconv('ascii//ignore//translit', 'utf-8', str).to_s
-
   # Downcase string
-  s.downcase!
+  str.downcase!
 
   # Remove apostrophes so isn't changes to isnt
-  s.gsub!(/'/, '')
+  str.gsub!(/'/, '')
 
   # Replace any non-letter or non-number character with a space
-  s.gsub!(/[^A-Za-z0-9]+/, ' ')
+  str.gsub!(/[^A-Za-z0-9]+/, ' ')
 
   # Remove spaces from beginning and end of string
-  s.strip!
+  str.strip!
 
   # Replace groups of spaces with single hyphen
-  s.gsub!(/\ +/, '-')
+  str.gsub!(/\ +/, '-')
 
-  return s
+  str
 end
 
 end

data/plugins/veoh.rb

@@ -1,46 +1,45 @@
 class Veoh < PluginBase
-	VEOH_API_BASE = "http://www.veoh.com/api/"
-	PREFERRED_FORMATS = [:mp4, :flash] # mp4 is preferred because it enables downloading full videos and not just previews
-	
-	#this will be called by the main app to check whether this plugin is responsible for the url passed
-	def self.matches_provider?(url)
-		url.include?("veoh.com")
-	end
+  VEOH_API_BASE = "http://www.veoh.com/api/"
+  PREFERRED_FORMATS = [:mp4, :flash] # mp4 is preferred because it enables downloading full videos and not just previews
+  
+  #this will be called by the main app to check whether this plugin is responsible for the url passed
+  def self.matches_provider?(url)
+    url.include?("veoh.com")
+  end
 
-	def self.get_urls_and_filenames(url)
-		veoh_id = url[/\/watch\/([\w\d]+)/, 1]
-		info_url = "#{VEOH_API_BASE}findByPermalink?permalink=#{veoh_id}"
-		info_doc = Nokogiri::XML(open(info_url))
+  def self.get_urls_and_filenames(url, options = {})
+    veoh_id = url[/\/watch\/([\w\d]+)/, 1]
+    info_url = "#{VEOH_API_BASE}findByPermalink?permalink=#{veoh_id}"
+    info_doc = Nokogiri::XML(open(info_url))
 
-		download_url = get_download_url(info_doc)
-		file_name = get_file_name(info_doc, download_url)
+    download_url = get_download_url(info_doc)
+    file_name = get_file_name(info_doc, download_url)
 
-		[{:url => download_url, :name => file_name}]
-	end
-	
-	#returns the first valid download url string, in order of the prefered formats, that is found for the video
-	def self.get_download_url(info_doc)
-		PREFERRED_FORMATS.each do |format|
-			a = get_attribute(format)
-			download_attr = info_doc.xpath('//rsp/videoList/video').first.attributes[a]
-			return(download_attr.content) unless download_attr.nil? || download_attr.content.empty?
-		end
-	end
-	
-	#the file name string is a combination of the video name and the extension
-	def self.get_file_name(info_doc, download_url)
-		name = info_doc.xpath('//rsp/videoList/video').first.attributes['title'].content
-		name.gsub!(" ", "_") # replace spaces with underscores
-		extension = download_url[/\/[\w\d]+(\.[\w\d]+)\?ct/, 1]
-		name + extension
-	end
+    [{:url => download_url, :name => file_name}]
+  end
+  
+  #returns the first valid download url string, in order of the prefered formats, that is found for the video
+  def self.get_download_url(info_doc)
+    PREFERRED_FORMATS.each do |format|
+      a = get_attribute(format)
+      download_attr = info_doc.xpath('//rsp/videoList/video').first.attributes[a]
+      return(download_attr.content) unless download_attr.nil? || download_attr.content.empty?
+    end
+  end
+  
+  #the file name string is a combination of the video name and the extension
+  def self.get_file_name(info_doc, download_url)
+    name = info_doc.xpath('//rsp/videoList/video').first.attributes['title'].content
+    extension = download_url[/\/[\w\d]+(\.[\w\d]+)\?ct/, 1]
+    PluginBase.make_filename_safe(name) + extension
+  end
 
-	def self.get_attribute(format)
-		case format
-		when :mp4
-			"ipodUrl"
-		when :flash
-			"previewUrl"
-		end
-	end
-end
+  def self.get_attribute(format)
+    case format
+    when :mp4
+      "ipodUrl"
+    when :flash
+      "previewUrl"
+    end
+  end
+end

data/plugins/vimeo.rb

@@ -1,25 +1,32 @@
 class Vimeo < PluginBase
-	#this will be called by the main app to check whether this plugin is responsible for the url passed
-	def self.matches_provider?(url)
-		url.include?("vimeo.com")
-	end
-	
-	def self.get_urls_and_filenames(url)
-		#the vimeo ID consists of 7 decimal numbers in the URL
-		vimeo_id = url[/\d{7,8}/]
-		doc = Nokogiri::XML(open("http://www.vimeo.com/moogaloop/load/clip:#{vimeo_id}"))
-		title = doc.at("//video/caption").inner_text
-		puts "[VIMEO] Title: #{title}"
-		request_signature = doc.at("//request_signature").inner_text
-		request_signature_expires = doc.at("//request_signature_expires").inner_text
-		
+  #this will be called by the main app to check whether this plugin is responsible for the url passed
+  def self.matches_provider?(url)
+    url.include?("vimeo.com")
+  end
+  
+  def self.get_urls_and_filenames(url, options = {})
+    #the vimeo ID consists of 7 decimal numbers in the URL
+    vimeo_id = url[/\d{7,8}/]
 
-		puts "[VIMEO] Request Signature: #{request_signature} expires: #{request_signature_expires}"
-		
-		download_url = "http://www.vimeo.com/moogaloop/play/clip:#{vimeo_id}/#{request_signature}/#{request_signature_expires}/?q=hd"
-		#todo: put the filename cleaning stuff into a seperate helper
-		file_name = title.delete("\"'").gsub(/[^0-9A-Za-z]/, '_') + ".flv"
-		puts "downloading to " + file_name
-		[{:url => download_url, :name => file_name}]
-	end
-end
+    agent = Mechanize.new      #use Mechanize for the automatic cookie handeling
+    agent.redirect_ok = false  #don't follow redirects so we do not download the video when we get it's url
+
+    video_page = agent.get("http://vimeo.com/#{vimeo_id}")
+    page_html = video_page.root.inner_html
+    doc = Nokogiri::HTML(page_html)
+    title = doc.at('meta[property="og:title"]').attributes['content'].value
+    puts "[VIMEO] Title: #{title.inspect}"
+
+    #the timestamp and sig info is in the embedded player javascript in the video page
+    timestamp = page_html[/"timestamp":(\d+),/, 1]
+    signature = page_html[/"signature":"([\d\w]+)",/, 1]
+
+    redirect_url = "http://player.vimeo.com/play_redirect?clip_id=#{vimeo_id}&sig=#{signature}&time=#{timestamp}&quality=hd,sd&codecs=H264,VP8,VP6"
+
+    #the download url is the value of the location (redirect) header
+    download_url = agent.get(redirect_url).header["location"]
+    file_name = PluginBase.make_filename_safe(title) + ".mp4"
+
+    [{:url => download_url, :name => file_name}]
+  end
+end

data/plugins/youtube.rb

@@ -1,143 +1,196 @@
-class Youtube < PluginBase
-	#this will be called by the main app to check whether this plugin is responsible for the url passed
-	def self.matches_provider?(url)
-		url.include?("youtube.com") || url.include?("youtu.be")
-	end
-	
-	def self.parse_playlist(url)
-		#http://www.youtube.com/view_play_list?p=F96B063007B44E1E&search_query=welt+auf+schwäbisch
-		#http://www.youtube.com/watch?v=9WEP5nCxkEY&videos=jKY836_WMhE&playnext_from=TL&playnext=1
-		#http://www.youtube.com/watch?v=Tk78sr5JMIU&videos=jKY836_WMhE
-
-		playlist_ID = url[/p=(\w{16})&?/,1]
-		puts "[YOUTUBE] Playlist ID: #{playlist_ID}"
-		url_array = Array.new
-		video_info = Nokogiri::HTML(open("http://gdata.youtube.com/feeds/api/playlists/#{playlist_ID}?v=2"))
-		video_info.search("//content").each do |video|
-			url_array << video["url"] if video["url"].include?("http://www.youtube.com/v/") #filters out rtsp links
-		end
-
-		puts "[YOUTUBE] #{url_array.size} links found!"
-		url_array
-	end
-	
-	
-	def self.get_urls_and_filenames(url)
-		return_values = []
-		if url.include?("view_play_list")
-			puts "[YOUTUBE] playlist found! analyzing..."
-			files = self.parse_playlist(url)
-			puts "[YOUTUBE] Starting playlist download"
-			files.each do |file|
-				puts "[YOUTUBE] Downloading next movie on the playlist (#{file})"
-				return_values << self.grab_single_url_filename(url)
-			end	
-		else
-				return_values << self.grab_single_url_filename(url)
-		end
-		return_values
-	end
-	
-	def self.grab_single_url_filename(url)
-		#the youtube video ID looks like this: [...]v=abc5a5_afe5agae6g&[...], we only want the ID (the \w in the brackets)
-		#addition: might also look like this /v/abc5-a5afe5agae6g
-		# alternative:	video_id = url[/v[\/=]([\w-]*)&?/, 1]
-		# First get the redirect
-                if url.include?("youtu.be")
-                  url = open(url).base_uri.to_s
-                end
-		video_id = url[/(v|embed)[\/=]([^\/\?\&]*)/,2]
-		if video_id.nil?
-			puts "no video id found."
-			exit
-		else
-			puts "[YOUTUBE] ID FOUND: #{video_id}"
-		end
-		#let's get some infos about the video. data is urlencoded
-		yt_url = "http://www.youtube.com/get_video_info?video_id=#{video_id}"
-		video_info = open(yt_url).read
-		#converting the huge infostring into a hash. simply by splitting it at the & and then splitting it into key and value arround the =
-		#[...]blabla=blubb&narf=poit&marc=awesome[...]
-		video_info_hash = Hash[*video_info.split("&").collect { |v| 
-      key, encoded_value = v.split("=")
-      if encoded_value.to_s.empty?
-		value = ""
-      else
-      #decode until everything is "normal"
-      	while (encoded_value != CGI::unescape(encoded_value)) do
-      		#"decoding"
-	      	encoded_value = CGI::unescape(encoded_value)
-      	end
-      	value = encoded_value
-      end
-
-      if key =~ /_map/
-      	orig_value = value
-        value = value.split(",")
-        if key == "url_encoded_fmt_stream_map"
-	        url_array = orig_value.split("url=").map{|url_string| url_string.chomp(",")}
-    	    result_hash = {}
-    	    url_array.each do |url|
-        		next if url.to_s.empty?
-		        format_id = url.match(/\&itag=(\d+)/)[1]
-				result_hash[format_id] = url
-	        end
-	        value = result_hash
-        elsif key == "fmt_map"
-          value = Hash[*value.collect{ |v| 
-              k2, *v2 = v.split("/")
-              [k2, v2]
-            }.flatten(1)]
-          elsif key == "fmt_url_map" || key == "fmt_stream_map"
-            Hash[*value.collect { |v| v.split("|")}.flatten]
-        end
-      end
-			[key, value]
-		}.flatten]
-		
-		if video_info_hash["status"] == "fail"
-			puts "Error: embedding disabled, no video info found"
-			exit
-		end
-		
-		title = video_info_hash["title"]
-		length_s = video_info_hash["length_seconds"]
-		token = video_info_hash["token"]
-
-		
-		#for the formats, see: http://en.wikipedia.org/wiki/YouTube#Quality_and_codecs
-		fmt_list = video_info_hash["fmt_list"].split(",")
-		available_formats = fmt_list.map{|format| format.split("/").first}
-		
-		format_ext = {}
-		format_ext["38"] = {:extension => "mp4", :name => "MP4 Highest Quality 4096x3027 (H.264, AAC)"}						
-		format_ext["37"] = {:extension => "mp4", :name => "MP4 Highest Quality 1920x1080 (H.264, AAC)"}
-		format_ext["22"] = {:extension => "mp4", :name => "MP4 1280x720 (H.264, AAC)"}
-		format_ext["45"] = {:extension => "webm", :name => "WebM 1280x720 (VP8, Vorbis)"}
-		format_ext["44"] = {:extension => "webm", :name => "WebM 854x480 (VP8, Vorbis)"}		
-		format_ext["18"] = {:extension => "mp4", :name => "MP4 640x360 (H.264, AAC)"}
-		format_ext["35"] = {:extension => "flv", :name => "FLV 854x480 (H.264, AAC)"}
-		format_ext["34"] = {:extension => "flv", :name => "FLV 640x360 (H.264, AAC)"}
-		format_ext["5"] = {:extension => "flv", :name => "FLV 400x240 (Soerenson H.263)"}
-		format_ext["17"] = {:extension => "3gp", :name => "3gp"}		
-		
-		#since 1.8 doesn't do ordered hashes
-		prefered_order = ["38","37","22","45","44","18","35","34","5","17"]
-		
-		selected_format = prefered_order.select{|possible_format| available_formats.include?(possible_format)}.first
-		
-		puts "[YOUTUBE] Title: #{title}"
-		puts "[YOUTUBE] Length: #{length_s} s"
-		puts "[YOUTUBE] t-parameter: #{token}"
-		#best quality seems always to be firsts
-		puts "[YOUTUBE] formats available: #{available_formats.inspect} (downloading format #{selected_format} -> #{format_ext[selected_format][:name]})"
-
-		#video_info_hash.keys.sort.each{|key| puts "#{key} : #{video_info_hash[key]}" }
-    download_url = video_info_hash["url_encoded_fmt_stream_map"][selected_format]
-    #if download url ends with a ';' followed by a codec string remove that part because it stops URI.parse from working
-    download_url = $1 if download_url =~ /(.*?);\scodecs=/
-		file_name = title.delete("\"'").gsub(/[^0-9A-Za-z]/, '_') + "." + format_ext[selected_format][:extension]
-		puts "downloading to " + file_name
-		{:url => download_url, :name => file_name}
-	end
-end
+
+class Youtube < PluginBase
+  #this will be called by the main app to check whether this plugin is responsible for the url passed
+  def self.matches_provider?(url)
+    url.include?("youtube.com") || url.include?("youtu.be")
+  end
+  
+  #get all videos and return their urls in an array
+  def self.get_video_urls(feed_url)
+    puts "[YOUTUBE] Retrieving videos..."
+    urls_titles = Hash.new
+    result_feed = Nokogiri::XML(open(feed_url))
+    urls_titles.merge!(grab_ut(result_feed))
+
+    #as long as the feed has a next link we follow it and add the resulting video urls
+    loop do   
+      next_link = result_feed.search("//feed/link[@rel='next']").first
+      break if next_link.nil?
+      result_feed = Nokogiri::HTML(open(next_link["href"]))
+      urls_titles.merge!(grab_ut(result_feed))
+    end
+
+    self.filter_urls(urls_titles)
+  end
+
+  #returns only the urls that match the --filter argument regex (if present)
+  def self.filter_urls(url_hash)
+    if @filter
+      puts "[YOUTUBE] Using filter: #{@filter}"
+      filtered = url_hash.select { |url, title| title =~ @filter }
+      filtered.keys
+    else
+      url_hash.keys
+    end
+  end
+
+  #extract all video urls and their titles from a feed and return in a hash
+  def self.grab_ut(feed)
+    feed.remove_namespaces!  #so that we can get to the titles easily
+    urls   = feed.search("//entry/link[@rel='alternate']").map { |link| link["href"] }
+    titles = feed.search("//entry/group/title").map { |title| title.text } 
+    Hash[urls.zip(titles)]    #hash like this: url => title
+  end
+
+  def self.parse_playlist(url)
+    #http://www.youtube.com/view_play_list?p=F96B063007B44E1E&search_query=welt+auf+schwäbisch
+    #http://www.youtube.com/watch?v=9WEP5nCxkEY&videos=jKY836_WMhE&playnext_from=TL&playnext=1
+    #http://www.youtube.com/watch?v=Tk78sr5JMIU&videos=jKY836_WMhE
+
+    playlist_ID = url[/(?:list=PL|p=)(\w{16})&?/,1]
+    puts "[YOUTUBE] Playlist ID: #{playlist_ID}"
+    feed_url = "http://gdata.youtube.com/feeds/api/playlists/#{playlist_ID}?&max-results=50&v=2"
+    url_array = self.get_video_urls(feed_url)
+    puts "[YOUTUBE] #{url_array.size} links found!"
+    url_array
+  end
+
+  def self.parse_user(username)
+    puts "[YOUTUBE] User: #{username}"
+    feed_url = "http://gdata.youtube.com/feeds/api/users/#{username}/uploads?&max-results=50&v=2"
+    url_array = get_video_urls(feed_url)
+    puts "[YOUTUBE] #{url_array.size} links found!"
+    url_array
+  end
+
+  def self.get_urls_and_filenames(url, options = {})
+    @filter = options[:playlist_filter]                                    #used to filter a playlist in self.filter_urls
+    return_values = []
+    if url.include?("view_play_list") || url.include?("playlist?list=")    #if playlist
+      puts "[YOUTUBE] playlist found! analyzing..."
+      files = self.parse_playlist(url)
+      puts "[YOUTUBE] Starting playlist download"
+      files.each do |file|
+        puts "[YOUTUBE] Downloading next movie on the playlist (#{file})"
+        return_values << self.grab_single_url_filename(file)
+      end  
+    elsif match = url.match(/\/user\/([\w\d]+)$/)                          #if user url, e.g. youtube.com/user/woot
+      username = match[1]
+      video_urls = self.parse_user(username)
+      puts "[YOUTUBE] Starting user videos download"
+      video_urls.each do |url|
+        puts "[YOUTUBE] Downloading next user video (#{url})"
+        return_values << self.grab_single_url_filename(url)
+      end
+    else                                                                   #if single video
+      return_values << self.grab_single_url_filename(url)
+    end 
+    return_values.reject! { |value| value == :no_embed }   #remove results that can not be downloaded
+
+    if return_values.empty?
+      raise CouldNotDownloadVideoError, "No videos could be downloaded - embedding disabled."
+    else
+      return_values
+    end
+  end
+ 
+  def self.grab_single_url_filename(url)
+    #the youtube video ID looks like this: [...]v=abc5a5_afe5agae6g&[...], we only want the ID (the \w in the brackets)
+    #addition: might also look like this /v/abc5-a5afe5agae6g
+    # alternative:  video_id = url[/v[\/=]([\w-]*)&?/, 1]
+    # First get the redirect
+    if url.include?("youtu.be")
+      url = open(url).base_uri.to_s
+    end
+    video_id = url[/(v|embed)[=\/]([^\/\?\&]*)/,2]
+    if video_id.nil?
+      raise CouldNotDownloadVideoError, "No video id found."
+    else
+      puts "[YOUTUBE] ID FOUND: #{video_id}"
+    end
+    #let's get some infos about the video. data is urlencoded
+    yt_url = "http://www.youtube.com/get_video_info?video_id=#{video_id}"
+    video_info = RestClient.get(yt_url).body
+    #converting the huge infostring into a hash. simply by splitting it at the & and then splitting it into key and value arround the =
+    #[...]blabla=blubb&narf=poit&marc=awesome[...]
+    video_info_hash = Hash[*video_info.split("&").collect { |v| 
+      key, encoded_value = v.split("=")
+      if encoded_value.to_s.empty?
+        value = ""
+      else
+      #decode until everything is "normal"
+        while (encoded_value != CGI::unescape(encoded_value)) do
+          #"decoding"
+          encoded_value = CGI::unescape(encoded_value)
+        end
+        value = encoded_value
+      end
+
+      if key =~ /_map/
+        orig_value = value
+        value = value.split(",")
+        if key == "url_encoded_fmt_stream_map"
+          url_array = orig_value.split("url=").map{|url_string| url_string.chomp(",")}
+          result_hash = {}
+          url_array.each do |url|
+            next if url.to_s.empty? || url.to_s.match(/^itag/)
+            format_id = url[/\&itag=(\d+)/, 1]
+            result_hash[format_id] = url
+          end
+          value = result_hash
+        elsif key == "fmt_map"
+          value = Hash[*value.collect { |v| 
+              k2, *v2 = v.split("/")
+              [k2, v2]
+            }.flatten(1)]
+        elsif key == "fmt_url_map" || key == "fmt_stream_map"
+          Hash[*value.collect { |v| v.split("|")}.flatten]
+        end
+      end
+      [key, value]
+    }.flatten]
+    
+    if video_info_hash["status"] == "fail"
+      return :no_embed
+    end
+    
+    title = video_info_hash["title"]
+    length_s = video_info_hash["length_seconds"]
+    token = video_info_hash["token"]
+
+    #for the formats, see: http://en.wikipedia.org/wiki/YouTube#Quality_and_codecs
+    fmt_list = video_info_hash["fmt_list"].split(",")
+    available_formats = fmt_list.map{|format| format.split("/").first}
+    
+    format_ext = {}
+    format_ext["38"] = {:extension => "mp4", :name => "MP4 Highest Quality 4096x3027 (H.264, AAC)"}            
+    format_ext["37"] = {:extension => "mp4", :name => "MP4 Highest Quality 1920x1080 (H.264, AAC)"}
+    format_ext["22"] = {:extension => "mp4", :name => "MP4 1280x720 (H.264, AAC)"}
+    format_ext["45"] = {:extension => "webm", :name => "WebM 1280x720 (VP8, Vorbis)"}
+    format_ext["44"] = {:extension => "webm", :name => "WebM 854x480 (VP8, Vorbis)"}    
+    format_ext["18"] = {:extension => "mp4", :name => "MP4 640x360 (H.264, AAC)"}
+    format_ext["35"] = {:extension => "flv", :name => "FLV 854x480 (H.264, AAC)"}
+    format_ext["34"] = {:extension => "flv", :name => "FLV 640x360 (H.264, AAC)"}
+    format_ext["5"] = {:extension => "flv", :name => "FLV 400x240 (Soerenson H.263)"}
+    format_ext["17"] = {:extension => "3gp", :name => "3gp"}    
+    
+    #since 1.8 doesn't do ordered hashes
+    prefered_order = ["38","37","22","45","44","18","35","34","5","17"]
+    
+    selected_format = prefered_order.select{|possible_format| available_formats.include?(possible_format)}.first
+    
+    puts "[YOUTUBE] Title: #{title}"
+    puts "[YOUTUBE] Length: #{length_s} s"
+    puts "[YOUTUBE] t-parameter: #{token}"
+    #best quality seems always to be firsts
+    puts "[YOUTUBE] formats available: #{available_formats.inspect} (downloading format #{selected_format} -> #{format_ext[selected_format][:name]})"
+
+    #video_info_hash.keys.sort.each{|key| puts "#{key} : #{video_info_hash[key]}" }
+    download_url = video_info_hash["url_encoded_fmt_stream_map"][selected_format]
+    #if download url ends with a ';' followed by a codec string remove that part because it stops URI.parse from working
+    download_url = $1 if download_url =~ /(.*?);\scodecs=/
+    file_name = PluginBase.make_filename_safe(title) + "." + format_ext[selected_format][:extension]
+    puts "downloading to " + file_name
+    {:url => download_url, :name => file_name}
+  end
+end