viddl-rb 0.68 → 0.70

data/plugins/metacafe.rb

@@ -11,7 +11,7 @@ class Metacafe < PluginBase
     url.include?("metacafe.com")
   end
   
-  def self.get_urls_and_filenames(url)
+  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))
@@ -25,16 +25,14 @@ class Metacafe < PluginBase
     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]}]
+        
+    [{: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
-      puts "ERROR: Can only download videos that has the ID in the URL."
-      exit
+      raise CouldNotDownloadVideoError, "Can only download videos that has the ID in the URL."
     end
     id
   end

data/plugins/soundcloud.rb

@@ -1,3 +1,4 @@
+require 'rest_client'
 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)
@@ -5,8 +6,8 @@ class Soundcloud < PluginBase
   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"

data/plugins/veoh.rb

@@ -1,45 +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
-		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
+    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
+  def self.get_attribute(format)
+    case format
+    when :mp4
+      "ipodUrl"
+    when :flash
+      "previewUrl"
+    end
+  end
 end

data/plugins/vimeo.rb

@@ -1,12 +1,10 @@
-
-
 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)
+  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}/]
 
@@ -15,9 +13,9 @@ class Vimeo < PluginBase
 
     video_page = agent.get("http://vimeo.com/#{vimeo_id}")
     page_html = video_page.root.inner_html
-
-    title = page_html[/<meta\s+property="og:title"\s+content="(.+?)"/, 1]
-    puts "[VIMEO] Title: #{title}"
+    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]
@@ -31,4 +29,4 @@ class Vimeo < PluginBase
 
     [{:url => download_url, :name => file_name}]
   end
-end
+end

data/plugins/youtube.rb

@@ -1,197 +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
-  
-  #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::HTML(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)
-    #get the --filter arg or "" if it is not present (because nil would break the next line)
-    filter = ARGV.find( proc {""} ) { |arg| arg =~ /--filter=/ }
-    regex = filter[/--filter=(.+?)(?:\/|$)/, 1]
-    if regex
-      puts "[YOUTUBE] Using filter: #{regex}"
-      ignore_case = filter.include?("/i")
-      filtered = url_hash.select { |url, title| title =~ Regexp.new(regex, ignore_case) }
-      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)
-    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
-    return_values.empty? ? exit : return_values            #if no videos could be downloaded exit 
-  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"
-      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
+
+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