X-Git-Url: http://git.bitcoin.ninja/index.cgi?a=blobdiff_plain;f=youtube-dl;h=10dd7c7916c990815c4c388211e1c17d709b1dce;hb=1392f3f52cffec6054862c9031cc54e377131014;hp=cedbf5977667d2100fe27184a222f00908be8f4c;hpb=3aaf887e9890ca48858751b175d998efc35acb02;p=youtube-dl
diff --git a/youtube-dl b/youtube-dl
index cedbf5977..10dd7c791 100755
--- a/youtube-dl
+++ b/youtube-dl
@@ -2,6 +2,7 @@
# -*- coding: utf-8 -*-
# Author: Ricardo Garcia Gonzalez
# Author: Danny Colligan
+# Author: Benjamin Johnson
# License: Public domain code
import htmlentitydefs
import httplib
@@ -13,13 +14,20 @@ import os.path
import re
import socket
import string
+import subprocess
import sys
import time
import urllib
import urllib2
+# parse_qs was moved from the cgi module to the urlparse module recently.
+try:
+ from urlparse import parse_qs
+except ImportError:
+ from cgi import parse_qs
+
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',
+ 'User-Agent': 'Mozilla/5.0 (Windows; U; Windows NT 6.1; en-US; rv:1.9.2) Gecko/20100115 Firefox/3.6',
'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',
@@ -27,6 +35,75 @@ std_headers = {
simple_title_chars = string.ascii_letters.decode('ascii') + string.digits.decode('ascii')
+def preferredencoding():
+ """Get preferred encoding.
+
+ Returns the best encoding scheme for the system, based on
+ locale.getpreferredencoding() and some further tweaks.
+ """
+ def yield_preferredencoding():
+ try:
+ pref = locale.getpreferredencoding()
+ u'TEST'.encode(pref)
+ except:
+ pref = 'UTF-8'
+ while True:
+ yield pref
+ return yield_preferredencoding().next()
+
+def htmlentity_transform(matchobj):
+ """Transforms an HTML entity to a Unicode character.
+
+ This function receives a match object and is intended to be used with
+ the re.sub() function.
+ """
+ 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 sanitize_title(utitle):
+ """Sanitizes a video title so it could be used as part of a filename."""
+ utitle = re.sub(ur'(?u)&(.+?);', htmlentity_transform, utitle)
+ return utitle.replace(unicode(os.sep), u'%')
+
+def sanitize_open(filename, open_mode):
+ """Try to open the given filename, and slightly tweak it if this fails.
+
+ Attempts to open the given filename. If this fails, it tries to change
+ the filename slightly, step by step, until it's either able to open it
+ or it fails and raises a final exception, like the standard open()
+ function.
+
+ It returns the tuple (stream, definitive_file_name).
+ """
+ try:
+ stream = open(filename, open_mode)
+ return (stream, filename)
+ except (IOError, OSError), err:
+ # In case of error, try to remove win32 forbidden chars
+ filename = re.sub(ur'[<>:"\|\?\*]', u'#', filename)
+
+ # An exception here should be caught in the caller
+ stream = open(filename, open_mode)
+ return (stream, filename)
+
+
class DownloadError(Exception):
"""Download Error exception.
@@ -52,6 +129,29 @@ class PostProcessingError(Exception):
"""
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.
+ """
+ pass
+
+class ContentTooShortError(Exception):
+ """Content Too Short exception.
+
+ This exception may be raised by FileDownloader objects when a file they
+ download is too small for what the server announced first, indicating
+ the connection was probably interrupted.
+ """
+ # Both in bytes
+ downloaded = None
+ expected = None
+
+ def __init__(self, downloaded, expected):
+ self.downloaded = downloaded
+ self.expected = expected
+
class FileDownloader(object):
"""File Downloader class.
@@ -65,9 +165,10 @@ 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
@@ -90,6 +191,7 @@ class FileDownloader(object):
ignoreerrors: Do not stop on download errors.
ratelimit: Download speed limit, in bytes/sec.
nooverwrites: Prevent overwriting files.
+ continuedl: Try to continue downloads if possible.
"""
params = None
@@ -118,10 +220,12 @@ class FileDownloader(object):
def format_bytes(bytes):
if bytes is None:
return 'N/A'
- if bytes == 0:
+ if type(bytes) is str:
+ bytes = float(bytes)
+ if bytes == 0.0:
exponent = 0
else:
- exponent = long(math.log(float(bytes), 1024.0))
+ exponent = long(math.log(bytes, 1024.0))
suffix = 'bkMGTPEZY'[exponent]
converted = float(bytes) / float(1024**exponent)
return '%.2f%s' % (converted, suffix)
@@ -158,13 +262,13 @@ class FileDownloader(object):
new_min = max(bytes / 2.0, 1.0)
new_max = min(max(bytes * 2.0, 1.0), 4194304) # Do not surpass 4 MB
if elapsed_time < 0.001:
- return int(new_max)
+ return long(new_max)
rate = bytes / elapsed_time
if rate > new_max:
- return int(new_max)
+ return long(new_max)
if rate < new_min:
- return int(new_min)
- return int(rate)
+ return long(new_min)
+ return long(rate)
@staticmethod
def parse_bytes(bytestr):
@@ -176,6 +280,16 @@ class FileDownloader(object):
multiplier = 1024.0 ** 'bkmgtpezy'.index(matchobj.group(2).lower())
return long(round(number * multiplier))
+ @staticmethod
+ def verify_url(url):
+ """Verify a URL is valid and data could be downloaded. Return real data URL."""
+ request = urllib2.Request(url, None, std_headers)
+ data = urllib2.urlopen(request)
+ data.read(1)
+ url = data.geturl()
+ data.close()
+ return url
+
def add_info_extractor(self, ie):
"""Add an InfoExtractor object to the end of the list."""
self._ies.append(ie)
@@ -186,15 +300,19 @@ class FileDownloader(object):
self._pps.append(pp)
pp.set_downloader(self)
- def to_stdout(self, message, skip_eol=False):
+ def to_stdout(self, message, skip_eol=False, ignore_encoding_errors=False):
"""Print message to stdout if not in quiet mode."""
- if not self.params.get('quiet', False):
- print u'%s%s' % (message, [u'\n', u''][skip_eol]),
+ try:
+ if not self.params.get('quiet', False):
+ print (u'%s%s' % (message, [u'\n', u''][skip_eol])).encode(preferredencoding()),
sys.stdout.flush()
+ except (UnicodeEncodeError), err:
+ if not ignore_encoding_errors:
+ raise
def to_stderr(self, message):
"""Print message to stderr."""
- print >>sys.stderr, message
+ print >>sys.stderr, message.encode(preferredencoding())
def fixed_template(self):
"""Checks if the output template is fixed."""
@@ -228,12 +346,27 @@ class FileDownloader(object):
def report_destination(self, filename):
"""Report destination filename."""
- self.to_stdout(u'[download] Destination: %s' % filename)
+ self.to_stdout(u'[download] Destination: %s' % filename, ignore_encoding_errors=True)
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_resuming_byte(self, resume_len):
+ """Report attemtp to resume at given byte."""
+ self.to_stdout(u'[download] Resuming download at byte %s' % resume_len)
+
+ def report_file_already_downloaded(self, file_name):
+ """Report file has already been fully downloaded."""
+ try:
+ self.to_stdout(u'[download] %s has already been downloaded' % file_name)
+ except (UnicodeEncodeError), err:
+ self.to_stdout(u'[download] The file has already been downloaded')
+
+ def report_unable_to_resume(self):
+ """Report it was impossible to resume download."""
+ self.to_stdout(u'[download] Unable to resume')
def report_finish(self):
"""Report download finished."""
@@ -241,50 +374,56 @@ class FileDownloader(object):
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']
- if self.params.get('forceurl', False):
- print info_dict['url']
-
# Do nothing else if in simulate mode
if self.params.get('simulate', False):
- return
+ # Verify URL if it's an HTTP one
+ if info_dict['url'].startswith('http'):
+ try:
+ info_dict['url'] = self.verify_url(info_dict['url'].encode('utf-8')).decode('utf-8')
+ except (OSError, IOError, urllib2.URLError, httplib.HTTPException, socket.error), err:
+ raise UnavailableFormatError
+
+ # Forced printings
+ if self.params.get('forcetitle', False):
+ print info_dict['title'].encode(preferredencoding(), 'xmlcharrefreplace')
+ if self.params.get('forceurl', False):
+ print info_dict['url'].encode(preferredencoding(), 'xmlcharrefreplace')
+ return
+
try:
- filename = self.params['outtmpl'] % info_dict
- self.report_destination(filename)
+ template_dict = dict(info_dict)
+ template_dict['epoch'] = unicode(long(time.time()))
+ filename = self.params['outtmpl'] % template_dict
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)
+ if self.params.get('nooverwrites', False) and os.path.exists(filename):
+ self.to_stderr(u'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()
+ success = self._do_download(filename, info_dict['url'].encode('utf-8'))
except (OSError, IOError), err:
- self.trouble('ERROR: unable to write video data: %s' % str(err))
- return
+ 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))
+ except (ContentTooShortError, ), err:
+ self.trouble('ERROR: content too short (expected %s bytes and served %s)' % (err.expected, err.downloaded))
return
- return
+ if success:
+ 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."""
@@ -301,21 +440,8 @@ class FileDownloader(object):
# Suitable InfoExtractor found
suitable_found = True
- # Extract information from URL
- all_results = ie.extract(url)
- results = [x for x in all_results if x is not None]
-
- # See if there were problems extracting any information
- if len(results) != len(all_results):
- self.trouble()
-
- # Two results could go to the same file
- if len(results) > 1 and self.fixed_template():
- raise SameFileError(self.params['outtmpl'])
-
- # Process each result
- for result in results:
- self.process_info(result)
+ # Extract information from URL and process it
+ ie.extract(url)
# Suitable InfoExtractor had been found; go to next URL
break
@@ -334,21 +460,79 @@ class FileDownloader(object):
if info is None:
break
- def _do_download(self, stream, url):
+ def _download_with_rtmpdump(self, filename, url):
+ self.report_destination(filename)
+
+ # Check for rtmpdump first
+ try:
+ subprocess.call(['rtmpdump', '-h'], stdout=(file(os.path.devnull, 'w')), stderr=subprocess.STDOUT)
+ except (OSError, IOError):
+ self.trouble(u'ERROR: RTMP download detected but "rtmpdump" could not be run')
+ return False
+
+ # Download using rtmpdump. rtmpdump returns exit code 2 when
+ # the connection was interrumpted and resuming appears to be
+ # possible. This is part of rtmpdump's normal usage, AFAIK.
+ basic_args = ['rtmpdump', '-q', '-r', url, '-o', filename]
+ retval = subprocess.call(basic_args + [[], ['-e', '-k', '1']][self.params.get('continuedl', False)])
+ while retval == 2 or retval == 1:
+ self.to_stdout(u'\r[rtmpdump] %s bytes' % os.path.getsize(filename), skip_eol=True)
+ time.sleep(2.0) # This seems to be needed
+ retval = subprocess.call(basic_args + ['-e'] + [[], ['-k', '1']][retval == 1])
+ if retval == 0:
+ self.to_stdout(u'\r[rtmpdump] %s bytes' % os.path.getsize(filename))
+ return True
+ else:
+ self.trouble('ERROR: rtmpdump exited with code %d' % retval)
+ return False
+
+ def _do_download(self, filename, url):
+ # Attempt to download using rtmpdump
+ if url.startswith('rtmp'):
+ return self._download_with_rtmpdump(filename, url)
+
+ stream = None
+ open_mode = 'wb'
+ basic_request = urllib2.Request(url, None, std_headers)
request = urllib2.Request(url, None, std_headers)
- data = urllib2.urlopen(request)
+
+ # Establish possible resume length
+ if os.path.isfile(filename):
+ resume_len = os.path.getsize(filename)
+ else:
+ resume_len = 0
+
+ # Request parameters in case of being able to resume
+ if self.params.get('continuedl', False) and resume_len != 0:
+ self.report_resuming_byte(resume_len)
+ request.add_header('Range','bytes=%d-' % resume_len)
+ open_mode = 'ab'
+
+ # Establish connection
+ try:
+ data = urllib2.urlopen(request)
+ except (urllib2.HTTPError, ), err:
+ if err.code != 416: # 416 is 'Requested range not satisfiable'
+ raise
+ # Unable to resume
+ data = urllib2.urlopen(basic_request)
+ content_length = data.info()['Content-Length']
+
+ if content_length is not None and long(content_length) == resume_len:
+ # Because the file had already been fully downloaded
+ self.report_file_already_downloaded(filename)
+ return True
+ else:
+ # Because the server didn't let us
+ self.report_unable_to_resume()
+ open_mode = 'wb'
+
data_len = data.info().get('Content-length', None)
data_len_str = self.format_bytes(data_len)
byte_counter = 0
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.report_progress(percent_str, data_len_str, speed_str, eta_str)
-
# Download and write
before = time.time()
data_block = data.read(block_size)
@@ -357,15 +541,31 @@ class FileDownloader(object):
if data_block_len == 0:
break
byte_counter += data_block_len
+
+ # Open file just in time
+ if stream is None:
+ try:
+ (stream, filename) = sanitize_open(filename, open_mode)
+ self.report_destination(filename)
+ except (OSError, IOError), err:
+ self.trouble('ERROR: unable to open for writing: %s' % str(err))
+ return False
stream.write(data_block)
block_size = self.best_block_size(after - before, data_block_len)
+ # 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.report_progress(percent_str, data_len_str, speed_str, eta_str)
+
# 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))
+ raise ContentTooShortError(byte_counter, long(data_len))
+ return True
class InfoExtractor(object):
"""Information Extractor class.
@@ -373,9 +573,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.
@@ -430,39 +631,24 @@ class InfoExtractor(object):
class YoutubeIE(InfoExtractor):
"""Information extractor for youtube.com."""
- _VALID_URL = r'^((?:http://)?(?:\w+\.)?youtube\.com/(?:(?:v/)|(?:(?:watch(?:\.php)?)?\?(?:.+&)?v=)))?([0-9A-Za-z_-]+)(?(1).+)?$'
+ _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 = ['37', '22', '35', '18', '34', '5', '17', '13', None] # listed in order of priority for -b flag
+ _video_extensions = {
+ '13': '3gp',
+ '17': 'mp4',
+ '18': 'mp4',
+ '22': 'mp4',
+ '37': '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')
@@ -475,17 +661,21 @@ class YoutubeIE(InfoExtractor):
"""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_video_info_webpage_download(self, video_id):
+ """Report attempt to download video info webpage."""
+ self._downloader.to_stdout(u'[youtube] %s: Downloading video info 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):
+ def report_unavailable_format(self, video_id, format):
"""Report extracted video URL."""
- self._downloader.to_stdout(u'[youtube] %s: URL: %s' % (video_id, video_real_url))
+ self._downloader.to_stdout(u'[youtube] %s: Format %s not available' % (video_id, format))
+
+ def report_rtmp_download(self):
+ """Indicate the download will use the RTMP protocol."""
+ self._downloader.to_stdout(u'[youtube] RTMP download detected')
def _real_initialize(self):
if self._downloader is None:
@@ -553,88 +743,119 @@ class YoutubeIE(InfoExtractor):
self.report_age_confirmation()
age_results = urllib2.urlopen(request).read()
except (urllib2.URLError, httplib.HTTPException, socket.error), err:
- self._downloader.to_stderr(u'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(self._VALID_URL, url)
if mobj is None:
- self._downloader.to_stderr(u'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.params
format_param = params.get('format', None)
+ if format_param == '0':
+ format_param = self._available_formats[quality_index]
+ best_quality = True
- # Extension
- video_extension = {
- '17': '3gp',
- '18': 'mp4',
- '22': 'mp4',
- }.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.to_stderr(u'ERROR: unable to download video webpage: %s' % str(err))
- return [None]
- self.report_information_extraction(video_id)
-
- # "t" param
- mobj = re.search(r', "t": "([^"]+)"', video_webpage)
- if mobj is None:
- self._downloader.to_stderr(u'ERROR: unable to extract "t" parameter')
- return [None]
- 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.to_stderr(u'ERROR: unable to extract uploader nickname')
- return [None]
- video_uploader = mobj.group(1)
+ while True:
+ # Extension
+ video_extension = self._video_extensions.get(format_param, 'flv')
- # title
- mobj = re.search(r'(?im)