From 4e1582f372d74d551e19d319e5b345002def480d Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Jaime=20Marqui=CC=81nez=20Ferra=CC=81ndiz?=
 <jaimemf93@gmail.com>
Date: Mon, 4 Mar 2013 11:27:25 +0100
Subject: [PATCH 01/37] Use red color when printing error messages

---
 youtube_dl/FileDownloader.py | 12 ++++++++++++
 1 file changed, 12 insertions(+)

diff --git a/youtube_dl/FileDownloader.py b/youtube_dl/FileDownloader.py
index 57f741c30..2f6c393a4 100644
--- a/youtube_dl/FileDownloader.py
+++ b/youtube_dl/FileDownloader.py
@@ -246,6 +246,18 @@ def report_warning(self, message):
         warning_message=u'%s %s' % (_msg_header,message)
         self.to_stderr(warning_message)
 
+    def report_error(self, message, tb=None):
+        '''
+        Do the same as trouble, but prefixes the message with 'ERROR:', colored
+        in red if stderr is a tty file.
+        '''
+        if sys.stderr.isatty():
+            _msg_header = u'\033[0;31mERROR:\033[0m'
+        else:
+            _msg_header = u'ERROR:'
+        error_message = u'%s %s' % (_msg_header, message)
+        self.trouble(error_message, tb)
+
     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)

From 6622d22c79aa35ab1bd99c453afbdbecc0a9d61d Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Jaime=20Marqui=CC=81nez=20Ferra=CC=81ndiz?=
 <jaimemf93@gmail.com>
Date: Mon, 4 Mar 2013 11:47:58 +0100
Subject: [PATCH 02/37] Use report_error in FileDownloader.py

---
 youtube_dl/FileDownloader.py | 40 ++++++++++++++++++++----------------
 1 file changed, 22 insertions(+), 18 deletions(-)

diff --git a/youtube_dl/FileDownloader.py b/youtube_dl/FileDownloader.py
index 2f6c393a4..8d21a79d5 100644
--- a/youtube_dl/FileDownloader.py
+++ b/youtube_dl/FileDownloader.py
@@ -289,7 +289,7 @@ def try_rename(self, old_filename, new_filename):
                 return
             os.rename(encodeFilename(old_filename), encodeFilename(new_filename))
         except (IOError, OSError) as err:
-            self.trouble(u'ERROR: unable to rename file')
+            self.report_error(u'unable to rename file')
 
     def try_utime(self, filename, last_modified_hdr):
         """Try to set the last-modified time of the given file."""
@@ -385,7 +385,7 @@ def prepare_filename(self, info_dict):
             filename = self.params['outtmpl'] % template_dict
             return filename
         except (ValueError, KeyError) as err:
-            self.trouble(u'ERROR: invalid system charset or erroneous output template')
+            self.report_error(u'invalid system charset or erroneous output template')
             return None
 
     def _match_entry(self, info_dict):
@@ -449,7 +449,7 @@ def process_info(self, info_dict):
             if dn != '' and not os.path.exists(dn): # dn is already encoded
                 os.makedirs(dn)
         except (OSError, IOError) as err:
-            self.trouble(u'ERROR: unable to create directory ' + compat_str(err))
+            self.report_error(u'unable to create directory ' + compat_str(err))
             return
 
         if self.params.get('writedescription', False):
@@ -459,7 +459,7 @@ def process_info(self, info_dict):
                 with io.open(encodeFilename(descfn), 'w', encoding='utf-8') as descfile:
                     descfile.write(info_dict['description'])
             except (OSError, IOError):
-                self.trouble(u'ERROR: Cannot write description file ' + descfn)
+                self.report_error(u'Cannot write description file ' + descfn)
                 return
 
         if self.params.get('writesubtitles', False) and 'subtitles' in info_dict and info_dict['subtitles']:
@@ -471,7 +471,7 @@ def process_info(self, info_dict):
                 with io.open(encodeFilename(srtfn), 'w', encoding='utf-8') as srtfile:
                     srtfile.write(info_dict['subtitles'])
             except (OSError, IOError):
-                self.trouble(u'ERROR: Cannot write subtitles file ' + descfn)
+                self.report_error(u'Cannot write subtitles file ' + descfn)
                 return
 
         if self.params.get('writeinfojson', False):
@@ -481,7 +481,7 @@ def process_info(self, info_dict):
                 json_info_dict = dict((k, v) for k,v in info_dict.items() if not k in ['urlhandle'])
                 write_json_file(json_info_dict, encodeFilename(infofn))
             except (OSError, IOError):
-                self.trouble(u'ERROR: Cannot write metadata to JSON file ' + infofn)
+                self.report_error(u'Cannot write metadata to JSON file ' + infofn)
                 return
 
         if not self.params.get('skip_download', False):
@@ -493,17 +493,17 @@ def process_info(self, info_dict):
                 except (OSError, IOError) as err:
                     raise UnavailableVideoError()
                 except (compat_urllib_error.URLError, compat_http_client.HTTPException, socket.error) as err:
-                    self.trouble(u'ERROR: unable to download video data: %s' % str(err))
+                    self.report_error(u'unable to download video data: %s' % str(err))
                     return
                 except (ContentTooShortError, ) as err:
-                    self.trouble(u'ERROR: content too short (expected %s bytes and served %s)' % (err.expected, err.downloaded))
+                    self.report_error(u'content too short (expected %s bytes and served %s)' % (err.expected, err.downloaded))
                     return
 
             if success:
                 try:
                     self.post_process(filename, info_dict)
                 except (PostProcessingError) as err:
-                    self.trouble(u'ERROR: postprocessing: %s' % str(err))
+                    self.report_error(u'postprocessing: %s' % str(err))
                     return
 
     def download(self, url_list):
@@ -534,7 +534,7 @@ def download(self, url_list):
                     break
                 except Exception as e:
                     if self.params.get('ignoreerrors', False):
-                        self.trouble(u'ERROR: ' + compat_str(e), tb=compat_str(traceback.format_exc()))
+                        self.report_error(u'' + compat_str(e), tb=compat_str(traceback.format_exc()))
                         break
                     else:
                         raise
@@ -548,13 +548,14 @@ def download(self, url_list):
                         self.increment_downloads()
                         self.process_info(video)
                     except UnavailableVideoError:
-                        self.trouble(u'\nERROR: unable to download video')
+                        self.to_stderr(u"\n")
+                        self.report_error(u'unable to download video')
 
                 # Suitable InfoExtractor had been found; go to next URL
                 break
 
             if not suitable_found:
-                self.trouble(u'ERROR: no suitable InfoExtractor: %s' % url)
+                self.report_error(u'no suitable InfoExtractor: %s' % url)
 
         return self._download_retcode
 
@@ -589,7 +590,7 @@ def _download_with_rtmpdump(self, filename, url, player_url, page_url):
         try:
             subprocess.call(['rtmpdump', '-h'], stdout=(open(os.path.devnull, 'w')), stderr=subprocess.STDOUT)
         except (OSError, IOError):
-            self.trouble(u'ERROR: RTMP download detected but "rtmpdump" could not be run')
+            self.report_error(u'RTMP download detected but "rtmpdump" could not be run')
             return False
 
         # Download using rtmpdump. rtmpdump returns exit code 2 when
@@ -634,7 +635,8 @@ def _download_with_rtmpdump(self, filename, url, player_url, page_url):
             })
             return True
         else:
-            self.trouble(u'\nERROR: rtmpdump exited with code %d' % retval)
+            self.to_stderr(u"\n")
+            self.report_error(u'rtmpdump exited with code %d' % retval)
             return False
 
     def _do_download(self, filename, info_dict):
@@ -734,7 +736,7 @@ def _do_download(self, filename, info_dict):
                 self.report_retry(count, retries)
 
         if count > retries:
-            self.trouble(u'ERROR: giving up after %s retries' % retries)
+            self.report_error(u'giving up after %s retries' % retries)
             return False
 
         data_len = data.info().get('Content-length', None)
@@ -770,12 +772,13 @@ def _do_download(self, filename, info_dict):
                     filename = self.undo_temp_name(tmpfilename)
                     self.report_destination(filename)
                 except (OSError, IOError) as err:
-                    self.trouble(u'ERROR: unable to open for writing: %s' % str(err))
+                    self.report_error(u'unable to open for writing: %s' % str(err))
                     return False
             try:
                 stream.write(data_block)
             except (IOError, OSError) as err:
-                self.trouble(u'\nERROR: unable to write data: %s' % str(err))
+                self.to_stderr(u"\n")
+                self.report_error(u'unable to write data: %s' % str(err))
                 return False
             if not self.params.get('noresizebuffer', False):
                 block_size = self.best_block_size(after - before, len(data_block))
@@ -801,7 +804,8 @@ def _do_download(self, filename, info_dict):
             self.slow_down(start, byte_counter - resume_len)
 
         if stream is None:
-            self.trouble(u'\nERROR: Did not get any data blocks')
+            self.to_stderr(u"\n")
+            self.report_error(u'Did not get any data blocks')
             return False
         stream.close()
         self.report_finish()

From e5f30ade100b33127f31dd8989585a87e6faa6e4 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Jaime=20Marqui=CC=81nez=20Ferra=CC=81ndiz?=
 <jaimemf93@gmail.com>
Date: Mon, 4 Mar 2013 15:56:14 +0100
Subject: [PATCH 03/37] Use report_error in InfoExtractors.py

Some calls haven't been changed
---
 youtube_dl/InfoExtractors.py | 300 +++++++++++++++++------------------
 1 file changed, 150 insertions(+), 150 deletions(-)

diff --git a/youtube_dl/InfoExtractors.py b/youtube_dl/InfoExtractors.py
index 7ce84fe79..6328332a7 100755
--- a/youtube_dl/InfoExtractors.py
+++ b/youtube_dl/InfoExtractors.py
@@ -388,13 +388,13 @@ def _real_initialize(self):
             self.report_age_confirmation()
             age_results = compat_urllib_request.urlopen(request).read().decode('utf-8')
         except (compat_urllib_error.URLError, compat_http_client.HTTPException, socket.error) as err:
-            self._downloader.trouble(u'ERROR: unable to confirm age: %s' % compat_str(err))
+            self._downloader.report_error(u'unable to confirm age: %s' % compat_str(err))
             return
 
     def _extract_id(self, url):
         mobj = re.match(self._VALID_URL, url, re.VERBOSE)
         if mobj is None:
-            self._downloader.trouble(u'ERROR: invalid URL: %s' % url)
+            self._downloader.report_error(u'invalid URL: %s' % url)
             return
         video_id = mobj.group(2)
         return video_id
@@ -413,7 +413,7 @@ def _real_extract(self, url):
         try:
             video_webpage_bytes = compat_urllib_request.urlopen(request).read()
         except (compat_urllib_error.URLError, compat_http_client.HTTPException, socket.error) as err:
-            self._downloader.trouble(u'ERROR: unable to download video webpage: %s' % compat_str(err))
+            self._downloader.report_error(u'unable to download video webpage: %s' % compat_str(err))
             return
 
         video_webpage = video_webpage_bytes.decode('utf-8', 'ignore')
@@ -438,18 +438,18 @@ def _real_extract(self, url):
                 if 'token' in video_info:
                     break
             except (compat_urllib_error.URLError, compat_http_client.HTTPException, socket.error) as err:
-                self._downloader.trouble(u'ERROR: unable to download video info webpage: %s' % compat_str(err))
+                self._downloader.report_error(u'unable to download video info webpage: %s' % compat_str(err))
                 return
         if 'token' not in video_info:
             if 'reason' in video_info:
-                self._downloader.trouble(u'ERROR: YouTube said: %s' % video_info['reason'][0])
+                self._downloader.report_error(u'YouTube said: %s' % video_info['reason'][0])
             else:
-                self._downloader.trouble(u'ERROR: "token" parameter not in video info for unknown reason')
+                self._downloader.report_error(u'"token" parameter not in video info for unknown reason')
             return
 
         # Check for "rental" videos
         if 'ypc_video_rental_bar_text' in video_info and 'author' not in video_info:
-            self._downloader.trouble(u'ERROR: "rental" videos not supported')
+            self._downloader.report_error(u'"rental" videos not supported')
             return
 
         # Start extracting information
@@ -457,7 +457,7 @@ def _real_extract(self, url):
 
         # uploader
         if 'author' not in video_info:
-            self._downloader.trouble(u'ERROR: unable to extract uploader name')
+            self._downloader.report_error(u'unable to extract uploader name')
             return
         video_uploader = compat_urllib_parse.unquote_plus(video_info['author'][0])
 
@@ -471,7 +471,7 @@ def _real_extract(self, url):
 
         # title
         if 'title' not in video_info:
-            self._downloader.trouble(u'ERROR: unable to extract video title')
+            self._downloader.report_error(u'unable to extract video title')
             return
         video_title = compat_urllib_parse.unquote_plus(video_info['title'][0])
 
@@ -537,7 +537,7 @@ def _real_extract(self, url):
                 format_list = available_formats
             existing_formats = [x for x in format_list if x in url_map]
             if len(existing_formats) == 0:
-                self._downloader.trouble(u'ERROR: no known formats available for video')
+                self._downloader.report_error(u'no known formats available for video')
                 return
             if self._downloader.params.get('listformats', None):
                 self._print_formats(existing_formats)
@@ -558,10 +558,10 @@ def _real_extract(self, url):
                         video_url_list = [(rf, url_map[rf])]
                         break
                 if video_url_list is None:
-                    self._downloader.trouble(u'ERROR: requested format not available')
+                    self._downloader.report_error(u'requested format not available')
                     return
         else:
-            self._downloader.trouble(u'ERROR: no conn or url_encoded_fmt_stream_map information found in video info')
+            self._downloader.report_error(u'no conn or url_encoded_fmt_stream_map information found in video info')
             return
 
         results = []
@@ -624,7 +624,7 @@ def _real_initialize(self):
             self.report_disclaimer()
             disclaimer = compat_urllib_request.urlopen(request).read()
         except (compat_urllib_error.URLError, compat_http_client.HTTPException, socket.error) as err:
-            self._downloader.trouble(u'ERROR: unable to retrieve disclaimer: %s' % compat_str(err))
+            self._downloader.report_error(u'unable to retrieve disclaimer: %s' % compat_str(err))
             return
 
         # Confirm age
@@ -637,14 +637,14 @@ def _real_initialize(self):
             self.report_age_confirmation()
             disclaimer = compat_urllib_request.urlopen(request).read()
         except (compat_urllib_error.URLError, compat_http_client.HTTPException, socket.error) as err:
-            self._downloader.trouble(u'ERROR: unable to confirm age: %s' % compat_str(err))
+            self._downloader.report_error(u'unable to confirm age: %s' % compat_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._downloader.trouble(u'ERROR: invalid URL: %s' % url)
+            self._downloader.report_error(u'invalid URL: %s' % url)
             return
 
         video_id = mobj.group(1)
@@ -661,7 +661,7 @@ def _real_extract(self, url):
             self.report_download_webpage(video_id)
             webpage = compat_urllib_request.urlopen(request).read()
         except (compat_urllib_error.URLError, compat_http_client.HTTPException, socket.error) as err:
-            self._downloader.trouble(u'ERROR: unable retrieve video webpage: %s' % compat_str(err))
+            self._downloader.report_error(u'unable retrieve video webpage: %s' % compat_str(err))
             return
 
         # Extract URL, uploader and title from webpage
@@ -681,15 +681,15 @@ def _real_extract(self, url):
         else:
             mobj = re.search(r' name="flashvars" value="(.*?)"', webpage)
             if mobj is None:
-                self._downloader.trouble(u'ERROR: unable to extract media URL')
+                self._downloader.report_error(u'unable to extract media URL')
                 return
             vardict = compat_parse_qs(mobj.group(1))
             if 'mediaData' not in vardict:
-                self._downloader.trouble(u'ERROR: unable to extract media URL')
+                self._downloader.report_error(u'unable to extract media URL')
                 return
             mobj = re.search(r'"mediaURL":"(http.*?)","key":"(.*?)"', vardict['mediaData'][0])
             if mobj is None:
-                self._downloader.trouble(u'ERROR: unable to extract media URL')
+                self._downloader.report_error(u'unable to extract media URL')
                 return
             mediaURL = mobj.group(1).replace('\\/', '/')
             video_extension = mediaURL[-3:]
@@ -697,13 +697,13 @@ def _real_extract(self, url):
 
         mobj = re.search(r'(?im)<title>(.*) - Video</title>', webpage)
         if mobj is None:
-            self._downloader.trouble(u'ERROR: unable to extract title')
+            self._downloader.report_error(u'unable to extract title')
             return
         video_title = mobj.group(1).decode('utf-8')
 
         mobj = re.search(r'submitter=(.*?);', webpage)
         if mobj is None:
-            self._downloader.trouble(u'ERROR: unable to extract uploader nickname')
+            self._downloader.report_error(u'unable to extract uploader nickname')
             return
         video_uploader = mobj.group(1)
 
@@ -735,7 +735,7 @@ def _real_extract(self, url):
         # Extract id and simplified title from URL
         mobj = re.match(self._VALID_URL, url)
         if mobj is None:
-            self._downloader.trouble(u'ERROR: invalid URL: %s' % url)
+            self._downloader.report_error(u'invalid URL: %s' % url)
             return
 
         video_id = mobj.group(1).split('_')[0].split('?')[0]
@@ -751,7 +751,7 @@ def _real_extract(self, url):
         self.report_extraction(video_id)
         mobj = re.search(r'\s*var flashvars = (.*)', webpage)
         if mobj is None:
-            self._downloader.trouble(u'ERROR: unable to extract media URL')
+            self._downloader.report_error(u'unable to extract media URL')
             return
         flashvars = compat_urllib_parse.unquote(mobj.group(1))
 
@@ -761,12 +761,12 @@ def _real_extract(self, url):
                 self._downloader.to_screen(u'[dailymotion] Using %s' % key)
                 break
         else:
-            self._downloader.trouble(u'ERROR: unable to extract video URL')
+            self._downloader.report_error(u'unable to extract video URL')
             return
 
         mobj = re.search(r'"' + max_quality + r'":"(.+?)"', flashvars)
         if mobj is None:
-            self._downloader.trouble(u'ERROR: unable to extract video URL')
+            self._downloader.report_error(u'unable to extract video URL')
             return
 
         video_url = compat_urllib_parse.unquote(mobj.group(1)).replace('\\/', '/')
@@ -775,7 +775,7 @@ def _real_extract(self, url):
 
         mobj = re.search(r'<meta property="og:title" content="(?P<title>[^"]*)" />', webpage)
         if mobj is None:
-            self._downloader.trouble(u'ERROR: unable to extract title')
+            self._downloader.report_error(u'unable to extract title')
             return
         video_title = unescapeHTML(mobj.group('title'))
 
@@ -827,7 +827,7 @@ def _real_extract(self, url):
         # Extract id from URL
         mobj = re.match(self._VALID_URL, url)
         if mobj is None:
-            self._downloader.trouble(u'ERROR: Invalid URL: %s' % url)
+            self._downloader.report_error(u'Invalid URL: %s' % url)
             return
 
         video_id = mobj.group(1)
@@ -840,14 +840,14 @@ def _real_extract(self, url):
             self.report_download_webpage(video_id)
             webpage = compat_urllib_request.urlopen(request).read()
         except (compat_urllib_error.URLError, compat_http_client.HTTPException, socket.error) as err:
-            self._downloader.trouble(u'ERROR: Unable to retrieve video webpage: %s' % compat_str(err))
+            self._downloader.report_error(u'Unable to retrieve video webpage: %s' % compat_str(err))
             return
 
         # Extract URL, uploader, and title from webpage
         self.report_extraction(video_id)
         mobj = re.search(r'<link rel="video_src" href=".*\?file=([^"]+)" />', webpage)
         if mobj is None:
-            self._downloader.trouble(u'ERROR: unable to extract media URL')
+            self._downloader.report_error(u'unable to extract media URL')
             return
         mediaURL = compat_urllib_parse.unquote(mobj.group(1))
 
@@ -855,7 +855,7 @@ def _real_extract(self, url):
 
         mobj = re.search(r'<title>(.*) video by (.*) - Photobucket</title>', webpage)
         if mobj is None:
-            self._downloader.trouble(u'ERROR: unable to extract title')
+            self._downloader.report_error(u'unable to extract title')
             return
         video_title = mobj.group(1).decode('utf-8')
 
@@ -896,7 +896,7 @@ def _real_extract(self, url, new_video=True):
         # Extract ID from URL
         mobj = re.match(self._VALID_URL, url)
         if mobj is None:
-            self._downloader.trouble(u'ERROR: Invalid URL: %s' % url)
+            self._downloader.report_error(u'Invalid URL: %s' % url)
             return
 
         video_id = mobj.group(2)
@@ -909,18 +909,18 @@ def _real_extract(self, url, new_video=True):
             try:
                 webpage = compat_urllib_request.urlopen(request).read()
             except (compat_urllib_error.URLError, compat_http_client.HTTPException, socket.error) as err:
-                self._downloader.trouble(u'ERROR: Unable to retrieve video webpage: %s' % compat_str(err))
+                self._downloader.report_error(u'Unable to retrieve video webpage: %s' % compat_str(err))
                 return
 
             mobj = re.search(r'\("id", "([0-9]+)"\);', webpage)
             if mobj is None:
-                self._downloader.trouble(u'ERROR: Unable to extract id field')
+                self._downloader.report_error(u'Unable to extract id field')
                 return
             yahoo_id = mobj.group(1)
 
             mobj = re.search(r'\("vid", "([0-9]+)"\);', webpage)
             if mobj is None:
-                self._downloader.trouble(u'ERROR: Unable to extract vid field')
+                self._downloader.report_error(u'Unable to extract vid field')
                 return
             yahoo_vid = mobj.group(1)
 
@@ -933,34 +933,34 @@ def _real_extract(self, url, new_video=True):
             self.report_download_webpage(video_id)
             webpage = compat_urllib_request.urlopen(request).read()
         except (compat_urllib_error.URLError, compat_http_client.HTTPException, socket.error) as err:
-            self._downloader.trouble(u'ERROR: Unable to retrieve video webpage: %s' % compat_str(err))
+            self._downloader.report_error(u'Unable to retrieve video webpage: %s' % compat_str(err))
             return
 
         # Extract uploader and title from webpage
         self.report_extraction(video_id)
         mobj = re.search(r'<meta name="title" content="(.*)" />', webpage)
         if mobj is None:
-            self._downloader.trouble(u'ERROR: unable to extract video title')
+            self._downloader.report_error(u'unable to extract video title')
             return
         video_title = mobj.group(1).decode('utf-8')
 
         mobj = re.search(r'<h2 class="ti-5"><a href="http://video\.yahoo\.com/(people|profile)/[0-9]+" beacon=".*">(.*)</a></h2>', webpage)
         if mobj is None:
-            self._downloader.trouble(u'ERROR: unable to extract video uploader')
+            self._downloader.report_error(u'unable to extract video uploader')
             return
         video_uploader = mobj.group(1).decode('utf-8')
 
         # Extract video thumbnail
         mobj = re.search(r'<link rel="image_src" href="(.*)" />', webpage)
         if mobj is None:
-            self._downloader.trouble(u'ERROR: unable to extract video thumbnail')
+            self._downloader.report_error(u'unable to extract video thumbnail')
             return
         video_thumbnail = mobj.group(1).decode('utf-8')
 
         # Extract video description
         mobj = re.search(r'<meta name="description" content="(.*)" />', webpage)
         if mobj is None:
-            self._downloader.trouble(u'ERROR: unable to extract video description')
+            self._downloader.report_error(u'unable to extract video description')
             return
         video_description = mobj.group(1).decode('utf-8')
         if not video_description:
@@ -969,13 +969,13 @@ def _real_extract(self, url, new_video=True):
         # Extract video height and width
         mobj = re.search(r'<meta name="video_height" content="([0-9]+)" />', webpage)
         if mobj is None:
-            self._downloader.trouble(u'ERROR: unable to extract video height')
+            self._downloader.report_error(u'unable to extract video height')
             return
         yv_video_height = mobj.group(1)
 
         mobj = re.search(r'<meta name="video_width" content="([0-9]+)" />', webpage)
         if mobj is None:
-            self._downloader.trouble(u'ERROR: unable to extract video width')
+            self._downloader.report_error(u'unable to extract video width')
             return
         yv_video_width = mobj.group(1)
 
@@ -991,13 +991,13 @@ def _real_extract(self, url, new_video=True):
             self.report_download_webpage(video_id)
             webpage = compat_urllib_request.urlopen(request).read()
         except (compat_urllib_error.URLError, compat_http_client.HTTPException, socket.error) as err:
-            self._downloader.trouble(u'ERROR: Unable to retrieve video webpage: %s' % compat_str(err))
+            self._downloader.report_error(u'Unable to retrieve video webpage: %s' % compat_str(err))
             return
 
         # Extract media URL from playlist XML
         mobj = re.search(r'<STREAM APP="(http://.*)" FULLPATH="/?(/.*\.flv\?[^"]*)"', webpage)
         if mobj is None:
-            self._downloader.trouble(u'ERROR: Unable to extract media URL')
+            self._downloader.report_error(u'Unable to extract media URL')
             return
         video_url = compat_urllib_parse.unquote(mobj.group(1) + mobj.group(2)).decode('utf-8')
         video_url = unescapeHTML(video_url)
@@ -1036,7 +1036,7 @@ def _real_extract(self, url, new_video=True):
         # Extract ID from URL
         mobj = re.match(self._VALID_URL, url)
         if mobj is None:
-            self._downloader.trouble(u'ERROR: Invalid URL: %s' % url)
+            self._downloader.report_error(u'Invalid URL: %s' % url)
             return
 
         video_id = mobj.group('id')
@@ -1052,7 +1052,7 @@ def _real_extract(self, url, new_video=True):
             webpage_bytes = compat_urllib_request.urlopen(request).read()
             webpage = webpage_bytes.decode('utf-8')
         except (compat_urllib_error.URLError, compat_http_client.HTTPException, socket.error) as err:
-            self._downloader.trouble(u'ERROR: Unable to retrieve video webpage: %s' % compat_str(err))
+            self._downloader.report_error(u'Unable to retrieve video webpage: %s' % compat_str(err))
             return
 
         # Now we begin extracting as much information as we can from what we
@@ -1065,7 +1065,7 @@ def _real_extract(self, url, new_video=True):
             config = webpage.split(' = {config:')[1].split(',assets:')[0]
             config = json.loads(config)
         except:
-            self._downloader.trouble(u'ERROR: unable to extract info section')
+            self._downloader.report_error(u'unable to extract info section')
             return
 
         # Extract title
@@ -1115,7 +1115,7 @@ def _real_extract(self, url, new_video=True):
                 self._downloader.to_screen(u'[vimeo] %s: Downloading %s file at %s quality' % (video_id, video_codec.upper(), video_quality))
                 break
         else:
-            self._downloader.trouble(u'ERROR: no known codec found')
+            self._downloader.report_error(u'no known codec found')
             return
 
         video_url = "http://player.vimeo.com/play_redirect?clip_id=%s&sig=%s&time=%s&quality=%s&codecs=%s&type=moogaloop_local&embed_location=" \
@@ -1159,10 +1159,10 @@ def fetch_webpage(self, url):
             self.report_download_webpage(url)
             webpage = compat_urllib_request.urlopen(request).read()
         except (compat_urllib_error.URLError, compat_http_client.HTTPException, socket.error) as err:
-            self._downloader.trouble(u'ERROR: Unable to retrieve video webpage: %s' % compat_str(err))
+            self._downloader.report_error(u'Unable to retrieve video webpage: %s' % compat_str(err))
             return
         except ValueError as err:
-            self._downloader.trouble(u'ERROR: Invalid URL: %s' % url)
+            self._downloader.report_error(u'Invalid URL: %s' % url)
             return
         return webpage
 
@@ -1172,7 +1172,7 @@ def grep_webpage(self, url, regex, regexFlags, matchTuples):
         info = {}
 
         if mobj is None:
-            self._downloader.trouble(u'ERROR: Invalid URL: %s' % url)
+            self._downloader.report_error(u'Invalid URL: %s' % url)
             return
 
         for (i, key, err) in matchTuples:
@@ -1356,12 +1356,12 @@ def _real_extract(self, url):
             self.report_download_webpage(video_id)
             webpage = compat_urllib_request.urlopen(request).read()
         except (compat_urllib_error.URLError, compat_http_client.HTTPException, socket.error) as err:
-            self._downloader.trouble(u'ERROR: Unable to retrieve video webpage: %s' % compat_str(err))
+            self._downloader.report_error(u'Unable to retrieve video webpage: %s' % compat_str(err))
             return
         except ValueError as err:
             # since this is the last-resort InfoExtractor, if
             # this error is thrown, it'll be thrown here
-            self._downloader.trouble(u'ERROR: Invalid URL: %s' % url)
+            self._downloader.report_error(u'Invalid URL: %s' % url)
             return
 
         self.report_extraction(video_id)
@@ -1374,13 +1374,13 @@ def _real_extract(self, url):
             # Broaden the search a little bit: JWPlayer JS loader
             mobj = re.search(r'[^A-Za-z0-9]?file:\s*["\'](http[^\'"&]*)', webpage)
         if mobj is None:
-            self._downloader.trouble(u'ERROR: Invalid URL: %s' % url)
+            self._downloader.report_error(u'Invalid URL: %s' % url)
             return
 
         # It's possible that one of the regexes
         # matched, but returned an empty group:
         if mobj.group(1) is None:
-            self._downloader.trouble(u'ERROR: Invalid URL: %s' % url)
+            self._downloader.report_error(u'Invalid URL: %s' % url)
             return
 
         video_url = compat_urllib_parse.unquote(mobj.group(1))
@@ -1398,14 +1398,14 @@ def _real_extract(self, url):
         # and so on and so forth; it's just not practical
         mobj = re.search(r'<title>(.*)</title>', webpage)
         if mobj is None:
-            self._downloader.trouble(u'ERROR: unable to extract title')
+            self._downloader.report_error(u'unable to extract title')
             return
         video_title = mobj.group(1)
 
         # video uploader is domain name
         mobj = re.match(r'(?:https?://)?([^/]*)/.*', url)
         if mobj is None:
-            self._downloader.trouble(u'ERROR: unable to extract title')
+            self._downloader.report_error(u'unable to extract title')
             return
         video_uploader = mobj.group(1)
 
@@ -1437,7 +1437,7 @@ def report_download_page(self, query, pagenum):
     def _real_extract(self, query):
         mobj = re.match(self._VALID_URL, query)
         if mobj is None:
-            self._downloader.trouble(u'ERROR: invalid search query "%s"' % query)
+            self._downloader.report_error(u'invalid search query "%s"' % query)
             return
 
         prefix, query = query.split(':')
@@ -1453,7 +1453,7 @@ def _real_extract(self, query):
             try:
                 n = int(prefix)
                 if n <= 0:
-                    self._downloader.trouble(u'ERROR: invalid download number %s for query "%s"' % (n, query))
+                    self._downloader.report_error(u'invalid download number %s for query "%s"' % (n, query))
                     return
                 elif n > self._max_youtube_results:
                     self._downloader.report_warning(u'ytsearch returns max %i results (you requested %i)' % (self._max_youtube_results, n))
@@ -1478,7 +1478,7 @@ def _download_n_results(self, query, n):
             try:
                 data = compat_urllib_request.urlopen(request).read().decode('utf-8')
             except (compat_urllib_error.URLError, compat_http_client.HTTPException, socket.error) as err:
-                self._downloader.trouble(u'ERROR: unable to download API page: %s' % compat_str(err))
+                self._downloader.report_error(u'unable to download API page: %s' % compat_str(err))
                 return
             api_response = json.loads(data)['data']
 
@@ -1519,7 +1519,7 @@ def report_download_page(self, query, pagenum):
     def _real_extract(self, query):
         mobj = re.match(self._VALID_URL, query)
         if mobj is None:
-            self._downloader.trouble(u'ERROR: invalid search query "%s"' % query)
+            self._downloader.report_error(u'invalid search query "%s"' % query)
             return
 
         prefix, query = query.split(':')
@@ -1535,7 +1535,7 @@ def _real_extract(self, query):
             try:
                 n = int(prefix)
                 if n <= 0:
-                    self._downloader.trouble(u'ERROR: invalid download number %s for query "%s"' % (n, query))
+                    self._downloader.report_error(u'invalid download number %s for query "%s"' % (n, query))
                     return
                 elif n > self._max_google_results:
                     self._downloader.report_warning(u'gvsearch returns max %i results (you requested %i)' % (self._max_google_results, n))
@@ -1559,7 +1559,7 @@ def _download_n_results(self, query, n):
             try:
                 page = compat_urllib_request.urlopen(request).read()
             except (compat_urllib_error.URLError, compat_http_client.HTTPException, socket.error) as err:
-                self._downloader.trouble(u'ERROR: unable to download webpage: %s' % compat_str(err))
+                self._downloader.report_error(u'unable to download webpage: %s' % compat_str(err))
                 return
 
             # Extract video identifiers
@@ -1603,7 +1603,7 @@ def report_download_page(self, query, pagenum):
     def _real_extract(self, query):
         mobj = re.match(self._VALID_URL, query)
         if mobj is None:
-            self._downloader.trouble(u'ERROR: invalid search query "%s"' % query)
+            self._downloader.report_error(u'invalid search query "%s"' % query)
             return
 
         prefix, query = query.split(':')
@@ -1619,7 +1619,7 @@ def _real_extract(self, query):
             try:
                 n = int(prefix)
                 if n <= 0:
-                    self._downloader.trouble(u'ERROR: invalid download number %s for query "%s"' % (n, query))
+                    self._downloader.report_error(u'invalid download number %s for query "%s"' % (n, query))
                     return
                 elif n > self._max_yahoo_results:
                     self._downloader.report_warning(u'yvsearch returns max %i results (you requested %i)' % (self._max_yahoo_results, n))
@@ -1644,7 +1644,7 @@ def _download_n_results(self, query, n):
             try:
                 page = compat_urllib_request.urlopen(request).read()
             except (compat_urllib_error.URLError, compat_http_client.HTTPException, socket.error) as err:
-                self._downloader.trouble(u'ERROR: unable to download webpage: %s' % compat_str(err))
+                self._downloader.report_error(u'unable to download webpage: %s' % compat_str(err))
                 return
 
             # Extract video identifiers
@@ -1706,7 +1706,7 @@ def _real_extract(self, url):
         # Extract playlist id
         mobj = re.match(self._VALID_URL, url, re.VERBOSE)
         if mobj is None:
-            self._downloader.trouble(u'ERROR: invalid url: %s' % url)
+            self._downloader.report_error(u'invalid url: %s' % url)
             return
 
         # Download playlist videos from API
@@ -1721,17 +1721,17 @@ def _real_extract(self, url):
             try:
                 page = compat_urllib_request.urlopen(url).read().decode('utf8')
             except (compat_urllib_error.URLError, compat_http_client.HTTPException, socket.error) as err:
-                self._downloader.trouble(u'ERROR: unable to download webpage: %s' % compat_str(err))
+                self._downloader.report_error(u'unable to download webpage: %s' % compat_str(err))
                 return
 
             try:
                 response = json.loads(page)
             except ValueError as err:
-                self._downloader.trouble(u'ERROR: Invalid JSON in API response: ' + compat_str(err))
+                self._downloader.report_error(u'Invalid JSON in API response: ' + compat_str(err))
                 return
 
             if not 'feed' in response or not 'entry' in response['feed']:
-                self._downloader.trouble(u'ERROR: Got a malformed response from YouTube API')
+                self._downloader.report_error(u'Got a malformed response from YouTube API')
                 return
             videos += [ (entry['yt$position']['$t'], entry['content']['src'])
                         for entry in response['feed']['entry']
@@ -1777,7 +1777,7 @@ def _real_extract(self, url):
         # Extract channel id
         mobj = re.match(self._VALID_URL, url)
         if mobj is None:
-            self._downloader.trouble(u'ERROR: invalid url: %s' % url)
+            self._downloader.report_error(u'invalid url: %s' % url)
             return
 
         # Download channel pages
@@ -1792,7 +1792,7 @@ def _real_extract(self, url):
             try:
                 page = compat_urllib_request.urlopen(request).read().decode('utf8')
             except (compat_urllib_error.URLError, compat_http_client.HTTPException, socket.error) as err:
-                self._downloader.trouble(u'ERROR: unable to download webpage: %s' % compat_str(err))
+                self._downloader.report_error(u'unable to download webpage: %s' % compat_str(err))
                 return
 
             # Extract video identifiers
@@ -1835,7 +1835,7 @@ def _real_extract(self, url):
         # Extract username
         mobj = re.match(self._VALID_URL, url)
         if mobj is None:
-            self._downloader.trouble(u'ERROR: invalid url: %s' % url)
+            self._downloader.report_error(u'invalid url: %s' % url)
             return
 
         username = mobj.group(1)
@@ -1857,7 +1857,7 @@ def _real_extract(self, url):
             try:
                 page = compat_urllib_request.urlopen(request).read().decode('utf-8')
             except (compat_urllib_error.URLError, compat_http_client.HTTPException, socket.error) as err:
-                self._downloader.trouble(u'ERROR: unable to download webpage: %s' % compat_str(err))
+                self._downloader.report_error(u'unable to download webpage: %s' % compat_str(err))
                 return
 
             # Extract video identifiers
@@ -1915,7 +1915,7 @@ def _real_extract(self, url):
         # Extract username
         mobj = re.match(self._VALID_URL, url)
         if mobj is None:
-            self._downloader.trouble(u'ERROR: invalid url: %s' % url)
+            self._downloader.report_error(u'invalid url: %s' % url)
             return
 
         username = mobj.group(1)
@@ -1929,7 +1929,7 @@ def _real_extract(self, url):
             mobj = re.search(r'data-users-id="([^"]+)"', page)
             page_base = page_base % mobj.group(1)
         except (compat_urllib_error.URLError, compat_http_client.HTTPException, socket.error) as err:
-            self._downloader.trouble(u'ERROR: unable to download webpage: %s' % compat_str(err))
+            self._downloader.report_error(u'unable to download webpage: %s' % compat_str(err))
             return
 
 
@@ -1948,7 +1948,7 @@ def _real_extract(self, url):
             try:
                 page = compat_urllib_request.urlopen(request).read().decode('utf-8')
             except (compat_urllib_error.URLError, compat_http_client.HTTPException, socket.error) as err:
-                self._downloader.trouble(u'ERROR: unable to download webpage: %s' % str(err))
+                self._downloader.report_error(u'unable to download webpage: %s' % str(err))
                 return
 
             # Extract video identifiers
@@ -2012,7 +2012,7 @@ def _real_extract(self, url):
             self.report_download_webpage(file_id)
             webpage = compat_urllib_request.urlopen(request).read()
         except (compat_urllib_error.URLError, compat_http_client.HTTPException, socket.error) as err:
-            self._downloader.trouble(u'ERROR: Unable to retrieve file webpage: %s' % compat_str(err))
+            self._downloader.report_error(u'Unable to retrieve file webpage: %s' % compat_str(err))
             return
 
         # Search for the real file URL
@@ -2022,9 +2022,9 @@ def _real_extract(self, url):
             mobj = re.search(r'<strong>(Attention.*?)</strong>', webpage, re.DOTALL)
             if (mobj is not None) and (mobj.group(1) is not None):
                 restriction_message = re.sub('\s+', ' ', mobj.group(1)).strip()
-                self._downloader.trouble(u'ERROR: %s' % restriction_message)
+                self._downloader.report_error(u'%s' % restriction_message)
             else:
-                self._downloader.trouble(u'ERROR: unable to extract download URL from: %s' % url)
+                self._downloader.report_error(u'unable to extract download URL from: %s' % url)
             return
 
         file_url = mobj.group(1)
@@ -2033,7 +2033,7 @@ def _real_extract(self, url):
         # Search for file title
         mobj = re.search(r'<b title="(.*?)">', webpage)
         if mobj is None:
-            self._downloader.trouble(u'ERROR: unable to extract title')
+            self._downloader.report_error(u'unable to extract title')
             return
         file_title = mobj.group(1).decode('utf-8')
 
@@ -2106,7 +2106,7 @@ def _real_initialize(self):
     def _real_extract(self, url):
         mobj = re.match(self._VALID_URL, url)
         if mobj is None:
-            self._downloader.trouble(u'ERROR: invalid URL: %s' % url)
+            self._downloader.report_error(u'invalid URL: %s' % url)
             return
         video_id = mobj.group('ID')
 
@@ -2162,7 +2162,7 @@ def report_direct_download(self, title):
     def _real_extract(self, url):
         mobj = re.match(self._VALID_URL, url)
         if mobj is None:
-            self._downloader.trouble(u'ERROR: invalid URL: %s' % url)
+            self._downloader.report_error(u'invalid URL: %s' % url)
             return
 
         urlp = compat_urllib_parse_urlparse(url)
@@ -2209,7 +2209,7 @@ def _real_extract(self, url):
                 json_code_bytes = urlh.read()
                 json_code = json_code_bytes.decode('utf-8')
             except (compat_urllib_error.URLError, compat_http_client.HTTPException, socket.error) as err:
-                self._downloader.trouble(u'ERROR: unable to read video info webpage: %s' % compat_str(err))
+                self._downloader.report_error(u'unable to read video info webpage: %s' % compat_str(err))
                 return
 
             try:
@@ -2240,7 +2240,7 @@ def _real_extract(self, url):
                     'user_agent': 'iTunes/10.6.1',
                 }
             except (ValueError,KeyError) as err:
-                self._downloader.trouble(u'ERROR: unable to parse video information: %s' % repr(err))
+                self._downloader.report_error(u'unable to parse video information: %s' % repr(err))
                 return
 
         return [info]
@@ -2262,7 +2262,7 @@ def report_extraction(self, video_id):
     def _real_extract(self,url):
         mobj = re.match(self._VALID_URL, url)
         if mobj is None:
-            self._download.trouble(u'ERROR: invalid URL: %s' % url)
+            self._download.report_error(u'invalid URL: %s' % url)
             return
 
         video_id = mobj.group(1)
@@ -2275,13 +2275,13 @@ def _real_extract(self,url):
         mobj = re.search(r'<link rel=\'image_src\' href=\'(http://is[0-9].myvideo\.de/de/movie[0-9]+/[a-f0-9]+)/thumbs/.*?\.jpg\' />',
                  webpage)
         if mobj is None:
-            self._downloader.trouble(u'ERROR: unable to extract media URL')
+            self._downloader.report_error(u'unable to extract media URL')
             return
         video_url = mobj.group(1) + ('/%s.flv' % video_id)
 
         mobj = re.search('<title>([^<]+)</title>', webpage)
         if mobj is None:
-            self._downloader.trouble(u'ERROR: unable to extract title')
+            self._downloader.report_error(u'unable to extract title')
             return
 
         video_title = mobj.group(1)
@@ -2354,7 +2354,7 @@ def _print_formats(self, formats):
     def _real_extract(self, url):
         mobj = re.match(self._VALID_URL, url, re.VERBOSE)
         if mobj is None:
-            self._downloader.trouble(u'ERROR: invalid URL: %s' % url)
+            self._downloader.report_error(u'invalid URL: %s' % url)
             return
 
         if mobj.group('shortname'):
@@ -2385,16 +2385,16 @@ def _real_extract(self, url):
             html = htmlHandle.read()
             webpage = html.decode('utf-8')
         except (compat_urllib_error.URLError, compat_http_client.HTTPException, socket.error) as err:
-            self._downloader.trouble(u'ERROR: unable to download webpage: %s' % compat_str(err))
+            self._downloader.report_error(u'unable to download webpage: %s' % compat_str(err))
             return
         if dlNewest:
             url = htmlHandle.geturl()
             mobj = re.match(self._VALID_URL, url, re.VERBOSE)
             if mobj is None:
-                self._downloader.trouble(u'ERROR: Invalid redirected URL: ' + url)
+                self._downloader.report_error(u'Invalid redirected URL: ' + url)
                 return
             if mobj.group('episode') == '':
-                self._downloader.trouble(u'ERROR: Redirected URL is still not specific: ' + url)
+                self._downloader.report_error(u'Redirected URL is still not specific: ' + url)
                 return
             epTitle = mobj.group('episode')
 
@@ -2407,7 +2407,7 @@ def _real_extract(self, url):
 
             altMovieParams = re.findall('data-mgid="([^"]*(?:episode|video).*?:.*?)"', webpage)
             if len(altMovieParams) == 0:
-                self._downloader.trouble(u'ERROR: unable to find Flash URL in webpage ' + url)
+                self._downloader.report_error(u'unable to find Flash URL in webpage ' + url)
                 return
             else:
                 mMovieParams = [("http://media.mtvnservices.com/" + altMovieParams[0], altMovieParams[0])]
@@ -2418,7 +2418,7 @@ def _real_extract(self, url):
         try:
             indexXml = compat_urllib_request.urlopen(indexUrl).read()
         except (compat_urllib_error.URLError, compat_http_client.HTTPException, socket.error) as err:
-            self._downloader.trouble(u'ERROR: unable to download episode index: ' + compat_str(err))
+            self._downloader.report_error(u'unable to download episode index: ' + compat_str(err))
             return
 
         results = []
@@ -2439,7 +2439,7 @@ def _real_extract(self, url):
             try:
                 configXml = compat_urllib_request.urlopen(configReq).read()
             except (compat_urllib_error.URLError, compat_http_client.HTTPException, socket.error) as err:
-                self._downloader.trouble(u'ERROR: unable to download webpage: %s' % compat_str(err))
+                self._downloader.report_error(u'unable to download webpage: %s' % compat_str(err))
                 return
 
             cdoc = xml.etree.ElementTree.fromstring(configXml)
@@ -2506,7 +2506,7 @@ def report_config_download(self, showName):
     def _real_extract(self, url):
         mobj = re.match(self._VALID_URL, url)
         if mobj is None:
-            self._downloader.trouble(u'ERROR: invalid URL: %s' % url)
+            self._downloader.report_error(u'invalid URL: %s' % url)
             return
         showName = mobj.group('showname')
         videoId = mobj.group('episode')
@@ -2518,7 +2518,7 @@ def _real_extract(self, url):
             m = re.match(r'text/html; charset="?([^"]+)"?', webPage.headers['Content-Type'])
             webPage = webPageBytes.decode(m.group(1) if m else 'utf-8')
         except (compat_urllib_error.URLError, compat_http_client.HTTPException, socket.error) as err:
-            self._downloader.trouble(u'ERROR: unable to download webpage: ' + compat_str(err))
+            self._downloader.report_error(u'unable to download webpage: ' + compat_str(err))
             return
 
         descMatch = re.search('<meta name="description" content="([^"]*)"', webPage)
@@ -2536,7 +2536,7 @@ def _real_extract(self, url):
             m = re.match(r'text/html; charset="?([^"]+)"?', configJSON.headers['Content-Type'])
             configJSON = configJSON.read().decode(m.group(1) if m else 'utf-8')
         except (compat_urllib_error.URLError, compat_http_client.HTTPException, socket.error) as err:
-            self._downloader.trouble(u'ERROR: unable to download configuration: ' + compat_str(err))
+            self._downloader.report_error(u'unable to download configuration: ' + compat_str(err))
             return
 
         # Technically, it's JavaScript, not JSON
@@ -2545,7 +2545,7 @@ def _real_extract(self, url):
         try:
             config = json.loads(configJSON)
         except (ValueError,) as err:
-            self._downloader.trouble(u'ERROR: Invalid JSON in configuration file: ' + compat_str(err))
+            self._downloader.report_error(u'Invalid JSON in configuration file: ' + compat_str(err))
             return
 
         playlist = config['playlist']
@@ -2583,7 +2583,7 @@ def report_extraction(self, video_id):
     def _real_extract(self, url):
         mobj = re.match(self._VALID_URL, url)
         if mobj is None:
-            self._downloader.trouble(u'ERROR: invalid URL: %s' % url)
+            self._downloader.report_error(u'invalid URL: %s' % url)
             return
         video_id = mobj.group('videoid')
 
@@ -2598,7 +2598,7 @@ def _real_extract(self, url):
         try:
             metaXml = compat_urllib_request.urlopen(xmlUrl).read()
         except (compat_urllib_error.URLError, compat_http_client.HTTPException, socket.error) as err:
-            self._downloader.trouble(u'ERROR: unable to download video info XML: %s' % compat_str(err))
+            self._downloader.report_error(u'unable to download video info XML: %s' % compat_str(err))
             return
 
         mdoc = xml.etree.ElementTree.fromstring(metaXml)
@@ -2617,7 +2617,7 @@ def _real_extract(self, url):
         try:
             manifestXml = compat_urllib_request.urlopen(manifest_url).read()
         except (compat_urllib_error.URLError, compat_http_client.HTTPException, socket.error) as err:
-            self._downloader.trouble(u'ERROR: unable to download video info XML: %s' % compat_str(err))
+            self._downloader.report_error(u'unable to download video info XML: %s' % compat_str(err))
             return
 
         adoc = xml.etree.ElementTree.fromstring(manifestXml)
@@ -2650,7 +2650,7 @@ def report_extraction(self, video_id):
     def _real_extract(self, url):
         mobj = re.match(self._VALID_URL, url)
         if mobj is None:
-            self._downloader.trouble(u'ERROR: invalid URL: %s' % url)
+            self._downloader.report_error(u'invalid URL: %s' % url)
             return
         video_id = mobj.group(1)
 
@@ -2662,7 +2662,7 @@ def _real_extract(self, url):
         # Extract video URL
         mobj = re.search(r'flv_url=(.+?)&', webpage)
         if mobj is None:
-            self._downloader.trouble(u'ERROR: unable to extract video url')
+            self._downloader.report_error(u'unable to extract video url')
             return
         video_url = compat_urllib_parse.unquote(mobj.group(1))
 
@@ -2670,7 +2670,7 @@ def _real_extract(self, url):
         # Extract title
         mobj = re.search(r'<title>(.*?)\s+-\s+XVID', webpage)
         if mobj is None:
-            self._downloader.trouble(u'ERROR: unable to extract video title')
+            self._downloader.report_error(u'unable to extract video title')
             return
         video_title = mobj.group(1)
 
@@ -2678,7 +2678,7 @@ def _real_extract(self, url):
         # Extract video thumbnail
         mobj = re.search(r'http://(?:img.*?\.)xvideos.com/videos/thumbs/[a-fA-F0-9]+/[a-fA-F0-9]+/[a-fA-F0-9]+/[a-fA-F0-9]+/([a-fA-F0-9.]+jpg)', webpage)
         if mobj is None:
-            self._downloader.trouble(u'ERROR: unable to extract video thumbnail')
+            self._downloader.report_error(u'unable to extract video thumbnail')
             return
         video_thumbnail = mobj.group(0)
 
@@ -2722,7 +2722,7 @@ def report_extraction(self, video_id):
     def _real_extract(self, url):
         mobj = re.match(self._VALID_URL, url)
         if mobj is None:
-            self._downloader.trouble(u'ERROR: invalid URL: %s' % url)
+            self._downloader.report_error(u'invalid URL: %s' % url)
             return
 
         # extract uploader (which is in the url)
@@ -2740,7 +2740,7 @@ def _real_extract(self, url):
             info_json_bytes = compat_urllib_request.urlopen(request).read()
             info_json = info_json_bytes.decode('utf-8')
         except (compat_urllib_error.URLError, compat_http_client.HTTPException, socket.error) as err:
-            self._downloader.trouble(u'ERROR: unable to download video webpage: %s' % compat_str(err))
+            self._downloader.report_error(u'unable to download video webpage: %s' % compat_str(err))
             return
 
         info = json.loads(info_json)
@@ -2753,7 +2753,7 @@ def _real_extract(self, url):
             stream_json_bytes = compat_urllib_request.urlopen(request).read()
             stream_json = stream_json_bytes.decode('utf-8')
         except (compat_urllib_error.URLError, compat_http_client.HTTPException, socket.error) as err:
-            self._downloader.trouble(u'ERROR: unable to download stream definitions: %s' % compat_str(err))
+            self._downloader.report_error(u'unable to download stream definitions: %s' % compat_str(err))
             return
 
         streams = json.loads(stream_json)
@@ -2781,7 +2781,7 @@ def report_extraction(self, video_id):
     def _real_extract(self, url):
         mobj = re.match(self._VALID_URL, url)
         if mobj is None:
-            self._downloader.trouble(u'ERROR: invalid URL: %s' % url)
+            self._downloader.report_error(u'invalid URL: %s' % url)
             return
 
         webpage = self._download_webpage(url, video_id=url)
@@ -2790,7 +2790,7 @@ def _real_extract(self, url):
         # Extract video URL
         mobj = re.search(r"jsclassref='([^']*)'", webpage)
         if mobj is None:
-            self._downloader.trouble(u'ERROR: unable to extract video url')
+            self._downloader.report_error(u'unable to extract video url')
             return
         real_id = compat_urllib_parse.unquote(base64.b64decode(mobj.group(1).encode('ascii')).decode('utf-8'))
         video_url = 'rtmpe://video.infoq.com/cfx/st/' + real_id
@@ -2798,7 +2798,7 @@ def _real_extract(self, url):
         # Extract title
         mobj = re.search(r'contentTitle = "(.*?)";', webpage)
         if mobj is None:
-            self._downloader.trouble(u'ERROR: unable to extract video title')
+            self._downloader.report_error(u'unable to extract video title')
             return
         video_title = mobj.group(1)
 
@@ -2881,7 +2881,7 @@ def _print_formats(self, formats):
     def _real_extract(self, url):
         mobj = re.match(self._VALID_URL, url)
         if mobj is None:
-            self._downloader.trouble(u'ERROR: invalid URL: %s' % url)
+            self._downloader.report_error(u'invalid URL: %s' % url)
             return
         # extract uploader & filename from url
         uploader = mobj.group(1).decode('utf-8')
@@ -2895,7 +2895,7 @@ def _real_extract(self, url):
             self.report_download_json(file_url)
             jsonData = compat_urllib_request.urlopen(request).read()
         except (compat_urllib_error.URLError, compat_http_client.HTTPException, socket.error) as err:
-            self._downloader.trouble(u'ERROR: Unable to retrieve file: %s' % compat_str(err))
+            self._downloader.report_error(u'Unable to retrieve file: %s' % compat_str(err))
             return
 
         # parse JSON
@@ -2919,7 +2919,7 @@ def _real_extract(self, url):
                     break # got it!
         else:
             if req_format not in formats:
-                self._downloader.trouble(u'ERROR: format is not available')
+                self._downloader.report_error(u'format is not available')
                 return
 
             url_list = self.get_urls(formats, req_format)
@@ -2973,7 +2973,7 @@ def _real_extract(self, url):
             try:
                 metaXml = compat_urllib_request.urlopen(xmlUrl).read()
             except (compat_urllib_error.URLError, compat_http_client.HTTPException, socket.error) as err:
-                self._downloader.trouble(u'ERROR: unable to download video info XML: %s' % compat_str(err))
+                self._downloader.report_error(u'unable to download video info XML: %s' % compat_str(err))
                 return
             mdoc = xml.etree.ElementTree.fromstring(metaXml)
             try:
@@ -3032,7 +3032,7 @@ def _real_extract(self, url):
             try:
                 rootpage = compat_urllib_request.urlopen(rootURL).read()
             except (compat_urllib_error.URLError, compat_http_client.HTTPException, socket.error) as err:
-                self._downloader.trouble(u'ERROR: unable to download course info page: ' + compat_str(err))
+                self._downloader.report_error(u'unable to download course info page: ' + compat_str(err))
                 return
 
             info['title'] = info['id']
@@ -3064,7 +3064,7 @@ def report_extraction(self, video_id):
     def _real_extract(self, url):
         mobj = re.match(self._VALID_URL, url)
         if mobj is None:
-            self._downloader.trouble(u'ERROR: invalid URL: %s' % url)
+            self._downloader.report_error(u'invalid URL: %s' % url)
             return
         if not mobj.group('proto'):
             url = 'http://' + url
@@ -3074,25 +3074,25 @@ def _real_extract(self, url):
 
         mobj = re.search(r'<meta name="mtv_vt" content="([^"]+)"/>', webpage)
         if mobj is None:
-            self._downloader.trouble(u'ERROR: unable to extract song name')
+            self._downloader.report_error(u'unable to extract song name')
             return
         song_name = unescapeHTML(mobj.group(1).decode('iso-8859-1'))
         mobj = re.search(r'<meta name="mtv_an" content="([^"]+)"/>', webpage)
         if mobj is None:
-            self._downloader.trouble(u'ERROR: unable to extract performer')
+            self._downloader.report_error(u'unable to extract performer')
             return
         performer = unescapeHTML(mobj.group(1).decode('iso-8859-1'))
         video_title = performer + ' - ' + song_name
 
         mobj = re.search(r'<meta name="mtvn_uri" content="([^"]+)"/>', webpage)
         if mobj is None:
-            self._downloader.trouble(u'ERROR: unable to mtvn_uri')
+            self._downloader.report_error(u'unable to mtvn_uri')
             return
         mtvn_uri = mobj.group(1)
 
         mobj = re.search(r'MTVN.Player.defaultPlaylistId = ([0-9]+);', webpage)
         if mobj is None:
-            self._downloader.trouble(u'ERROR: unable to extract content id')
+            self._downloader.report_error(u'unable to extract content id')
             return
         content_id = mobj.group(1)
 
@@ -3102,7 +3102,7 @@ def _real_extract(self, url):
         try:
             metadataXml = compat_urllib_request.urlopen(request).read()
         except (compat_urllib_error.URLError, compat_http_client.HTTPException, socket.error) as err:
-            self._downloader.trouble(u'ERROR: unable to download video metadata: %s' % compat_str(err))
+            self._downloader.report_error(u'unable to download video metadata: %s' % compat_str(err))
             return
 
         mdoc = xml.etree.ElementTree.fromstring(metadataXml)
@@ -3174,7 +3174,7 @@ def _get_file_id(self, fileId, seed):
     def _real_extract(self, url):
         mobj = re.match(self._VALID_URL, url)
         if mobj is None:
-            self._downloader.trouble(u'ERROR: invalid URL: %s' % url)
+            self._downloader.report_error(u'invalid URL: %s' % url)
             return
         video_id = mobj.group('ID')
 
@@ -3185,7 +3185,7 @@ def _real_extract(self, url):
             self.report_download_webpage(video_id)
             jsondata = compat_urllib_request.urlopen(request).read()
         except (compat_urllib_error.URLError, compat_http_client.HTTPException, socket.error) as err:
-            self._downloader.trouble(u'ERROR: Unable to retrieve video webpage: %s' % compat_str(err))
+            self._downloader.report_error(u'Unable to retrieve video webpage: %s' % compat_str(err))
             return
 
         self.report_extraction(video_id)
@@ -3216,7 +3216,7 @@ def _real_extract(self, url):
             fileid = config['data'][0]['streamfileids'][format]
             keys = [s['k'] for s in config['data'][0]['segs'][format]]
         except (UnicodeDecodeError, ValueError, KeyError):
-            self._downloader.trouble(u'ERROR: unable to extract info section')
+            self._downloader.report_error(u'unable to extract info section')
             return
 
         files_info=[]
@@ -3263,7 +3263,7 @@ def report_extraction(self, video_id):
     def _real_extract(self, url):
         mobj = re.match(self._VALID_URL, url)
         if mobj is None:
-            self._downloader.trouble(u'ERROR: invalid URL: %s' % url)
+            self._downloader.report_error(u'invalid URL: %s' % url)
             return
         video_id = mobj.group(1)
 
@@ -3274,24 +3274,24 @@ def _real_extract(self, url):
             webpage_bytes = compat_urllib_request.urlopen(url).read()
             webpage = webpage_bytes.decode('utf-8')
         except (compat_urllib_error.URLError, compat_http_client.HTTPException, socket.error) as err:
-            self._downloader.trouble(u'ERROR: unable to download video webpage: %s' % err)
+            self._downloader.report_error(u'unable to download video webpage: %s' % err)
             return
 
         result = re.search(self.VIDEO_URL_RE, webpage)
         if result is None:
-            self._downloader.trouble(u'ERROR: unable to extract video url')
+            self._downloader.report_error(u'unable to extract video url')
             return
         video_url = compat_urllib_parse.unquote(result.group(1))
 
         result = re.search(self.VIDEO_TITLE_RE, webpage)
         if result is None:
-            self._downloader.trouble(u'ERROR: unable to extract video title')
+            self._downloader.report_error(u'unable to extract video title')
             return
         video_title = result.group(1)
 
         result = re.search(self.VIDEO_THUMB_RE, webpage)
         if result is None:
-            self._downloader.trouble(u'ERROR: unable to extract video thumbnail')
+            self._downloader.report_error(u'unable to extract video thumbnail')
             return
         video_thumbnail = result.group(1)
 
@@ -3340,7 +3340,7 @@ def _real_extract(self, url):
         # Extract id from URL
         mobj = re.match(self._VALID_URL, url)
         if mobj is None:
-            self._downloader.trouble(u'ERROR: Invalid URL: %s' % url)
+            self._downloader.report_error(u'Invalid URL: %s' % url)
             return
 
         post_url = mobj.group(0)
@@ -3354,7 +3354,7 @@ def _real_extract(self, url):
         try:
             webpage = compat_urllib_request.urlopen(request).read().decode('utf-8')
         except (compat_urllib_error.URLError, compat_http_client.HTTPException, socket.error) as err:
-            self._downloader.trouble(u'ERROR: Unable to retrieve entry webpage: %s' % compat_str(err))
+            self._downloader.report_error(u'Unable to retrieve entry webpage: %s' % compat_str(err))
             return
 
         # Extract update date
@@ -3389,14 +3389,14 @@ def _real_extract(self, url):
         pattern = '"(https\://plus\.google\.com/photos/.*?)",,"image/jpeg","video"\]'
         mobj = re.search(pattern, webpage)
         if mobj is None:
-            self._downloader.trouble(u'ERROR: unable to extract video page URL')
+            self._downloader.report_error(u'unable to extract video page URL')
 
         video_page = mobj.group(1)
         request = compat_urllib_request.Request(video_page)
         try:
             webpage = compat_urllib_request.urlopen(request).read().decode('utf-8')
         except (compat_urllib_error.URLError, compat_http_client.HTTPException, socket.error) as err:
-            self._downloader.trouble(u'ERROR: Unable to retrieve video webpage: %s' % compat_str(err))
+            self._downloader.report_error(u'Unable to retrieve video webpage: %s' % compat_str(err))
             return
         self.report_extract_vid_page(video_page)
 
@@ -3406,7 +3406,7 @@ def _real_extract(self, url):
         pattern = '\d+,\d+,(\d+),"(http\://redirector\.googlevideo\.com.*?)"'
         mobj = re.findall(pattern, webpage)
         if len(mobj) == 0:
-            self._downloader.trouble(u'ERROR: unable to extract video links')
+            self._downloader.report_error(u'unable to extract video links')
 
         # Sort in resolution
         links = sorted(mobj)
@@ -3438,7 +3438,7 @@ class NBAIE(InfoExtractor):
     def _real_extract(self, url):
         mobj = re.match(self._VALID_URL, url)
         if mobj is None:
-            self._downloader.trouble(u'ERROR: invalid URL: %s' % url)
+            self._downloader.report_error(u'invalid URL: %s' % url)
             return
 
         video_id = mobj.group(1)
@@ -3494,13 +3494,13 @@ def _parse_page(self, url):
             webpage_bytes = urlh.read()
             webpage = webpage_bytes.decode('utf-8', 'ignore')
         except (compat_urllib_error.URLError, compat_http_client.HTTPException, socket.error) as err:
-            self._downloader.trouble(u'ERROR: unable to download video info JSON: %s' % compat_str(err))
+            self._downloader.report_error(u'unable to download video info JSON: %s' % compat_str(err))
             return
 
         response = json.loads(webpage)
         if type(response) != list:
             error_text = response.get('error', 'unknown error')
-            self._downloader.trouble(u'ERROR: Justin.tv API: %s' % error_text)
+            self._downloader.report_error(u'Justin.tv API: %s' % error_text)
             return
         info = []
         for clip in response:
@@ -3525,7 +3525,7 @@ def _parse_page(self, url):
     def _real_extract(self, url):
         mobj = re.match(self._VALID_URL, url)
         if mobj is None:
-            self._downloader.trouble(u'ERROR: invalid URL: %s' % url)
+            self._downloader.report_error(u'invalid URL: %s' % url)
             return
 
         api = 'http://api.justin.tv'
@@ -3560,7 +3560,7 @@ class FunnyOrDieIE(InfoExtractor):
     def _real_extract(self, url):
         mobj = re.match(self._VALID_URL, url)
         if mobj is None:
-            self._downloader.trouble(u'ERROR: invalid URL: %s' % url)
+            self._downloader.report_error(u'invalid URL: %s' % url)
             return
 
         video_id = mobj.group('id')
@@ -3568,7 +3568,7 @@ def _real_extract(self, url):
 
         m = re.search(r'<video[^>]*>\s*<source[^>]*>\s*<source src="(?P<url>[^"]+)"', webpage, re.DOTALL)
         if not m:
-            self._downloader.trouble(u'ERROR: unable to find video information')
+            self._downloader.report_error(u'unable to find video information')
         video_url = unescapeHTML(m.group('url'))
 
         m = re.search(r"class='player_page_h1'>\s+<a.*?>(?P<title>.*?)</a>", webpage)
@@ -3621,7 +3621,7 @@ def _real_extract(self, url):
             video_url = vid.group('videoURL')
             video_thumb = thumb.group('thumbnail')
             if not video_url:
-                self._downloader.trouble(u'ERROR: Cannot find video url for %s' % video_id)
+                self._downloader.report_error(u'Cannot find video url for %s' % video_id)
             info = {
                 'id':video_id,
                 'url':video_url,
@@ -3711,7 +3711,7 @@ def _specific(self, req_format, formats):
     def _real_extract(self, url):
         mobj = re.match(self._VALID_URL, url)
         if mobj is None:
-            self._downloader.trouble(u'ERROR: invalid URL: %s' % url)
+            self._downloader.report_error(u'invalid URL: %s' % url)
             return
 
         video_id = mobj.group('videoid')
@@ -3803,7 +3803,7 @@ def _real_extract(self, url):
         else:
             format = self._specific( req_format, formats )
             if result is None:
-                self._downloader.trouble(u'ERROR: requested format not available')
+                self._downloader.report_error(u'requested format not available')
                 return
             return [format]
 
@@ -3816,7 +3816,7 @@ class PornotubeIE(InfoExtractor):
     def _real_extract(self, url):
         mobj = re.match(self._VALID_URL, url)
         if mobj is None:
-            self._downloader.trouble(u'ERROR: invalid URL: %s' % url)
+            self._downloader.report_error(u'invalid URL: %s' % url)
             return
 
         video_id = mobj.group('videoid')
@@ -3829,7 +3829,7 @@ def _real_extract(self, url):
         VIDEO_URL_RE = r'url: "(?P<url>http://video[0-9].pornotube.com/.+\.flv)",'
         result = re.search(VIDEO_URL_RE, webpage)
         if result is None:
-            self._downloader.trouble(u'ERROR: unable to extract video url')
+            self._downloader.report_error(u'unable to extract video url')
             return
         video_url = compat_urllib_parse.unquote(result.group('url'))
 
@@ -3837,7 +3837,7 @@ def _real_extract(self, url):
         VIDEO_UPLOADED_RE = r'<div class="video_added_by">Added (?P<date>[0-9\/]+) by'
         result = re.search(VIDEO_UPLOADED_RE, webpage)
         if result is None:
-            self._downloader.trouble(u'ERROR: unable to extract video title')
+            self._downloader.report_error(u'unable to extract video title')
             return
         upload_date = result.group('date')
 
@@ -3858,7 +3858,7 @@ class YouJizzIE(InfoExtractor):
     def _real_extract(self, url):
         mobj = re.match(self._VALID_URL, url)
         if mobj is None:
-            self._downloader.trouble(u'ERROR: invalid URL: %s' % url)
+            self._downloader.report_error(u'invalid URL: %s' % url)
             return
 
         video_id = mobj.group('videoid')
@@ -4059,13 +4059,13 @@ def _real_extract(self, url):
         # extract values from metadata
         url_flv_el = metadata.find('url_flv')
         if url_flv_el is None:
-            self._downloader.trouble(u'ERROR: unable to extract download url')
+            self._downloader.report_error(u'unable to extract download url')
             return
         video_url = url_flv_el.text
         extension = os.path.splitext(video_url)[1][1:]
         title_el = metadata.find('title')
         if title_el is None:
-            self._downloader.trouble(u'ERROR: unable to extract title')
+            self._downloader.report_error(u'unable to extract title')
             return
         title = title_el.text
         format_id_el = metadata.find('format_id')

From c9fa1cbab6b24f48449aca3b0eddabee6d95a7d1 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Jaime=20Marqui=CC=81nez=20Ferra=CC=81ndiz?=
 <jaimemf93@gmail.com>
Date: Tue, 5 Mar 2013 21:13:17 +0100
Subject: [PATCH 04/37] More trouble calls changed in InfoExtractors.py

The calls with the message starting with 'WARNING' have been changed to report_warning instead of report_error
---
 youtube_dl/InfoExtractors.py | 16 ++++++++--------
 1 file changed, 8 insertions(+), 8 deletions(-)

diff --git a/youtube_dl/InfoExtractors.py b/youtube_dl/InfoExtractors.py
index 6328332a7..83bf5b8f6 100755
--- a/youtube_dl/InfoExtractors.py
+++ b/youtube_dl/InfoExtractors.py
@@ -467,7 +467,7 @@ def _real_extract(self, url):
         if mobj is not None:
             video_uploader_id = mobj.group(1)
         else:
-            self._downloader.trouble(u'WARNING: unable to extract uploader nickname')
+            self._downloader.report_warning(u'unable to extract uploader nickname')
 
         # title
         if 'title' not in video_info:
@@ -477,7 +477,7 @@ def _real_extract(self, url):
 
         # thumbnail image
         if 'thumbnail_url' not in video_info:
-            self._downloader.trouble(u'WARNING: unable to extract video thumbnail')
+            self._downloader.report_warning(u'unable to extract video thumbnail')
             video_thumbnail = ''
         else:   # don't panic if we can't find it
             video_thumbnail = compat_urllib_parse.unquote_plus(video_info['thumbnail_url'][0])
@@ -509,7 +509,7 @@ def _real_extract(self, url):
                 self._downloader.trouble(srt_error)
 
         if 'length_seconds' not in video_info:
-            self._downloader.trouble(u'WARNING: unable to extract video duration')
+            self._downloader.report_warning(u'unable to extract video duration')
             video_duration = ''
         else:
             video_duration = compat_urllib_parse.unquote_plus(video_info['length_seconds'][0])
@@ -785,7 +785,7 @@ def _real_extract(self, url):
             # lookin for official user
             mobj_official = re.search(r'<span rel="author"[^>]+?>([^<]+?)</span>', webpage)
             if mobj_official is None:
-                self._downloader.trouble(u'WARNING: unable to extract uploader nickname')
+                self._downloader.report_warning(u'unable to extract uploader nickname')
             else:
                 video_uploader = mobj_official.group(1)
         else:
@@ -2449,7 +2449,7 @@ def _real_extract(self, url):
                 turls.append(finfo)
 
             if len(turls) == 0:
-                self._downloader.trouble(u'\nERROR: unable to download ' + mediaId + ': No videos found')
+                self._downloader.report_error(u'unable to download ' + mediaId + ': No videos found')
                 continue
 
             if self._downloader.params.get('listformats', None):
@@ -2609,7 +2609,7 @@ def _real_extract(self, url):
             info['thumbnail'] = videoNode.findall('./thumbnail')[0].text
             manifest_url = videoNode.findall('./file')[0].text
         except IndexError:
-            self._downloader.trouble(u'\nERROR: Invalid metadata XML file')
+            self._downloader.report_error(u'Invalid metadata XML file')
             return
 
         manifest_url += '?hdcore=2.10.3'
@@ -2626,7 +2626,7 @@ def _real_extract(self, url):
             node_id = media_node.attrib['url']
             video_id = adoc.findall('./{http://ns.adobe.com/f4m/1.0}id')[0].text
         except IndexError as err:
-            self._downloader.trouble(u'\nERROR: Invalid manifest file')
+            self._downloader.report_error(u'Invalid manifest file')
             return
 
         url_pr = compat_urllib_parse_urlparse(manifest_url)
@@ -2980,7 +2980,7 @@ def _real_extract(self, url):
                 info['title'] = mdoc.findall('./title')[0].text
                 info['url'] = baseUrl + mdoc.findall('./videoFile')[0].text
             except IndexError:
-                self._downloader.trouble(u'\nERROR: Invalid metadata XML file')
+                self._downloader.report_error(u'Invalid metadata XML file')
                 return
             info['ext'] = info['url'].rpartition('.')[2]
             return [info]

From 40634747f74d2c85b28ee33f11672378c9b30949 Mon Sep 17 00:00:00 2001
From: Johny Mo Swag <johnymo@me.com>
Date: Wed, 6 Mar 2013 21:09:55 -0800
Subject: [PATCH 05/37] Support for WorldStarHipHop.com

---
 youtube_dl/InfoExtractors.py | 63 +++++++++++++++++++++++++++++++++++-
 1 file changed, 62 insertions(+), 1 deletion(-)

diff --git a/youtube_dl/InfoExtractors.py b/youtube_dl/InfoExtractors.py
index 6b03bf307..8be2f160c 100755
--- a/youtube_dl/InfoExtractors.py
+++ b/youtube_dl/InfoExtractors.py
@@ -2557,7 +2557,7 @@ def _real_extract(self, url):
             'uploader': showName,
             'upload_date': None,
             'title': showName,
-            'ext': 'mp4',
+            'ext': 'flv',
             'thumbnail': imgUrl,
             'description': description,
             'player_url': playerUrl,
@@ -3654,6 +3654,66 @@ def _real_extract(self, url):
                   }
         return [info]
 
+class WorldStarHipHopIE(InfoExtractor):
+    _VALID_URL = r"""(http://(?:www|m).worldstar(?:candy|hiphop)\.com.*)"""
+    IE_NAME = u'WorldStarHipHop'
+
+    def _real_extract(self, url):
+        results = []
+
+        _src_url = r"""(http://hw-videos.*(?:mp4|flv))"""
+
+        webpage_src = compat_urllib_request.urlopen(str(url)).read()
+
+        mobj = re.search(_src_url, webpage_src)
+
+        if mobj is not None:
+            video_url = mobj.group()
+            if 'mp4' in video_url:
+                ext = '.mp4'
+            else:
+                ext = '.flv'
+        else:
+            video_url = None
+            ext = None
+
+        _title = r"""<title>(.*)</title>"""
+
+        mobj = re.search(_title, webpage_src)
+        
+        if mobj is not None:
+            title = mobj.group(1)
+            title = title.replace("&#039;", "")
+            title = title.replace("&#39;", "")
+            title = title.replace('Video: ', '')
+            title = title.replace('&quot;', '"')
+            title = title.replace('&amp;', 'n')
+        else:
+            title = None
+
+        _thumbnail = r"""rel="image_src" href="(.*)" />"""
+
+        mobj = re.search(_thumbnail, webpage_src)
+
+        # Getting thumbnail and if not thumbnail sets correct title for WSHH candy video.
+        if mobj is not None:
+            thumbnail = mobj.group(1)
+        else:
+            _title = r"""candytitles.*>(.*)</span>"""
+            mobj = re.search(_title, webpage_src)
+            if mobj is not None:
+                title = mobj.group(1)
+            thumbnail = None
+
+        results.append({
+            'url' : video_url,
+            'title' : title,
+            'thumbnail' : thumbnail,
+            'ext' : ext
+            })
+
+        return results
+
 class RBMARadioIE(InfoExtractor):
     _VALID_URL = r'https?://(?:www\.)?rbmaradio\.com/shows/(?P<videoID>[^/]+)$'
 
@@ -4133,6 +4193,7 @@ def gen_extractors():
         GooglePlusIE(),
         ArteTvIE(),
         NBAIE(),
+        WorldStarHipHopIE(),
         JustinTVIE(),
         FunnyOrDieIE(),
         SteamIE(),

From 61e40c88a989d31b6f06d7001f614d62f06941a5 Mon Sep 17 00:00:00 2001
From: Johny Mo Swag <johnymo@me.com>
Date: Wed, 6 Mar 2013 21:14:46 -0800
Subject: [PATCH 06/37] fixed typo

---
 youtube_dl/InfoExtractors.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/youtube_dl/InfoExtractors.py b/youtube_dl/InfoExtractors.py
index 8be2f160c..58803c48a 100755
--- a/youtube_dl/InfoExtractors.py
+++ b/youtube_dl/InfoExtractors.py
@@ -2557,7 +2557,7 @@ def _real_extract(self, url):
             'uploader': showName,
             'upload_date': None,
             'title': showName,
-            'ext': 'flv',
+            'ext': 'mp4',
             'thumbnail': imgUrl,
             'description': description,
             'player_url': playerUrl,

From b3bcca0844cc8197cbb5e1e8127b1b8164304940 Mon Sep 17 00:00:00 2001
From: Johny Mo Swag <johnymo@me.com>
Date: Thu, 7 Mar 2013 15:39:17 -0800
Subject: [PATCH 07/37] clean up

---
 youtube_dl/InfoExtractors.py | 28 +++++++++++-----------------
 1 file changed, 11 insertions(+), 17 deletions(-)

diff --git a/youtube_dl/InfoExtractors.py b/youtube_dl/InfoExtractors.py
index 58803c48a..178b0beed 100755
--- a/youtube_dl/InfoExtractors.py
+++ b/youtube_dl/InfoExtractors.py
@@ -3659,20 +3659,19 @@ class WorldStarHipHopIE(InfoExtractor):
     IE_NAME = u'WorldStarHipHop'
 
     def _real_extract(self, url):
-        results = []
-
         _src_url = r"""(http://hw-videos.*(?:mp4|flv))"""
 
         webpage_src = compat_urllib_request.urlopen(str(url)).read()
+        webpage_src = webpage_src.decode('utf-8')
 
         mobj = re.search(_src_url, webpage_src)
 
         if mobj is not None:
             video_url = mobj.group()
             if 'mp4' in video_url:
-                ext = '.mp4'
+                ext = 'mp4'
             else:
-                ext = '.flv'
+                ext = 'flv'
         else:
             video_url = None
             ext = None
@@ -3683,16 +3682,12 @@ def _real_extract(self, url):
         
         if mobj is not None:
             title = mobj.group(1)
-            title = title.replace("&#039;", "")
-            title = title.replace("&#39;", "")
-            title = title.replace('Video: ', '')
-            title = title.replace('&quot;', '"')
-            title = title.replace('&amp;', 'n')
         else:
-            title = None
+            title = 'World Start Hip Hop - %s' % time.ctime()
 
         _thumbnail = r"""rel="image_src" href="(.*)" />"""
 
+        print title
         mobj = re.search(_thumbnail, webpage_src)
 
         # Getting thumbnail and if not thumbnail sets correct title for WSHH candy video.
@@ -3705,13 +3700,12 @@ def _real_extract(self, url):
                 title = mobj.group(1)
             thumbnail = None
 
-        results.append({
-            'url' : video_url,
-            'title' : title,
-            'thumbnail' : thumbnail,
-            'ext' : ext
-            })
-
+        results = [{
+                    'url' : video_url,
+                    'title' : title,
+                    'thumbnail' : thumbnail,
+                    'ext' : ext,
+                    }]
         return results
 
 class RBMARadioIE(InfoExtractor):

From 64c78d50ccf05f34e27b652530fc8b702aa54122 Mon Sep 17 00:00:00 2001
From: Johny Mo Swag <johnymo@me.com>
Date: Thu, 7 Mar 2013 16:27:21 -0800
Subject: [PATCH 08/37] working - worldstarhiphop IE

Support for WorldStarHipHop
---
 .gitignore                   | 2 ++
 youtube_dl/InfoExtractors.py | 8 +++++---
 2 files changed, 7 insertions(+), 3 deletions(-)

diff --git a/.gitignore b/.gitignore
index 77469b8a7..328fed8bd 100644
--- a/.gitignore
+++ b/.gitignore
@@ -18,3 +18,5 @@ youtube-dl.tar.gz
 cover/
 updates_key.pem
 *.egg-info
+
+*.flv
diff --git a/youtube_dl/InfoExtractors.py b/youtube_dl/InfoExtractors.py
index 178b0beed..f69bad4f3 100755
--- a/youtube_dl/InfoExtractors.py
+++ b/youtube_dl/InfoExtractors.py
@@ -3655,7 +3655,7 @@ def _real_extract(self, url):
         return [info]
 
 class WorldStarHipHopIE(InfoExtractor):
-    _VALID_URL = r"""(http://(?:www|m).worldstar(?:candy|hiphop)\.com.*)"""
+    _VALID_URL = r'http://(?:www|m)\.worldstar(?:candy|hiphop)\.com/videos/video\.php\?v=(?P<id>.*)'
     IE_NAME = u'WorldStarHipHop'
 
     def _real_extract(self, url):
@@ -3686,8 +3686,6 @@ def _real_extract(self, url):
             title = 'World Start Hip Hop - %s' % time.ctime()
 
         _thumbnail = r"""rel="image_src" href="(.*)" />"""
-
-        print title
         mobj = re.search(_thumbnail, webpage_src)
 
         # Getting thumbnail and if not thumbnail sets correct title for WSHH candy video.
@@ -3700,7 +3698,11 @@ def _real_extract(self, url):
                 title = mobj.group(1)
             thumbnail = None
 
+        m = re.match(self._VALID_URL, url)
+        video_id = m.group('id')
+        
         results = [{
+                    'id': video_id,
                     'url' : video_url,
                     'title' : title,
                     'thumbnail' : thumbnail,

From 3b221c540640f7df9e4dc453a736dd25fe2505c4 Mon Sep 17 00:00:00 2001
From: Johny Mo Swag <johnymo@me.com>
Date: Fri, 8 Mar 2013 22:39:45 -0800
Subject: [PATCH 09/37] removed str used for other project.

---
 youtube_dl/InfoExtractors.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/youtube_dl/InfoExtractors.py b/youtube_dl/InfoExtractors.py
index f69bad4f3..c2e3c8983 100755
--- a/youtube_dl/InfoExtractors.py
+++ b/youtube_dl/InfoExtractors.py
@@ -3661,7 +3661,7 @@ class WorldStarHipHopIE(InfoExtractor):
     def _real_extract(self, url):
         _src_url = r"""(http://hw-videos.*(?:mp4|flv))"""
 
-        webpage_src = compat_urllib_request.urlopen(str(url)).read()
+        webpage_src = compat_urllib_request.urlopen(url).read()
         webpage_src = webpage_src.decode('utf-8')
 
         mobj = re.search(_src_url, webpage_src)

From 08ec0af7c69f5da0f8c75c84886694877b9b08bf Mon Sep 17 00:00:00 2001
From: Johny Mo Swag <johnymo@me.com>
Date: Fri, 8 Mar 2013 22:48:05 -0800
Subject: [PATCH 10/37] catch fatal error

---
 youtube_dl/InfoExtractors.py | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

diff --git a/youtube_dl/InfoExtractors.py b/youtube_dl/InfoExtractors.py
index c2e3c8983..a31aa759e 100755
--- a/youtube_dl/InfoExtractors.py
+++ b/youtube_dl/InfoExtractors.py
@@ -3666,6 +3666,9 @@ def _real_extract(self, url):
 
         mobj = re.search(_src_url, webpage_src)
 
+        m = re.match(self._VALID_URL, url)
+        video_id = m.group('id')
+
         if mobj is not None:
             video_url = mobj.group()
             if 'mp4' in video_url:
@@ -3673,8 +3676,8 @@ def _real_extract(self, url):
             else:
                 ext = 'flv'
         else:
-            video_url = None
-            ext = None
+            self._downloader.trouble(u'ERROR: Cannot find video url for %s' % video_id)
+            return
 
         _title = r"""<title>(.*)</title>"""
 
@@ -3697,9 +3700,6 @@ def _real_extract(self, url):
             if mobj is not None:
                 title = mobj.group(1)
             thumbnail = None
-
-        m = re.match(self._VALID_URL, url)
-        video_id = m.group('id')
         
         results = [{
                     'id': video_id,

From 51af426d89f9a9e720d70f3cac1ce24b3b8e4d8f Mon Sep 17 00:00:00 2001
From: Johny Mo Swag <johnymo@me.com>
Date: Fri, 8 Mar 2013 22:52:17 -0800
Subject: [PATCH 11/37] forgot to fix this.

---
 .gitignore | 4 +---
 1 file changed, 1 insertion(+), 3 deletions(-)

diff --git a/.gitignore b/.gitignore
index 328fed8bd..ca4e8f353 100644
--- a/.gitignore
+++ b/.gitignore
@@ -17,6 +17,4 @@ youtube-dl.tar.gz
 .coverage
 cover/
 updates_key.pem
-*.egg-info
-
-*.flv
+*.egg-info
\ No newline at end of file

From 8cc83b8dbea6e4f34f483c4a209158307df566f0 Mon Sep 17 00:00:00 2001
From: Filippo Valsorda <filippo.valsorda@gmail.com>
Date: Sat, 9 Mar 2013 10:05:43 +0100
Subject: [PATCH 12/37] Bubble up all the stack of exceptions and retry
 download tests on timeout errors

---
 test/test_download.py        | 16 +++++++++++++++-
 youtube_dl/FileDownloader.py | 16 +++++++++++++---
 youtube_dl/utils.py          |  6 +++++-
 3 files changed, 33 insertions(+), 5 deletions(-)

diff --git a/test/test_download.py b/test/test_download.py
index f1bccf58c..a8de1d002 100644
--- a/test/test_download.py
+++ b/test/test_download.py
@@ -20,6 +20,8 @@
 DEF_FILE = os.path.join(os.path.dirname(os.path.abspath(__file__)), 'tests.json')
 PARAMETERS_FILE = os.path.join(os.path.dirname(os.path.abspath(__file__)), "parameters.json")
 
+RETRIES = 3
+
 # General configuration (from __init__, not very elegant...)
 jar = compat_cookiejar.CookieJar()
 cookie_processor = compat_urllib_request.HTTPCookieProcessor(jar)
@@ -94,7 +96,19 @@ def _hook(status):
             _try_rm(tc['file'] + '.part')
             _try_rm(tc['file'] + '.info.json')
         try:
-            fd.download([test_case['url']])
+            for retry in range(1, RETRIES + 1):
+                try:
+                    fd.download([test_case['url']])
+                except (DownloadError, ExtractorError) as err:
+                    if retry == RETRIES: raise
+
+                    # Check if the exception is not a network related one
+                    if not err.exc_info[0] in (ZeroDivisionError, compat_urllib_error.URLError, socket.timeout):
+                        raise
+
+                    print('Retrying: {0} failed tries\n\n##########\n\n'.format(retry))
+                else:
+                    break
 
             for tc in test_cases:
                 if not test_case.get('params', {}).get('skip_download', False):
diff --git a/youtube_dl/FileDownloader.py b/youtube_dl/FileDownloader.py
index 3b2adf84b..a13a5f9d7 100644
--- a/youtube_dl/FileDownloader.py
+++ b/youtube_dl/FileDownloader.py
@@ -227,11 +227,21 @@ def trouble(self, message=None, tb=None):
             self.to_stderr(message)
         if self.params.get('verbose'):
             if tb is None:
-                tb_data = traceback.format_list(traceback.extract_stack())
-                tb = u''.join(tb_data)
+                if sys.exc_info()[0]:  # if .trouble has been called from an except block
+                    tb = u''
+                    if hasattr(sys.exc_info()[1], 'exc_info') and sys.exc_info()[1].exc_info[0]:
+                        tb += u''.join(traceback.format_exception(*sys.exc_info()[1].exc_info))
+                    tb += compat_str(traceback.format_exc())
+                else:
+                    tb_data = traceback.format_list(traceback.extract_stack())
+                    tb = u''.join(tb_data)
             self.to_stderr(tb)
         if not self.params.get('ignoreerrors', False):
-            raise DownloadError(message)
+            if sys.exc_info()[0] and hasattr(sys.exc_info()[1], 'exc_info') and sys.exc_info()[1].exc_info[0]:
+                exc_info = sys.exc_info()[1].exc_info
+            else:
+                exc_info = sys.exc_info()
+            raise DownloadError(message, exc_info)
         self._download_retcode = 1
 
     def report_warning(self, message):
diff --git a/youtube_dl/utils.py b/youtube_dl/utils.py
index 95bd94843..88d4ece13 100644
--- a/youtube_dl/utils.py
+++ b/youtube_dl/utils.py
@@ -435,6 +435,7 @@ def __init__(self, msg, tb=None):
         """ tb, if given, is the original traceback (so that it can be printed out). """
         super(ExtractorError, self).__init__(msg)
         self.traceback = tb
+        self.exc_info = sys.exc_info()  # preserve original exception
 
     def format_traceback(self):
         if self.traceback is None:
@@ -449,7 +450,10 @@ class DownloadError(Exception):
     configured to continue on errors. They will contain the appropriate
     error message.
     """
-    pass
+    def __init__(self, msg, exc_info=None):
+        """ exc_info, if given, is the original exception that caused the trouble (as returned by sys.exc_info()). """
+        super(DownloadError, self).__init__(msg)
+        self.exc_info = exc_info
 
 
 class SameFileError(Exception):

From c3971870616fb24c298b8f6f1bf1ec7c16c75470 Mon Sep 17 00:00:00 2001
From: Philipp Hagemeister <phihag@phihag.de>
Date: Sat, 16 Mar 2013 23:52:17 +0100
Subject: [PATCH 13/37] Spiegel: Support hash at end of URL

---
 youtube_dl/InfoExtractors.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/youtube_dl/InfoExtractors.py b/youtube_dl/InfoExtractors.py
index 44b4c4376..5339bc0cd 100755
--- a/youtube_dl/InfoExtractors.py
+++ b/youtube_dl/InfoExtractors.py
@@ -4097,7 +4097,7 @@ def _real_extract(self, url):
         return [info]
 
 class SpiegelIE(InfoExtractor):
-    _VALID_URL = r'https?://(?:www\.)?spiegel\.de/video/[^/]*-(?P<videoID>[0-9]+)(?:\.html)?$'
+    _VALID_URL = r'https?://(?:www\.)?spiegel\.de/video/[^/]*-(?P<videoID>[0-9]+)(?:\.html)?(?:#.*)$'
 
     def _real_extract(self, url):
         m = re.match(self._VALID_URL, url)

From 5011cded16d15bb03c2f172ddae81499d764e28a Mon Sep 17 00:00:00 2001
From: dodo <dodo.the.last@gmail.com>
Date: Sun, 24 Mar 2013 02:24:07 +0100
Subject: [PATCH 14/37] SoundcloudSetIE

info extractor for soundcloud sets
---
 youtube_dl/InfoExtractors.py | 82 ++++++++++++++++++++++++++++++++++++
 1 file changed, 82 insertions(+)

diff --git a/youtube_dl/InfoExtractors.py b/youtube_dl/InfoExtractors.py
index 835428f32..87a926068 100755
--- a/youtube_dl/InfoExtractors.py
+++ b/youtube_dl/InfoExtractors.py
@@ -2802,6 +2802,87 @@ def _real_extract(self, url):
             'description': info['description'],
         }]
 
+class SoundcloudSetIE(InfoExtractor):
+    """Information extractor for soundcloud.com sets
+       To access the media, the uid of the song and a stream token
+       must be extracted from the page source and the script must make
+       a request to media.soundcloud.com/crossdomain.xml. Then
+       the media can be grabbed by requesting from an url composed
+       of the stream token and uid
+     """
+
+    _VALID_URL = r'^(?:https?://)?(?:www\.)?soundcloud\.com/([\w\d-]+)/sets/([\w\d-]+)'
+    IE_NAME = u'soundcloud'
+
+    def __init__(self, downloader=None):
+        InfoExtractor.__init__(self, downloader)
+
+    def report_resolve(self, video_id):
+        """Report information extraction."""
+        self._downloader.to_screen(u'[%s] %s: Resolving id' % (self.IE_NAME, video_id))
+
+    def report_extraction(self, video_id):
+        """Report information extraction."""
+        self._downloader.to_screen(u'[%s] %s: Retrieving stream' % (self.IE_NAME, video_id))
+
+    def _real_extract(self, url):
+        mobj = re.match(self._VALID_URL, url)
+        if mobj is None:
+            self._downloader.trouble(u'ERROR: invalid URL: %s' % url)
+            return
+
+        # extract uploader (which is in the url)
+        uploader = mobj.group(1)
+        # extract simple title (uploader + slug of song title)
+        slug_title =  mobj.group(2)
+        simple_title = uploader + u'-' + slug_title
+
+        self.report_resolve('%s/sets/%s' % (uploader, slug_title))
+
+        url = 'http://soundcloud.com/%s/sets/%s' % (uploader, slug_title)
+        resolv_url = 'http://api.soundcloud.com/resolve.json?url=' + url + '&client_id=b45b1aa10f1ac2941910a7f0d10f8e28'
+        request = compat_urllib_request.Request(resolv_url)
+        try:
+            info_json_bytes = compat_urllib_request.urlopen(request).read()
+            info_json = info_json_bytes.decode('utf-8')
+        except (compat_urllib_error.URLError, compat_http_client.HTTPException, socket.error) as err:
+            self._downloader.trouble(u'ERROR: unable to download video webpage: %s' % compat_str(err))
+            return
+
+        videos = []
+        info = json.loads(info_json)
+        if 'errors' in info:
+            for err in info['errors']:
+                self._downloader.trouble(u'ERROR: unable to download video webpage: %s' % compat_str(err['error_message']))
+            return
+
+        for track in info['tracks']:
+            video_id = track['id']
+            self.report_extraction('%s/sets/%s' % (uploader, slug_title))
+
+            streams_url = 'https://api.sndcdn.com/i1/tracks/' + str(video_id) + '/streams?client_id=b45b1aa10f1ac2941910a7f0d10f8e28'
+            request = compat_urllib_request.Request(streams_url)
+            try:
+                stream_json_bytes = compat_urllib_request.urlopen(request).read()
+                stream_json = stream_json_bytes.decode('utf-8')
+            except (compat_urllib_error.URLError, compat_http_client.HTTPException, socket.error) as err:
+                self._downloader.trouble(u'ERROR: unable to download stream definitions: %s' % compat_str(err))
+                return
+
+            streams = json.loads(stream_json)
+            mediaURL = streams['http_mp3_128_url']
+
+            videos.append({
+                'id':       video_id,
+                'url':      mediaURL,
+                'uploader': track['user']['username'],
+                'upload_date':  track['created_at'],
+                'title':    track['title'],
+                'ext':      u'mp3',
+                'description': track['description'],
+            })
+        return videos
+
 
 class InfoQIE(InfoExtractor):
     """Information extractor for infoq.com"""
@@ -4187,6 +4268,7 @@ def gen_extractors():
         EscapistIE(),
         CollegeHumorIE(),
         XVideosIE(),
+        SoundcloudSetIE(),
         SoundcloudIE(),
         InfoQIE(),
         MixcloudIE(),

From db74c11d2b8ceea7ba04ef9cc3086d0209de10d4 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Jaime=20Marqui=CC=81nez=20Ferra=CC=81ndiz?=
 <jaimemf93@gmail.com>
Date: Tue, 26 Mar 2013 18:13:52 +0100
Subject: [PATCH 15/37] Add an Atom feed generator in devscripts

---
 devscripts/gh-pages/update-feed.py | 83 ++++++++++++++++++++++++++++++
 devscripts/release.sh              |  1 +
 2 files changed, 84 insertions(+)
 create mode 100755 devscripts/gh-pages/update-feed.py

diff --git a/devscripts/gh-pages/update-feed.py b/devscripts/gh-pages/update-feed.py
new file mode 100755
index 000000000..7158d7a0b
--- /dev/null
+++ b/devscripts/gh-pages/update-feed.py
@@ -0,0 +1,83 @@
+#!/usr/bin/env python3
+
+import sys
+
+import xml.etree.ElementTree as ET
+import xml.dom.minidom as minidom
+
+import datetime
+
+if len(sys.argv) <= 1:
+	print('Specify the version number as parameter')
+	sys.exit()
+version = sys.argv[1]
+
+out_file = "atom.atom"
+in_file = out_file
+
+now = datetime.datetime.now()
+now_iso = now.isoformat()
+
+atom_url = "http://www.w3.org/2005/Atom"
+
+#Some utilities functions
+def atom_tag(tag):
+	#Return a tag in the atom namespace
+	return "{{{}}}{}".format(atom_url,tag)
+	
+def atom_SubElement(parent,tag):
+	return ET.SubElement(parent,atom_tag(tag))
+	
+class YDLUpdateAtomEntry(object):
+	def __init__(self,parent,title,id ,link, downloads_link):
+		self.entry = entry = atom_SubElement(parent, "entry")
+		#We set the values:
+		atom_id = atom_SubElement(entry, "id")
+		atom_id.text = id
+		atom_title = atom_SubElement(entry, "title")
+		atom_title.text = title
+		atom_link = atom_SubElement(entry, "link")
+		atom_link.set("href", link)
+		atom_content = atom_SubElement(entry, "content")
+		atom_content.set("type", "xhtml")
+		#Here we go:
+		div = ET.SubElement(atom_content,"div")
+		div.set("xmlns", "http://www.w3.org/1999/xhtml")
+		div.text = "Downloads available at "
+		a = ET.SubElement(div, "a")
+		a.set("href", downloads_link)
+		a.text = downloads_link
+		
+		#Author info
+		atom_author = atom_SubElement(entry, "author")
+		author_name = atom_SubElement(atom_author, "name")
+		author_name.text = "The youtube-dl maintainers"
+		#If someone wants to put an email adress:
+		#author_email = atom_SubElement(atom_author, "email")
+		#author_email.text = the_email
+		
+		atom_updated = atom_SubElement(entry,"updated")
+		up = parent.find(atom_tag("updated"))
+		atom_updated.text = up.text = now_iso
+	
+	@classmethod
+	def entry(cls,parent, version):
+		update_id = "youtube-dl-{}".format(version)
+		update_title = "New version {}".format(version)
+		downloads_link = "http://youtube-dl.org/downloads/{}/".format(version)
+		#There's probably no better link
+		link = "http://rg3.github.com/youtube-dl"
+		return cls(parent, update_title, update_id, link, downloads_link)
+		
+
+atom = ET.parse(in_file)
+
+root = atom.getroot()
+
+#Otherwise when saving all tags will be prefixed with a 'ns0:'
+ET.register_namespace("atom",atom_url)
+
+update_entry = YDLUpdateAtomEntry.entry(root, version)
+
+#Find some way of pretty printing
+atom.write(out_file,encoding="utf-8",xml_declaration=True)
diff --git a/devscripts/release.sh b/devscripts/release.sh
index ee650f221..6e89d55b3 100755
--- a/devscripts/release.sh
+++ b/devscripts/release.sh
@@ -69,6 +69,7 @@ ROOT=$(pwd)
     ORIGIN_URL=$(git config --get remote.origin.url)
     cd build/gh-pages
     "$ROOT/devscripts/gh-pages/add-version.py" $version
+    "$ROOT/devscripts/gh-pages/update-feed.py" $version
     "$ROOT/devscripts/gh-pages/sign-versions.py" < "$ROOT/updates_key.pem"
     "$ROOT/devscripts/gh-pages/generate-download.py"
     "$ROOT/devscripts/gh-pages/update-copyright.py"

From 1ee97784052d9f57ec618164a2a4c502186d93b2 Mon Sep 17 00:00:00 2001
From: Chirantan Ekbote <chirantan.ekbote@gmail.com>
Date: Wed, 27 Mar 2013 15:57:11 -0400
Subject: [PATCH 16/37] Use sys.stdout.buffer instead of sys.stdout

sys.stdout defaults to text mode, we need to use the underlying buffer
instead when writing binary data.

Signed-off-by: Chirantan Ekbote <chirantan.ekbote@gmail.com>
---
 youtube_dl/utils.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/youtube_dl/utils.py b/youtube_dl/utils.py
index 95bd94843..901b5b5ad 100644
--- a/youtube_dl/utils.py
+++ b/youtube_dl/utils.py
@@ -329,7 +329,7 @@ def sanitize_open(filename, open_mode):
             if sys.platform == 'win32':
                 import msvcrt
                 msvcrt.setmode(sys.stdout.fileno(), os.O_BINARY)
-            return (sys.stdout, filename)
+            return (sys.stdout.buffer, filename)
         stream = open(encodeFilename(filename), open_mode)
         return (stream, filename)
     except (IOError, OSError) as err:

From 898280a056b577c64005647cae68caf8f16ca059 Mon Sep 17 00:00:00 2001
From: Filippo Valsorda <filippo.valsorda@gmail.com>
Date: Thu, 28 Mar 2013 13:13:03 +0100
Subject: [PATCH 17/37] use sys.stdout.buffer only on Python3

---
 youtube_dl/utils.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/youtube_dl/utils.py b/youtube_dl/utils.py
index 901b5b5ad..49af7d7c0 100644
--- a/youtube_dl/utils.py
+++ b/youtube_dl/utils.py
@@ -329,7 +329,7 @@ def sanitize_open(filename, open_mode):
             if sys.platform == 'win32':
                 import msvcrt
                 msvcrt.setmode(sys.stdout.fileno(), os.O_BINARY)
-            return (sys.stdout.buffer, filename)
+            return (sys.stdout.buffer if hasattr(sys.stdout, 'buffer') else sys.stdout, filename)
         stream = open(encodeFilename(filename), open_mode)
         return (stream, filename)
     except (IOError, OSError) as err:

From a91556fd74adf8ccfa4f923e21a0150e97d38bde Mon Sep 17 00:00:00 2001
From: Philipp Hagemeister <phihag@phihag.de>
Date: Fri, 29 Mar 2013 00:19:58 +0100
Subject: [PATCH 18/37] Add a note on MaxDownloadsReached (#732, thanks to
 CBGoodBuddy)

---
 youtube_dl/FileDownloader.py | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/youtube_dl/FileDownloader.py b/youtube_dl/FileDownloader.py
index 725d4a016..96130152d 100644
--- a/youtube_dl/FileDownloader.py
+++ b/youtube_dl/FileDownloader.py
@@ -548,6 +548,9 @@ def download(self, url_list):
                 except ExtractorError as de: # An error we somewhat expected
                     self.trouble(u'ERROR: ' + compat_str(de), de.format_traceback())
                     break
+                except MaxDownloadsReached:
+                    self.to_screen(u'[info] Maximum number of downloaded files reached.')
+                    raise
                 except Exception as e:
                     if self.params.get('ignoreerrors', False):
                         self.trouble(u'ERROR: ' + compat_str(e), tb=compat_str(traceback.format_exc()))

From 44e939514ebb37f002bc9a2663e8669c3a201da8 Mon Sep 17 00:00:00 2001
From: Johny Mo Swag <johny@johnymoswag.com>
Date: Thu, 28 Mar 2013 20:05:28 -0700
Subject: [PATCH 19/37] Added test for WorldStarHipHop

---
 test/tests.json | 9 +++++++++
 1 file changed, 9 insertions(+)

diff --git a/test/tests.json b/test/tests.json
index 7af3c2892..4190c5387 100644
--- a/test/tests.json
+++ b/test/tests.json
@@ -293,5 +293,14 @@
     "info_dict": {
         "title": "Absolute Mehrheit vom 17.02.2013 - Die Highlights, Teil 2"
     }
+  },
+  {
+    "name": "WorldStarHipHop",
+    "url": "http://www.worldstarhiphop.com/videos/video.php?v=wshh6a7q1ny0G34ZwuIO",
+    "file": "wshh6a7q1ny0G34ZwuIO.mp4",
+    "md5": "9d04de741161603bf7071bbf4e883186",
+    "info_dict": {
+        "title": "Video: KO Of The Week: MMA Fighter Gets Knocked Out By Swift Head Kick! "
+    }
   }
 ]

From 43113d92cc89cb6c9ff98a1b45512a92c71abb23 Mon Sep 17 00:00:00 2001
From: kkalpakloglou <kkalpakloglou@yahoo.com>
Date: Tue, 26 Mar 2013 22:37:08 +0200
Subject: [PATCH 20/37] Update InfoExtractors.py

---
 youtube_dl/InfoExtractors.py | 43 ++++++++++++++++++++++++++++++++++--
 1 file changed, 41 insertions(+), 2 deletions(-)

diff --git a/youtube_dl/InfoExtractors.py b/youtube_dl/InfoExtractors.py
index 8e164760b..eb1f32480 100755
--- a/youtube_dl/InfoExtractors.py
+++ b/youtube_dl/InfoExtractors.py
@@ -4160,6 +4160,46 @@ def _real_extract(self, url):
         }
         return [info]
 
+class liveleakIE(InfoExtractor):
+
+    _VALID_URL = r'^(?:http?://)?(?:\w+\.)?liveleak\.com/view\?(?:.*?)i=(?P<video_id>\d+)(?:.*)'
+    IE_NAME = u'liveleak'
+
+    def _real_extract(self, url):
+        mobj = re.match(self._VALID_URL, url)
+        if mobj is None:
+            self._downloader.trouble(u'ERROR: invalid URL: %s' % url)
+            return
+
+        video_id = mobj.group(1)
+        if video_id.endswith('/index.html'):
+            video_id = video_id[:-len('/index.html')]
+
+        webpage = self._download_webpage(url, video_id)
+
+        video_url = u'http://edge.liveleak.com/80281E/u/u/ll2_player_files/mp55/player.swf?config=http://www.liveleak.com/player?a=config%26item_token=' + video_id
+        m = re.search(r'<meta property="og:title" content="(?P<title>.*?)"', webpage)
+        if not m:
+            self._downloader.trouble(u'Cannot find video title')
+        title = unescapeHTML(m.group('title'))
+
+        m = re.search(r'<meta property="og:description" content="(?P<desc>.*?)"', webpage)
+        if m:
+            desc = unescapeHTML(m.group('desc'))
+        else:
+            desc = None
+
+
+        info = {
+            'id':  video_id,
+            'url': video_url,
+            'ext': 'mp4',
+            'title': title,
+            'description': desc
+        }
+
+        return [info]
+
 
 def gen_extractors():
     """ Return a list of an instance of every supported extractor.
@@ -4210,7 +4250,6 @@ def gen_extractors():
         TEDIE(),
         MySpassIE(),
         SpiegelIE(),
+        liveleakIE(),
         GenericIE()
     ]
-
-

From 0cd358676c06cc5915b3fb98388645833da4d7e0 Mon Sep 17 00:00:00 2001
From: Filippo Valsorda <filippo.valsorda@gmail.com>
Date: Fri, 29 Mar 2013 15:13:24 +0100
Subject: [PATCH 21/37] Rebased, fixed and extended LiveLeak.com support

close #757 - close #761
---
 test/tests.json              | 11 +++++++++++
 youtube_dl/InfoExtractors.py | 27 ++++++++++++++++++---------
 2 files changed, 29 insertions(+), 9 deletions(-)

diff --git a/test/tests.json b/test/tests.json
index fd9d33332..929d454ff 100644
--- a/test/tests.json
+++ b/test/tests.json
@@ -308,5 +308,16 @@
     "info_dict": {
         "title": "Vulkanausbruch in Ecuador: Der \"Feuerschlund\" ist wieder aktiv"
     }
+  },
+  {
+    "name": "LiveLeak",
+    "md5":  "0813c2430bea7a46bf13acf3406992f4",
+    "url":  "http://www.liveleak.com/view?i=757_1364311680",
+    "file":  "757_1364311680.mp4",
+    "info_dict": {
+        "title": "Most unlucky car accident",
+        "description": "extremely bad day for this guy..!",
+        "uploader": "ljfriel2"
+    }
   }
 ]
diff --git a/youtube_dl/InfoExtractors.py b/youtube_dl/InfoExtractors.py
index eb1f32480..45a23989a 100755
--- a/youtube_dl/InfoExtractors.py
+++ b/youtube_dl/InfoExtractors.py
@@ -4160,9 +4160,9 @@ def _real_extract(self, url):
         }
         return [info]
 
-class liveleakIE(InfoExtractor):
+class LiveLeakIE(InfoExtractor):
 
-    _VALID_URL = r'^(?:http?://)?(?:\w+\.)?liveleak\.com/view\?(?:.*?)i=(?P<video_id>\d+)(?:.*)'
+    _VALID_URL = r'^(?:http?://)?(?:\w+\.)?liveleak\.com/view\?(?:.*?)i=(?P<video_id>[\w_]+)(?:.*)'
     IE_NAME = u'liveleak'
 
     def _real_extract(self, url):
@@ -4171,17 +4171,20 @@ def _real_extract(self, url):
             self._downloader.trouble(u'ERROR: invalid URL: %s' % url)
             return
 
-        video_id = mobj.group(1)
-        if video_id.endswith('/index.html'):
-            video_id = video_id[:-len('/index.html')]
+        video_id = mobj.group('video_id')
 
         webpage = self._download_webpage(url, video_id)
 
-        video_url = u'http://edge.liveleak.com/80281E/u/u/ll2_player_files/mp55/player.swf?config=http://www.liveleak.com/player?a=config%26item_token=' + video_id
+        m = re.search(r'file: "(.*?)",', webpage)
+        if not m:
+            self._downloader.report_error(u'unable to find video url')
+            return
+        video_url = m.group(1)
+
         m = re.search(r'<meta property="og:title" content="(?P<title>.*?)"', webpage)
         if not m:
             self._downloader.trouble(u'Cannot find video title')
-        title = unescapeHTML(m.group('title'))
+        title = unescapeHTML(m.group('title')).replace('LiveLeak.com -', '').strip()
 
         m = re.search(r'<meta property="og:description" content="(?P<desc>.*?)"', webpage)
         if m:
@@ -4189,13 +4192,19 @@ def _real_extract(self, url):
         else:
             desc = None
 
+        m = re.search(r'By:.*?(\w+)</a>', webpage)
+        if m:
+            uploader = clean_html(m.group(1))
+        else:
+            uploader = None
 
         info = {
             'id':  video_id,
             'url': video_url,
             'ext': 'mp4',
             'title': title,
-            'description': desc
+            'description': desc,
+            'uploader': uploader
         }
 
         return [info]
@@ -4250,6 +4259,6 @@ def gen_extractors():
         TEDIE(),
         MySpassIE(),
         SpiegelIE(),
-        liveleakIE(),
+        LiveLeakIE(),
         GenericIE()
     ]

From 1f46c152628bdd6b97212ced758b9f83063b5820 Mon Sep 17 00:00:00 2001
From: Filippo Valsorda <filippo.valsorda@gmail.com>
Date: Fri, 29 Mar 2013 15:31:38 +0100
Subject: [PATCH 22/37] fix SpiegelIE

---
 youtube_dl/InfoExtractors.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/youtube_dl/InfoExtractors.py b/youtube_dl/InfoExtractors.py
index 45a23989a..83cb32196 100755
--- a/youtube_dl/InfoExtractors.py
+++ b/youtube_dl/InfoExtractors.py
@@ -4128,7 +4128,7 @@ def _real_extract(self, url):
         return [info]
 
 class SpiegelIE(InfoExtractor):
-    _VALID_URL = r'https?://(?:www\.)?spiegel\.de/video/[^/]*-(?P<videoID>[0-9]+)(?:\.html)?(?:#.*)$'
+    _VALID_URL = r'https?://(?:www\.)?spiegel\.de/video/[^/]*-(?P<videoID>[0-9]+)(?:\.html)?(?:#.*)?$'
 
     def _real_extract(self, url):
         m = re.match(self._VALID_URL, url)

From 7decf8951cd500acc6ed7c9ad049996957e26d73 Mon Sep 17 00:00:00 2001
From: Filippo Valsorda <filippo.valsorda@gmail.com>
Date: Fri, 29 Mar 2013 15:59:13 +0100
Subject: [PATCH 23/37] fix FunnyOrDieIE, MyVideoIE, TEDIE

---
 youtube_dl/InfoExtractors.py | 8 ++++----
 youtube_dl/utils.py          | 2 +-
 2 files changed, 5 insertions(+), 5 deletions(-)

diff --git a/youtube_dl/InfoExtractors.py b/youtube_dl/InfoExtractors.py
index 83cb32196..b3c3dbb43 100755
--- a/youtube_dl/InfoExtractors.py
+++ b/youtube_dl/InfoExtractors.py
@@ -2305,7 +2305,7 @@ def _real_extract(self,url):
         webpage = self._download_webpage(webpage_url, video_id)
 
         self.report_extraction(video_id)
-        mobj = re.search(r'<link rel=\'image_src\' href=\'(http://is[0-9].myvideo\.de/de/movie[0-9]+/[a-f0-9]+)/thumbs/.*?\.jpg\' />',
+        mobj = re.search(r'<link rel=\'image_src\' href=\'(http://is[0-9].myvideo\.de/de/movie[0-9]+/[a-f0-9]+)/thumbs/.*?\.jpg\'',
                  webpage)
         if mobj is None:
             self._downloader.report_error(u'unable to extract media URL')
@@ -3604,10 +3604,10 @@ def _real_extract(self, url):
             self._downloader.report_error(u'unable to find video information')
         video_url = unescapeHTML(m.group('url'))
 
-        m = re.search(r"class='player_page_h1'>\s+<a.*?>(?P<title>.*?)</a>", webpage)
+        m = re.search(r"<h1 class='player_page_h1'.*?>(?P<title>.*?)</h1>", webpage, flags=re.DOTALL)
         if not m:
             self._downloader.trouble(u'Cannot find video title')
-        title = unescapeHTML(m.group('title'))
+        title = clean_html(m.group('title'))
 
         m = re.search(r'<meta property="og:description" content="(?P<desc>.*?)"', webpage)
         if m:
@@ -4051,7 +4051,7 @@ def _talk_info(self, url, video_id=0):
         videoName=m.group('name')
         webpage=self._download_webpage(url, video_id, 'Downloading \"%s\" page' % videoName)
         # If the url includes the language we get the title translated
-        title_RE=r'<h1><span id="altHeadline" >(?P<title>.*)</span></h1>'
+        title_RE=r'<span id="altHeadline" >(?P<title>.*)</span>'
         title=re.search(title_RE, webpage).group('title')
         info_RE=r'''<script\ type="text/javascript">var\ talkDetails\ =(.*?)
                         "id":(?P<videoID>[\d]+).*?
diff --git a/youtube_dl/utils.py b/youtube_dl/utils.py
index 49af7d7c0..d366c4173 100644
--- a/youtube_dl/utils.py
+++ b/youtube_dl/utils.py
@@ -311,7 +311,7 @@ def clean_html(html):
     html = re.sub('<.*?>', '', html)
     # Replace html entities
     html = unescapeHTML(html)
-    return html
+    return html.strip()
 
 
 def sanitize_open(filename, open_mode):

From 6060788083df366dae1cd75d4c1eac8e46918765 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Jaime=20Marqui=CC=81nez=20Ferra=CC=81ndiz?=
 <jaimemf93@gmail.com>
Date: Fri, 29 Mar 2013 19:42:33 +0100
Subject: [PATCH 24/37] Write a new feed each time, reading from versions.json

---
 devscripts/gh-pages/update-feed.py | 110 +++++++++++------------------
 devscripts/release.sh              |   2 +-
 2 files changed, 43 insertions(+), 69 deletions(-)

diff --git a/devscripts/gh-pages/update-feed.py b/devscripts/gh-pages/update-feed.py
index 7158d7a0b..f8b9fb594 100755
--- a/devscripts/gh-pages/update-feed.py
+++ b/devscripts/gh-pages/update-feed.py
@@ -1,83 +1,57 @@
 #!/usr/bin/env python3
 
-import sys
-
-import xml.etree.ElementTree as ET
-import xml.dom.minidom as minidom
-
 import datetime
 
-if len(sys.argv) <= 1:
-	print('Specify the version number as parameter')
-	sys.exit()
-version = sys.argv[1]
+import textwrap
 
-out_file = "atom.atom"
-in_file = out_file
+import json
+
+atom_template=textwrap.dedent("""\
+								<?xml version='1.0' encoding='utf-8'?>
+									<atom:feed xmlns:atom="http://www.w3.org/2005/Atom">
+									<atom:subtitle>Updates feed.</atom:subtitle>
+									<atom:id>youtube-dl-updates-feed</atom:id>
+									<atom:updated>@TIMESTAMP@</atom:updated>
+									@ENTRIES@
+								</atom:feed>""")
+
+entry_template=textwrap.dedent("""
+								<atom:entry>
+									<atom:id>youtube-dl-@VERSION@</atom:id>
+									<atom:title>New version @VERSION@</atom:title>
+									<atom:link href="http://rg3.github.com/youtube-dl" />
+									<atom:content type="xhtml">
+										<div xmlns="http://www.w3.org/1999/xhtml">
+											Downloads available at <a href="http://youtube-dl.org/downloads/@VERSION@/">http://youtube-dl.org/downloads/@VERSION@/</a>
+										</div>
+									</atom:content>
+									<atom:author>
+										<atom:name>The youtube-dl maintainers</atom:name>
+									</atom:author>
+									<atom:updated>@TIMESTAMP@</atom:updated>
+								</atom:entry>
+								""")
 
 now = datetime.datetime.now()
 now_iso = now.isoformat()
 
-atom_url = "http://www.w3.org/2005/Atom"
+atom_template = atom_template.replace('@TIMESTAMP@',now_iso)
 
-#Some utilities functions
-def atom_tag(tag):
-	#Return a tag in the atom namespace
-	return "{{{}}}{}".format(atom_url,tag)
-	
-def atom_SubElement(parent,tag):
-	return ET.SubElement(parent,atom_tag(tag))
-	
-class YDLUpdateAtomEntry(object):
-	def __init__(self,parent,title,id ,link, downloads_link):
-		self.entry = entry = atom_SubElement(parent, "entry")
-		#We set the values:
-		atom_id = atom_SubElement(entry, "id")
-		atom_id.text = id
-		atom_title = atom_SubElement(entry, "title")
-		atom_title.text = title
-		atom_link = atom_SubElement(entry, "link")
-		atom_link.set("href", link)
-		atom_content = atom_SubElement(entry, "content")
-		atom_content.set("type", "xhtml")
-		#Here we go:
-		div = ET.SubElement(atom_content,"div")
-		div.set("xmlns", "http://www.w3.org/1999/xhtml")
-		div.text = "Downloads available at "
-		a = ET.SubElement(div, "a")
-		a.set("href", downloads_link)
-		a.text = downloads_link
-		
-		#Author info
-		atom_author = atom_SubElement(entry, "author")
-		author_name = atom_SubElement(atom_author, "name")
-		author_name.text = "The youtube-dl maintainers"
-		#If someone wants to put an email adress:
-		#author_email = atom_SubElement(atom_author, "email")
-		#author_email.text = the_email
-		
-		atom_updated = atom_SubElement(entry,"updated")
-		up = parent.find(atom_tag("updated"))
-		atom_updated.text = up.text = now_iso
-	
-	@classmethod
-	def entry(cls,parent, version):
-		update_id = "youtube-dl-{}".format(version)
-		update_title = "New version {}".format(version)
-		downloads_link = "http://youtube-dl.org/downloads/{}/".format(version)
-		#There's probably no better link
-		link = "http://rg3.github.com/youtube-dl"
-		return cls(parent, update_title, update_id, link, downloads_link)
-		
+entries=[]
 
-atom = ET.parse(in_file)
+versions_info = json.load(open('update/versions.json'))
+versions = list(versions_info['versions'].keys())
+versions.sort()
 
-root = atom.getroot()
+for v in versions:
+	entry = entry_template.replace('@TIMESTAMP@',v.replace('.','-'))
+	entry = entry.replace('@VERSION@',v)
+	entries.append(entry)
 
-#Otherwise when saving all tags will be prefixed with a 'ns0:'
-ET.register_namespace("atom",atom_url)
+entries_str = textwrap.indent(''.join(entries), '\t')
+atom_template = atom_template.replace('@ENTRIES@', entries_str)
+
+with open('update/atom.atom','w',encoding='utf-8') as atom_file:
+	atom_file.write(atom_template)
 
-update_entry = YDLUpdateAtomEntry.entry(root, version)
 
-#Find some way of pretty printing
-atom.write(out_file,encoding="utf-8",xml_declaration=True)
diff --git a/devscripts/release.sh b/devscripts/release.sh
index 6e89d55b3..b2a91f817 100755
--- a/devscripts/release.sh
+++ b/devscripts/release.sh
@@ -69,7 +69,7 @@ ROOT=$(pwd)
     ORIGIN_URL=$(git config --get remote.origin.url)
     cd build/gh-pages
     "$ROOT/devscripts/gh-pages/add-version.py" $version
-    "$ROOT/devscripts/gh-pages/update-feed.py" $version
+    "$ROOT/devscripts/gh-pages/update-feed.py"
     "$ROOT/devscripts/gh-pages/sign-versions.py" < "$ROOT/updates_key.pem"
     "$ROOT/devscripts/gh-pages/generate-download.py"
     "$ROOT/devscripts/gh-pages/update-copyright.py"

From 1bf2801e6a6b76976de6651478893ea1619cf869 Mon Sep 17 00:00:00 2001
From: Philipp Hagemeister <phihag@phihag.de>
Date: Fri, 29 Mar 2013 21:22:57 +0100
Subject: [PATCH 25/37] release 2013.03.29

---
 README.md             | 14 ++++++++++----
 youtube_dl/version.py |  2 +-
 2 files changed, 11 insertions(+), 5 deletions(-)

diff --git a/README.md b/README.md
index 7c09d0c0d..338b6133f 100644
--- a/README.md
+++ b/README.md
@@ -18,7 +18,7 @@ # OPTIONS
     --version                print program version and exit
     -U, --update             update this program to latest version
     -i, --ignore-errors      continue on download errors
-    -r, --rate-limit LIMIT   download rate limit (e.g. 50k or 44.6m)
+    -r, --rate-limit LIMIT   maximum download rate (e.g. 50k or 44.6m)
     -R, --retries RETRIES    number of retries (default is 10)
     --buffer-size SIZE       size of download buffer (e.g. 1024 or 16k) (default
                              is 1024)
@@ -97,10 +97,16 @@ ## Video Format Options:
                              requested
     --max-quality FORMAT     highest quality format to download
     -F, --list-formats       list all available formats (currently youtube only)
-    --write-srt              write video closed captions to a .srt file
+    --write-sub              write subtitle file (currently youtube only)
+    --only-sub               downloads only the subtitles (no video)
+    --all-subs               downloads all the available subtitles of the video
                              (currently youtube only)
-    --srt-lang LANG          language of the closed captions to download
-                             (optional) use IETF language tags like 'en'
+    --list-subs              lists all available subtitles for the video
+                             (currently youtube only)
+    --sub-format LANG        subtitle format [srt/sbv] (default=srt) (currently
+                             youtube only)
+    --sub-lang LANG          language of the subtitles to download (optional)
+                             use IETF language tags like 'en'
 
 ## Authentication Options:
     -u, --username USERNAME  account username
diff --git a/youtube_dl/version.py b/youtube_dl/version.py
index ce8f6ca23..cb2270001 100644
--- a/youtube_dl/version.py
+++ b/youtube_dl/version.py
@@ -1,2 +1,2 @@
 
-__version__ = '2013.02.25'
+__version__ = '2013.03.29'

From c238be3e3a5f9511f7ec43f6244e109113490a0a Mon Sep 17 00:00:00 2001
From: Philipp Hagemeister <phihag@phihag.de>
Date: Fri, 29 Mar 2013 21:41:20 +0100
Subject: [PATCH 26/37] Correct feed title

---
 devscripts/gh-pages/update-feed.py | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/devscripts/gh-pages/update-feed.py b/devscripts/gh-pages/update-feed.py
index f8b9fb594..79e94a098 100755
--- a/devscripts/gh-pages/update-feed.py
+++ b/devscripts/gh-pages/update-feed.py
@@ -8,8 +8,8 @@
 
 atom_template=textwrap.dedent("""\
 								<?xml version='1.0' encoding='utf-8'?>
-									<atom:feed xmlns:atom="http://www.w3.org/2005/Atom">
-									<atom:subtitle>Updates feed.</atom:subtitle>
+								<atom:feed xmlns:atom="http://www.w3.org/2005/Atom">
+									<atom:title>youtube-dl releases</atom:title>
 									<atom:id>youtube-dl-updates-feed</atom:id>
 									<atom:updated>@TIMESTAMP@</atom:updated>
 									@ENTRIES@

From fbbdf475b1a534389585d696db5e6c8b3fd212fb Mon Sep 17 00:00:00 2001
From: Philipp Hagemeister <phihag@phihag.de>
Date: Fri, 29 Mar 2013 21:44:06 +0100
Subject: [PATCH 27/37] Different feed file name

---
 devscripts/gh-pages/update-feed.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/devscripts/gh-pages/update-feed.py b/devscripts/gh-pages/update-feed.py
index 79e94a098..e299429c1 100755
--- a/devscripts/gh-pages/update-feed.py
+++ b/devscripts/gh-pages/update-feed.py
@@ -51,7 +51,7 @@
 entries_str = textwrap.indent(''.join(entries), '\t')
 atom_template = atom_template.replace('@ENTRIES@', entries_str)
 
-with open('update/atom.atom','w',encoding='utf-8') as atom_file:
+with open('update/releases.atom','w',encoding='utf-8') as atom_file:
 	atom_file.write(atom_template)
 
 

From 0fb375640990d5f1038000dc7937cd6cba6dfeb2 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Jaime=20Marqui=CC=81nez=20Ferra=CC=81ndiz?=
 <jaimemf93@gmail.com>
Date: Sat, 30 Mar 2013 14:11:33 +0100
Subject: [PATCH 28/37] Fix crash when subtitles are not found

---
 youtube_dl/InfoExtractors.py | 8 +++++++-
 1 file changed, 7 insertions(+), 1 deletion(-)

diff --git a/youtube_dl/InfoExtractors.py b/youtube_dl/InfoExtractors.py
index 2881ae67c..71f57b7c9 100755
--- a/youtube_dl/InfoExtractors.py
+++ b/youtube_dl/InfoExtractors.py
@@ -282,8 +282,14 @@ def _request_subtitle(self, sub_lang, sub_name, video_id, format):
         return (None, sub_lang, sub)
 
     def _extract_subtitle(self, video_id):
+        """
+        Return a list with a tuple:
+        [(error_message, sub_lang, sub)]
+        """
         sub_lang_list = self._get_available_subtitles(video_id)
         sub_format = self._downloader.params.get('subtitlesformat')
+        if  isinstance(sub_lang_list,tuple): #There was some error, it didn't get the available subtitles
+            return [(sub_lang_list[0], None, None)]
         if self._downloader.params.get('subtitleslang', False):
             sub_lang = self._downloader.params.get('subtitleslang')
         elif 'en' in sub_lang_list:
@@ -291,7 +297,7 @@ def _extract_subtitle(self, video_id):
         else:
             sub_lang = list(sub_lang_list.keys())[0]
         if not sub_lang in sub_lang_list:
-            return (u'WARNING: no closed captions found in the specified language "%s"' % sub_lang, None)
+            return [(u'WARNING: no closed captions found in the specified language "%s"' % sub_lang, None, None)]
 
         subtitle = self._request_subtitle(sub_lang, sub_lang_list[sub_lang].encode('utf-8'), video_id, sub_format)
         return [subtitle]

From 6a205c8876eda3b34bd3b1f1f875bbd1b4ebdcbc Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Jaime=20Marqui=CC=81nez=20Ferra=CC=81ndiz?=
 <jaimemf93@gmail.com>
Date: Sat, 30 Mar 2013 14:17:12 +0100
Subject: [PATCH 29/37] More fixes on subtitles errors handling

---
 youtube_dl/InfoExtractors.py | 8 ++++++--
 1 file changed, 6 insertions(+), 2 deletions(-)

diff --git a/youtube_dl/InfoExtractors.py b/youtube_dl/InfoExtractors.py
index 71f57b7c9..8caace3af 100755
--- a/youtube_dl/InfoExtractors.py
+++ b/youtube_dl/InfoExtractors.py
@@ -265,6 +265,10 @@ def _list_available_subtitles(self, video_id):
         self.report_video_subtitles_available(video_id, sub_lang_list)
 
     def _request_subtitle(self, sub_lang, sub_name, video_id, format):
+        """
+        Return tuple:
+        (error_message, sub_lang, sub)
+        """
         self.report_video_subtitles_request(video_id, sub_lang, format)
         params = compat_urllib_parse.urlencode({
             'lang': sub_lang,
@@ -276,9 +280,9 @@ def _request_subtitle(self, sub_lang, sub_name, video_id, format):
         try:
             sub = compat_urllib_request.urlopen(url).read().decode('utf-8')
         except (compat_urllib_error.URLError, compat_http_client.HTTPException, socket.error) as err:
-            return (u'WARNING: unable to download video subtitles: %s' % compat_str(err), None)
+            return (u'WARNING: unable to download video subtitles: %s' % compat_str(err), None, None)
         if not sub:
-            return (u'WARNING: Did not fetch video subtitles', None)
+            return (u'WARNING: Did not fetch video subtitles', None, None)
         return (None, sub_lang, sub)
 
     def _extract_subtitle(self, video_id):

From fa41fbd3189b36300a4558b722dea5857a7e4214 Mon Sep 17 00:00:00 2001
From: Filippo Valsorda <filippo.valsorda@gmail.com>
Date: Sun, 31 Mar 2013 03:02:05 +0200
Subject: [PATCH 30/37] don't catch YT user URLs in YoutubePlaylistIE (fix
 #754, fix #763)

---
 youtube_dl/InfoExtractors.py | 6 ++----
 1 file changed, 2 insertions(+), 4 deletions(-)

diff --git a/youtube_dl/InfoExtractors.py b/youtube_dl/InfoExtractors.py
index 2881ae67c..cca7e1b54 100755
--- a/youtube_dl/InfoExtractors.py
+++ b/youtube_dl/InfoExtractors.py
@@ -1710,9 +1710,7 @@ class YoutubePlaylistIE(InfoExtractor):
                         (?:
                            (?:course|view_play_list|my_playlists|artist|playlist|watch)
                            \? (?:.*?&)*? (?:p|a|list)=
-                        |  user/.*?/user/
                         |  p/
-                        |  user/.*?#[pg]/c/
                         )
                         ((?:PL|EC|UU)?[0-9A-Za-z-_]{10,})
                         .*
@@ -3796,7 +3794,7 @@ def _real_extract(self, url):
         _title = r"""<title>(.*)</title>"""
 
         mobj = re.search(_title, webpage_src)
-        
+
         if mobj is not None:
             title = mobj.group(1)
         else:
@@ -3814,7 +3812,7 @@ def _real_extract(self, url):
             if mobj is not None:
                 title = mobj.group(1)
             thumbnail = None
-        
+
         results = [{
                     'id': video_id,
                     'url' : video_url,

From f375d4b7de17b1ac3d8fda9d4f071e1e55be1963 Mon Sep 17 00:00:00 2001
From: Filippo Valsorda <filippo.valsorda@gmail.com>
Date: Sun, 31 Mar 2013 03:12:28 +0200
Subject: [PATCH 31/37] import all IEs when testing to resemble more closely
 the real env

---
 test/test_download.py | 5 ++---
 1 file changed, 2 insertions(+), 3 deletions(-)

diff --git a/test/test_download.py b/test/test_download.py
index a8de1d002..e29092c45 100644
--- a/test/test_download.py
+++ b/test/test_download.py
@@ -81,9 +81,8 @@ def test_template(self):
         params.update(test_case.get('params', {}))
 
         fd = FileDownloader(params)
-        fd.add_info_extractor(ie())
-        for ien in test_case.get('add_ie', []):
-            fd.add_info_extractor(getattr(youtube_dl.InfoExtractors, ien + 'IE')())
+        for ie in youtube_dl.InfoExtractors.gen_extractors():
+            fd.add_info_extractor(ie)
         finished_hook_called = set()
         def _hook(status):
             if status['status'] == 'finished':

From 90a99c1b5e01b86c793fb9ecb80a2521d8ae0f79 Mon Sep 17 00:00:00 2001
From: Filippo Valsorda <filippo.valsorda@gmail.com>
Date: Sun, 31 Mar 2013 03:29:34 +0200
Subject: [PATCH 32/37] retry on UnavailableVideoError

---
 test/test_download.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/test/test_download.py b/test/test_download.py
index e29092c45..59a6e1498 100644
--- a/test/test_download.py
+++ b/test/test_download.py
@@ -102,7 +102,7 @@ def _hook(status):
                     if retry == RETRIES: raise
 
                     # Check if the exception is not a network related one
-                    if not err.exc_info[0] in (ZeroDivisionError, compat_urllib_error.URLError, socket.timeout):
+                    if not err.exc_info[0] in (compat_urllib_error.URLError, socket.timeout, UnavailableVideoError):
                         raise
 
                     print('Retrying: {0} failed tries\n\n##########\n\n'.format(retry))

From bc97f6d60ceacdaffe6a6dbfd403a08ce06229eb Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Jaime=20Marqui=CC=81nez=20Ferra=CC=81ndiz?=
 <jaimemf93@gmail.com>
Date: Sun, 31 Mar 2013 12:10:12 +0200
Subject: [PATCH 33/37] Use report_error in subtitles error handling

---
 youtube_dl/InfoExtractors.py | 14 +++++++-------
 1 file changed, 7 insertions(+), 7 deletions(-)

diff --git a/youtube_dl/InfoExtractors.py b/youtube_dl/InfoExtractors.py
index 8caace3af..13b1f99b5 100755
--- a/youtube_dl/InfoExtractors.py
+++ b/youtube_dl/InfoExtractors.py
@@ -253,11 +253,11 @@ def _get_available_subtitles(self, video_id):
         try:
             sub_list = compat_urllib_request.urlopen(request).read().decode('utf-8')
         except (compat_urllib_error.URLError, compat_http_client.HTTPException, socket.error) as err:
-            return (u'WARNING: unable to download video subtitles: %s' % compat_str(err), None)
+            return (u'unable to download video subtitles: %s' % compat_str(err), None)
         sub_lang_list = re.findall(r'name="([^"]*)"[^>]+lang_code="([\w\-]+)"', sub_list)
         sub_lang_list = dict((l[1], l[0]) for l in sub_lang_list)
         if not sub_lang_list:
-            return (u'WARNING: video doesn\'t have subtitles', None)
+            return (u'video doesn\'t have subtitles', None)
         return sub_lang_list
 
     def _list_available_subtitles(self, video_id):
@@ -280,9 +280,9 @@ def _request_subtitle(self, sub_lang, sub_name, video_id, format):
         try:
             sub = compat_urllib_request.urlopen(url).read().decode('utf-8')
         except (compat_urllib_error.URLError, compat_http_client.HTTPException, socket.error) as err:
-            return (u'WARNING: unable to download video subtitles: %s' % compat_str(err), None, None)
+            return (u'unable to download video subtitles: %s' % compat_str(err), None, None)
         if not sub:
-            return (u'WARNING: Did not fetch video subtitles', None, None)
+            return (u'Did not fetch video subtitles', None, None)
         return (None, sub_lang, sub)
 
     def _extract_subtitle(self, video_id):
@@ -301,7 +301,7 @@ def _extract_subtitle(self, video_id):
         else:
             sub_lang = list(sub_lang_list.keys())[0]
         if not sub_lang in sub_lang_list:
-            return [(u'WARNING: no closed captions found in the specified language "%s"' % sub_lang, None, None)]
+            return [(u'no closed captions found in the specified language "%s"' % sub_lang, None, None)]
 
         subtitle = self._request_subtitle(sub_lang, sub_lang_list[sub_lang].encode('utf-8'), video_id, sub_format)
         return [subtitle]
@@ -542,14 +542,14 @@ def _real_extract(self, url):
             if video_subtitles:
                 (sub_error, sub_lang, sub) = video_subtitles[0]
                 if sub_error:
-                    self._downloader.trouble(sub_error)
+                    self._downloader.report_error(sub_error)
 
         if self._downloader.params.get('allsubtitles', False):
             video_subtitles = self._extract_all_subtitles(video_id)
             for video_subtitle in video_subtitles:
                 (sub_error, sub_lang, sub) = video_subtitle
                 if sub_error:
-                    self._downloader.trouble(sub_error)
+                    self._downloader.report_error(sub_error)
 
         if self._downloader.params.get('listsubtitles', False):
             sub_lang_list = self._list_available_subtitles(video_id)

From ef767f9fd5e852940de999da4962657bca452c0d Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Jaime=20Marqui=CC=81nez=20Ferra=CC=81ndiz?=
 <jaimemf93@gmail.com>
Date: Sun, 31 Mar 2013 12:19:13 +0200
Subject: [PATCH 34/37] Fix crash when subtitles are not found and the option
 --all-subs is given

---
 youtube_dl/InfoExtractors.py | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/youtube_dl/InfoExtractors.py b/youtube_dl/InfoExtractors.py
index 13b1f99b5..1bd9e25c4 100755
--- a/youtube_dl/InfoExtractors.py
+++ b/youtube_dl/InfoExtractors.py
@@ -309,6 +309,8 @@ def _extract_subtitle(self, video_id):
     def _extract_all_subtitles(self, video_id):
         sub_lang_list = self._get_available_subtitles(video_id)
         sub_format = self._downloader.params.get('subtitlesformat')
+        if  isinstance(sub_lang_list,tuple): #There was some error, it didn't get the available subtitles
+            return [(sub_lang_list[0], None, None)]
         subtitles = []
         for sub_lang in sub_lang_list:
             subtitle = self._request_subtitle(sub_lang, sub_lang_list[sub_lang].encode('utf-8'), video_id, sub_format)

From bafeed9f5dd4613c6b0597f1328968658abb7cb9 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Jaime=20Marqui=CC=81nez=20Ferra=CC=81ndiz?=
 <jaimemf93@gmail.com>
Date: Sun, 31 Mar 2013 12:21:35 +0200
Subject: [PATCH 35/37] Don't crash in FileDownloader if subtitles couldn't be
 found and errors are ignored

---
 youtube_dl/FileDownloader.py | 38 +++++++++++++++++++++---------------
 1 file changed, 22 insertions(+), 16 deletions(-)

diff --git a/youtube_dl/FileDownloader.py b/youtube_dl/FileDownloader.py
index d82aa2d83..7c5a52be1 100644
--- a/youtube_dl/FileDownloader.py
+++ b/youtube_dl/FileDownloader.py
@@ -485,14 +485,17 @@ def process_info(self, info_dict):
             subtitle = info_dict['subtitles'][0]
             (sub_error, sub_lang, sub) = subtitle
             sub_format = self.params.get('subtitlesformat')
-            try:
-                sub_filename = filename.rsplit('.', 1)[0] + u'.' + sub_lang + u'.' + sub_format
-                self.report_writesubtitles(sub_filename)
-                with io.open(encodeFilename(sub_filename), 'w', encoding='utf-8') as subfile:
-                    subfile.write(sub)
-            except (OSError, IOError):
-                self.report_error(u'Cannot write subtitles file ' + descfn)
-                return
+            if sub_error:
+                self.report_warning("Some error while getting the subtitles")
+            else:
+                try:
+                    sub_filename = filename.rsplit('.', 1)[0] + u'.' + sub_lang + u'.' + sub_format
+                    self.report_writesubtitles(sub_filename)
+                    with io.open(encodeFilename(sub_filename), 'w', encoding='utf-8') as subfile:
+                        subfile.write(sub)
+                except (OSError, IOError):
+                    self.report_error(u'Cannot write subtitles file ' + descfn)
+                    return
             if self.params.get('onlysubtitles', False):
                 return 
 
@@ -501,14 +504,17 @@ def process_info(self, info_dict):
             sub_format = self.params.get('subtitlesformat')
             for subtitle in subtitles:
                 (sub_error, sub_lang, sub) = subtitle
-                try:
-                    sub_filename = filename.rsplit('.', 1)[0] + u'.' + sub_lang + u'.' + sub_format
-                    self.report_writesubtitles(sub_filename)
-                    with io.open(encodeFilename(sub_filename), 'w', encoding='utf-8') as subfile:
-                            subfile.write(sub)
-                except (OSError, IOError):
-                    self.trouble(u'ERROR: Cannot write subtitles file ' + descfn)
-                    return
+                if sub_error:
+                    self.report_warning("Some error while getting the subtitles")
+                else:
+                    try:
+                        sub_filename = filename.rsplit('.', 1)[0] + u'.' + sub_lang + u'.' + sub_format
+                        self.report_writesubtitles(sub_filename)
+                        with io.open(encodeFilename(sub_filename), 'w', encoding='utf-8') as subfile:
+                                subfile.write(sub)
+                    except (OSError, IOError):
+                        self.trouble(u'ERROR: Cannot write subtitles file ' + descfn)
+                        return
             if self.params.get('onlysubtitles', False):
                 return 
 

From 37cd9f522f4da057f098b584e46e44e2b512a254 Mon Sep 17 00:00:00 2001
From: Philipp Hagemeister <phihag@phihag.de>
Date: Mon, 1 Apr 2013 23:43:20 +0200
Subject: [PATCH 36/37] Restore youtube-dl (update) binary (#770)

---
 youtube-dl | Bin 59506 -> 3447 bytes
 1 file changed, 0 insertions(+), 0 deletions(-)

diff --git a/youtube-dl b/youtube-dl
index ef9f332410cdea77f0bc2f47432a1a0a29c66786..e6f05c17327ed58f8db66e6dc7d2a38380355d61 100755
GIT binary patch
literal 3447
zcmbVOdvDt|5dVAr6qgpAq}5eK$&%#&DbS%Q)@^8tq+Ky2fk8<pTdhoKBvsq{^gHTh
zH*MBoK?L)0?>qkP9-o{xN}eW#I7RUp>b+i9VlpW<btN^Zy_!O$hV4gHi7BkPT9-vK
znP|B`n*jaw)Qv3Z+?DuOgGvKekXD<T>t%Pb>@Oy`OR?7Qy47(ZWhKwxF}!V6ga5Te
z|6x&+40Di*FF&I!^1Z!5rT7Y`po*2?x{<W}gnOs6Gndr{l$K4Z2b*i2erh$gcfD)F
zrCM`8j1Jcnj^T>*siG3gLgZCTU<^s@U9YK)N)E?VH{KnbpM!q}63H+DyOz&TVyW<O
z?4n4k3~j6Ax)98AS~{*2N^R?Xjf0ntk=Gt1wq-d^N0^jV`e~_(zY)&CYk38&C<<gj
zyWOsf5<zq^G5U{Ko}L36?Go_(`8mYxehetds;jMC2yKsNQ(%$PM*4=`b-&(SXO86C
zWwO_(i0|fD|Hyo>W2AKp(R%Am!6e9j^z);ml){hT?Owg={WT7ZvK}zlKJxGxlql>`
zmE*uqlsM~l=XsU`PtDqL+>cdpOw@*;$PbEcyfgm}PR<8bVy8@vNqogArC-HuH1ozk
z>q0>yMWqKJq`wdc9sgO{D3{`v;m#i2ah|d-6&)y*=2EL|q1PRG;N9*5Mj!opFX@Zu
zTios<+Q+n>#l}V2hx8lJH>1z*&OCEw_~^{1DE{|2u*Jc?(KZv-?&*z{?q<b`Fvb3s
z<o-FmlMPNL^h8~yGnCTZ%0i>vSick}@BtxRbFsn<vVstxNE%Jg7dA+EmjM?U<zWl^
zs?kk?&$1E(Vx~Y>(9{{%2!&Qy=1>WQO(hX@u|fA%(Chq$%6IER!L}$%qA&M^n01YU
z)+xGhO=wAHwIrwl6dI+`va0BsE-NYbkXLlJCLOYBk`hlIQuE5-nX%iz@(Oj!L{QFU
zLGP_YG_C8i(^I($+!f`zNnFC@(}SO<S+x~q#WQ!UH|4ag#+K3OCk_Iux>AL%<et23
z4e4<I2lIjoQ8$#70ny*^4c^D|VDiI2HOUEg1kn%_n4odF`fM<1^8W417w;~X@2`HR
zn@8*KncQXM^wH#xi>vF`mv4H;BPmb8`kf?RzgzYs*5udg2MBwNR<7x8R&UGo^6L7<
z^0$jW$spU?Ewac%oMmwydtt!*JWE)}BR`Ml$s$a$C}MM3u`FlvXdZ<b3qm&I9&N)}
zl4iaa&izH0hDnsOEC@5sqxsBFgFH_cJod8y8H?kHrM@>`EJ7Z80YetDERKS7vGC^@
zc(ZUGC28zM3!i?_Tg>7`l&3jkNfhM)`U~`C81Om61!pV_WBTVQau&}#j%hH@(||aV
zC?N~em~ocQ*ldPgkYp_N7|Ss7G04gIc@p^Z%!_A!l;a|pLKKF<+@Zms1FVX&m!?#~
z_K;IEC%7M$m%sHL&?Fdlg|@AWtE<baGpa0TUnJBhH-$3YQ&Hi<6J@~@7{ri@ajY0J
z(>7U3#5bo2mxhaqUY9*2*r5T0XSU;J*tO9{=g;E4i{2M$a_*Y)SN0cILrHhNY4oKT
zoJqO3wKP<T=7iV-E1`E@x$w3`uFUJ*17DeYYUC(gGNF&2HA0<b0DoX_{d`EHd5;5O
z8!aG+F}=gcB3L8HNC`ZeT4UzIi-g9vLadC^Q5l7BkkG2SIkMx9CaLn@u6xsuX00}M
zS+l9{#f~~PDPPjSq0S8`JL5ppXX2=pPoaCY<9oYbJ!8bb_W$4)MWPU&d0E`^eA2u7
zwc|q^th<|G*@wjBN@?qkU}-EwDzWu<>#vt{V-Wz8*kS$=xJ@fUd7(*y5!9DwI~=t8
zw5${!K-7MH*<$DvF0b2#W5!=<X!j~(D8)u_>Jg@g3{c+I8x7#SMN|TlgB43N<B}=;
zsO$EP_CVmcYupX(wyoIFgN~QF^F3eL-96jB$l72Q6{&gUt!A>7I+Q8j4cF=V%Yr=w
z-i#;EzU~1ZreJLonv*Cb)T{GOuNeW&u5bBAz6_n|{|B`qUpw4N8!1g1kHY$m*8h?w
VgcEqv4HG~(0kRQCgGDzp`~&H2U`7A{

literal 59506
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
GxBmd(Qkxk7


From c2b293ba3021d323a3d8ccbabeb3ebb993b276aa Mon Sep 17 00:00:00 2001
From: Philipp Hagemeister <phihag@phihag.de>
Date: Wed, 3 Apr 2013 19:43:53 +0200
Subject: [PATCH 37/37] release 2013.04.03

---
 youtube_dl/version.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/youtube_dl/version.py b/youtube_dl/version.py
index cb2270001..c433e2eaa 100644
--- a/youtube_dl/version.py
+++ b/youtube_dl/version.py
@@ -1,2 +1,2 @@
 
-__version__ = '2013.03.29'
+__version__ = '2013.04.03'