X-Git-Url: http://git.bitcoin.ninja/index.cgi?a=blobdiff_plain;f=youtube-dl;h=08afab4f801e4d84c86e6285bada64a53c241d8e;hb=43f35682e9cf509459097e6fdebe2f10c95094f1;hp=2c1d1aa3b84b5e3cda680e22fe0a6a39dc91c777;hpb=90663284b2c742ae84d3dd00876af9b681ee78ee;p=youtube-dl

diff --git a/youtube-dl b/youtube-dl
index 2c1d1aa3b..08afab4f8 100755
--- a/youtube-dl
+++ b/youtube-dl
@@ -1,9 +1,11 @@
 #!/usr/bin/env python
 # -*- coding: utf-8 -*-
 # Author: Ricardo Garcia Gonzalez
+# Author: Danny Colligan
 # License: Public domain code
 import htmlentitydefs
 import httplib
+import locale
 import math
 import netrc
 import os
@@ -16,8 +18,8 @@ import time
 import urllib
 import urllib2
 
-std_headers = {	
-	'User-Agent': 'Mozilla/5.0 (Windows; U; Windows NT 5.1; en-US; rv:1.9.0.1) Gecko/2008070208 Firefox/3.0.1',
+std_headers = {
+	'User-Agent': 'Mozilla/5.0 (Windows; U; Windows NT 6.0; en-US; rv:1.9.0.8) Gecko/2009032609 Firefox/3.0.8',
 	'Accept-Charset': 'ISO-8859-1,utf-8;q=0.7,*;q=0.7',
 	'Accept': 'text/xml,application/xml,application/xhtml+xml,text/html;q=0.9,text/plain;q=0.8,image/png,*/*;q=0.5',
 	'Accept-Language': 'en-us,en;q=0.5',
@@ -42,6 +44,21 @@ class SameFileError(Exception):
 	"""
 	pass
 
+class PostProcessingError(Exception):
+	"""Post Processing exception.
+
+	This exception may be raised by PostProcessor's .run() method to
+	indicate an error in the postprocessing task.
+	"""
+	pass
+
+class UnavailableFormatError(Exception):
+	"""Unavailable Format exception.
+
+	This exception will be thrown when a video is requested
+	in a format that is not available for that video.
+	"""
+
 class FileDownloader(object):
 	"""File Downloader class.
 
@@ -55,16 +72,17 @@ class FileDownloader(object):
 	For this, file downloader objects have a method that allows
 	InfoExtractors to be registered in a given order. When it is passed
 	a URL, the file downloader handles it to the first InfoExtractor it
-	finds that reports being able to handle it. The InfoExtractor returns
-	all the information to the FileDownloader and the latter downloads the
-	file or does whatever it's instructed to do.
+	finds that reports being able to handle it. The InfoExtractor extracts
+	all the information about the video or videos the URL refers to, and
+	asks the FileDownloader to process the video information, possibly
+	downloading the video.
 
 	File downloaders accept a lot of parameters. In order not to saturate
 	the object constructor with arguments, it receives a dictionary of
-	options instead. These options are available through the get_params()
-	method for the InfoExtractors to use. The FileDownloader also registers
-	itself as the downloader in charge for the InfoExtractors that are
-	added to it, so this is a "mutual registration".
+	options instead. These options are available through the params
+	attribute for the InfoExtractors to use. The FileDownloader also
+	registers itself as the downloader in charge for the InfoExtractors
+	that are added to it, so this is a "mutual registration".
 
 	Available options:
 
@@ -78,21 +96,28 @@ class FileDownloader(object):
 	format:		Video format code.
 	outtmpl:	Template for output names.
 	ignoreerrors:	Do not stop on download errors.
+	ratelimit:	Download speed limit, in bytes/sec.
+	nooverwrites:	Prevent overwriting files.
 	"""
 
-	_params = None
+	params = None
 	_ies = []
+	_pps = []
+	_download_retcode = None
 
 	def __init__(self, params):
 		"""Create a FileDownloader object with the given options."""
 		self._ies = []
-		self.set_params(params)
+		self._pps = []
+		self._download_retcode = 0
+		self.params = params
 	
 	@staticmethod
 	def pmkdir(filename):
 		"""Create directory components in filename. Similar to Unix "mkdir -p"."""
 		components = filename.split(os.sep)
 		aggregate = [os.sep.join(components[0:x]) for x in xrange(1, len(components))]
+		aggregate = ['%s%s' % (x, os.sep) for x in aggregate] # Finish names with separator
 		for dir in aggregate:
 			if not os.path.exists(dir):
 				os.mkdir(dir)
@@ -129,7 +154,7 @@ class FileDownloader(object):
 			return '--:--'
 		return '%02d:%02d' % (eta_mins, eta_secs)
 
- 	@staticmethod
+	@staticmethod
 	def calc_speed(start, now, bytes):
 		dif = now - start
 		if bytes == 0 or dif < 0.001: # One millisecond
@@ -149,113 +174,164 @@ class FileDownloader(object):
 			return int(new_min)
 		return int(rate)
 
-	def set_params(self, params):
-		"""Sets parameters."""
-		if type(params) != dict:
-			raise ValueError('params: dictionary expected')
-		self._params = params
-	
-	def get_params(self):
-		"""Get parameters."""
-		return self._params
+	@staticmethod
+	def parse_bytes(bytestr):
+		"""Parse a string indicating a byte quantity into a long integer."""
+		matchobj = re.match(r'(?i)^(\d+(?:\.\d+)?)([kMGTPEZY]?)$', bytestr)
+		if matchobj is None:
+			return None
+		number = float(matchobj.group(1))
+		multiplier = 1024.0 ** 'bkmgtpezy'.index(matchobj.group(2).lower())
+		return long(round(number * multiplier))
 
 	def add_info_extractor(self, ie):
 		"""Add an InfoExtractor object to the end of the list."""
 		self._ies.append(ie)
 		ie.set_downloader(self)
 	
+	def add_post_processor(self, pp):
+		"""Add a PostProcessor object to the end of the chain."""
+		self._pps.append(pp)
+		pp.set_downloader(self)
+	
 	def to_stdout(self, message, skip_eol=False):
 		"""Print message to stdout if not in quiet mode."""
-		if not self._params.get('quiet', False):
-			sys.stdout.write('%s%s' % (message, ['\n', ''][skip_eol]))
+		if not self.params.get('quiet', False):
+			print (u'%s%s' % (message, [u'\n', u''][skip_eol])).encode(locale.getpreferredencoding()),
 			sys.stdout.flush()
 	
 	def to_stderr(self, message):
 		"""Print message to stderr."""
-		sys.stderr.write('%s\n' % message)
+		print >>sys.stderr, message
 	
 	def fixed_template(self):
 		"""Checks if the output template is fixed."""
-		return (re.search(ur'(?u)%\(.+?\)s', self._params['outtmpl']) is None)
+		return (re.search(ur'(?u)%\(.+?\)s', self.params['outtmpl']) is None)
 
 	def trouble(self, message=None):
 		"""Determine action to take when a download problem appears.
 
 		Depending on if the downloader has been configured to ignore
 		download errors or not, this method may throw an exception or
-		not when errors are found, after printing the message. If it
-		doesn't raise, it returns an error code suitable to be returned
-		later as a program exit code to indicate error.
+		not when errors are found, after printing the message.
 		"""
 		if message is not None:
 			self.to_stderr(message)
-		if not self._params.get('ignoreerrors', False):
+		if not self.params.get('ignoreerrors', False):
 			raise DownloadError(message)
-		return 1
+		self._download_retcode = 1
+
+	def slow_down(self, start_time, byte_counter):
+		"""Sleep if the download speed is over the rate limit."""
+		rate_limit = self.params.get('ratelimit', None)
+		if rate_limit is None or byte_counter == 0:
+			return
+		now = time.time()
+		elapsed = now - start_time
+		if elapsed <= 0.0:
+			return
+		speed = float(byte_counter) / elapsed
+		if speed > rate_limit:
+			time.sleep((byte_counter - rate_limit * (now - start_time)) / rate_limit)
+
+	def report_destination(self, filename):
+		"""Report destination filename."""
+		self.to_stdout(u'[download] Destination: %s' % filename)
+	
+	def report_progress(self, percent_str, data_len_str, speed_str, eta_str):
+		"""Report download progress."""
+		self.to_stdout(u'\r[download] %s of %s at %s ETA %s' %
+				(percent_str, data_len_str, speed_str, eta_str), skip_eol=True)
+	
+	def report_finish(self):
+		"""Report download finished."""
+		self.to_stdout(u'')
+
+	def process_info(self, info_dict):
+		"""Process a single dictionary returned by an InfoExtractor."""
+		# Forced printings
+		if self.params.get('forcetitle', False):
+			print info_dict['title'].encode(locale.getpreferredencoding())
+		if self.params.get('forceurl', False):
+			print info_dict['url'].encode(locale.getpreferredencoding())
+			
+		# Do nothing else if in simulate mode
+		if self.params.get('simulate', False):
+			return
+
+		try:
+			template_dict = dict(info_dict)
+			template_dict['epoch'] = unicode(long(time.time()))
+			filename = self.params['outtmpl'] % template_dict
+			self.report_destination(filename)
+		except (ValueError, KeyError), err:
+			self.trouble('ERROR: invalid output template or system charset: %s' % str(err))
+		if self.params['nooverwrites'] and os.path.exists(filename):
+			self.to_stderr('WARNING: file exists: %s; skipping' % filename)
+			return
+
+		try:
+			self.pmkdir(filename)
+		except (OSError, IOError), err:
+			self.trouble('ERROR: unable to create directories: %s' % str(err))
+			return
+
+		try:
+			outstream = open(filename, 'wb')
+		except (OSError, IOError), err:
+			self.trouble('ERROR: unable to open for writing: %s' % str(err))
+			return
+
+		try:
+			self._do_download(outstream, info_dict['url'])
+			outstream.close()
+		except (OSError, IOError), err:
+			os.remove(filename)
+			raise UnavailableFormatError
+		except (urllib2.URLError, httplib.HTTPException, socket.error), err:
+			self.trouble('ERROR: unable to download video data: %s' % str(err))
+			return
+
+		try:
+			self.post_process(filename, info_dict)
+		except (PostProcessingError), err:
+			self.trouble('ERROR: postprocessing: %s' % str(err))
+			return
 
 	def download(self, url_list):
 		"""Download a given list of URLs."""
-		retcode = 0
 		if len(url_list) > 1 and self.fixed_template():
-			raise SameFileError(self._params['outtmpl'])
+			raise SameFileError(self.params['outtmpl'])
 
 		for url in url_list:
 			suitable_found = False
 			for ie in self._ies:
+				# Go to next InfoExtractor if not suitable
 				if not ie.suitable(url):
 					continue
+
 				# Suitable InfoExtractor found
 				suitable_found = True
-				all_results = ie.extract(url)
-				results = [x for x in all_results if x is not None]
-				if len(results) != len(all_results):
-					retcode = self.trouble()
-
-				if len(results) > 1 and self.fixed_template():
-					raise SameFileError(self._params['outtmpl'])
-
-				for result in results:
-
-					# Forced printings
-					if self._params.get('forcetitle', False):
-						print result['title']
-					if self._params.get('forceurl', False):
-						print result['url']
-						
-					# Do nothing else if in simulate mode
-					if self._params.get('simulate', False):
-						continue
 
-					try:
-						filename = self._params['outtmpl'] % result
-						self.to_stdout('[download] Destination: %s' % filename)
-					except (ValueError, KeyError), err:
-						retcode = self.trouble('ERROR: invalid output template: %s' % str(err))
-						continue
-					try:
-						self.pmkdir(filename)
-					except (OSError, IOError), err:
-						retcode = self.trouble('ERROR: unable to create directories: %s' % str(err))
-						continue
-					try:
-						outstream = open(filename, 'wb')
-					except (OSError, IOError), err:
-						retcode = self.trouble('ERROR: unable to open for writing: %s' % str(err))
-						continue
-					try:
-						self._do_download(outstream, result['url'])
-						outstream.close()
-					except (OSError, IOError), err:
-						retcode = self.trouble('ERROR: unable to write video data: %s' % str(err))
-						continue
-					except (urllib2.URLError, httplib.HTTPException, socket.error), err:
-						retcode = self.trouble('ERROR: unable to download video data: %s' % str(err))
-						continue
+				# Extract information from URL and process it
+				ie.extract(url)
+
+				# Suitable InfoExtractor had been found; go to next URL
 				break
+
 			if not suitable_found:
-				retcode = self.trouble('ERROR: no suitable InfoExtractor: %s' % url)
+				self.trouble('ERROR: no suitable InfoExtractor: %s' % url)
+
+		return self._download_retcode
 
-		return retcode
+	def post_process(self, filename, ie_info):
+		"""Run the postprocessing chain on the given file."""
+		info = dict(ie_info)
+		info['filepath'] = filename
+		for pp in self._pps:
+			info = pp.run(info)
+			if info is None:
+				break
 	
 	def _do_download(self, stream, url):
 		request = urllib2.Request(url, None, std_headers)
@@ -266,12 +342,13 @@ class FileDownloader(object):
 		block_size = 1024
 		start = time.time()
 		while True:
+			# Progress message
 			percent_str = self.calc_percent(byte_counter, data_len)
 			eta_str = self.calc_eta(start, time.time(), data_len, byte_counter)
 			speed_str = self.calc_speed(start, time.time(), byte_counter)
-			self.to_stdout('\r[download] %s of %s at %s ETA %s' %
-					(percent_str, data_len_str, speed_str, eta_str), skip_eol=True)
+			self.report_progress(percent_str, data_len_str, speed_str, eta_str)
 
+			# Download and write
 			before = time.time()
 			data_block = data.read(block_size)
 			after = time.time()
@@ -282,7 +359,10 @@ class FileDownloader(object):
 			stream.write(data_block)
 			block_size = self.best_block_size(after - before, data_block_len)
 
-		self.to_stdout('')
+			# Apply rate limit
+			self.slow_down(start, byte_counter)
+
+		self.report_finish()
 		if data_len is not None and str(byte_counter) != data_len:
 			raise ValueError('Content too short: %s/%s bytes' % (byte_counter, data_len))
 
@@ -292,9 +372,10 @@ class InfoExtractor(object):
 	Information extractors are the classes that, given a URL, extract
 	information from the video (or videos) the URL refers to. This
 	information includes the real video URL, the video title and simplified
-	title, author and others. It is returned in a list of dictionaries when
-	calling its extract() method. It is a list because a URL can refer to
-	more than one video (think of playlists). The dictionaries must include
+	title, author and others. The information is stored in a dictionary
+	which is then passed to the FileDownloader. The FileDownloader
+	processes this information possibly downloading the video to the file
+	system, among other possible outcomes. The dictionaries must include
 	the following fields:
 
 	id:		Video identifier.
@@ -321,7 +402,7 @@ class InfoExtractor(object):
 	@staticmethod
 	def suitable(url):
 		"""Receives a URL and returns True if suitable for this IE."""
-		return True
+		return False
 
 	def initialize(self):
 		"""Initializes an instance (authentication, etc)."""
@@ -338,15 +419,6 @@ class InfoExtractor(object):
 		"""Sets the downloader for this IE."""
 		self._downloader = downloader
 	
-	def to_stdout(self, message):
-		"""Print message to stdout if downloader is not in quiet mode."""
-		if self._downloader is None or not self._downloader.get_params().get('quiet', False):
-			print message
-	
-	def to_stderr(self, message):
-		"""Print message to stderr."""
-		sys.stderr.write('%s\n' % message)
-
 	def _real_initialize(self):
 		"""Real initialization process. Redefine in subclasses."""
 		pass
@@ -358,17 +430,81 @@ class InfoExtractor(object):
 class YoutubeIE(InfoExtractor):
 	"""Information extractor for youtube.com."""
 
-	_LOGIN_URL = 'http://www.youtube.com/login?next=/'
-	_AGE_URL = 'http://www.youtube.com/verify_age?next_url=/'
+	_VALID_URL = r'^((?:http://)?(?:\w+\.)?youtube\.com/(?:(?:v/)|(?:(?:watch(?:\.php)?)?\?(?:.+&)?v=)))?([0-9A-Za-z_-]+)(?(1).+)?$'
+	_LANG_URL = r'http://uk.youtube.com/?hl=en&persist_hl=1&gl=US&persist_gl=1&opt_out_ackd=1'
+	_LOGIN_URL = 'http://www.youtube.com/signup?next=/&gl=US&hl=en'
+	_AGE_URL = 'http://www.youtube.com/verify_age?next_url=/&gl=US&hl=en'
 	_NETRC_MACHINE = 'youtube'
+	_available_formats = ['22', '35', '18', '17', '13'] # listed in order of priority for -b flag
+	_video_extensions = {
+		'13': '3gp',
+		'17': 'mp4',
+		'18': 'mp4',
+		'22': 'mp4',
+	}
 
+	@staticmethod
+	def suitable(url):
+		return (re.match(YoutubeIE._VALID_URL, url) is not None)
+
+	@staticmethod
+	def htmlentity_transform(matchobj):
+		"""Transforms an HTML entity to a Unicode character."""
+		entity = matchobj.group(1)
+
+		# Known non-numeric HTML entity
+		if entity in htmlentitydefs.name2codepoint:
+			return unichr(htmlentitydefs.name2codepoint[entity])
+
+		# Unicode character
+		mobj = re.match(ur'(?u)#(x?\d+)', entity)
+		if mobj is not None:
+			numstr = mobj.group(1)
+			if numstr.startswith(u'x'):
+				base = 16
+				numstr = u'0%s' % numstr
+			else:
+				base = 10
+			return unichr(long(numstr, base))
+
+		# Unknown entity in name, return its literal representation
+		return (u'&%s;' % entity)
+
+	def report_lang(self):
+		"""Report attempt to set language."""
+		self._downloader.to_stdout(u'[youtube] Setting language')
+
+	def report_login(self):
+		"""Report attempt to log in."""
+		self._downloader.to_stdout(u'[youtube] Logging in')
+	
+	def report_age_confirmation(self):
+		"""Report attempt to confirm age."""
+		self._downloader.to_stdout(u'[youtube] Confirming age')
+	
+	def report_webpage_download(self, video_id):
+		"""Report attempt to download webpage."""
+		self._downloader.to_stdout(u'[youtube] %s: Downloading video webpage' % video_id)
+	
+	def report_information_extraction(self, video_id):
+		"""Report attempt to extract video information."""
+		self._downloader.to_stdout(u'[youtube] %s: Extracting video information' % video_id)
+	
+	def report_video_url(self, video_id, video_real_url):
+		"""Report extracted video URL."""
+		self._downloader.to_stdout(u'[youtube] %s: URL: %s' % (video_id, video_real_url))
+	
+	def report_unavailable_format(self, video_id, format):
+		"""Report extracted video URL."""
+		self._downloader.to_stdout(u'[youtube] %s: Format %s not available' % (video_id, format))
+	
 	def _real_initialize(self):
 		if self._downloader is None:
 			return
 
 		username = None
 		password = None
-		downloader_params = self._downloader.get_params()
+		downloader_params = self._downloader.params
 
 		# Attempt to use provided username and password or .netrc data
 		if downloader_params.get('username', None) is not None:
@@ -383,9 +519,18 @@ class YoutubeIE(InfoExtractor):
 				else:
 					raise netrc.NetrcParseError('No authenticators for %s' % self._NETRC_MACHINE)
 			except (IOError, netrc.NetrcParseError), err:
-				self.to_stderr('WARNING: parsing .netrc: %s' % str(err))
+				self._downloader.to_stderr(u'WARNING: parsing .netrc: %s' % str(err))
 				return
 
+		# Set language
+		request = urllib2.Request(self._LANG_URL, None, std_headers)
+		try:
+			self.report_lang()
+			urllib2.urlopen(request).read()
+		except (urllib2.URLError, httplib.HTTPException, socket.error), err:
+			self._downloader.to_stderr(u'WARNING: unable to set language: %s' % str(err))
+			return
+
 		# No authentication to be performed
 		if username is None:
 			return
@@ -400,13 +545,13 @@ class YoutubeIE(InfoExtractor):
 				}
 		request = urllib2.Request(self._LOGIN_URL, urllib.urlencode(login_form), std_headers)
 		try:
-			self.to_stdout('[youtube] Logging in')
+			self.report_login()
 			login_results = urllib2.urlopen(request).read()
 			if re.search(r'(?i)<form[^>]* name="loginForm"', login_results) is not None:
-				self.to_stderr('WARNING: unable to log in: bad username or password')
+				self._downloader.to_stderr(u'WARNING: unable to log in: bad username or password')
 				return
 		except (urllib2.URLError, httplib.HTTPException, socket.error), err:
-			self.to_stderr('WARNING: unable to log in: %s' % str(err))
+			self._downloader.to_stderr(u'WARNING: unable to log in: %s' % str(err))
 			return
 	
 		# Confirm age
@@ -416,82 +561,427 @@ class YoutubeIE(InfoExtractor):
 				}
 		request = urllib2.Request(self._AGE_URL, urllib.urlencode(age_form), std_headers)
 		try:
-			self.to_stdout('[youtube] Confirming age')
+			self.report_age_confirmation()
 			age_results = urllib2.urlopen(request).read()
 		except (urllib2.URLError, httplib.HTTPException, socket.error), err:
-			self.to_stderr('ERROR: unable to confirm age: %s' % str(err))
+			self._downloader.trouble(u'ERROR: unable to confirm age: %s' % str(err))
 			return
 
 	def _real_extract(self, url):
 		# Extract video id from URL
-		mobj = re.match(r'^((?:http://)?(?:\w+\.)?youtube\.com/(?:(?:v/)|(?:(?:watch(?:\.php)?)?\?(?:.+&)?v=)))?([0-9A-Za-z_-]+)(?(1).+)?$', url)
+		mobj = re.match(self._VALID_URL, url)
 		if mobj is None:
-			self.to_stderr('ERROR: invalid URL: %s' % url)
-			return [None]
+			self._downloader.trouble(u'ERROR: invalid URL: %s' % url)
+			return
 		video_id = mobj.group(2)
 
 		# Downloader parameters
+		best_quality = False
 		format_param = None
+		quality_index = 0
 		if self._downloader is not None:
-			params = self._downloader.get_params()
+			params = self._downloader.params
 			format_param = params.get('format', None)
+			if format_param == '0':
+				format_param = self._available_formats[quality_index]
+				best_quality = True
+
+		while True:
+			try:
+				# Extension
+				video_extension = self._video_extensions.get(format_param, 'flv')
+
+				# Normalize URL, including format
+				normalized_url = 'http://www.youtube.com/watch?v=%s&gl=US&hl=en' % video_id
+				if format_param is not None:
+					normalized_url = '%s&fmt=%s' % (normalized_url, format_param)
+				request = urllib2.Request(normalized_url, None, std_headers)
+				try:
+					self.report_webpage_download(video_id)
+					video_webpage = urllib2.urlopen(request).read()
+				except (urllib2.URLError, httplib.HTTPException, socket.error), err:
+					self._downloader.trouble(u'ERROR: unable to download video webpage: %s' % str(err))
+					return
+				self.report_information_extraction(video_id)
+				
+				# "t" param
+				mobj = re.search(r', "t": "([^"]+)"', video_webpage)
+				if mobj is None:
+					self._downloader.trouble(u'ERROR: unable to extract "t" parameter')
+					return
+				video_real_url = 'http://www.youtube.com/get_video?video_id=%s&t=%s&el=detailpage&ps=' % (video_id, mobj.group(1))
+				if format_param is not None:
+					video_real_url = '%s&fmt=%s' % (video_real_url, format_param)
+				self.report_video_url(video_id, video_real_url)
+
+				# uploader
+				mobj = re.search(r"var watchUsername = '([^']+)';", video_webpage)
+				if mobj is None:
+					self._downloader.trouble(u'ERROR: unable to extract uploader nickname')
+					return
+				video_uploader = mobj.group(1)
+
+				# title
+				mobj = re.search(r'(?im)<title>YouTube - ([^<]*)</title>', video_webpage)
+				if mobj is None:
+					self._downloader.trouble(u'ERROR: unable to extract video title')
+					return
+				video_title = mobj.group(1).decode('utf-8')
+				video_title = re.sub(ur'(?u)&(.+?);', self.htmlentity_transform, video_title)
+				video_title = video_title.replace(os.sep, u'%')
+
+				# simplified title
+				simple_title = re.sub(ur'(?u)([^%s]+)' % simple_title_chars, ur'_', video_title)
+				simple_title = simple_title.strip(ur'_')
+
+				# Process video information
+				self._downloader.process_info({
+					'id':		video_id.decode('utf-8'),
+					'url':		video_real_url.decode('utf-8'),
+					'uploader':	video_uploader.decode('utf-8'),
+					'title':	video_title,
+					'stitle':	simple_title,
+					'ext':		video_extension.decode('utf-8'),
+				})
+
+				return
+
+			except UnavailableFormatError, err:
+				if best_quality:
+					if quality_index == len(self._available_formats) - 1:
+						# I don't ever expect this to happen
+						self._downloader.trouble(u'ERROR: no known formats available for video')
+						return
+					else:
+						self.report_unavailable_format(video_id, format_param)
+						quality_index += 1
+						format_param = self._available_formats[quality_index]
+						continue
+				else: 
+					self._downloader.trouble('ERROR: format not available for video')
+					return
+
+
+class MetacafeIE(InfoExtractor):
+	"""Information Extractor for metacafe.com."""
+
+	_VALID_URL = r'(?:http://)?(?:www\.)?metacafe\.com/watch/([^/]+)/([^/]+)/.*'
+	_DISCLAIMER = 'http://www.metacafe.com/family_filter/'
+	_FILTER_POST = 'http://www.metacafe.com/f/index.php?inputType=filter&controllerGroup=user'
+	_youtube_ie = None
 
-		# Extension
-		video_extension = {'18': 'mp4', '17': '3gp'}.get(format_param, 'flv')
+	def __init__(self, youtube_ie, downloader=None):
+		InfoExtractor.__init__(self, downloader)
+		self._youtube_ie = youtube_ie
 
-		# Normalize URL, including format
-		normalized_url = 'http://www.youtube.com/watch?v=%s' % video_id
-		if format_param is not None:
-			normalized_url = '%s&fmt=%s' % (normalized_url, format_param)
-		request = urllib2.Request(normalized_url, None, std_headers)
+	@staticmethod
+	def suitable(url):
+		return (re.match(MetacafeIE._VALID_URL, url) is not None)
+
+	def report_disclaimer(self):
+		"""Report disclaimer retrieval."""
+		self._downloader.to_stdout(u'[metacafe] Retrieving disclaimer')
+
+	def report_age_confirmation(self):
+		"""Report attempt to confirm age."""
+		self._downloader.to_stdout(u'[metacafe] Confirming age')
+	
+	def report_download_webpage(self, video_id):
+		"""Report webpage download."""
+		self._downloader.to_stdout(u'[metacafe] %s: Downloading webpage' % video_id)
+	
+	def report_extraction(self, video_id):
+		"""Report information extraction."""
+		self._downloader.to_stdout(u'[metacafe] %s: Extracting information' % video_id)
+
+	def _real_initialize(self):
+		# Retrieve disclaimer
+		request = urllib2.Request(self._DISCLAIMER, None, std_headers)
+		try:
+			self.report_disclaimer()
+			disclaimer = urllib2.urlopen(request).read()
+		except (urllib2.URLError, httplib.HTTPException, socket.error), err:
+			self._downloader.trouble(u'ERROR: unable to retrieve disclaimer: %s' % str(err))
+			return
+
+		# Confirm age
+		disclaimer_form = {
+			'filters': '0',
+			'submit': "Continue - I'm over 18",
+			}
+		request = urllib2.Request(self._FILTER_POST, urllib.urlencode(disclaimer_form), std_headers)
 		try:
-			self.to_stdout('[youtube] %s: Downloading video webpage' % video_id)
-			video_webpage = urllib2.urlopen(request).read()
+			self.report_age_confirmation()
+			disclaimer = urllib2.urlopen(request).read()
 		except (urllib2.URLError, httplib.HTTPException, socket.error), err:
-			self.to_stderr('ERROR: unable to download video webpage: %s' % str(err))
-			return [None]
-		self.to_stdout('[youtube] %s: Extracting video information' % video_id)
-		
-		# "t" param
-		mobj = re.search(r', "t": "([^"]+)"', video_webpage)
+			self._downloader.trouble(u'ERROR: unable to confirm age: %s' % str(err))
+			return
+	
+	def _real_extract(self, url):
+		# Extract id and simplified title from URL
+		mobj = re.match(self._VALID_URL, url)
 		if mobj is None:
-			self.to_stderr('ERROR: unable to extract "t" parameter')
-			return [None]
-		video_real_url = 'http://www.youtube.com/get_video?video_id=%s&t=%s' % (video_id, mobj.group(1))
-		if format_param is not None:
-			video_real_url = '%s&fmt=%s' % (video_real_url, format_param)
-		self.to_stdout('[youtube] %s: URL: %s' % (video_id, video_real_url))
-
-		# uploader
-		mobj = re.search(r'More From: ([^<]*)<', video_webpage)
+			self._downloader.trouble(u'ERROR: invalid URL: %s' % url)
+			return
+
+		video_id = mobj.group(1)
+
+		# Check if video comes from YouTube
+		mobj2 = re.match(r'^yt-(.*)$', video_id)
+		if mobj2 is not None:
+			self._youtube_ie.extract('http://www.youtube.com/watch?v=%s' % mobj2.group(1))
+			return
+
+		simple_title = mobj.group(2).decode('utf-8')
+		video_extension = 'flv'
+
+		# Retrieve video webpage to extract further information
+		request = urllib2.Request('http://www.metacafe.com/watch/%s/' % video_id)
+		try:
+			self.report_download_webpage(video_id)
+			webpage = urllib2.urlopen(request).read()
+		except (urllib2.URLError, httplib.HTTPException, socket.error), err:
+			self._downloader.trouble(u'ERROR: unable retrieve video webpage: %s' % str(err))
+			return
+
+		# Extract URL, uploader and title from webpage
+		self.report_extraction(video_id)
+		mobj = re.search(r'(?m)&mediaURL=(http.*?\.flv)', webpage)
 		if mobj is None:
-			self.to_stderr('ERROR: unable to extract uploader nickname')
-			return [None]
-		video_uploader = mobj.group(1)
+			self._downloader.trouble(u'ERROR: unable to extract media URL')
+			return
+		mediaURL = urllib.unquote(mobj.group(1))
 
-		# title
-		mobj = re.search(r'(?im)<title>YouTube - ([^<]*)</title>', video_webpage)
+		mobj = re.search(r'(?m)&gdaKey=(.*?)&', webpage)
 		if mobj is None:
-			self.to_stderr('ERROR: unable to extract video title')
-			return [None]
+			self._downloader.trouble(u'ERROR: unable to extract gdaKey')
+			return
+		gdaKey = mobj.group(1)
+
+		video_url = '%s?__gda__=%s' % (mediaURL, gdaKey)
+
+		mobj = re.search(r'(?im)<title>(.*) - Video</title>', webpage)
+		if mobj is None:
+			self._downloader.trouble(u'ERROR: unable to extract title')
+			return
 		video_title = mobj.group(1).decode('utf-8')
-		video_title = re.sub(ur'(?u)&(.+?);', lambda x: unichr(htmlentitydefs.name2codepoint[x.group(1)]), video_title)
-		video_title = video_title.replace(os.sep, u'%')
-
-		# simplified title
-		simple_title = re.sub(ur'(?u)([^%s]+)' % simple_title_chars, ur'_', video_title)
-		simple_title = simple_title.strip(ur'_')
-
-		# Return information
-		return [{
-			'id':		video_id,
-			'url':		video_real_url,
-			'uploader':	video_uploader,
-			'title':	video_title,
-			'stitle':	simple_title,
-			'ext':		video_extension,
-			}]
 
+		mobj = re.search(r'(?ms)<li id="ChnlUsr">.*?Submitter:.*?<a .*?>(.*?)<', webpage)
+		if mobj is None:
+			self._downloader.trouble(u'ERROR: unable to extract uploader nickname')
+			return
+		video_uploader = mobj.group(1)
+
+		try:
+			# Process video information
+			self._downloader.process_info({
+				'id':		video_id.decode('utf-8'),
+				'url':		video_url.decode('utf-8'),
+				'uploader':	video_uploader.decode('utf-8'),
+				'title':	video_title,
+				'stitle':	simple_title,
+				'ext':		video_extension.decode('utf-8'),
+			})
+		except UnavailableFormatError:
+			self._downloader.trouble(u'ERROR: format not available for video')
+
+
+class YoutubeSearchIE(InfoExtractor):
+	"""Information Extractor for YouTube search queries."""
+	_VALID_QUERY = r'ytsearch(\d+|all)?:[\s\S]+'
+	_TEMPLATE_URL = 'http://www.youtube.com/results?search_query=%s&page=%s&gl=US&hl=en'
+	_VIDEO_INDICATOR = r'href="/watch\?v=.+?"'
+	_MORE_PAGES_INDICATOR = r'>Next</a>'
+	_youtube_ie = None
+	_max_youtube_results = 1000
+
+	def __init__(self, youtube_ie, downloader=None):
+		InfoExtractor.__init__(self, downloader)
+		self._youtube_ie = youtube_ie
+	
+	@staticmethod
+	def suitable(url):
+		return (re.match(YoutubeSearchIE._VALID_QUERY, url) is not None)
+
+	def report_download_page(self, query, pagenum):
+		"""Report attempt to download playlist page with given number."""
+		self._downloader.to_stdout(u'[youtube] query "%s": Downloading page %s' % (query, pagenum))
+
+	def _real_initialize(self):
+		self._youtube_ie.initialize()
+	
+	def _real_extract(self, query):
+		mobj = re.match(self._VALID_QUERY, query)
+		if mobj is None:
+			self._downloader.trouble(u'ERROR: invalid search query "%s"' % query)
+			return
+
+		prefix, query = query.split(':')
+		prefix = prefix[8:]
+		if prefix == '':
+			self._download_n_results(query, 1)
+			return
+		elif prefix == 'all':
+			self._download_n_results(query, self._max_youtube_results)
+			return
+		else:
+			try:
+				n = int(prefix)
+				if n <= 0:
+					self._downloader.trouble(u'ERROR: invalid download number %s for query "%s"' % (n, query))
+					return
+				elif n > self._max_youtube_results:
+					self._downloader.to_stderr(u'WARNING: ytsearch returns max %i results (you requested %i)'  % (self._max_youtube_results, n))
+					n = self._max_youtube_results
+				self._download_n_results(query, n)
+				return
+			except ValueError: # parsing prefix as int fails
+				self._download_n_results(query, 1)
+				return
+
+	def _download_n_results(self, query, n):
+		"""Downloads a specified number of results for a query"""
+
+		video_ids = []
+		already_seen = set()
+		pagenum = 1
+
+		while True:
+			self.report_download_page(query, pagenum)
+			result_url = self._TEMPLATE_URL % (urllib.quote_plus(query), pagenum)
+			request = urllib2.Request(result_url, None, std_headers)
+			try:
+				page = urllib2.urlopen(request).read()
+			except (urllib2.URLError, httplib.HTTPException, socket.error), err:
+				self._downloader.trouble(u'ERROR: unable to download webpage: %s' % str(err))
+				return
+
+			# Extract video identifiers
+			for mobj in re.finditer(self._VIDEO_INDICATOR, page):
+				video_id = page[mobj.span()[0]:mobj.span()[1]].split('=')[2][:-1]
+				if video_id not in already_seen:
+					video_ids.append(video_id)
+					already_seen.add(video_id)
+					if len(video_ids) == n:
+						# Specified n videos reached
+						for id in video_ids:
+							self._youtube_ie.extract('http://www.youtube.com/watch?v=%s' % id)
+						return
+
+			if self._MORE_PAGES_INDICATOR not in page:
+				for id in video_ids:
+					self._youtube_ie.extract('http://www.youtube.com/watch?v=%s' % id)
+				return
+
+			pagenum = pagenum + 1
+
+class YoutubePlaylistIE(InfoExtractor):
+	"""Information Extractor for YouTube playlists."""
+
+	_VALID_URL = r'(?:http://)?(?:\w+\.)?youtube.com/view_play_list\?p=(.+)'
+	_TEMPLATE_URL = 'http://www.youtube.com/view_play_list?p=%s&page=%s&gl=US&hl=en'
+	_VIDEO_INDICATOR = r'/watch\?v=(.+?)&'
+	_MORE_PAGES_INDICATOR = r'/view_play_list?p=%s&amp;page=%s'
+	_youtube_ie = None
+
+	def __init__(self, youtube_ie, downloader=None):
+		InfoExtractor.__init__(self, downloader)
+		self._youtube_ie = youtube_ie
+	
+	@staticmethod
+	def suitable(url):
+		return (re.match(YoutubePlaylistIE._VALID_URL, url) is not None)
+
+	def report_download_page(self, playlist_id, pagenum):
+		"""Report attempt to download playlist page with given number."""
+		self._downloader.to_stdout(u'[youtube] PL %s: Downloading page #%s' % (playlist_id, pagenum))
+
+	def _real_initialize(self):
+		self._youtube_ie.initialize()
+	
+	def _real_extract(self, url):
+		# Extract playlist id
+		mobj = re.match(self._VALID_URL, url)
+		if mobj is None:
+			self._downloader.trouble(u'ERROR: invalid url: %s' % url)
+			return
+
+		# Download playlist pages
+		playlist_id = mobj.group(1)
+		video_ids = []
+		pagenum = 1
+
+		while True:
+			self.report_download_page(playlist_id, pagenum)
+			request = urllib2.Request(self._TEMPLATE_URL % (playlist_id, pagenum), None, std_headers)
+			try:
+				page = urllib2.urlopen(request).read()
+			except (urllib2.URLError, httplib.HTTPException, socket.error), err:
+				self._downloader.trouble(u'ERROR: unable to download webpage: %s' % str(err))
+				return
+
+			# Extract video identifiers
+			ids_in_page = []
+			for mobj in re.finditer(self._VIDEO_INDICATOR, page):
+				if mobj.group(1) not in ids_in_page:
+					ids_in_page.append(mobj.group(1))
+			video_ids.extend(ids_in_page)
+
+			if (self._MORE_PAGES_INDICATOR % (playlist_id, pagenum + 1)) not in page:
+				break
+			pagenum = pagenum + 1
+
+		for id in video_ids:
+			self._youtube_ie.extract('http://www.youtube.com/watch?v=%s' % id)
+		return
+
+class PostProcessor(object):
+	"""Post Processor class.
+
+	PostProcessor objects can be added to downloaders with their
+	add_post_processor() method. When the downloader has finished a
+	successful download, it will take its internal chain of PostProcessors
+	and start calling the run() method on each one of them, first with
+	an initial argument and then with the returned value of the previous
+	PostProcessor.
+
+	The chain will be stopped if one of them ever returns None or the end
+	of the chain is reached.
+
+	PostProcessor objects follow a "mutual registration" process similar
+	to InfoExtractor objects.
+	"""
+
+	_downloader = None
+
+	def __init__(self, downloader=None):
+		self._downloader = downloader
+
+	def set_downloader(self, downloader):
+		"""Sets the downloader for this PP."""
+		self._downloader = downloader
+	
+	def run(self, information):
+		"""Run the PostProcessor.
+
+		The "information" argument is a dictionary like the ones
+		composed by InfoExtractors. The only difference is that this
+		one has an extra field called "filepath" that points to the
+		downloaded file.
+
+		When this method returns None, the postprocessing chain is
+		stopped. However, this method may return an information
+		dictionary that will be passed to the next postprocessing
+		object in the chain. It can be the one it received after
+		changing some fields.
+
+		In addition, this method may raise a PostProcessingError
+		exception that will be taken into account by the downloader
+		it was called from.
+		"""
+		return information # by default, do nothing
+	
+### MAIN PROGRAM ###
 if __name__ == '__main__':
 	try:
 		# Modules needed only when running the main program
@@ -505,60 +995,108 @@ if __name__ == '__main__':
 
 		# Parse command line
 		parser = optparse.OptionParser(
-				usage='Usage: %prog [options] url...',
-				version='INTERNAL',
-				conflict_handler='resolve',
-				)
+			usage='Usage: %prog [options] url...',
+			version='2009.05.11',
+			conflict_handler='resolve',
+		)
+
 		parser.add_option('-h', '--help',
 				action='help', help='print this help text and exit')
 		parser.add_option('-v', '--version',
 				action='version', help='print program version and exit')
-		parser.add_option('-u', '--username',
+		parser.add_option('-i', '--ignore-errors',
+				action='store_true', dest='ignoreerrors', help='continue on download errors', default=False)
+		parser.add_option('-r', '--rate-limit',
+				dest='ratelimit', metavar='L', help='download rate limit (e.g. 50k or 44.6m)')
+
+		authentication = optparse.OptionGroup(parser, 'Authentication Options')
+		authentication.add_option('-u', '--username',
 				dest='username', metavar='UN', help='account username')
-		parser.add_option('-p', '--password',
+		authentication.add_option('-p', '--password',
 				dest='password', metavar='PW', help='account password')
-		parser.add_option('-o', '--output',
-				dest='outtmpl', metavar='TPL', help='output filename template')
-		parser.add_option('-q', '--quiet',
+		authentication.add_option('-n', '--netrc',
+				action='store_true', dest='usenetrc', help='use .netrc authentication data', default=False)
+		parser.add_option_group(authentication)
+
+		video_format = optparse.OptionGroup(parser, 'Video Format Options')
+		video_format.add_option('-f', '--format',
+				action='append', dest='format', metavar='FMT', help='video format code')
+		video_format.add_option('-b', '--best-quality',
+				action='append_const', dest='format', help='download the best quality video possible', const='0')
+		video_format.add_option('-m', '--mobile-version',
+				action='append_const', dest='format', help='alias for -f 17', const='17')
+		video_format.add_option('-d', '--high-def',
+				action='append_const', dest='format', help='alias for -f 22', const='22')
+		parser.add_option_group(video_format)
+
+		verbosity = optparse.OptionGroup(parser, 'Verbosity / Simulation Options')
+		verbosity.add_option('-q', '--quiet',
 				action='store_true', dest='quiet', help='activates quiet mode', default=False)
-		parser.add_option('-s', '--simulate',
+		verbosity.add_option('-s', '--simulate',
 				action='store_true', dest='simulate', help='do not download video', default=False)
-		parser.add_option('-t', '--title',
-				action='store_true', dest='usetitle', help='use title in file name', default=False)
-		parser.add_option('-l', '--literal',
-				action='store_true', dest='useliteral', help='use literal title in file name', default=False)
-		parser.add_option('-n', '--netrc',
-				action='store_true', dest='usenetrc', help='use .netrc authentication data', default=False)
-		parser.add_option('-g', '--get-url',
+		verbosity.add_option('-g', '--get-url',
 				action='store_true', dest='geturl', help='simulate, quiet but print URL', default=False)
-		parser.add_option('-e', '--get-title',
+		verbosity.add_option('-e', '--get-title',
 				action='store_true', dest='gettitle', help='simulate, quiet but print title', default=False)
-		parser.add_option('-f', '--format',
-				dest='format', metavar='FMT', help='video format code')
-		parser.add_option('-b', '--best-quality',
-				action='store_const', dest='video_format', help='alias for -f 18', const='18')
-		parser.add_option('-m', '--mobile-version',
-				action='store_const', dest='video_format', help='alias for -f 17', const='17')
-		parser.add_option('-i', '--ignore-errors',
-				action='store_true', dest='ignoreerrors', help='continue on download errors', default=False)
+		parser.add_option_group(verbosity)
+
+		filesystem = optparse.OptionGroup(parser, 'Filesystem Options')
+		filesystem.add_option('-t', '--title',
+				action='store_true', dest='usetitle', help='use title in file name', default=False)
+		filesystem.add_option('-l', '--literal',
+				action='store_true', dest='useliteral', help='use literal title in file name', default=False)
+		filesystem.add_option('-o', '--output',
+				dest='outtmpl', metavar='TPL', help='output filename template')
+		filesystem.add_option('-a', '--batch-file',
+				dest='batchfile', metavar='F', help='file containing URLs to download')
+		filesystem.add_option('-w', '--no-overwrites',
+				action='store_true', dest='nooverwrites', help='do not overwrite files', default=False)
+		parser.add_option_group(filesystem)
+
 		(opts, args) = parser.parse_args()
 
+		# Batch file verification
+		batchurls = []
+		if opts.batchfile is not None:
+			try:
+				batchurls = open(opts.batchfile, 'r').readlines()
+				batchurls = [x.strip() for x in batchurls]
+				batchurls = [x for x in batchurls if len(x) > 0]
+			except IOError:
+				sys.exit(u'ERROR: batch file could not be read')
+		all_urls = batchurls + args
+
 		# Conflicting, missing and erroneous options
-		if len(args) < 1:
-			sys.exit('ERROR: you must provide at least one URL')
+		if len(all_urls) < 1:
+			parser.error(u'you must provide at least one URL')
 		if opts.usenetrc and (opts.username is not None or opts.password is not None):
-			sys.exit('ERROR: using .netrc conflicts with giving username/password')
+			parser.error(u'using .netrc conflicts with giving username/password')
 		if opts.password is not None and opts.username is None:
-			sys.exit('ERROR: account username missing')
+			parser.error(u'account username missing')
 		if opts.outtmpl is not None and (opts.useliteral or opts.usetitle):
-			sys.exit('ERROR: using output template conflicts with using title or literal title')
+			parser.error(u'using output template conflicts with using title or literal title')
 		if opts.usetitle and opts.useliteral:
-			sys.exit('ERROR: using title conflicts with using literal title')
+			parser.error(u'using title conflicts with using literal title')
 		if opts.username is not None and opts.password is None:
-			opts.password = getpass.getpass('Type account password and press return:')
+			opts.password = getpass.getpass(u'Type account password and press return:')
+		if opts.ratelimit is not None:
+			numeric_limit = FileDownloader.parse_bytes(opts.ratelimit)
+			if numeric_limit is None:
+				parser.error(u'invalid rate limit specified')
+			opts.ratelimit = numeric_limit
+		if opts.format is not None and len(opts.format) > 1:
+			parser.error(u'pass at most one of the video format option flags (-f, -b, -m, -d)')
+		if opts.format is None:
+			real_format = None
+		else:
+			real_format = opts.format[0]
+
 
 		# Information extractors
 		youtube_ie = YoutubeIE()
+		metacafe_ie = MetacafeIE(youtube_ie)
+		youtube_pl_ie = YoutubePlaylistIE(youtube_ie)
+		youtube_search_ie = YoutubeSearchIE(youtube_ie)
 
 		# File downloader
 		fd = FileDownloader({
@@ -569,20 +1107,25 @@ if __name__ == '__main__':
 			'forceurl': opts.geturl,
 			'forcetitle': opts.gettitle,
 			'simulate': (opts.simulate or opts.geturl or opts.gettitle),
-			'format': opts.format,
-			'outtmpl': ((opts.outtmpl is not None and opts.outtmpl)
-				or (opts.usetitle and '%(stitle)s-%(id)s.%(ext)s')
-				or (opts.useliteral and '%(title)s-%(id)s.%(ext)s')
-				or '%(id)s.%(ext)s'),
+			'format': real_format,
+			'outtmpl': ((opts.outtmpl is not None and opts.outtmpl.decode(locale.getpreferredencoding()))
+				or (opts.usetitle and u'%(stitle)s-%(id)s.%(ext)s')
+				or (opts.useliteral and u'%(title)s-%(id)s.%(ext)s')
+				or u'%(id)s.%(ext)s'),
 			'ignoreerrors': opts.ignoreerrors,
+			'ratelimit': opts.ratelimit,
+			'nooverwrites': opts.nooverwrites,
 			})
+		fd.add_info_extractor(youtube_search_ie)
+		fd.add_info_extractor(youtube_pl_ie)
+		fd.add_info_extractor(metacafe_ie)
 		fd.add_info_extractor(youtube_ie)
-		retcode = fd.download(args)
+		retcode = fd.download(all_urls)
 		sys.exit(retcode)
 
 	except DownloadError:
 		sys.exit(1)
 	except SameFileError:
-		sys.exit('ERROR: fixed output name but more than one file to download')
+		sys.exit(u'ERROR: fixed output name but more than one file to download')
 	except KeyboardInterrupt:
-		sys.exit('\nERROR: Interrupted by user')
+		sys.exit(u'\nERROR: Interrupted by user')