viddl-rb 0.8 → 0.61

data/helper/plugin-helper.rb

@@ -1,60 +1,10 @@
-module ViddlRb
-
-  class PluginBase
-
-    #this exception is raised by the plugins when it was not 
-    #possible to donwload the video for some reason.
-    class CouldNotDownloadVideoError < StandardError; end
-
-    #some static stuff
-    class << self
-      attr_accessor :io
-      attr_reader   :registered_plugins
-    end
-
-    #all calls to #puts, #print and #p from any plugin instance will be redirected to this object 
-    @io = $stdout
-    @registered_plugins = []
-
-    #if you inherit from this class, the child gets added to the "registered plugins" array
-    def self.inherited(child)
-      PluginBase.registered_plugins << child
-    end
-
-    #takes a string a returns a new string that is file name safe
-    #deletes \"' and replaces anything else that is not a digit or letter with _
-    def self.make_filename_safe(string)
-      string.delete("\"'").gsub(/[^\d\w]/, '_')
-    end
-
-    #the following methods redirects the Kernel printing methods (except #p) to the
-    #PluginBase IO object. this is because sometimes we want plugins to
-    #write to something else than $stdout
-
-    def self.puts(*objects)
-      PluginBase.io.puts(*objects)
-      nil
-    end
-
-    def self.print(*objects)
-      PluginBase.io.print(*objects)
-      nil
-    end
-
-    def self.putc(int)
-      PluginBase.io.putc(int)
-      nil
-    end
-
-    def self.printf(string, *objects)
-      if string.is_a?(IO) || string.is_a?(StringIO)
-        super(string, *objects)  # so we don't redirect the printf that prints to a separate IO object
-      else
-        PluginBase.io.printf(string, *objects)
-      end
-      nil
-    end
-  end
-
-end
-
+class PluginBase
+#some static stuff
+  class << self; attr_reader :registered_plugins end
+    @registered_plugins = []
+
+#if you inherit from this class, the child gets added to the "registered plugins" array
+  def self.inherited(child)
+    PluginBase.registered_plugins << child
+  end
+end

data/plugins/blip.rb

@@ -1,4 +1,3 @@
-
 class Blip < 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)
@@ -6,12 +5,12 @@ class Blip < PluginBase
   end
 
   # return the url for original video file and title
-  def self.get_urls_and_filenames(url, options = {})
+  def self.get_urls_and_filenames(url)
     id           = self.to_id(url)
     xml_url      = "http://blip.tv/rss/#{id}"
     doc          = Nokogiri::XML(open(xml_url))
     user         = doc.at("//channel/item/blip:user").inner_text
-    title        = PluginBase.make_filename_safe(doc.at("//channel/item/title").inner_text)
+    title        = doc.at("//channel/item/title").inner_text.gsub(" ", "_")
     download_url = doc.at("//channel/item/media:group/media:content").attributes["url"].value
     extention    = download_url.split(".").last
     file_name    = "#{id}-#{user}-#{title}.#{extention}"

data/plugins/metacafe.rb

@@ -3,58 +3,59 @@
 # 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, 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'])
+	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
 
-    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
+	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
 end

data/plugins/soundcloud.rb

@@ -1,4 +1,3 @@
-require 'open-uri'
 class Soundcloud < 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)
@@ -6,8 +5,8 @@ class Soundcloud < PluginBase
   end
 
   # return the url for original video file and title
-  def self.get_urls_and_filenames(url, options = {})
-    doc          = Nokogiri::HTML(open(get_http_url(url)))
+  def self.get_urls_and_filenames(url)
+    doc          = Nokogiri::XML(open(url))
     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"
@@ -16,27 +15,24 @@ class Soundcloud < PluginBase
   end
 
   def self.transliterate(str)
-    # Based on permalink_fu by Rick Olsen
+  # Based on permalink_fu by Rick Olsen
 
-    # Downcase string
-    str.downcase!
+  # Downcase string
+  str.downcase!
 
-    # Remove apostrophes so isn't changes to isnt
-    str.gsub!(/'/, '')
+  # Remove apostrophes so isn't changes to isnt
+  str.gsub!(/'/, '')
 
-    # Replace any non-letter or non-number character with a space
-    str.gsub!(/[^A-Za-z0-9]+/, ' ')
+  # Replace any non-letter or non-number character with a space
+  str.gsub!(/[^A-Za-z0-9]+/, ' ')
 
-    # Remove spaces from beginning and end of string
-    str.strip!
+  # Remove spaces from beginning and end of string
+  str.strip!
 
-    # Replace groups of spaces with single hyphen
-    str.gsub!(/\ +/, '-')
+  # Replace groups of spaces with single hyphen
+  str.gsub!(/\ +/, '-')
 
-    str
-  end
+  str
+end
 
-  def self.get_http_url(url)
-    url.sub(/https?:\/\//, "http:\/\/")
-  end
 end

data/plugins/veoh.rb

@@ -1,45 +1,46 @@
 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, options = {})
-    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)
+		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
-    extension = download_url[/\/[\w\d]+(\.[\w\d]+)\?ct/, 1]
-    PluginBase.make_filename_safe(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
+		name.gsub!(" ", "_") # replace spaces with underscores
+		extension = download_url[/\/[\w\d]+(\.[\w\d]+)\?ct/, 1]
+		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,32 +1,25 @@
 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, options = {})
-    #the vimeo ID consists of 7 decimal numbers in the URL
-    vimeo_id = url[/\d{7,8}/]
+	#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
+		
 
-    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
+		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

data/plugins/youtube.rb

@@ -1,271 +1,143 @@
-
 class Youtube < PluginBase
-
-  # see http://en.wikipedia.org/wiki/YouTube#Quality_and_codecs
-  # TODO: we don't have all the formats from the wiki article here
-  VIDEO_FORMATS = {
-    "38" => {:extension => "mp4",  :name => "MP4 Highest Quality 4096x3027 (H.264, AAC)"},
-    "37" => {:extension => "mp4",  :name => "MP4 Highest Quality 1920x1080 (H.264, AAC)"},
-    "22" => {:extension => "mp4",  :name => "MP4 1280x720 (H.264, AAC)"},
-    "46" => {:extension => "webm", :name => "WebM 1920x1080 (VP8, Vorbis)"},
-    "45" => {:extension => "webm", :name => "WebM 1280x720 (VP8, Vorbis)"},
-    "44" => {:extension => "webm", :name => "WebM 854x480 (VP8, Vorbis)"},
-    "43" => {:extension => "webm", :name => "WebM 480×360 (VP8, Vorbis)"},
-    "18" => {:extension => "mp4",  :name => "MP4 640x360 (H.264, AAC)"},
-    "35" => {:extension => "flv",  :name => "FLV 854x480 (H.264, AAC)"},
-    "34" => {:extension => "flv",  :name => "FLV 640x360 (H.264, AAC)"},
-    "5"  => {:extension => "flv",  :name => "FLV 400x240 (Soerenson H.263)"},
-    "17" => {:extension => "3gp",  :name => "3gp"}
-  }
-
-  DEFAULT_FORMAT_ORDER = %w[38 37 22 46 45 44 43 18 35 34 5 17]
-  VIDEO_INFO_URL       = "http://www.youtube.com/get_video_info?video_id="
-  VIDEO_INFO_PARMS     = "&ps=default&eurl=&gl=US&hl=en"
-
-  # 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.get_urls_and_filenames(url, options = {})
-    @quality    = options[:quality]
-    filter      = options[:playlist_filter]
-    parser      = PlaylistParser.new
-    return_vals = []
-
-    if playlist_urls = parser.get_playlist_urls(url, filter)
-      playlist_urls.each { |url| return_vals << grab_single_url_filename(url) }
-    else
-      return_vals << grab_single_url_filename(url)
-    end
-
-    clean_return_values(return_vals)
-  end
-
-  def self.clean_return_values(return_values)
-    cleaned = return_values.reject { |val| val == :no_embed }
-
-    if cleaned.empty?
-      download_error("No videos could be downloaded.")
-    else
-      cleaned
-    end
-  end
-
-  def self.grab_single_url_filename(url)
-    grab_url_embeddable(url) || grab_url_non_embeddable(url)
-  end
-
-  def self.grab_url_embeddable(url)
-    video_info   = get_video_info(url)
-    video_params = extract_video_parameters(video_info)
-    unless video_params[:embeddable]
-      notify("VIDEO IS NOT EMBEDDABLE")
-      return false
-    end
-
-    urls_formats    = extract_urls_formats(video_info)
-    selected_format = choose_format(urls_formats)
-    title           = video_params[:title]
-    file_name       = PluginBase.make_filename_safe(title) + "." + VIDEO_FORMATS[selected_format][:extension]
-
-    {:url => urls_formats[selected_format], :name => file_name}
-  end
-
-  def self.grab_url_non_embeddable(url)
-    video_info = open(url).read
-    stream_map = video_info[/url_encoded_fmt_stream_map\" *: *\"([^\"]+)\"/,1]
-    urls_formats = parse_stream_map(url_decode(stream_map))
-    selected_format = choose_format(urls_formats)
-    title = video_info[/<meta name="title" content="([^"]*)">/, 1]
-    file_name = PluginBase.make_filename_safe(title) + "." + VIDEO_FORMATS[selected_format][:extension]
-
-    # cleaning
-    clean_url = urls_formats[selected_format].gsub(/\\u0026[^&]*/, "")
-
-    {:url => clean_url, :name => file_name}
-  end
-
-  def self.get_video_info(url)
-    id = extract_video_id(url)
-    request_url = VIDEO_INFO_URL + id + VIDEO_INFO_PARMS
-    open(request_url).read
-  end
-
-  def self.extract_video_id(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]
-    url = open(url).base_uri.to_s if url.include?("youtu.be")
-    video_id = url[/(v|embed)[=\/]([^\/\?\&]*)/, 2]
-
-    if video_id
-      notify("ID FOUND: #{video_id}")
-      video_id
-    else
-      download_error("No video id found.")
-    end
-  end
-
-  def self.extract_video_parameters(video_info)
-    decoded = url_decode(video_info)
-
-    {:title      => decoded[/title=(.+?)(?:&|$)/, 1],
-     :length_sec => decoded[/length_seconds=(.+?)(?:&|$)/, 1],
-     :author     => decoded[/author=(.+?)(?:&|$)/, 1],
-     :embeddable => !decoded.include?("status=fail")}
-  end
-
-  def self.extract_urls_formats(video_info)
-    stream_map = video_info[/url_encoded_fmt_stream_map=(.+?)(?:&|$)/, 1]
-    parse_stream_map(stream_map)
-  end
-
-  def self.parse_stream_map(stream_map)
-    urls = extract_download_urls(stream_map)
-    formats_urls = {}
-
-    urls.each do |url|
-      format = url[/itag=(\d+)/, 1]
-      formats_urls[format] = url
-    end
-
-    formats_urls
-  end
-
-  def self.extract_download_urls(stream_map)
-    entries = stream_map.split("%2C")
-    decoded = entries.map { |entry| url_decode(entry) }
-
-    decoded.map do |entry|
-      url = entry[/url=(.*?itag=.+?)(?:itag=|;|$)/, 1]
-      sig = entry[/sig=(.+?)(?:&|$)/, 1]
-
-      url + "&signature=#{sig}"
-    end
-  end
-
-  def self.choose_format(urls_formats)
-    available_formats = urls_formats.keys
-
-    if @quality                        #if the user specified a format
-      ext = @quality[:extension]
-      res = @quality[:resolution]
-      #gets a nested array with all the formats of the same res as the user wanted
-      requested = VIDEO_FORMATS.select { |id, format| format[:name].include?(res) }.to_a
-
-      if requested.empty?
-        notify "Requested format \"#{res}:#{ext}\" not found. Downloading default format."
-        get_default_format(available_formats)
+	#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
-        pick = requested.find { |format| format[1][:extension] == ext }             # get requsted extension if possible
-        pick ? pick.first : get_default_format(requested.map { |req| req.first })   # else return the default format
+      #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
-    else
-      get_default_format(available_formats)
-    end
-  end
-
-  def self.get_default_format(available)
-    DEFAULT_FORMAT_ORDER.find { |default| available.include?(default) }
-  end
-
-  def self.url_decode(text)
-    while text != (decoded = CGI::unescape(text)) do
-      text = decoded
-    end
-    text
-  end
-
-  def self.notify(message)
-    puts "[YOUTUBE] #{message}"
-  end
-
-  def self.download_error(message)
-    raise CouldNotDownloadVideoError, message
-  end
-
-  #
-  # class PlaylistParser
-  #_____________________
-
-  class PlaylistParser
-
-    PLAYLIST_FEED = "http://gdata.youtube.com/feeds/api/playlists/%s?&max-results=50&v=2"
-    USER_FEED     = "http://gdata.youtube.com/feeds/api/users/%s/uploads?&max-results=50&v=2"
-
-    def get_playlist_urls(url, filter = nil)
-      @filter = filter
 
-      if url.include?("view_play_list") || url.include?("playlist?list=")     # if playlist URL
-        parse_playlist(url)
-      elsif username = url[/\/user\/([\w\d]+)(?:\/|$)/, 1]                       # if user URL
-        parse_user(username)
-      else                                                                    # if neither return nil
-        nil
+      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
-    end
-
-    def 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=)(.+?)(?:&|\/|$)/, 1]
-      notify "Playlist ID: #{playlist_ID}"
-      feed_url = PLAYLIST_FEED % playlist_ID
-      url_array = get_video_urls(feed_url)
-      notify "#{url_array.size} links found!"
-      url_array
-    end
-
-    def parse_user(username)
-      notify "User: #{username}"
-      feed_url = USER_FEED % username
-      url_array = get_video_urls(feed_url)
-      notify "#{url_array.size} links found!"
-      url_array
-    end
-
-    #get all videos and return their urls in an array
-    def get_video_urls(feed_url)
-      notify "Retrieving videos..."
-      urls_titles = {}
-      result_feed = Nokogiri::XML(open(feed_url))
-      urls_titles.merge!(grab_urls_and_titles(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_urls_and_titles(result_feed))
-      end
-
-      filter_urls(urls_titles)
-    end
-
-    #extract all video urls and their titles from a feed and return in a hash
-    def grab_urls_and_titles(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
-
-    #returns only the urls that match the --filter argument regex (if present)
-    def filter_urls(url_hash)
-      if @filter
-        notify "Using filter: #{@filter}"
-        filtered = url_hash.select { |url, title| title =~ @filter }
-        filtered.keys
-      else
-        url_hash.keys
-      end
-    end
-
-    def notify(message)
-      Youtube.notify(message)
-    end
-  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