From 2e5d60b7db7020b726cd54ee4cad8f2afbd1479d Mon Sep 17 00:00:00 2001
From: Ismael Mejia <iemejia@gmail.com>
Date: Thu, 21 Feb 2013 20:51:35 +0100
Subject: [PATCH 001/221] Removed conversion from youtube closed caption format
 to srt since youtube api supports the 'srt' format

---
 test/test_youtube_subtitles.py |  4 ++--
 youtube_dl/InfoExtractors.py   | 24 ++++--------------------
 2 files changed, 6 insertions(+), 22 deletions(-)

diff --git a/test/test_youtube_subtitles.py b/test/test_youtube_subtitles.py
index 5d3566a35..ff09ea459 100644
--- a/test/test_youtube_subtitles.py
+++ b/test/test_youtube_subtitles.py
@@ -43,7 +43,7 @@ class TestYoutubeSubtitles(unittest.TestCase):
         DL.params['writesubtitles'] = True
         IE = YoutubeIE(DL)
         info_dict = IE.extract('QRS8MkLhQmM')
-        self.assertEqual(md5(info_dict[0]['subtitles']), 'c3228550d59116f3c29fba370b55d033')
+        self.assertEqual(md5(info_dict[0]['subtitles']), '4cd9278a35ba2305f47354ee13472260')
 
     def test_youtube_subtitles_it(self):
         DL = FakeDownloader()
@@ -51,7 +51,7 @@ class TestYoutubeSubtitles(unittest.TestCase):
         DL.params['subtitleslang'] = 'it'
         IE = YoutubeIE(DL)
         info_dict = IE.extract('QRS8MkLhQmM')
-        self.assertEqual(md5(info_dict[0]['subtitles']), '132a88a0daf8e1520f393eb58f1f646a')
+        self.assertEqual(md5(info_dict[0]['subtitles']), '164a51f16f260476a05b50fe4c2f161d')
 
 if __name__ == '__main__':
     unittest.main()
diff --git a/youtube_dl/InfoExtractors.py b/youtube_dl/InfoExtractors.py
index d3c3ac264..e3998fbe8 100755
--- a/youtube_dl/InfoExtractors.py
+++ b/youtube_dl/InfoExtractors.py
@@ -228,23 +228,6 @@ class YoutubeIE(InfoExtractor):
         """Indicate the download will use the RTMP protocol."""
         self._downloader.to_screen(u'[youtube] RTMP download detected')
 
-    def _closed_captions_xml_to_srt(self, xml_string):
-        srt = ''
-        texts = re.findall(r'<text start="([\d\.]+)"( dur="([\d\.]+)")?>([^<]+)</text>', xml_string, re.MULTILINE)
-        # TODO parse xml instead of regex
-        for n, (start, dur_tag, dur, caption) in enumerate(texts):
-            if not dur: dur = '4'
-            start = float(start)
-            end = start + float(dur)
-            start = "%02i:%02i:%02i,%03i" %(start/(60*60), start/60%60, start%60, start%1*1000)
-            end = "%02i:%02i:%02i,%03i" %(end/(60*60), end/60%60, end%60, end%1*1000)
-            caption = unescapeHTML(caption)
-            caption = unescapeHTML(caption) # double cycle, intentional
-            srt += str(n+1) + '\n'
-            srt += start + ' --> ' + end + '\n'
-            srt += caption + '\n\n'
-        return srt
-
     def _extract_subtitles(self, video_id):
         self.report_video_subtitles_download(video_id)
         request = compat_urllib_request.Request('http://video.google.com/timedtext?hl=en&type=list&v=%s' % video_id)
@@ -268,15 +251,16 @@ class YoutubeIE(InfoExtractor):
             'lang': srt_lang,
             'name': srt_lang_list[srt_lang].encode('utf-8'),
             'v': video_id,
+            'fmt': 'srt',
         })
         url = 'http://www.youtube.com/api/timedtext?' + params
         try:
-            srt_xml = compat_urllib_request.urlopen(url).read().decode('utf-8')
+            srt = 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)
-        if not srt_xml:
+        if not srt:
             return (u'WARNING: Did not fetch video subtitles', None)
-        return (None, self._closed_captions_xml_to_srt(srt_xml))
+        return (None, srt)
 
     def _print_formats(self, formats):
         print('Available formats:')

From cdb130b09a16865b81fd34d19b74fa634d45cad7 Mon Sep 17 00:00:00 2001
From: Ismael Mejia <iemejia@gmail.com>
Date: Thu, 21 Feb 2013 22:12:36 +0100
Subject: [PATCH 002/221] Added new option '--only-srt' to download only the
 subtitles of a video Improved option '--srt-lang'  - it shows the argument in
 case of missing subtitles  - added language suffix for non-english languages
 (e.g. video.it.srt)

---
 test/test_youtube_subtitles.py | 7 +++++++
 youtube_dl/FileDownloader.py   | 5 +++++
 youtube_dl/InfoExtractors.py   | 7 ++++++-
 youtube_dl/__init__.py         | 4 ++++
 4 files changed, 22 insertions(+), 1 deletion(-)

diff --git a/test/test_youtube_subtitles.py b/test/test_youtube_subtitles.py
index ff09ea459..77c275b75 100644
--- a/test/test_youtube_subtitles.py
+++ b/test/test_youtube_subtitles.py
@@ -53,5 +53,12 @@ class TestYoutubeSubtitles(unittest.TestCase):
         info_dict = IE.extract('QRS8MkLhQmM')
         self.assertEqual(md5(info_dict[0]['subtitles']), '164a51f16f260476a05b50fe4c2f161d')
 
+    def test_youtube_onlysubtitles(self):
+        DL = FakeDownloader()
+        DL.params['onlysubtitles'] = True
+        IE = YoutubeIE(DL)
+        info_dict = IE.extract('QRS8MkLhQmM')
+        self.assertEqual(md5(info_dict[0]['subtitles']), '4cd9278a35ba2305f47354ee13472260')
+
 if __name__ == '__main__':
     unittest.main()
diff --git a/youtube_dl/FileDownloader.py b/youtube_dl/FileDownloader.py
index 53c2d1dce..487c9dadb 100644
--- a/youtube_dl/FileDownloader.py
+++ b/youtube_dl/FileDownloader.py
@@ -79,6 +79,7 @@ class FileDownloader(object):
     writedescription:  Write the video description to a .description file
     writeinfojson:     Write the video description to a .info.json file
     writesubtitles:    Write the video subtitles to a .srt file
+    onlysubtitles:     Downloads only the subtitles of the video
     subtitleslang:     Language of the subtitles to download
     test:              Download only first bytes to test the downloader.
     keepvideo:         Keep the video file after post-processing
@@ -443,9 +444,13 @@ class FileDownloader(object):
             # that way it will silently go on when used with unsupporting IE
             try:
                 srtfn = filename.rsplit('.', 1)[0] + u'.srt'
+                if self.params.get('subtitleslang', False):
+                    srtfn = filename.rsplit('.', 1)[0] + u'.' + self.params['subtitleslang'] + u'.srt'
                 self.report_writesubtitles(srtfn)
                 with io.open(encodeFilename(srtfn), 'w', encoding='utf-8') as srtfile:
                     srtfile.write(info_dict['subtitles'])
+                if self.params.get('onlysubtitles', False):
+                    return 
             except (OSError, IOError):
                 self.trouble(u'ERROR: Cannot write subtitles file ' + descfn)
                 return
diff --git a/youtube_dl/InfoExtractors.py b/youtube_dl/InfoExtractors.py
index e3998fbe8..51b263383 100755
--- a/youtube_dl/InfoExtractors.py
+++ b/youtube_dl/InfoExtractors.py
@@ -228,6 +228,7 @@ class YoutubeIE(InfoExtractor):
         """Indicate the download will use the RTMP protocol."""
         self._downloader.to_screen(u'[youtube] RTMP download detected')
 
+
     def _extract_subtitles(self, video_id):
         self.report_video_subtitles_download(video_id)
         request = compat_urllib_request.Request('http://video.google.com/timedtext?hl=en&type=list&v=%s' % video_id)
@@ -246,7 +247,7 @@ class YoutubeIE(InfoExtractor):
         else:
             srt_lang = list(srt_lang_list.keys())[0]
         if not srt_lang in srt_lang_list:
-            return (u'WARNING: no closed captions found in the specified language', None)
+            return (u'WARNING: no closed captions found in the specified language "%s"' % srt_lang, None)
         params = compat_urllib_parse.urlencode({
             'lang': srt_lang,
             'name': srt_lang_list[srt_lang].encode('utf-8'),
@@ -483,6 +484,10 @@ class YoutubeIE(InfoExtractor):
 
         # closed captions
         video_subtitles = None
+        if self._downloader.params.get('subtitleslang', False):
+            self._downloader.params['writesubtitles'] = True
+        if self._downloader.params.get('onlysubtitles', False):
+            self._downloader.params['writesubtitles'] = True
         if self._downloader.params.get('writesubtitles', False):
             (srt_error, video_subtitles) = self._extract_subtitles(video_id)
             if srt_error:
diff --git a/youtube_dl/__init__.py b/youtube_dl/__init__.py
index 23e3c2ac2..ababeac87 100644
--- a/youtube_dl/__init__.py
+++ b/youtube_dl/__init__.py
@@ -176,6 +176,9 @@ def parseOpts():
     video_format.add_option('--write-srt',
             action='store_true', dest='writesubtitles',
             help='write video closed captions to a .srt file (currently youtube only)', default=False)
+    video_format.add_option('--only-srt',
+            action='store_true', dest='onlysubtitles',
+            help='downloads only the subtitles of the video (currently youtube only)', default=False)
     video_format.add_option('--srt-lang',
             action='store', dest='subtitleslang', metavar='LANG',
             help='language of the closed captions to download (optional) use IETF language tags like \'en\'')
@@ -450,6 +453,7 @@ def _real_main():
         'writedescription': opts.writedescription,
         'writeinfojson': opts.writeinfojson,
         'writesubtitles': opts.writesubtitles,
+        'onlysubtitles': opts.onlysubtitles,
         'subtitleslang': opts.subtitleslang,
         'matchtitle': decodeOption(opts.matchtitle),
         'rejecttitle': decodeOption(opts.rejecttitle),

From df8db1aa2107f204fa14c157d7a536e45ceb65c4 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Jaime=20Marqui=CC=81nez=20Ferra=CC=81ndiz?=
 <jaimemf93@gmail.com>
Date: Tue, 26 Feb 2013 23:33:58 +0100
Subject: [PATCH 003/221] Create extract_info method

---
 youtube_dl/FileDownloader.py | 85 +++++++++++++++++++-----------------
 1 file changed, 44 insertions(+), 41 deletions(-)

diff --git a/youtube_dl/FileDownloader.py b/youtube_dl/FileDownloader.py
index 192ad37d2..b26c34729 100644
--- a/youtube_dl/FileDownloader.py
+++ b/youtube_dl/FileDownloader.py
@@ -377,6 +377,44 @@ class FileDownloader(object):
             if re.search(rejecttitle, title, re.IGNORECASE):
                 return u'"' + title + '" title matched reject pattern "' + rejecttitle + '"'
         return None
+        
+    def extract_info(self, url):
+        '''
+        Returns a list with a dictionary for each video we find.
+         '''
+        suitable_found = False
+        for ie in self._ies:
+            # Go to next InfoExtractor if not suitable
+            if not ie.suitable(url):
+                continue
+
+            # Warn if the _WORKING attribute is False
+            if not ie.working():
+                self.to_stderr(u'WARNING: the program functionality for this site has been marked as broken, '
+                               u'and will probably not work. If you want to go on, use the -i option.')
+
+            # Suitable InfoExtractor found
+            suitable_found = True
+
+            # Extract information from URL and process it
+            try:
+                videos = ie.extract(url)
+                for video in videos or []:
+                    if not 'extractor' in video:
+                        #The extractor has already been set somewher else
+                        video['extractor'] = ie.IE_NAME
+                return videos
+            except ExtractorError as de: # An error we somewhat expected
+                self.trouble(u'ERROR: ' + compat_str(de), de.format_traceback())
+                break
+            except Exception as e:
+                if self.params.get('ignoreerrors', False):
+                    self.trouble(u'ERROR: ' + compat_str(e), tb=compat_str(traceback.format_exc()))
+                    break
+                else:
+                    raise
+        if not suitable_found:
+                self.trouble(u'ERROR: no suitable InfoExtractor: %s' % url)
 
     def process_info(self, info_dict):
         """Process a single dictionary returned by an InfoExtractor."""
@@ -488,49 +526,14 @@ class FileDownloader(object):
             raise SameFileError(self.params['outtmpl'])
 
         for url in url_list:
-            suitable_found = False
-            for ie in self._ies:
-                # Go to next InfoExtractor if not suitable
-                if not ie.suitable(url):
-                    continue
+            videos = self.extract_info(url)
 
-                # Warn if the _WORKING attribute is False
-                if not ie.working():
-                    self.to_stderr(u'WARNING: the program functionality for this site has been marked as broken, '
-                                   u'and will probably not work. If you want to go on, use the -i option.')
-
-                # Suitable InfoExtractor found
-                suitable_found = True
-
-                # Extract information from URL and process it
+            for video in videos or []:
                 try:
-                    videos = ie.extract(url)
-                except ExtractorError as de: # An error we somewhat expected
-                    self.trouble(u'ERROR: ' + compat_str(de), de.format_traceback())
-                    break
-                except Exception as e:
-                    if self.params.get('ignoreerrors', False):
-                        self.trouble(u'ERROR: ' + compat_str(e), tb=compat_str(traceback.format_exc()))
-                        break
-                    else:
-                        raise
-
-                if len(videos or []) > 1 and self.fixed_template():
-                    raise SameFileError(self.params['outtmpl'])
-
-                for video in videos or []:
-                    video['extractor'] = ie.IE_NAME
-                    try:
-                        self.increment_downloads()
-                        self.process_info(video)
-                    except UnavailableVideoError:
-                        self.trouble(u'\nERROR: 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.increment_downloads()
+                    self.process_info(video)
+                except UnavailableVideoError:
+                    self.trouble(u'\nERROR: unable to download video')
 
         return self._download_retcode
 

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 004/221] 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 @@ class FileDownloader(object):
         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 005/221] 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 @@ class FileDownloader(object):
                 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 @@ class FileDownloader(object):
             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 @@ class FileDownloader(object):
             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 @@ class FileDownloader(object):
                 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 @@ class FileDownloader(object):
                 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 @@ class FileDownloader(object):
                 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 @@ class FileDownloader(object):
                 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 @@ class FileDownloader(object):
                     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 @@ class FileDownloader(object):
                         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 @@ class FileDownloader(object):
         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 @@ class FileDownloader(object):
             })
             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 @@ class FileDownloader(object):
                 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 @@ class FileDownloader(object):
                     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 @@ class FileDownloader(object):
             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 006/221] 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 @@ class YoutubeIE(InfoExtractor):
             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 @@ class YoutubeIE(InfoExtractor):
         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 @@ class YoutubeIE(InfoExtractor):
                 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 @@ class YoutubeIE(InfoExtractor):
 
         # 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 @@ class YoutubeIE(InfoExtractor):
 
         # 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 @@ class YoutubeIE(InfoExtractor):
                 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 @@ class YoutubeIE(InfoExtractor):
                         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 @@ class MetacafeIE(InfoExtractor):
             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 @@ class MetacafeIE(InfoExtractor):
             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 @@ class MetacafeIE(InfoExtractor):
             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 @@ class MetacafeIE(InfoExtractor):
         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 @@ class MetacafeIE(InfoExtractor):
 
         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 @@ class DailymotionIE(InfoExtractor):
         # 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 @@ class DailymotionIE(InfoExtractor):
         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 @@ class DailymotionIE(InfoExtractor):
                 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 @@ class DailymotionIE(InfoExtractor):
 
         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 @@ class PhotobucketIE(InfoExtractor):
         # 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 @@ class PhotobucketIE(InfoExtractor):
             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 @@ class PhotobucketIE(InfoExtractor):
 
         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 @@ class YahooIE(InfoExtractor):
         # 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 @@ class YahooIE(InfoExtractor):
             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 @@ class YahooIE(InfoExtractor):
             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 @@ class YahooIE(InfoExtractor):
         # 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 @@ class YahooIE(InfoExtractor):
             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 @@ class VimeoIE(InfoExtractor):
         # 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 @@ class VimeoIE(InfoExtractor):
             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 @@ class VimeoIE(InfoExtractor):
             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 @@ class VimeoIE(InfoExtractor):
                 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 @@ class ArteTvIE(InfoExtractor):
             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 @@ class ArteTvIE(InfoExtractor):
         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 @@ class GenericIE(InfoExtractor):
             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 @@ class GenericIE(InfoExtractor):
             # 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 @@ class GenericIE(InfoExtractor):
         # 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 @@ class YoutubeSearchIE(InfoExtractor):
     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 @@ class YoutubeSearchIE(InfoExtractor):
             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 @@ class YoutubeSearchIE(InfoExtractor):
             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 @@ class GoogleSearchIE(InfoExtractor):
     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 @@ class GoogleSearchIE(InfoExtractor):
             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 @@ class GoogleSearchIE(InfoExtractor):
             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 @@ class YahooSearchIE(InfoExtractor):
     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 @@ class YahooSearchIE(InfoExtractor):
             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 @@ class YahooSearchIE(InfoExtractor):
             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 @@ class YoutubePlaylistIE(InfoExtractor):
         # 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 @@ class YoutubePlaylistIE(InfoExtractor):
             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 @@ class YoutubeChannelIE(InfoExtractor):
         # 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 @@ class YoutubeChannelIE(InfoExtractor):
             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 @@ class YoutubeUserIE(InfoExtractor):
         # 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 @@ class YoutubeUserIE(InfoExtractor):
             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 @@ class BlipTVUserIE(InfoExtractor):
         # 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 @@ class BlipTVUserIE(InfoExtractor):
             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 @@ class BlipTVUserIE(InfoExtractor):
             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 @@ class DepositFilesIE(InfoExtractor):
             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 @@ class DepositFilesIE(InfoExtractor):
             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 @@ class DepositFilesIE(InfoExtractor):
         # 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 @@ class FacebookIE(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')
 
@@ -2162,7 +2162,7 @@ class BlipTVIE(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
 
         urlp = compat_urllib_parse_urlparse(url)
@@ -2209,7 +2209,7 @@ class BlipTVIE(InfoExtractor):
                 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 @@ class BlipTVIE(InfoExtractor):
                     '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 @@ class MyVideoIE(InfoExtractor):
     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 @@ class MyVideoIE(InfoExtractor):
         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 @@ class ComedyCentralIE(InfoExtractor):
     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 @@ class ComedyCentralIE(InfoExtractor):
             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 @@ class ComedyCentralIE(InfoExtractor):
 
             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 @@ class ComedyCentralIE(InfoExtractor):
         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 @@ class ComedyCentralIE(InfoExtractor):
             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 @@ class EscapistIE(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
         showName = mobj.group('showname')
         videoId = mobj.group('episode')
@@ -2518,7 +2518,7 @@ class EscapistIE(InfoExtractor):
             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 @@ class EscapistIE(InfoExtractor):
             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 @@ class EscapistIE(InfoExtractor):
         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 @@ class CollegeHumorIE(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')
 
@@ -2598,7 +2598,7 @@ class CollegeHumorIE(InfoExtractor):
         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 @@ class CollegeHumorIE(InfoExtractor):
         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 @@ class XVideosIE(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)
 
@@ -2662,7 +2662,7 @@ class XVideosIE(InfoExtractor):
         # 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 @@ class XVideosIE(InfoExtractor):
         # 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 @@ class XVideosIE(InfoExtractor):
         # 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 @@ class SoundcloudIE(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
 
         # extract uploader (which is in the url)
@@ -2740,7 +2740,7 @@ class SoundcloudIE(InfoExtractor):
             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 @@ class SoundcloudIE(InfoExtractor):
             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 @@ class InfoQIE(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
 
         webpage = self._download_webpage(url, video_id=url)
@@ -2790,7 +2790,7 @@ class InfoQIE(InfoExtractor):
         # 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 @@ class InfoQIE(InfoExtractor):
         # 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 @@ class MixcloudIE(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
         # extract uploader & filename from url
         uploader = mobj.group(1).decode('utf-8')
@@ -2895,7 +2895,7 @@ class MixcloudIE(InfoExtractor):
             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 @@ class MixcloudIE(InfoExtractor):
                     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 @@ class StanfordOpenClassroomIE(InfoExtractor):
             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 @@ class StanfordOpenClassroomIE(InfoExtractor):
             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 @@ class MTVIE(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
         if not mobj.group('proto'):
             url = 'http://' + url
@@ -3074,25 +3074,25 @@ class MTVIE(InfoExtractor):
 
         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 @@ class MTVIE(InfoExtractor):
         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 @@ class YoukuIE(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')
 
@@ -3185,7 +3185,7 @@ class YoukuIE(InfoExtractor):
             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 @@ class YoukuIE(InfoExtractor):
             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 @@ class XNXXIE(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)
 
@@ -3274,24 +3274,24 @@ class XNXXIE(InfoExtractor):
             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 @@ class GooglePlusIE(InfoExtractor):
         # 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 @@ class GooglePlusIE(InfoExtractor):
         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 @@ class GooglePlusIE(InfoExtractor):
         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 @@ class GooglePlusIE(InfoExtractor):
         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 @@ class JustinTVIE(InfoExtractor):
             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 @@ class JustinTVIE(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
 
         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 @@ class FunnyOrDieIE(InfoExtractor):
 
         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 @@ class SteamIE(InfoExtractor):
             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 @@ class YouPornIE(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')
@@ -3803,7 +3803,7 @@ class YouPornIE(InfoExtractor):
         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 @@ class PornotubeIE(InfoExtractor):
         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 @@ class PornotubeIE(InfoExtractor):
         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 @@ class MySpassIE(InfoExtractor):
         # 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 631f73978c0ee851950ac697dfd73f9092abd3c3 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 22:16:42 +0100
Subject: [PATCH 007/221] Add a method for extracting info from a list of urls

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

diff --git a/youtube_dl/FileDownloader.py b/youtube_dl/FileDownloader.py
index b26c34729..f668b362b 100644
--- a/youtube_dl/FileDownloader.py
+++ b/youtube_dl/FileDownloader.py
@@ -415,6 +415,14 @@ class FileDownloader(object):
                     raise
         if not suitable_found:
                 self.trouble(u'ERROR: no suitable InfoExtractor: %s' % url)
+    def extract_info_iterable(self, urls):
+        '''
+            Return the videos founded for the urls
+        '''
+        results = []
+        for url in urls:
+            results.extend(self.extract_info(url))
+        return results
 
     def process_info(self, info_dict):
         """Process a single dictionary returned by an InfoExtractor."""

From 597cc8a45536aa4207c5ffc3e421fcebf2e08fe6 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 11:58:01 +0100
Subject: [PATCH 008/221] Use extract_info in YoutubePlaylist and YoutubeSearch

---
 test/test_youtube_lists.py   | 16 +++++++++-------
 youtube_dl/InfoExtractors.py |  8 +++-----
 2 files changed, 12 insertions(+), 12 deletions(-)

diff --git a/test/test_youtube_lists.py b/test/test_youtube_lists.py
index f4705bc5b..055bf69c8 100644
--- a/test/test_youtube_lists.py
+++ b/test/test_youtube_lists.py
@@ -10,6 +10,7 @@ sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
 
 from youtube_dl.InfoExtractors import YoutubeUserIE, YoutubePlaylistIE, YoutubeIE
 from youtube_dl.utils import *
+from youtube_dl.FileDownloader import FileDownloader
 
 PARAMETERS_FILE = os.path.join(os.path.dirname(os.path.abspath(__file__)), "parameters.json")
 with io.open(PARAMETERS_FILE, encoding='utf-8') as pf:
@@ -22,7 +23,7 @@ proxy_handler = compat_urllib_request.ProxyHandler()
 opener = compat_urllib_request.build_opener(proxy_handler, cookie_processor, YoutubeDLHandler())
 compat_urllib_request.install_opener(opener)
 
-class FakeDownloader(object):
+class FakeDownloader(FileDownloader):
     def __init__(self):
         self.result = []
         self.params = parameters
@@ -30,15 +31,16 @@ class FakeDownloader(object):
         print(s)
     def trouble(self, s):
         raise Exception(s)
-    def download(self, x):
-        self.result.append(x)
+    def extract_info(self, url):
+        self.result.append(url)
+        return url
 
 class TestYoutubeLists(unittest.TestCase):
     def test_youtube_playlist(self):
         dl = FakeDownloader()
         ie = YoutubePlaylistIE(dl)
         ie.extract('https://www.youtube.com/playlist?list=PLwiyx1dc3P2JR9N8gQaQN_BCvlSlap7re')
-        ytie_results = [YoutubeIE()._extract_id(r[0]) for r in dl.result]
+        ytie_results = [YoutubeIE()._extract_id(url) for url in dl.result]
         self.assertEqual(ytie_results, [ 'bV9L5Ht9LgY', 'FXxLjLQi3Fg', 'tU3Bgo5qJZE'])
 
     def test_issue_673(self):
@@ -58,7 +60,7 @@ class TestYoutubeLists(unittest.TestCase):
         dl = FakeDownloader()
         ie = YoutubePlaylistIE(dl)
         ie.extract('https://www.youtube.com/playlist?list=PLwP_SiAcdui0KVebT0mU9Apz359a4ubsC')
-        ytie_results = [YoutubeIE()._extract_id(r[0]) for r in dl.result]
+        ytie_results = [YoutubeIE()._extract_id(url) for url in dl.result]
         self.assertFalse('pElCt5oNDuI' in ytie_results)
         self.assertFalse('KdPEApIVdWM' in ytie_results)
 
@@ -67,9 +69,9 @@ class TestYoutubeLists(unittest.TestCase):
         ie = YoutubePlaylistIE(dl)
         # TODO find a > 100 (paginating?) videos course
         ie.extract('https://www.youtube.com/course?list=ECUl4u3cNGP61MdtwGTqZA0MreSaDybji8')
-        self.assertEqual(YoutubeIE()._extract_id(dl.result[0][0]), 'j9WZyLZCBzs')
+        self.assertEqual(YoutubeIE()._extract_id(dl.result[0]), 'j9WZyLZCBzs')
         self.assertEqual(len(dl.result), 25)
-        self.assertEqual(YoutubeIE()._extract_id(dl.result[-1][0]), 'rYefUsYuEp0')
+        self.assertEqual(YoutubeIE()._extract_id(dl.result[-1]), 'rYefUsYuEp0')
 
     def test_youtube_channel(self):
         # I give up, please find a channel that does paginate and test this like test_youtube_playlist_long
diff --git a/youtube_dl/InfoExtractors.py b/youtube_dl/InfoExtractors.py
index 7ce84fe79..8a7694a76 100755
--- a/youtube_dl/InfoExtractors.py
+++ b/youtube_dl/InfoExtractors.py
@@ -1756,9 +1756,7 @@ class YoutubePlaylistIE(InfoExtractor):
         else:
             self._downloader.to_screen(u'[youtube] PL %s: Found %i videos, downloading %i' % (playlist_id, total, len(videos)))
 
-        for video in videos:
-            self._downloader.download([video])
-        return
+        return self._downloader.extract_info_iterable(videos)
 
 
 class YoutubeChannelIE(InfoExtractor):
@@ -1892,8 +1890,8 @@ class YoutubeUserIE(InfoExtractor):
         self._downloader.to_screen(u"[youtube] user %s: Collected %d video ids (downloading %d of them)" %
                 (username, all_ids_count, len(video_ids)))
 
-        for video_id in video_ids:
-            self._downloader.download(['http://www.youtube.com/watch?v=%s' % video_id])
+        urls = ['http://www.youtube.com/watch?v=%s' % video_id for video_id in video_ids]
+        return self._downloader.extract_info_iterable(urls)
 
 
 class BlipTVUserIE(InfoExtractor):

From f6e6da9525150487476d4990693eedf73acffab1 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 12:26:18 +0100
Subject: [PATCH 009/221] Use extract_info in BlipTV User and Youtube Channel

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

diff --git a/youtube_dl/InfoExtractors.py b/youtube_dl/InfoExtractors.py
index 8a7694a76..d79f6068f 100755
--- a/youtube_dl/InfoExtractors.py
+++ b/youtube_dl/InfoExtractors.py
@@ -1806,9 +1806,8 @@ class YoutubeChannelIE(InfoExtractor):
 
         self._downloader.to_screen(u'[youtube] Channel %s: Found %i videos' % (channel_id, len(video_ids)))
 
-        for id in video_ids:
-            self._downloader.download(['http://www.youtube.com/watch?v=%s' % id])
-        return
+        urls = ['http://www.youtube.com/watch?v=%s' % id for id in video_ids]
+        return self._downloader.extract_info_iterable(urls)
 
 
 class YoutubeUserIE(InfoExtractor):
@@ -1981,8 +1980,8 @@ class BlipTVUserIE(InfoExtractor):
         self._downloader.to_screen(u"[%s] user %s: Collected %d video ids (downloading %d of them)" %
                 (self.IE_NAME, username, all_ids_count, len(video_ids)))
 
-        for video_id in video_ids:
-            self._downloader.download([u'http://blip.tv/'+video_id])
+        urls = [u'http://blip.tv/%s' % video_id for video_id in video_ids]
+        return self._downloader.extract_info_iterable(urls)
 
 
 class DepositFilesIE(InfoExtractor):

From 6ac7f082c469b3b2153735ae8475e1d0fc8b5439 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 20:14:32 +0100
Subject: [PATCH 010/221] `extract_info` now expects `ie.extract` to return a
 list in the format proposed in issue 608.

Each element should have a '_type' key specifying if it's a video, an url or a playlist.
`extract_info` will process each element to get the full info
---
 youtube_dl/FileDownloader.py | 32 ++++++++++++++++++++++++++------
 1 file changed, 26 insertions(+), 6 deletions(-)

diff --git a/youtube_dl/FileDownloader.py b/youtube_dl/FileDownloader.py
index 9b630c123..68fad11bc 100644
--- a/youtube_dl/FileDownloader.py
+++ b/youtube_dl/FileDownloader.py
@@ -410,12 +410,9 @@ class FileDownloader(object):
 
             # Extract information from URL and process it
             try:
-                videos = ie.extract(url)
-                for video in videos or []:
-                    if not 'extractor' in video:
-                        #The extractor has already been set somewher else
-                        video['extractor'] = ie.IE_NAME
-                return videos
+                ie_results = ie.extract(url)
+                results = self.process_ie_results(ie_results, ie)
+                return results
             except ExtractorError as de: # An error we somewhat expected
                 self.trouble(u'ERROR: ' + compat_str(de), de.format_traceback())
                 break
@@ -435,6 +432,29 @@ class FileDownloader(object):
         for url in urls:
             results.extend(self.extract_info(url))
         return results
+        
+    def process_ie_results(self, ie_results, ie):
+        """
+        Take the results of the ie and return a list of videos.
+        For url elements it will seartch the suitable ie and get the videos
+        For playlist elements it will process each of the elements of the 'entries' key
+        """
+        results = [] 
+        for result in ie_results or []:
+            result_type = result.get('_type', 'video') #If not given we suppose it's a video, support the dafault old system
+            if result_type == 'video':
+                if not 'extractor' in result:
+                    #The extractor has already been set somewhere else
+                    result['extractor'] = ie.IE_NAME
+                results.append(result)
+            elif result_type == 'url':
+                #We get the videos pointed by the url
+                results.extend(self.extract_info(result['url']))
+            elif result_type == 'playlist':
+                #We process each entry in the playlist
+                entries_result = self.process_ie_results(result['entries'], ie)
+                results.extend(entries_result)
+        return results
 
     def process_info(self, info_dict):
         """Process a single dictionary returned by an InfoExtractor."""

From 8a38a194fb08a253986cdbafa02cf699ef76c9a5 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 20:55:48 +0100
Subject: [PATCH 011/221] Add auxiliary methods to InfoExtractor to set the
 '_type' key and use them for some playlist IEs

---
 test/test_youtube_lists.py   | 35 +++++++++++++++++++++--------------
 youtube_dl/InfoExtractors.py | 30 ++++++++++++++++++++++++++----
 2 files changed, 47 insertions(+), 18 deletions(-)

diff --git a/test/test_youtube_lists.py b/test/test_youtube_lists.py
index 055bf69c8..9e91484f8 100644
--- a/test/test_youtube_lists.py
+++ b/test/test_youtube_lists.py
@@ -36,31 +36,37 @@ class FakeDownloader(FileDownloader):
         return url
 
 class TestYoutubeLists(unittest.TestCase):
+    def assertIsPlaylist(self,info):
+        """Make sure the info has '_type' set to 'playlist'"""
+        self.assertEqual(info['_type'], 'playlist')
+
     def test_youtube_playlist(self):
         dl = FakeDownloader()
         ie = YoutubePlaylistIE(dl)
-        ie.extract('https://www.youtube.com/playlist?list=PLwiyx1dc3P2JR9N8gQaQN_BCvlSlap7re')
-        ytie_results = [YoutubeIE()._extract_id(url) for url in dl.result]
+        result = ie.extract('https://www.youtube.com/playlist?list=PLwiyx1dc3P2JR9N8gQaQN_BCvlSlap7re')[0]
+        self.assertIsPlaylist(result)
+        ytie_results = [YoutubeIE()._extract_id(url['url']) for url in result['entries']]
         self.assertEqual(ytie_results, [ 'bV9L5Ht9LgY', 'FXxLjLQi3Fg', 'tU3Bgo5qJZE'])
 
     def test_issue_673(self):
         dl = FakeDownloader()
         ie = YoutubePlaylistIE(dl)
-        ie.extract('PLBB231211A4F62143')
-        self.assertTrue(len(dl.result) > 40)
+        result = ie.extract('PLBB231211A4F62143')[0]
+        self.assertTrue(len(result['entries']) > 40)
 
     def test_youtube_playlist_long(self):
         dl = FakeDownloader()
         ie = YoutubePlaylistIE(dl)
-        ie.extract('https://www.youtube.com/playlist?list=UUBABnxM4Ar9ten8Mdjj1j0Q')
-        self.assertTrue(len(dl.result) >= 799)
+        result = ie.extract('https://www.youtube.com/playlist?list=UUBABnxM4Ar9ten8Mdjj1j0Q')[0]
+        self.assertIsPlaylist(result)
+        self.assertTrue(len(result['entries']) >= 799)
 
     def test_youtube_playlist_with_deleted(self):
         #651
         dl = FakeDownloader()
         ie = YoutubePlaylistIE(dl)
-        ie.extract('https://www.youtube.com/playlist?list=PLwP_SiAcdui0KVebT0mU9Apz359a4ubsC')
-        ytie_results = [YoutubeIE()._extract_id(url) for url in dl.result]
+        result = ie.extract('https://www.youtube.com/playlist?list=PLwP_SiAcdui0KVebT0mU9Apz359a4ubsC')[0]
+        ytie_results = [YoutubeIE()._extract_id(url['url']) for url in result['entries']]
         self.assertFalse('pElCt5oNDuI' in ytie_results)
         self.assertFalse('KdPEApIVdWM' in ytie_results)
 
@@ -68,10 +74,11 @@ class TestYoutubeLists(unittest.TestCase):
         dl = FakeDownloader()
         ie = YoutubePlaylistIE(dl)
         # TODO find a > 100 (paginating?) videos course
-        ie.extract('https://www.youtube.com/course?list=ECUl4u3cNGP61MdtwGTqZA0MreSaDybji8')
-        self.assertEqual(YoutubeIE()._extract_id(dl.result[0]), 'j9WZyLZCBzs')
-        self.assertEqual(len(dl.result), 25)
-        self.assertEqual(YoutubeIE()._extract_id(dl.result[-1]), 'rYefUsYuEp0')
+        result = ie.extract('https://www.youtube.com/course?list=ECUl4u3cNGP61MdtwGTqZA0MreSaDybji8')[0]
+        entries = result['entries']
+        self.assertEqual(YoutubeIE()._extract_id(entries[0]['url']), 'j9WZyLZCBzs')
+        self.assertEqual(len(entries), 25)
+        self.assertEqual(YoutubeIE()._extract_id(entries[-1]['url']), 'rYefUsYuEp0')
 
     def test_youtube_channel(self):
         # I give up, please find a channel that does paginate and test this like test_youtube_playlist_long
@@ -80,8 +87,8 @@ class TestYoutubeLists(unittest.TestCase):
     def test_youtube_user(self):
         dl = FakeDownloader()
         ie = YoutubeUserIE(dl)
-        ie.extract('https://www.youtube.com/user/TheLinuxFoundation')
-        self.assertTrue(len(dl.result) >= 320)
+        result = ie.extract('https://www.youtube.com/user/TheLinuxFoundation')[0]
+        self.assertTrue(len(result['entries']) >= 320)
 
 if __name__ == '__main__':
     unittest.main()
diff --git a/youtube_dl/InfoExtractors.py b/youtube_dl/InfoExtractors.py
index d79f6068f..895658f49 100755
--- a/youtube_dl/InfoExtractors.py
+++ b/youtube_dl/InfoExtractors.py
@@ -128,6 +128,24 @@ class InfoExtractor(object):
         urlh = self._request_webpage(url_or_request, video_id, note, errnote)
         webpage_bytes = urlh.read()
         return webpage_bytes.decode('utf-8', 'replace')
+        
+    #Methods for following #608
+    #They set the correct value of the '_type' key
+    def video_result(self, video_info):
+        """Returns a video"""
+        video_info['_type'] = 'video'
+        return video_info
+    def url_result(self, url, ie=None):
+        """Returns a url that points to a page that should be processed"""
+        #TODO: ie should be the class used for getting the info
+        video_info = {'_type': 'url',
+                      'url': url}
+        return video_info
+    def playlist_result(self, entries):
+        """Returns a playlist"""
+        video_info = {'_type': 'playlist',
+                      'entries': entries}
+        return video_info
 
 
 class YoutubeIE(InfoExtractor):
@@ -1756,7 +1774,8 @@ class YoutubePlaylistIE(InfoExtractor):
         else:
             self._downloader.to_screen(u'[youtube] PL %s: Found %i videos, downloading %i' % (playlist_id, total, len(videos)))
 
-        return self._downloader.extract_info_iterable(videos)
+        url_results = [self.url_result(url) for url in videos]
+        return [self.playlist_result(url_results)]
 
 
 class YoutubeChannelIE(InfoExtractor):
@@ -1807,7 +1826,8 @@ class YoutubeChannelIE(InfoExtractor):
         self._downloader.to_screen(u'[youtube] Channel %s: Found %i videos' % (channel_id, len(video_ids)))
 
         urls = ['http://www.youtube.com/watch?v=%s' % id for id in video_ids]
-        return self._downloader.extract_info_iterable(urls)
+        url_entries = [self.url_result(url) for url in urls]
+        return [self.playlist_result(url_entries)]
 
 
 class YoutubeUserIE(InfoExtractor):
@@ -1890,7 +1910,8 @@ class YoutubeUserIE(InfoExtractor):
                 (username, all_ids_count, len(video_ids)))
 
         urls = ['http://www.youtube.com/watch?v=%s' % video_id for video_id in video_ids]
-        return self._downloader.extract_info_iterable(urls)
+        url_results = [self.url_result(url) for url in urls]
+        return [self.playlist_result(url_results)]
 
 
 class BlipTVUserIE(InfoExtractor):
@@ -1981,7 +2002,8 @@ class BlipTVUserIE(InfoExtractor):
                 (self.IE_NAME, username, all_ids_count, len(video_ids)))
 
         urls = [u'http://blip.tv/%s' % video_id for video_id in video_ids]
-        return self._downloader.extract_info_iterable(urls)
+        url_entries = [self.url_result(url) for url in urls]
+        return [self.playlist_result(url_entries)]
 
 
 class DepositFilesIE(InfoExtractor):

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 012/221] 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 @@ class YoutubeIE(InfoExtractor):
         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 @@ class YoutubeIE(InfoExtractor):
 
         # 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 @@ class YoutubeIE(InfoExtractor):
                 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 @@ class DailymotionIE(InfoExtractor):
             # 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 @@ class ComedyCentralIE(InfoExtractor):
                 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 @@ class CollegeHumorIE(InfoExtractor):
             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 @@ class CollegeHumorIE(InfoExtractor):
             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 @@ class StanfordOpenClassroomIE(InfoExtractor):
                 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 a0d6fe7b924697c089ed7ae37df0ca590ac38a96 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 22:33:32 +0100
Subject: [PATCH 013/221] When a redirect is found return the new url using the
 new style

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

diff --git a/youtube_dl/InfoExtractors.py b/youtube_dl/InfoExtractors.py
index 895658f49..e714fa6b0 100755
--- a/youtube_dl/InfoExtractors.py
+++ b/youtube_dl/InfoExtractors.py
@@ -1311,7 +1311,7 @@ class GenericIE(InfoExtractor):
         self._downloader.to_screen(u'[redirect] Following redirect to %s' % new_url)
 
     def _test_redirect(self, url):
-        """Check if it is a redirect, like url shorteners, in case restart chain."""
+        """Check if it is a redirect, like url shorteners, in case return the new url."""
         class HeadRequest(compat_urllib_request.Request):
             def get_method(self):
                 return "HEAD"
@@ -1362,11 +1362,11 @@ class GenericIE(InfoExtractor):
             return False
 
         self.report_following_redirect(new_url)
-        self._downloader.download([new_url])
-        return True
+        return new_url
 
     def _real_extract(self, url):
-        if self._test_redirect(url): return
+        new_url = self._test_redirect(url)
+        if new_url: return [self.url_result(new_url)]
 
         video_id = url.split('/')[-1]
         request = compat_urllib_request.Request(url)

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 014/221] 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 @@ class EscapistIE(InfoExtractor):
             'uploader': showName,
             'upload_date': None,
             'title': showName,
-            'ext': 'mp4',
+            'ext': 'flv',
             'thumbnail': imgUrl,
             'description': description,
             'player_url': playerUrl,
@@ -3654,6 +3654,66 @@ class UstreamIE(InfoExtractor):
                   }
         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 015/221] 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 @@ class EscapistIE(InfoExtractor):
             '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 016/221] 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 @@ class WorldStarHipHopIE(InfoExtractor):
         
         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 @@ class WorldStarHipHopIE(InfoExtractor):
                 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 017/221] 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 @@ class UstreamIE(InfoExtractor):
         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 @@ class WorldStarHipHopIE(InfoExtractor):
             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 @@ class WorldStarHipHopIE(InfoExtractor):
                 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 018/221] 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 019/221] 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 @@ class WorldStarHipHopIE(InfoExtractor):
 
         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 @@ class WorldStarHipHopIE(InfoExtractor):
             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 @@ class WorldStarHipHopIE(InfoExtractor):
             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 020/221] 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 021/221] 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 @@ from youtube_dl.utils import *
 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 generator(test_case):
             _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 @@ class FileDownloader(object):
             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 @@ class ExtractorError(Exception):
         """ 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 e32b06e977447f6be78c02c66f35f609f81331ce Mon Sep 17 00:00:00 2001
From: Philipp Hagemeister <phihag@phihag.de>
Date: Tue, 12 Mar 2013 01:08:54 +0100
Subject: [PATCH 022/221] Spiegel IE

---
 test/tests.json              |  9 ++++++++
 youtube_dl/InfoExtractors.py | 43 +++++++++++++++++++++++++++++++++++-
 2 files changed, 51 insertions(+), 1 deletion(-)

diff --git a/test/tests.json b/test/tests.json
index e4ea0b41e..fd9d33332 100644
--- a/test/tests.json
+++ b/test/tests.json
@@ -299,5 +299,14 @@
     "url": "http://www.hodiho.fr/2013/02/regis-plante-sa-jeep.html",
     "file": "13601338388002.mp4",
     "md5": "85b90ccc9d73b4acd9138d3af4c27f89"
+  },
+  {
+    "name": "Spiegel",
+    "url": "http://www.spiegel.de/video/vulkan-tungurahua-in-ecuador-ist-wieder-aktiv-video-1259285.html",
+    "file": "1259285.mp4",
+    "md5": "2c2754212136f35fb4b19767d242f66e",
+    "info_dict": {
+        "title": "Vulkanausbruch in Ecuador: Der \"Feuerschlund\" ist wieder aktiv"
+    }
   }
 ]
diff --git a/youtube_dl/InfoExtractors.py b/youtube_dl/InfoExtractors.py
index baba4a9a2..44b4c4376 100755
--- a/youtube_dl/InfoExtractors.py
+++ b/youtube_dl/InfoExtractors.py
@@ -126,8 +126,14 @@ class InfoExtractor(object):
     def _download_webpage(self, url_or_request, video_id, note=None, errnote=None):
         """ Returns the data of the page as a string """
         urlh = self._request_webpage(url_or_request, video_id, note, errnote)
+        content_type = urlh.headers.get('Content-Type', '')
+        m = re.match(r'[a-zA-Z0-9_.-]+/[a-zA-Z0-9_.-]+\s*;\s*charset=(.+)', content_type)
+        if m:
+            encoding = m.group(1)
+        else:
+            encoding = 'utf-8'
         webpage_bytes = urlh.read()
-        return webpage_bytes.decode('utf-8', 'replace')
+        return webpage_bytes.decode(encoding, 'replace')
 
 
 class YoutubeIE(InfoExtractor):
@@ -4090,6 +4096,40 @@ class MySpassIE(InfoExtractor):
         }
         return [info]
 
+class SpiegelIE(InfoExtractor):
+    _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)
+        video_id = m.group('videoID')
+
+        webpage = self._download_webpage(url, video_id)
+        m = re.search(r'<div class="spVideoTitle">(.*?)</div>', webpage)
+        if not m:
+            raise ExtractorError(u'Cannot find title')
+        video_title = unescapeHTML(m.group(1))
+
+        xml_url = u'http://video2.spiegel.de/flash/' + video_id + u'.xml'
+        xml_code = self._download_webpage(xml_url, video_id,
+                    note=u'Downloading XML', errnote=u'Failed to download XML')
+
+        idoc = xml.etree.ElementTree.fromstring(xml_code)
+        last_type = idoc[-1]
+        filename = last_type.findall('./filename')[0].text
+        duration = float(last_type.findall('./duration')[0].text)
+
+        video_url = 'http://video2.spiegel.de/flash/' + filename
+        video_ext = filename.rpartition('.')[2]
+        info = {
+            'id': video_id,
+            'url': video_url,
+            'ext': video_ext,
+            'title': video_title,
+            'duration': duration,
+        }
+        return [info]
+
+
 def gen_extractors():
     """ Return a list of an instance of every supported extractor.
     The order does matter; the first extractor matched is the one handling the URL.
@@ -4138,6 +4178,7 @@ def gen_extractors():
         KeekIE(),
         TEDIE(),
         MySpassIE(),
+        SpiegelIE(),
         GenericIE()
     ]
 

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 023/221] 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 @@ class MySpassIE(InfoExtractor):
         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 ae608b8076497d70e2a95e5e939c1fb31e2dde53 Mon Sep 17 00:00:00 2001
From: Ismael Mejia <iemejia@gmail.com>
Date: Fri, 22 Feb 2013 02:52:55 +0100
Subject: [PATCH 024/221] Added new option '--all-srt' to download all the
 subtitles of a video. Only works in youtube for the moment.

---
 test/parameters.json           |  6 ++-
 test/test_youtube_subtitles.py | 31 ++++++++++++---
 youtube_dl/FileDownloader.py   | 28 ++++++++++---
 youtube_dl/InfoExtractors.py   | 73 ++++++++++++++++++++++++----------
 youtube_dl/__init__.py         |  4 ++
 5 files changed, 107 insertions(+), 35 deletions(-)

diff --git a/test/parameters.json b/test/parameters.json
index 8215d25c5..0d4bd644c 100644
--- a/test/parameters.json
+++ b/test/parameters.json
@@ -36,5 +36,7 @@
     "verbose": true, 
     "writedescription": false, 
     "writeinfojson": true, 
-    "writesubtitles": false
-}
\ No newline at end of file
+    "writesubtitles": false,
+    "onlysubtitles": false,
+    "allsubtitles": false
+}
diff --git a/test/test_youtube_subtitles.py b/test/test_youtube_subtitles.py
index 77c275b75..3b5a53fca 100644
--- a/test/test_youtube_subtitles.py
+++ b/test/test_youtube_subtitles.py
@@ -38,27 +38,48 @@ class FakeDownloader(object):
 md5 = lambda s: hashlib.md5(s.encode('utf-8')).hexdigest()
 
 class TestYoutubeSubtitles(unittest.TestCase):
+    def setUp(self):
+        DL = FakeDownloader()
+        DL.params['allsubtitles'] = False
+        DL.params['writesubtitles'] = False
+        
+    def test_youtube_no_subtitles(self):
+        DL = FakeDownloader()
+        DL.params['writesubtitles'] = False
+        IE = YoutubeIE(DL)
+        info_dict = IE.extract('QRS8MkLhQmM')
+        subtitles = info_dict[0]['subtitles']
+        self.assertEqual(subtitles, None)
     def test_youtube_subtitles(self):
         DL = FakeDownloader()
         DL.params['writesubtitles'] = True
         IE = YoutubeIE(DL)
         info_dict = IE.extract('QRS8MkLhQmM')
-        self.assertEqual(md5(info_dict[0]['subtitles']), '4cd9278a35ba2305f47354ee13472260')
-
+        sub = info_dict[0]['subtitles'][0]
+        self.assertEqual(md5(sub[2]), '4cd9278a35ba2305f47354ee13472260')
     def test_youtube_subtitles_it(self):
         DL = FakeDownloader()
         DL.params['writesubtitles'] = True
         DL.params['subtitleslang'] = 'it'
         IE = YoutubeIE(DL)
         info_dict = IE.extract('QRS8MkLhQmM')
-        self.assertEqual(md5(info_dict[0]['subtitles']), '164a51f16f260476a05b50fe4c2f161d')
-
+        sub = info_dict[0]['subtitles'][0]
+        self.assertEqual(md5(sub[2]), '164a51f16f260476a05b50fe4c2f161d')
     def test_youtube_onlysubtitles(self):
         DL = FakeDownloader()
+        DL.params['writesubtitles'] = True
         DL.params['onlysubtitles'] = True
         IE = YoutubeIE(DL)
         info_dict = IE.extract('QRS8MkLhQmM')
-        self.assertEqual(md5(info_dict[0]['subtitles']), '4cd9278a35ba2305f47354ee13472260')
+        sub = info_dict[0]['subtitles'][0]
+        self.assertEqual(md5(sub[2]), '4cd9278a35ba2305f47354ee13472260')
+    def test_youtube_allsubtitles(self):
+        DL = FakeDownloader()
+        DL.params['allsubtitles'] = True
+        IE = YoutubeIE(DL)
+        info_dict = IE.extract('QRS8MkLhQmM')
+        subtitles = info_dict[0]['subtitles']
+        self.assertEqual(len(subtitles), 12)
 
 if __name__ == '__main__':
     unittest.main()
diff --git a/youtube_dl/FileDownloader.py b/youtube_dl/FileDownloader.py
index 487c9dadb..e496b8a8d 100644
--- a/youtube_dl/FileDownloader.py
+++ b/youtube_dl/FileDownloader.py
@@ -80,6 +80,7 @@ class FileDownloader(object):
     writeinfojson:     Write the video description to a .info.json file
     writesubtitles:    Write the video subtitles to a .srt file
     onlysubtitles:     Downloads only the subtitles of the video
+    allsubtitles:      Downloads all the subtitles of the video
     subtitleslang:     Language of the subtitles to download
     test:              Download only first bytes to test the downloader.
     keepvideo:         Keep the video file after post-processing
@@ -442,18 +443,33 @@ class FileDownloader(object):
         if self.params.get('writesubtitles', False) and 'subtitles' in info_dict and info_dict['subtitles']:
             # subtitles download errors are already managed as troubles in relevant IE
             # that way it will silently go on when used with unsupporting IE
+            subtitle = info_dict['subtitles'][0]
+            (srt_error, srt_lang, srt) = subtitle
             try:
-                srtfn = filename.rsplit('.', 1)[0] + u'.srt'
-                if self.params.get('subtitleslang', False):
-                    srtfn = filename.rsplit('.', 1)[0] + u'.' + self.params['subtitleslang'] + u'.srt'
+                srtfn = filename.rsplit('.', 1)[0] + u'.' + srt_lang + u'.srt'
                 self.report_writesubtitles(srtfn)
                 with io.open(encodeFilename(srtfn), 'w', encoding='utf-8') as srtfile:
-                    srtfile.write(info_dict['subtitles'])
-                if self.params.get('onlysubtitles', False):
-                    return 
+                    srtfile.write(srt)
             except (OSError, IOError):
                 self.trouble(u'ERROR: Cannot write subtitles file ' + descfn)
                 return
+            if self.params.get('onlysubtitles', False):
+                return 
+
+        if self.params.get('allsubtitles', False) and 'subtitles' in info_dict and info_dict['subtitles']:
+            subtitles = info_dict['subtitles']
+            for subtitle in subtitles:
+                (srt_error, srt_lang, srt) = subtitle
+                try:
+                    srtfn = filename.rsplit('.', 1)[0] + u'.' + srt_lang + u'.srt'
+                    self.report_writesubtitles(srtfn)
+                    with io.open(encodeFilename(srtfn), 'w', encoding='utf-8') as srtfile:
+                            srtfile.write(srt)
+                except (OSError, IOError):
+                    self.trouble(u'ERROR: Cannot write subtitles file ' + descfn)
+                    return
+            if self.params.get('onlysubtitles', False):
+                return 
 
         if self.params.get('writeinfojson', False):
             infofn = filename + u'.info.json'
diff --git a/youtube_dl/InfoExtractors.py b/youtube_dl/InfoExtractors.py
index 51b263383..a220de80a 100755
--- a/youtube_dl/InfoExtractors.py
+++ b/youtube_dl/InfoExtractors.py
@@ -216,6 +216,10 @@ class YoutubeIE(InfoExtractor):
         """Report attempt to download video info webpage."""
         self._downloader.to_screen(u'[youtube] %s: Downloading video subtitles' % video_id)
 
+    def report_video_subtitles_request(self, video_id, lang):
+        """Report attempt to download video info webpage."""
+        self._downloader.to_screen(u'[youtube] %s: Downloading video subtitles for lang: %s' % (video_id,lang))
+
     def report_information_extraction(self, video_id):
         """Report attempt to extract video information."""
         self._downloader.to_screen(u'[youtube] %s: Extracting video information' % video_id)
@@ -228,9 +232,7 @@ class YoutubeIE(InfoExtractor):
         """Indicate the download will use the RTMP protocol."""
         self._downloader.to_screen(u'[youtube] RTMP download detected')
 
-
-    def _extract_subtitles(self, video_id):
-        self.report_video_subtitles_download(video_id)
+    def _get_available_subtitles(self, video_id):
         request = compat_urllib_request.Request('http://video.google.com/timedtext?hl=en&type=list&v=%s' % video_id)
         try:
             srt_list = compat_urllib_request.urlopen(request).read().decode('utf-8')
@@ -240,19 +242,15 @@ class YoutubeIE(InfoExtractor):
         srt_lang_list = dict((l[1], l[0]) for l in srt_lang_list)
         if not srt_lang_list:
             return (u'WARNING: video has no closed captions', None)
-        if self._downloader.params.get('subtitleslang', False):
-            srt_lang = self._downloader.params.get('subtitleslang')
-        elif 'en' in srt_lang_list:
-            srt_lang = 'en'
-        else:
-            srt_lang = list(srt_lang_list.keys())[0]
-        if not srt_lang in srt_lang_list:
-            return (u'WARNING: no closed captions found in the specified language "%s"' % srt_lang, None)
+        return srt_lang_list
+
+    def _request_subtitle(self, str_lang, str_name, video_id, format = 'srt'):
+        self.report_video_subtitles_request(video_id, str_lang)
         params = compat_urllib_parse.urlencode({
-            'lang': srt_lang,
-            'name': srt_lang_list[srt_lang].encode('utf-8'),
+            'lang': str_lang,
+            'name': str_name,
             'v': video_id,
-            'fmt': 'srt',
+            'fmt': format,
         })
         url = 'http://www.youtube.com/api/timedtext?' + params
         try:
@@ -261,7 +259,32 @@ class YoutubeIE(InfoExtractor):
             return (u'WARNING: unable to download video subtitles: %s' % compat_str(err), None)
         if not srt:
             return (u'WARNING: Did not fetch video subtitles', None)
-        return (None, srt)
+        return (None, str_lang, srt)
+
+    def _extract_subtitle(self, video_id):
+        self.report_video_subtitles_download(video_id)
+        srt_lang_list = self._get_available_subtitles(video_id)
+
+        if self._downloader.params.get('subtitleslang', False):
+            srt_lang = self._downloader.params.get('subtitleslang')
+        elif 'en' in srt_lang_list:
+            srt_lang = 'en'
+        else:
+            srt_lang = list(srt_lang_list.keys())[0]
+        if not srt_lang in srt_lang_list:
+            return (u'WARNING: no closed captions found in the specified language "%s"' % srt_lang, None)
+
+        sub = self._request_subtitle(srt_lang, srt_lang_list[srt_lang].encode('utf-8'), video_id)
+        return [sub]
+
+    def _extract_all_subtitles(self, video_id):
+        self.report_video_subtitles_download(video_id)
+        srt_lang_list = self._get_available_subtitles(video_id)
+        subs = []
+        for srt_lang in srt_lang_list:
+            sub = self._request_subtitle(srt_lang, srt_lang_list[srt_lang].encode('utf-8'), video_id)
+            subs.append(sub)
+        return subs
 
     def _print_formats(self, formats):
         print('Available formats:')
@@ -484,14 +507,20 @@ class YoutubeIE(InfoExtractor):
 
         # closed captions
         video_subtitles = None
-        if self._downloader.params.get('subtitleslang', False):
-            self._downloader.params['writesubtitles'] = True
-        if self._downloader.params.get('onlysubtitles', False):
-            self._downloader.params['writesubtitles'] = True
+
         if self._downloader.params.get('writesubtitles', False):
-            (srt_error, video_subtitles) = self._extract_subtitles(video_id)
-            if srt_error:
-                self._downloader.trouble(srt_error)
+            video_subtitles = self._extract_subtitle(video_id)
+            if video_subtitles:
+                (srt_error, srt_lang, srt) = video_subtitles[0]
+                if srt_error:
+                    self._downloader.trouble(srt_error)
+
+        if self._downloader.params.get('allsubtitles', False):
+            video_subtitles = self._extract_all_subtitles(video_id)
+            for video_subtitle in video_subtitles:
+                (srt_error, srt_lang, srt) = video_subtitle
+                if srt_error:
+                    self._downloader.trouble(srt_error)
 
         if 'length_seconds' not in video_info:
             self._downloader.trouble(u'WARNING: unable to extract video duration')
diff --git a/youtube_dl/__init__.py b/youtube_dl/__init__.py
index ababeac87..20a22a4d1 100644
--- a/youtube_dl/__init__.py
+++ b/youtube_dl/__init__.py
@@ -179,6 +179,9 @@ def parseOpts():
     video_format.add_option('--only-srt',
             action='store_true', dest='onlysubtitles',
             help='downloads only the subtitles of the video (currently youtube only)', default=False)
+    video_format.add_option('--all-srt',
+            action='store_true', dest='allsubtitles',
+            help='downloads all the available subtitles of the video (currently youtube only)', default=False)
     video_format.add_option('--srt-lang',
             action='store', dest='subtitleslang', metavar='LANG',
             help='language of the closed captions to download (optional) use IETF language tags like \'en\'')
@@ -454,6 +457,7 @@ def _real_main():
         'writeinfojson': opts.writeinfojson,
         'writesubtitles': opts.writesubtitles,
         'onlysubtitles': opts.onlysubtitles,
+        'allsubtitles': opts.allsubtitles,
         'subtitleslang': opts.subtitleslang,
         'matchtitle': decodeOption(opts.matchtitle),
         'rejecttitle': decodeOption(opts.rejecttitle),

From 553d097442ad5ee62d227de2e2703a2377dcf40f Mon Sep 17 00:00:00 2001
From: Ismael Mejia <iemejia@gmail.com>
Date: Fri, 22 Feb 2013 03:13:28 +0100
Subject: [PATCH 025/221] Refactor subtitle options from srt to the more
 generic 'sub'. In order to be more consistent with different subtitle
 formats. From: * --write-srt to --write-sub * --only-srt to --only-sub *
 --all-srt to --all-subs * --srt-lang to --sub-lang'

Refactored also all the mentions of srt for sub in all the source code.
---
 youtube_dl/FileDownloader.py | 26 +++++++-------
 youtube_dl/InfoExtractors.py | 68 ++++++++++++++++++------------------
 youtube_dl/__init__.py       | 14 ++++----
 3 files changed, 54 insertions(+), 54 deletions(-)

diff --git a/youtube_dl/FileDownloader.py b/youtube_dl/FileDownloader.py
index e496b8a8d..4549dd464 100644
--- a/youtube_dl/FileDownloader.py
+++ b/youtube_dl/FileDownloader.py
@@ -78,7 +78,7 @@ class FileDownloader(object):
     updatetime:        Use the Last-modified header to set output file timestamps.
     writedescription:  Write the video description to a .description file
     writeinfojson:     Write the video description to a .info.json file
-    writesubtitles:    Write the video subtitles to a .srt file
+    writesubtitles:    Write the video subtitles to a file (default=srt)
     onlysubtitles:     Downloads only the subtitles of the video
     allsubtitles:      Downloads all the subtitles of the video
     subtitleslang:     Language of the subtitles to download
@@ -291,9 +291,9 @@ class FileDownloader(object):
         """ Report that the description file is being written """
         self.to_screen(u'[info] Writing video description to: ' + descfn)
 
-    def report_writesubtitles(self, srtfn):
+    def report_writesubtitles(self, sub_filename):
         """ Report that the subtitles file is being written """
-        self.to_screen(u'[info] Writing video subtitles to: ' + srtfn)
+        self.to_screen(u'[info] Writing video subtitles to: ' + sub_filename)
 
     def report_writeinfojson(self, infofn):
         """ Report that the metadata file has been written """
@@ -444,12 +444,12 @@ class FileDownloader(object):
             # subtitles download errors are already managed as troubles in relevant IE
             # that way it will silently go on when used with unsupporting IE
             subtitle = info_dict['subtitles'][0]
-            (srt_error, srt_lang, srt) = subtitle
+            (sub_error, sub_lang, sub) = subtitle
             try:
-                srtfn = filename.rsplit('.', 1)[0] + u'.' + srt_lang + u'.srt'
-                self.report_writesubtitles(srtfn)
-                with io.open(encodeFilename(srtfn), 'w', encoding='utf-8') as srtfile:
-                    srtfile.write(srt)
+                sub_filename = filename.rsplit('.', 1)[0] + u'.' + sub_lang + u'.srt'
+                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
@@ -459,12 +459,12 @@ class FileDownloader(object):
         if self.params.get('allsubtitles', False) and 'subtitles' in info_dict and info_dict['subtitles']:
             subtitles = info_dict['subtitles']
             for subtitle in subtitles:
-                (srt_error, srt_lang, srt) = subtitle
+                (sub_error, sub_lang, sub) = subtitle
                 try:
-                    srtfn = filename.rsplit('.', 1)[0] + u'.' + srt_lang + u'.srt'
-                    self.report_writesubtitles(srtfn)
-                    with io.open(encodeFilename(srtfn), 'w', encoding='utf-8') as srtfile:
-                            srtfile.write(srt)
+                    sub_filename = filename.rsplit('.', 1)[0] + u'.' + sub_lang + u'.srt'
+                    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
diff --git a/youtube_dl/InfoExtractors.py b/youtube_dl/InfoExtractors.py
index a220de80a..e078bb083 100755
--- a/youtube_dl/InfoExtractors.py
+++ b/youtube_dl/InfoExtractors.py
@@ -47,7 +47,7 @@ class InfoExtractor(object):
     uploader_id:    Nickname or id of the video uploader.
     location:       Physical location of the video.
     player_url:     SWF Player URL (used for rtmpdump).
-    subtitles:      The .srt file contents.
+    subtitles:      The subtitle file contents.
     urlhandle:      [internal] The urlHandle to be used to download the file,
                     like returned by urllib.request.urlopen
 
@@ -235,56 +235,56 @@ class YoutubeIE(InfoExtractor):
     def _get_available_subtitles(self, video_id):
         request = compat_urllib_request.Request('http://video.google.com/timedtext?hl=en&type=list&v=%s' % video_id)
         try:
-            srt_list = compat_urllib_request.urlopen(request).read().decode('utf-8')
+            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)
-        srt_lang_list = re.findall(r'name="([^"]*)"[^>]+lang_code="([\w\-]+)"', srt_list)
-        srt_lang_list = dict((l[1], l[0]) for l in srt_lang_list)
-        if not srt_lang_list:
+        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 has no closed captions', None)
-        return srt_lang_list
+        return sub_lang_list
 
-    def _request_subtitle(self, str_lang, str_name, video_id, format = 'srt'):
-        self.report_video_subtitles_request(video_id, str_lang)
+    def _request_subtitle(self, sub_lang, sub_name, video_id, format = 'srt'):
+        self.report_video_subtitles_request(video_id, sub_lang)
         params = compat_urllib_parse.urlencode({
-            'lang': str_lang,
-            'name': str_name,
+            'lang': sub_lang,
+            'name': sub_name,
             'v': video_id,
             'fmt': format,
         })
         url = 'http://www.youtube.com/api/timedtext?' + params
         try:
-            srt = compat_urllib_request.urlopen(url).read().decode('utf-8')
+            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)
-        if not srt:
+        if not sub:
             return (u'WARNING: Did not fetch video subtitles', None)
-        return (None, str_lang, srt)
+        return (None, sub_lang, sub)
 
     def _extract_subtitle(self, video_id):
         self.report_video_subtitles_download(video_id)
-        srt_lang_list = self._get_available_subtitles(video_id)
+        sub_lang_list = self._get_available_subtitles(video_id)
 
         if self._downloader.params.get('subtitleslang', False):
-            srt_lang = self._downloader.params.get('subtitleslang')
-        elif 'en' in srt_lang_list:
-            srt_lang = 'en'
+            sub_lang = self._downloader.params.get('subtitleslang')
+        elif 'en' in sub_lang_list:
+            sub_lang = 'en'
         else:
-            srt_lang = list(srt_lang_list.keys())[0]
-        if not srt_lang in srt_lang_list:
-            return (u'WARNING: no closed captions found in the specified language "%s"' % srt_lang, None)
+            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)
 
-        sub = self._request_subtitle(srt_lang, srt_lang_list[srt_lang].encode('utf-8'), video_id)
-        return [sub]
+        subtitle = self._request_subtitle(sub_lang, sub_lang_list[sub_lang].encode('utf-8'), video_id)
+        return [subtitle]
 
     def _extract_all_subtitles(self, video_id):
         self.report_video_subtitles_download(video_id)
-        srt_lang_list = self._get_available_subtitles(video_id)
-        subs = []
-        for srt_lang in srt_lang_list:
-            sub = self._request_subtitle(srt_lang, srt_lang_list[srt_lang].encode('utf-8'), video_id)
-            subs.append(sub)
-        return subs
+        sub_lang_list = self._get_available_subtitles(video_id)
+        subtitles = []
+        for sub_lang in sub_lang_list:
+            subtitle = self._request_subtitle(sub_lang, sub_lang_list[sub_lang].encode('utf-8'), video_id)
+            subtitles.append(subtitle)
+        return subtitles
 
     def _print_formats(self, formats):
         print('Available formats:')
@@ -511,16 +511,16 @@ class YoutubeIE(InfoExtractor):
         if self._downloader.params.get('writesubtitles', False):
             video_subtitles = self._extract_subtitle(video_id)
             if video_subtitles:
-                (srt_error, srt_lang, srt) = video_subtitles[0]
-                if srt_error:
-                    self._downloader.trouble(srt_error)
+                (sub_error, sub_lang, sub) = video_subtitles[0]
+                if sub_error:
+                    self._downloader.trouble(sub_error)
 
         if self._downloader.params.get('allsubtitles', False):
             video_subtitles = self._extract_all_subtitles(video_id)
             for video_subtitle in video_subtitles:
-                (srt_error, srt_lang, srt) = video_subtitle
-                if srt_error:
-                    self._downloader.trouble(srt_error)
+                (sub_error, sub_lang, sub) = video_subtitle
+                if sub_error:
+                    self._downloader.trouble(sub_error)
 
         if 'length_seconds' not in video_info:
             self._downloader.trouble(u'WARNING: unable to extract video duration')
diff --git a/youtube_dl/__init__.py b/youtube_dl/__init__.py
index 20a22a4d1..495b5ac41 100644
--- a/youtube_dl/__init__.py
+++ b/youtube_dl/__init__.py
@@ -173,18 +173,18 @@ def parseOpts():
             action='store', dest='format_limit', metavar='FORMAT', help='highest quality format to download')
     video_format.add_option('-F', '--list-formats',
             action='store_true', dest='listformats', help='list all available formats (currently youtube only)')
-    video_format.add_option('--write-srt',
+    video_format.add_option('--write-sub',
             action='store_true', dest='writesubtitles',
-            help='write video closed captions to a .srt file (currently youtube only)', default=False)
-    video_format.add_option('--only-srt',
+            help='write subtitle file (currently youtube only)', default=False)
+    video_format.add_option('--only-sub',
             action='store_true', dest='onlysubtitles',
-            help='downloads only the subtitles of the video (currently youtube only)', default=False)
-    video_format.add_option('--all-srt',
+            help='downloads only the subtitles (no video)', default=False)
+    video_format.add_option('--all-subs',
             action='store_true', dest='allsubtitles',
             help='downloads all the available subtitles of the video (currently youtube only)', default=False)
-    video_format.add_option('--srt-lang',
+    video_format.add_option('--sub-lang',
             action='store', dest='subtitleslang', metavar='LANG',
-            help='language of the closed captions to download (optional) use IETF language tags like \'en\'')
+            help='language of the subtitles to download (optional) use IETF language tags like \'en\'')
 
     verbosity.add_option('-q', '--quiet',
             action='store_true', dest='quiet', help='activates quiet mode', default=False)

From 9e62bc443996c1950de0841997c76d110cb77c6e Mon Sep 17 00:00:00 2001
From: Ismael Mejia <iemejia@gmail.com>
Date: Fri, 22 Feb 2013 03:53:54 +0100
Subject: [PATCH 026/221] Added new option '--sub-format' to choose the format
 of the subtitles to downloade (defaut=srt)

---
 test/parameters.json           |  1 +
 test/test_youtube_subtitles.py | 10 +++++++++-
 youtube_dl/FileDownloader.py   |  9 ++++++---
 youtube_dl/InfoExtractors.py   | 11 ++++++-----
 youtube_dl/__init__.py         |  4 ++++
 5 files changed, 26 insertions(+), 9 deletions(-)

diff --git a/test/parameters.json b/test/parameters.json
index 0d4bd644c..750b1c96e 100644
--- a/test/parameters.json
+++ b/test/parameters.json
@@ -29,6 +29,7 @@
     "simulate": false, 
     "skip_download": false, 
     "subtitleslang": null, 
+    "subtitlesformat": "srt",
     "test": true, 
     "updatetime": true, 
     "usenetrc": false, 
diff --git a/test/test_youtube_subtitles.py b/test/test_youtube_subtitles.py
index 3b5a53fca..94adc4555 100644
--- a/test/test_youtube_subtitles.py
+++ b/test/test_youtube_subtitles.py
@@ -42,7 +42,7 @@ class TestYoutubeSubtitles(unittest.TestCase):
         DL = FakeDownloader()
         DL.params['allsubtitles'] = False
         DL.params['writesubtitles'] = False
-        
+        DL.params['subtitlesformat'] = 'srt'
     def test_youtube_no_subtitles(self):
         DL = FakeDownloader()
         DL.params['writesubtitles'] = False
@@ -80,6 +80,14 @@ class TestYoutubeSubtitles(unittest.TestCase):
         info_dict = IE.extract('QRS8MkLhQmM')
         subtitles = info_dict[0]['subtitles']
         self.assertEqual(len(subtitles), 12)
+    def test_youtube_subtitles_format(self):
+        DL = FakeDownloader()
+        DL.params['writesubtitles'] = True
+        DL.params['subtitlesformat'] = 'sbv'
+        IE = YoutubeIE(DL)
+        info_dict = IE.extract('QRS8MkLhQmM')
+        sub = info_dict[0]['subtitles'][0]
+        self.assertEqual(md5(sub[2]), '13aeaa0c245a8bed9a451cb643e3ad8b')
 
 if __name__ == '__main__':
     unittest.main()
diff --git a/youtube_dl/FileDownloader.py b/youtube_dl/FileDownloader.py
index 4549dd464..a041e1219 100644
--- a/youtube_dl/FileDownloader.py
+++ b/youtube_dl/FileDownloader.py
@@ -78,9 +78,10 @@ class FileDownloader(object):
     updatetime:        Use the Last-modified header to set output file timestamps.
     writedescription:  Write the video description to a .description file
     writeinfojson:     Write the video description to a .info.json file
-    writesubtitles:    Write the video subtitles to a file (default=srt)
+    writesubtitles:    Write the video subtitles to a file
     onlysubtitles:     Downloads only the subtitles of the video
     allsubtitles:      Downloads all the subtitles of the video
+    subtitlesformat:   Subtitle format [sbv/srt] (default=srt)
     subtitleslang:     Language of the subtitles to download
     test:              Download only first bytes to test the downloader.
     keepvideo:         Keep the video file after post-processing
@@ -445,8 +446,9 @@ class FileDownloader(object):
             # that way it will silently go on when used with unsupporting IE
             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'.srt'
+                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)
@@ -458,10 +460,11 @@ class FileDownloader(object):
 
         if self.params.get('allsubtitles', False) and 'subtitles' in info_dict and info_dict['subtitles']:
             subtitles = info_dict['subtitles']
+            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'.srt'
+                    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)
diff --git a/youtube_dl/InfoExtractors.py b/youtube_dl/InfoExtractors.py
index e078bb083..62522bb6c 100755
--- a/youtube_dl/InfoExtractors.py
+++ b/youtube_dl/InfoExtractors.py
@@ -244,7 +244,7 @@ class YoutubeIE(InfoExtractor):
             return (u'WARNING: video has no closed captions', None)
         return sub_lang_list
 
-    def _request_subtitle(self, sub_lang, sub_name, video_id, format = 'srt'):
+    def _request_subtitle(self, sub_lang, sub_name, video_id, format):
         self.report_video_subtitles_request(video_id, sub_lang)
         params = compat_urllib_parse.urlencode({
             'lang': sub_lang,
@@ -264,7 +264,7 @@ class YoutubeIE(InfoExtractor):
     def _extract_subtitle(self, video_id):
         self.report_video_subtitles_download(video_id)
         sub_lang_list = self._get_available_subtitles(video_id)
-
+        sub_format = self._downloader.params.get('subtitlesformat')
         if self._downloader.params.get('subtitleslang', False):
             sub_lang = self._downloader.params.get('subtitleslang')
         elif 'en' in sub_lang_list:
@@ -274,15 +274,16 @@ class YoutubeIE(InfoExtractor):
         if not sub_lang in sub_lang_list:
             return (u'WARNING: no closed captions found in the specified language "%s"' % sub_lang, None)
 
-        subtitle = self._request_subtitle(sub_lang, sub_lang_list[sub_lang].encode('utf-8'), video_id)
+        subtitle = self._request_subtitle(sub_lang, sub_lang_list[sub_lang].encode('utf-8'), video_id, sub_format)
         return [subtitle]
 
     def _extract_all_subtitles(self, video_id):
         self.report_video_subtitles_download(video_id)
         sub_lang_list = self._get_available_subtitles(video_id)
+        sub_format = self._downloader.params.get('subtitlesformat')
         subtitles = []
         for sub_lang in sub_lang_list:
-            subtitle = self._request_subtitle(sub_lang, sub_lang_list[sub_lang].encode('utf-8'), video_id)
+            subtitle = self._request_subtitle(sub_lang, sub_lang_list[sub_lang].encode('utf-8'), video_id, sub_format)
             subtitles.append(subtitle)
         return subtitles
 
@@ -505,7 +506,7 @@ class YoutubeIE(InfoExtractor):
         else:
             video_description = ''
 
-        # closed captions
+        # subtitles
         video_subtitles = None
 
         if self._downloader.params.get('writesubtitles', False):
diff --git a/youtube_dl/__init__.py b/youtube_dl/__init__.py
index 495b5ac41..914d030a3 100644
--- a/youtube_dl/__init__.py
+++ b/youtube_dl/__init__.py
@@ -182,6 +182,9 @@ def parseOpts():
     video_format.add_option('--all-subs',
             action='store_true', dest='allsubtitles',
             help='downloads all the available subtitles of the video (currently youtube only)', default=False)
+    video_format.add_option('--sub-format',
+            action='store', dest='subtitlesformat', metavar='LANG',
+            help='subtitle format [srt/sbv] (default=srt) (currently youtube only)', default='srt')
     video_format.add_option('--sub-lang',
             action='store', dest='subtitleslang', metavar='LANG',
             help='language of the subtitles to download (optional) use IETF language tags like \'en\'')
@@ -458,6 +461,7 @@ def _real_main():
         'writesubtitles': opts.writesubtitles,
         'onlysubtitles': opts.onlysubtitles,
         'allsubtitles': opts.allsubtitles,
+        'subtitlesformat': opts.subtitlesformat,
         'subtitleslang': opts.subtitleslang,
         'matchtitle': decodeOption(opts.matchtitle),
         'rejecttitle': decodeOption(opts.rejecttitle),

From 2a4093eaf3af07fa0a74926ce09cb49aba73017e Mon Sep 17 00:00:00 2001
From: Ismael Mejia <iemejia@gmail.com>
Date: Fri, 22 Feb 2013 04:50:05 +0100
Subject: [PATCH 027/221] Added new option '--list-subs' to show the available
 subtitle languages

---
 test/parameters.json           |  3 ++-
 test/test_youtube_subtitles.py |  7 +++++++
 youtube_dl/FileDownloader.py   |  1 +
 youtube_dl/InfoExtractors.py   | 26 +++++++++++++++++++-------
 youtube_dl/__init__.py         |  4 ++++
 5 files changed, 33 insertions(+), 8 deletions(-)

diff --git a/test/parameters.json b/test/parameters.json
index 750b1c96e..96998b5c3 100644
--- a/test/parameters.json
+++ b/test/parameters.json
@@ -39,5 +39,6 @@
     "writeinfojson": true, 
     "writesubtitles": false,
     "onlysubtitles": false,
-    "allsubtitles": false
+    "allsubtitles": false,
+    "listssubtitles": false
 }
diff --git a/test/test_youtube_subtitles.py b/test/test_youtube_subtitles.py
index 94adc4555..30f2246dd 100644
--- a/test/test_youtube_subtitles.py
+++ b/test/test_youtube_subtitles.py
@@ -43,6 +43,7 @@ class TestYoutubeSubtitles(unittest.TestCase):
         DL.params['allsubtitles'] = False
         DL.params['writesubtitles'] = False
         DL.params['subtitlesformat'] = 'srt'
+        DL.params['listsubtitles'] = False
     def test_youtube_no_subtitles(self):
         DL = FakeDownloader()
         DL.params['writesubtitles'] = False
@@ -88,6 +89,12 @@ class TestYoutubeSubtitles(unittest.TestCase):
         info_dict = IE.extract('QRS8MkLhQmM')
         sub = info_dict[0]['subtitles'][0]
         self.assertEqual(md5(sub[2]), '13aeaa0c245a8bed9a451cb643e3ad8b')
+    def test_youtube_list_subtitles(self):
+        DL = FakeDownloader()
+        DL.params['listsubtitles'] = True
+        IE = YoutubeIE(DL)
+        info_dict = IE.extract('QRS8MkLhQmM')
+        self.assertEqual(info_dict, None)
 
 if __name__ == '__main__':
     unittest.main()
diff --git a/youtube_dl/FileDownloader.py b/youtube_dl/FileDownloader.py
index a041e1219..164d25e54 100644
--- a/youtube_dl/FileDownloader.py
+++ b/youtube_dl/FileDownloader.py
@@ -81,6 +81,7 @@ class FileDownloader(object):
     writesubtitles:    Write the video subtitles to a file
     onlysubtitles:     Downloads only the subtitles of the video
     allsubtitles:      Downloads all the subtitles of the video
+    listsubtitles:     Lists all available subtitles for the video
     subtitlesformat:   Subtitle format [sbv/srt] (default=srt)
     subtitleslang:     Language of the subtitles to download
     test:              Download only first bytes to test the downloader.
diff --git a/youtube_dl/InfoExtractors.py b/youtube_dl/InfoExtractors.py
index 62522bb6c..ff1fab773 100755
--- a/youtube_dl/InfoExtractors.py
+++ b/youtube_dl/InfoExtractors.py
@@ -214,11 +214,16 @@ class YoutubeIE(InfoExtractor):
 
     def report_video_subtitles_download(self, video_id):
         """Report attempt to download video info webpage."""
-        self._downloader.to_screen(u'[youtube] %s: Downloading video subtitles' % video_id)
+        self._downloader.to_screen(u'[youtube] %s: Checking available subtitles' % video_id)
 
-    def report_video_subtitles_request(self, video_id, lang):
+    def report_video_subtitles_request(self, video_id, sub_lang, format):
         """Report attempt to download video info webpage."""
-        self._downloader.to_screen(u'[youtube] %s: Downloading video subtitles for lang: %s' % (video_id,lang))
+        self._downloader.to_screen(u'[youtube] %s: Downloading video subtitles for %s.%s' % (video_id, sub_lang, format))
+
+    def report_video_subtitles_available(self, video_id, sub_lang_list):
+        """Report available subtitles."""
+        sub_lang = ",".join(list(sub_lang_list.keys()))
+        self._downloader.to_screen(u'[youtube] %s: Available subtitles for video: %s' % (video_id, sub_lang))
 
     def report_information_extraction(self, video_id):
         """Report attempt to extract video information."""
@@ -233,6 +238,7 @@ class YoutubeIE(InfoExtractor):
         self._downloader.to_screen(u'[youtube] RTMP download detected')
 
     def _get_available_subtitles(self, video_id):
+        self.report_video_subtitles_download(video_id)
         request = compat_urllib_request.Request('http://video.google.com/timedtext?hl=en&type=list&v=%s' % video_id)
         try:
             sub_list = compat_urllib_request.urlopen(request).read().decode('utf-8')
@@ -241,11 +247,15 @@ class YoutubeIE(InfoExtractor):
         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 has no closed captions', None)
+            return (u'WARNING: video doesn\'t have download', None)
         return sub_lang_list
 
+    def _list_available_subtitles(self, video_id):
+        sub_lang_list = self._get_available_subtitles(video_id)
+        self.report_video_subtitles_available(video_id, sub_lang_list)
+
     def _request_subtitle(self, sub_lang, sub_name, video_id, format):
-        self.report_video_subtitles_request(video_id, sub_lang)
+        self.report_video_subtitles_request(video_id, sub_lang, format)
         params = compat_urllib_parse.urlencode({
             'lang': sub_lang,
             'name': sub_name,
@@ -262,7 +272,6 @@ class YoutubeIE(InfoExtractor):
         return (None, sub_lang, sub)
 
     def _extract_subtitle(self, video_id):
-        self.report_video_subtitles_download(video_id)
         sub_lang_list = self._get_available_subtitles(video_id)
         sub_format = self._downloader.params.get('subtitlesformat')
         if self._downloader.params.get('subtitleslang', False):
@@ -278,7 +287,6 @@ class YoutubeIE(InfoExtractor):
         return [subtitle]
 
     def _extract_all_subtitles(self, video_id):
-        self.report_video_subtitles_download(video_id)
         sub_lang_list = self._get_available_subtitles(video_id)
         sub_format = self._downloader.params.get('subtitlesformat')
         subtitles = []
@@ -523,6 +531,10 @@ class YoutubeIE(InfoExtractor):
                 if sub_error:
                     self._downloader.trouble(sub_error)
 
+        if self._downloader.params.get('listsubtitles', False):
+            sub_lang_list = self._list_available_subtitles(video_id)
+            return
+
         if 'length_seconds' not in video_info:
             self._downloader.trouble(u'WARNING: unable to extract video duration')
             video_duration = ''
diff --git a/youtube_dl/__init__.py b/youtube_dl/__init__.py
index 914d030a3..e5a7469af 100644
--- a/youtube_dl/__init__.py
+++ b/youtube_dl/__init__.py
@@ -182,6 +182,9 @@ def parseOpts():
     video_format.add_option('--all-subs',
             action='store_true', dest='allsubtitles',
             help='downloads all the available subtitles of the video (currently youtube only)', default=False)
+    video_format.add_option('--list-subs',
+            action='store_true', dest='listsubtitles',
+            help='lists all available subtitles for the video (currently youtube only)', default=False)
     video_format.add_option('--sub-format',
             action='store', dest='subtitlesformat', metavar='LANG',
             help='subtitle format [srt/sbv] (default=srt) (currently youtube only)', default='srt')
@@ -461,6 +464,7 @@ def _real_main():
         'writesubtitles': opts.writesubtitles,
         'onlysubtitles': opts.onlysubtitles,
         'allsubtitles': opts.allsubtitles,
+        'listsubtitles': opts.listsubtitles,
         'subtitlesformat': opts.subtitlesformat,
         'subtitleslang': opts.subtitleslang,
         'matchtitle': decodeOption(opts.matchtitle),

From c0ba10467457a58e7198b58793f3c4683b1c3ec7 Mon Sep 17 00:00:00 2001
From: Ismael Mejia <iemejia@gmail.com>
Date: Sat, 23 Feb 2013 16:24:59 +0100
Subject: [PATCH 028/221] Fixed typo in error message when no subtitles were
 available.

---
 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 ff1fab773..ab8bd2104 100755
--- a/youtube_dl/InfoExtractors.py
+++ b/youtube_dl/InfoExtractors.py
@@ -247,7 +247,7 @@ class YoutubeIE(InfoExtractor):
         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 download', None)
+            return (u'WARNING: video doesn\'t have subtitles', None)
         return sub_lang_list
 
     def _list_available_subtitles(self, video_id):

From b9fc428494b22623529d364387b8693cc3cb1503 Mon Sep 17 00:00:00 2001
From: Filippo Valsorda <filippo.valsorda@gmail.com>
Date: Wed, 20 Mar 2013 11:29:07 +0100
Subject: [PATCH 029/221] add '--write-srt' and '--srt-lang' aliases for
 backwards compatibility

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

diff --git a/youtube_dl/__init__.py b/youtube_dl/__init__.py
index e5a7469af..c4f64893d 100644
--- a/youtube_dl/__init__.py
+++ b/youtube_dl/__init__.py
@@ -173,7 +173,7 @@ def parseOpts():
             action='store', dest='format_limit', metavar='FORMAT', help='highest quality format to download')
     video_format.add_option('-F', '--list-formats',
             action='store_true', dest='listformats', help='list all available formats (currently youtube only)')
-    video_format.add_option('--write-sub',
+    video_format.add_option('--write-sub', '--write-srt',
             action='store_true', dest='writesubtitles',
             help='write subtitle file (currently youtube only)', default=False)
     video_format.add_option('--only-sub',
@@ -188,7 +188,7 @@ def parseOpts():
     video_format.add_option('--sub-format',
             action='store', dest='subtitlesformat', metavar='LANG',
             help='subtitle format [srt/sbv] (default=srt) (currently youtube only)', default='srt')
-    video_format.add_option('--sub-lang',
+    video_format.add_option('--sub-lang', '--srt-lang',
             action='store', dest='subtitleslang', metavar='LANG',
             help='language of the subtitles to download (optional) use IETF language tags like \'en\'')
 

From f10b2a9c14db686e7f9b7d050f41b26d5cc35e01 Mon Sep 17 00:00:00 2001
From: Filippo Valsorda <filippo.valsorda@gmail.com>
Date: Wed, 20 Mar 2013 12:13:52 +0100
Subject: [PATCH 030/221] fix KeekIE

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

diff --git a/youtube_dl/InfoExtractors.py b/youtube_dl/InfoExtractors.py
index 14fd644a2..835428f32 100755
--- a/youtube_dl/InfoExtractors.py
+++ b/youtube_dl/InfoExtractors.py
@@ -3986,11 +3986,11 @@ class KeekIE(InfoExtractor):
         webpage = self._download_webpage(url, video_id)
         m = re.search(r'<meta property="og:title" content="(?P<title>.+)"', webpage)
         title = unescapeHTML(m.group('title'))
-        m = re.search(r'<div class="bio-names-and-report">[\s\n]+<h4>(?P<uploader>\w+)</h4>', webpage)
-        uploader = unescapeHTML(m.group('uploader'))
+        m = re.search(r'<div class="user-name-and-bio">[\S\s]+?<h2>(?P<uploader>.+?)</h2>', webpage)
+        uploader = clean_html(m.group('uploader'))
         info = {
-                'id':video_id,
-                'url':video_url,
+                'id': video_id,
+                'url': video_url,
                 'ext': 'mp4',
                 'title': title,
                 'thumbnail': thumbnail,

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 031/221] 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 @@ class SoundcloudIE(InfoExtractor):
             '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 032/221] 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 033/221] 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 034/221] 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 d2c690828a8297c014d8053fbdee4e26fe11586a Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Jaime=20Marqui=CC=81nez=20Ferra=CC=81ndiz?=
 <jaimemf93@gmail.com>
Date: Thu, 28 Mar 2013 13:39:00 +0100
Subject: [PATCH 035/221] Add title and id to playlist results

Not all IE give both. They are not used yet.
---
 youtube_dl/InfoExtractors.py | 14 +++++++++-----
 1 file changed, 9 insertions(+), 5 deletions(-)

diff --git a/youtube_dl/InfoExtractors.py b/youtube_dl/InfoExtractors.py
index dd4a776e4..6053d14ec 100755
--- a/youtube_dl/InfoExtractors.py
+++ b/youtube_dl/InfoExtractors.py
@@ -147,10 +147,14 @@ class InfoExtractor(object):
         video_info = {'_type': 'url',
                       'url': url}
         return video_info
-    def playlist_result(self, entries):
+    def playlist_result(self, entries, playlist_id=None, playlist_title=None):
         """Returns a playlist"""
         video_info = {'_type': 'playlist',
                       'entries': entries}
+        if playlist_id:
+            video_info['id'] = playlist_id
+        if playlist_title:
+            video_info['title'] = playlist_title
         return video_info
 
 
@@ -1808,7 +1812,7 @@ class YoutubePlaylistIE(InfoExtractor):
             self._downloader.to_screen(u'[youtube] PL %s: Found %i videos, downloading %i' % (playlist_id, total, len(videos)))
 
         url_results = [self.url_result(url) for url in videos]
-        return [self.playlist_result(url_results)]
+        return [self.playlist_result(url_results, playlist_id)]
 
 
 class YoutubeChannelIE(InfoExtractor):
@@ -1860,7 +1864,7 @@ class YoutubeChannelIE(InfoExtractor):
 
         urls = ['http://www.youtube.com/watch?v=%s' % id for id in video_ids]
         url_entries = [self.url_result(url) for url in urls]
-        return [self.playlist_result(url_entries)]
+        return [self.playlist_result(url_entries, channel_id)]
 
 
 class YoutubeUserIE(InfoExtractor):
@@ -1944,7 +1948,7 @@ class YoutubeUserIE(InfoExtractor):
 
         urls = ['http://www.youtube.com/watch?v=%s' % video_id for video_id in video_ids]
         url_results = [self.url_result(url) for url in urls]
-        return [self.playlist_result(url_results)]
+        return [self.playlist_result(url_results, playlist_title = username)]
 
 
 class BlipTVUserIE(InfoExtractor):
@@ -2036,7 +2040,7 @@ class BlipTVUserIE(InfoExtractor):
 
         urls = [u'http://blip.tv/%s' % video_id for video_id in video_ids]
         url_entries = [self.url_result(url) for url in urls]
-        return [self.playlist_result(url_entries)]
+        return [self.playlist_result(url_entries, playlist_title = username)]
 
 
 class DepositFilesIE(InfoExtractor):

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 036/221] 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 @@ class FileDownloader(object):
                 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 037/221] 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 7eab8dc7504cf1f5f1dd03eb62e266ce24948b93 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 12:32:42 +0100
Subject: [PATCH 038/221] Pass the playlist info_dict to process_info

the playlist value can be used in the output template
---
 README.md                    |  1 +
 youtube_dl/FileDownloader.py | 11 ++++++++++-
 2 files changed, 11 insertions(+), 1 deletion(-)

diff --git a/README.md b/README.md
index 7c09d0c0d..1f3422ef8 100644
--- a/README.md
+++ b/README.md
@@ -138,6 +138,7 @@ The `-o` option allows users to indicate a template for the output file names. T
  - `ext`: The sequence will be replaced by the appropriate extension (like flv or mp4).
  - `epoch`: The sequence will be replaced by the Unix epoch when creating the file.
  - `autonumber`: The sequence will be replaced by a five-digit number that will be increased with each download, starting at zero.
+ - `playlist`: The name or the id of the playlist that contains the video.
 
 The current default template is `%(id)s.%(ext)s`, but that will be switchted to `%(title)s-%(id)s.%(ext)s` (which can be requested with `-t` at the moment).
 
diff --git a/youtube_dl/FileDownloader.py b/youtube_dl/FileDownloader.py
index 6af2acbee..d2b9be9ef 100644
--- a/youtube_dl/FileDownloader.py
+++ b/youtube_dl/FileDownloader.py
@@ -460,12 +460,21 @@ class FileDownloader(object):
             elif result_type == 'playlist':
                 #We process each entry in the playlist
                 entries_result = self.process_ie_results(result['entries'], ie)
-                results.extend(entries_result)
+                result['entries'] = entries_result
+                results.extend([result])
         return results
 
     def process_info(self, info_dict):
         """Process a single dictionary returned by an InfoExtractor."""
 
+        if info_dict.get('_type','video') == 'playlist':
+            playlist = info_dict.get('title', None) or info_dict.get('id', None)
+            self.to_screen(u'[download] Downloading playlist: %s'  % playlist)
+            for video in info_dict['entries']:
+                video['playlist'] = playlist
+                self.process_info(video)
+            return
+        
         # Keep for backwards compatibility
         info_dict['stitle'] = info_dict['title']
 

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 039/221] 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 @@ class SpiegelIE(InfoExtractor):
         }
         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 040/221] 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 @@ class SpiegelIE(InfoExtractor):
         }
         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 @@ class liveleakIE(InfoExtractor):
             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 @@ class liveleakIE(InfoExtractor):
         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 041/221] 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 @@ class MySpassIE(InfoExtractor):
         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 042/221] 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 @@ class MyVideoIE(InfoExtractor):
         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 @@ class FunnyOrDieIE(InfoExtractor):
             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 @@ class TEDIE(InfoExtractor):
         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 043/221] 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 044/221] 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 @@ which means you can modify it, redistribute it or use it however you like.
     --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 @@ which means you can modify it, redistribute it or use it however you like.
                              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 045/221] 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 @@ 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: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 046/221] 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 @@ for v in versions:
 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 047/221] 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 @@ class YoutubeIE(InfoExtractor):
         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 @@ class YoutubeIE(InfoExtractor):
         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 048/221] 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 @@ class YoutubeIE(InfoExtractor):
         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 @@ class YoutubeIE(InfoExtractor):
         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 049/221] 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 @@ class WorldStarHipHopIE(InfoExtractor):
         _title = r"""<title>(.*)</title>"""
 
         mobj = re.search(_title, webpage_src)
-        
+
         if mobj is not None:
             title = mobj.group(1)
         else:
@@ -3814,7 +3812,7 @@ class WorldStarHipHopIE(InfoExtractor):
             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 050/221] 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 generator(test_case):
         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 051/221] 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 generator(test_case):
                     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 052/221] 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 @@ class YoutubeIE(InfoExtractor):
         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 @@ class YoutubeIE(InfoExtractor):
         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 @@ class YoutubeIE(InfoExtractor):
         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 @@ class YoutubeIE(InfoExtractor):
             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 053/221] 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 @@ class YoutubeIE(InfoExtractor):
     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 054/221] 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 @@ class FileDownloader(object):
             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 @@ class FileDownloader(object):
             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 055/221] 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
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
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 056/221] 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'

From 43ff1a347d766bbaa7116f627680e8e74a8760d1 Mon Sep 17 00:00:00 2001
From: Ricardo Garcia <commits@rg3.name>
Date: Sat, 6 Apr 2013 10:46:17 +0200
Subject: [PATCH 057/221] Change rg3.github.com to rg3.github.io almost
 everywhere

---
 devscripts/gh-pages/update-feed.py             | 2 +-
 devscripts/transition_helper_exe/youtube-dl.py | 2 +-
 youtube-dl                                     | 4 ++--
 youtube_dl/update.py                           | 2 +-
 4 files changed, 5 insertions(+), 5 deletions(-)

diff --git a/devscripts/gh-pages/update-feed.py b/devscripts/gh-pages/update-feed.py
index e299429c1..cfff05fc8 100755
--- a/devscripts/gh-pages/update-feed.py
+++ b/devscripts/gh-pages/update-feed.py
@@ -19,7 +19,7 @@ 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:link href="http://rg3.github.io/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>
diff --git a/devscripts/transition_helper_exe/youtube-dl.py b/devscripts/transition_helper_exe/youtube-dl.py
index dbb4c99e1..6297dfd40 100644
--- a/devscripts/transition_helper_exe/youtube-dl.py
+++ b/devscripts/transition_helper_exe/youtube-dl.py
@@ -40,7 +40,7 @@ raw_input()
 
 filename = sys.argv[0]
 
-UPDATE_URL = "http://rg3.github.com/youtube-dl/update/"
+UPDATE_URL = "http://rg3.github.io/youtube-dl/update/"
 VERSION_URL = UPDATE_URL + 'LATEST_VERSION'
 JSON_URL = UPDATE_URL + 'versions.json'
 UPDATES_RSA_KEY = (0x9d60ee4d8f805312fdb15a62f87b95bd66177b91df176765d13514a0f1754bcd2057295c5b6f1d35daa6742c3ffc9a82d3e118861c207995a8031e151d863c9927e304576bc80692bc8e094896fcf11b66f3e29e04e3a71e9a11558558acea1840aec37fc396fb6b65dc81a1c4144e03bd1c011de62e3f1357b327d08426fe93, 65537)
diff --git a/youtube-dl b/youtube-dl
index e6f05c173..e3eb8774c 100755
--- a/youtube-dl
+++ b/youtube-dl
@@ -38,7 +38,7 @@ def rsa_verify(message, signature, key):
 
 sys.stderr.write(u'Hi! We changed distribution method and now youtube-dl needs to update itself one more time.\n')
 sys.stderr.write(u'This will only happen once. Simply press enter to go on. Sorry for the trouble!\n')
-sys.stderr.write(u'From now on, get the binaries from http://rg3.github.com/youtube-dl/download.html, not from the git repository.\n\n')
+sys.stderr.write(u'From now on, get the binaries from http://rg3.github.io/youtube-dl/download.html, not from the git repository.\n\n')
 
 try:
 	raw_input()
@@ -47,7 +47,7 @@ except NameError: # Python 3
 
 filename = sys.argv[0]
 
-UPDATE_URL = "http://rg3.github.com/youtube-dl/update/"
+UPDATE_URL = "http://rg3.github.io/youtube-dl/update/"
 VERSION_URL = UPDATE_URL + 'LATEST_VERSION'
 JSON_URL = UPDATE_URL + 'versions.json'
 UPDATES_RSA_KEY = (0x9d60ee4d8f805312fdb15a62f87b95bd66177b91df176765d13514a0f1754bcd2057295c5b6f1d35daa6742c3ffc9a82d3e118861c207995a8031e151d863c9927e304576bc80692bc8e094896fcf11b66f3e29e04e3a71e9a11558558acea1840aec37fc396fb6b65dc81a1c4144e03bd1c011de62e3f1357b327d08426fe93, 65537)
diff --git a/youtube_dl/update.py b/youtube_dl/update.py
index b446dd94c..d6e293875 100644
--- a/youtube_dl/update.py
+++ b/youtube_dl/update.py
@@ -37,7 +37,7 @@ def rsa_verify(message, signature, key):
 def update_self(to_screen, verbose, filename):
     """Update the program file with the latest version from the repository"""
 
-    UPDATE_URL = "http://rg3.github.com/youtube-dl/update/"
+    UPDATE_URL = "http://rg3.github.io/youtube-dl/update/"
     VERSION_URL = UPDATE_URL + 'LATEST_VERSION'
     JSON_URL = UPDATE_URL + 'versions.json'
     UPDATES_RSA_KEY = (0x9d60ee4d8f805312fdb15a62f87b95bd66177b91df176765d13514a0f1754bcd2057295c5b6f1d35daa6742c3ffc9a82d3e118861c207995a8031e151d863c9927e304576bc80692bc8e094896fcf11b66f3e29e04e3a71e9a11558558acea1840aec37fc396fb6b65dc81a1c4144e03bd1c011de62e3f1357b327d08426fe93, 65537)

From adb029ed813dd29463fa04d827f89f37457c713c Mon Sep 17 00:00:00 2001
From: Michael Walter <michael.walter@gmail.com>
Date: Sun, 7 Apr 2013 15:17:36 +0200
Subject: [PATCH 058/221] added --playpath/-y support to RTMP downloads (via
 'play_path' entry in 'info_dict')

---
 youtube_dl/FileDownloader.py | 7 +++++--
 1 file changed, 5 insertions(+), 2 deletions(-)

diff --git a/youtube_dl/FileDownloader.py b/youtube_dl/FileDownloader.py
index 7c5a52be1..e801db00a 100644
--- a/youtube_dl/FileDownloader.py
+++ b/youtube_dl/FileDownloader.py
@@ -629,7 +629,7 @@ class FileDownloader(object):
             except (IOError, OSError):
                 self.report_warning(u'Unable to remove downloaded video file')
 
-    def _download_with_rtmpdump(self, filename, url, player_url, page_url):
+    def _download_with_rtmpdump(self, filename, url, player_url, page_url, play_path):
         self.report_destination(filename)
         tmpfilename = self.temp_name(filename)
 
@@ -648,6 +648,8 @@ class FileDownloader(object):
             basic_args += ['-W', player_url]
         if page_url is not None:
             basic_args += ['--pageUrl', page_url]
+        if play_path is not None:
+            basic_args += ['-y', play_path]
         args = basic_args + [[], ['-e', '-k', '1']][self.params.get('continuedl', False)]
         if self.params.get('verbose', False):
             try:
@@ -702,7 +704,8 @@ class FileDownloader(object):
         if url.startswith('rtmp'):
             return self._download_with_rtmpdump(filename, url,
                                                 info_dict.get('player_url', None),
-                                                info_dict.get('page_url', None))
+                                                info_dict.get('page_url', None),
+                                                info_dict.get('play_path', None))
 
         tmpfilename = self.temp_name(filename)
         stream = None

From df2dedeefba281e37bbdae5534a3360320259b22 Mon Sep 17 00:00:00 2001
From: Michael Walter <michael.walter@gmail.com>
Date: Sun, 7 Apr 2013 15:23:48 +0200
Subject: [PATCH 059/221] added ARD InfoExtractor (german state television)

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

diff --git a/youtube_dl/InfoExtractors.py b/youtube_dl/InfoExtractors.py
index aa8074a9e..3d8145e16 100755
--- a/youtube_dl/InfoExtractors.py
+++ b/youtube_dl/InfoExtractors.py
@@ -4356,6 +4356,42 @@ class LiveLeakIE(InfoExtractor):
 
         return [info]
 
+class ARDIE(InfoExtractor):
+    IE_NAME = 'ard'
+    _VALID_URL = r'^(?:http?://)?mediathek\.daserste\.de/(?:.*/)(?P<video_id>[^/\?]+)(?:\?.*)?'
+    _TITLE = r'<h1 class="boxTopHeadline">(?P<title>.*)</h1>'
+    _MEDIA_STREAM = r'mediaCollection\.addMediaStream\((?P<media_type>\d+), (?P<quality>\d+), "(?P<rtmp_url>[^"]*)", "(?P<video_url>[^"]*)", "[^"]*"\)'
+
+    def _real_extract(self, url):
+        # determine video id from url
+        m = re.match(self._VALID_URL, url)
+        video_id = m.group('video_id')
+
+        # determine title and media streams from webpage
+        html = self._download_webpage(url, video_id)
+        title = re.search(self._TITLE, html).group('title')
+        streams = [m.groupdict() for m in re.finditer(self._MEDIA_STREAM, html)]
+        if not streams:
+            assert '"fsk"' in html
+            self._downloader.report_error(u'this video is only available after 8:00 pm')
+            return
+
+        # choose default media type and highest quality for now
+        stream = max([s for s in streams if int(s["media_type"]) == 0], key=lambda s: int(s["quality"]))
+        #stream = streams[-1]
+
+        # there's two possibilities: RTMP stream or HTTP download
+        info = {'id': video_id, 'title': title, 'ext': 'mp4'}
+        if stream['rtmp_url']:
+            self._downloader.to_screen(u'[%s] RTMP download detected' % self.IE_NAME)
+            assert stream['video_url'].startswith('mp4:')
+            info["url"] = stream["rtmp_url"]
+            info["play_path"] = stream['video_url']
+        else:
+            assert stream["video_url"].endswith('.mp4')
+            info["url"] = stream["video_url"]
+        return [info]
+
 
 def gen_extractors():
     """ Return a list of an instance of every supported extractor.
@@ -4409,5 +4445,6 @@ def gen_extractors():
         MySpassIE(),
         SpiegelIE(),
         LiveLeakIE(),
+        ARDIE(),
         GenericIE()
     ]

From d39919c03e45b3e8f804c23f78fae33cb4adc7df Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Jaime=20Marqui=CC=81nez=20Ferra=CC=81ndiz?=
 <jaime.marquinez.ferrandiz@gmail.com>
Date: Fri, 5 Apr 2013 13:01:59 +0200
Subject: [PATCH 060/221] Add progress counter for playlists

Closes #276
---
 youtube_dl/FileDownloader.py | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/youtube_dl/FileDownloader.py b/youtube_dl/FileDownloader.py
index 2237d355d..ba3277577 100644
--- a/youtube_dl/FileDownloader.py
+++ b/youtube_dl/FileDownloader.py
@@ -492,8 +492,10 @@ class FileDownloader(object):
         if info_dict.get('_type','video') == 'playlist':
             playlist = info_dict.get('title', None) or info_dict.get('id', None)
             self.to_screen(u'[download] Downloading playlist: %s'  % playlist)
-            for video in info_dict['entries']:
+            n_videos = len(info_dict['entries'])
+            for i,video in enumerate(info_dict['entries'],1):
                 video['playlist'] = playlist
+                self.to_screen(u'[download] Downloading video #%s of %s' %(i, n_videos))
                 self.process_info(video)
             return
         

From 146c12a2dafdb9ff0e5138aa0f9da38bddca6c8a Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Jaime=20Marqui=CC=81nez=20Ferra=CC=81ndiz?=
 <jaime.marquinez.ferrandiz@gmail.com>
Date: Wed, 10 Apr 2013 00:05:04 +0200
Subject: [PATCH 061/221] Change the order for extracting/downloading

Now it gets a video info and directly downloads it, the it pass to the next video founded.
---
 youtube_dl/FileDownloader.py | 103 ++++++++++++++++++-----------------
 1 file changed, 53 insertions(+), 50 deletions(-)

diff --git a/youtube_dl/FileDownloader.py b/youtube_dl/FileDownloader.py
index ba3277577..58be5caee 100644
--- a/youtube_dl/FileDownloader.py
+++ b/youtube_dl/FileDownloader.py
@@ -419,9 +419,10 @@ class FileDownloader(object):
                 return u'"' + title + '" title matched reject pattern "' + rejecttitle + '"'
         return None
         
-    def extract_info(self, url):
+    def extract_info(self, url, download = True):
         '''
         Returns a list with a dictionary for each video we find.
+        If 'download', also downloads the videos.
          '''
         suitable_found = False
         for ie in self._ies:
@@ -440,7 +441,12 @@ class FileDownloader(object):
             # Extract information from URL and process it
             try:
                 ie_results = ie.extract(url)
-                results = self.process_ie_results(ie_results, ie)
+                results = []
+                for ie_result in ie_results:
+                    if not 'extractor' in ie_result:
+                        #The extractor has already been set somewhere else
+                        ie_result['extractor'] = ie.IE_NAME
+                    results.append(self.process_ie_result(ie_result, download))
                 return results
             except ExtractorError as de: # An error we somewhat expected
                 self.trouble(u'ERROR: ' + compat_str(de), de.format_traceback())
@@ -453,51 +459,51 @@ class FileDownloader(object):
                     raise
         if not suitable_found:
                 self.trouble(u'ERROR: no suitable InfoExtractor: %s' % url)
-    def extract_info_iterable(self, urls):
-        '''
-            Return the videos founded for the urls
-        '''
-        results = []
-        for url in urls:
-            results.extend(self.extract_info(url))
-        return results
         
-    def process_ie_results(self, ie_results, ie):
+    def process_ie_result(self, ie_result, download = True):
         """
-        Take the results of the ie and return a list of videos.
-        For url elements it will seartch the suitable ie and get the videos
+        Take the result of the ie and return a list of videos.
+        For url elements it will search the suitable ie and get the videos
         For playlist elements it will process each of the elements of the 'entries' key
+        
+        It will also download the videos if 'download'.
         """
-        results = [] 
-        for result in ie_results or []:
-            result_type = result.get('_type', 'video') #If not given we suppose it's a video, support the dafault old system
-            if result_type == 'video':
-                if not 'extractor' in result:
-                    #The extractor has already been set somewhere else
-                    result['extractor'] = ie.IE_NAME
-                results.append(result)
-            elif result_type == 'url':
-                #We get the videos pointed by the url
-                results.extend(self.extract_info(result['url']))
-            elif result_type == 'playlist':
-                #We process each entry in the playlist
-                entries_result = self.process_ie_results(result['entries'], ie)
-                result['entries'] = entries_result
-                results.extend([result])
-        return results
+        result_type = ie_result.get('_type', 'video') #If not given we suppose it's a video, support the dafault old system
+        if result_type == 'video':
+            if 'playlist' not in ie_result:
+                #It isn't part of a playlist
+                ie_result['playlist'] = None
+            if download:
+                #Do the download:
+                self.process_info(ie_result)
+            return ie_result
+        elif result_type == 'url':
+            #We get the video pointed by the url
+            result = self.extract_info(ie_result['url'], download)[0]
+            return result
+        elif result_type == 'playlist':
+            #We process each entry in the playlist
+            playlist = ie_result.get('title', None) or ie_result.get('id', None)
+            self.to_screen(u'[download] Downloading playlist: %s'  % playlist)
+            n_videos = len(ie_result['entries'])
+            playlist_results = []
+            for i,entry in enumerate(ie_result['entries'],1):
+                self.to_screen(u'[download] Downloading video #%s of %s' %(i, n_videos))
+                entry_result = self.process_ie_result(entry, False)
+                entry_result['playlist'] = playlist
+                #We must do the download here to correctly set the 'playlist' key
+                if download:
+                    self.process_info(entry_result)
+                playlist_results.append(entry_result)
+            result = ie_result.copy()
+            result['entries'] = playlist_results
+            return result
 
     def process_info(self, info_dict):
         """Process a single dictionary returned by an InfoExtractor."""
 
-        if info_dict.get('_type','video') == 'playlist':
-            playlist = info_dict.get('title', None) or info_dict.get('id', None)
-            self.to_screen(u'[download] Downloading playlist: %s'  % playlist)
-            n_videos = len(info_dict['entries'])
-            for i,video in enumerate(info_dict['entries'],1):
-                video['playlist'] = playlist
-                self.to_screen(u'[download] Downloading video #%s of %s' %(i, n_videos))
-                self.process_info(video)
-            return
+        #We increment the download the download count here to match the previous behaviour.
+        self.increment_downloads()
         
         # Keep for backwards compatibility
         info_dict['stitle'] = info_dict['title']
@@ -633,17 +639,14 @@ class FileDownloader(object):
             raise SameFileError(self.params['outtmpl'])
 
         for url in url_list:
-            videos = self.extract_info(url)
-
-            for video in videos or []:
-                try:
-                    self.increment_downloads()
-                    self.process_info(video)
-                except UnavailableVideoError:
-                    self.trouble(u'\nERROR: unable to download video')
-                except MaxDownloadsReached:
-                    self.to_screen(u'[info] Maximum number of downloaded files reached.')
-                    raise
+            try:
+                #It also downloads the videos
+                videos = self.extract_info(url)
+            except UnavailableVideoError:
+                self.trouble(u'\nERROR: unable to download video')
+            except MaxDownloadsReached:
+                self.to_screen(u'[info] Maximum number of downloaded files reached.')
+                raise
 
         return self._download_retcode
 

From 532d797824a1ec48480f1d10075e66a90aa53449 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Jaime=20Marqui=CC=81nez=20Ferra=CC=81ndiz?=
 <jaime.marquinez.ferrandiz@gmail.com>
Date: Wed, 10 Apr 2013 00:06:03 +0200
Subject: [PATCH 062/221] In MetacafeIE return a url if YoutubeIE should do the
 job

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

diff --git a/youtube_dl/InfoExtractors.py b/youtube_dl/InfoExtractors.py
index 81eaddc72..b7371365a 100755
--- a/youtube_dl/InfoExtractors.py
+++ b/youtube_dl/InfoExtractors.py
@@ -723,8 +723,7 @@ class MetacafeIE(InfoExtractor):
         # Check if video comes from YouTube
         mobj2 = re.match(r'^yt-(.*)$', video_id)
         if mobj2 is not None:
-            self._downloader.download(['http://www.youtube.com/watch?v=%s' % mobj2.group(1)])
-            return
+            return [self.url_result('http://www.youtube.com/watch?v=%s' % mobj2.group(1))]
 
         # Retrieve video webpage to extract further information
         request = compat_urllib_request.Request('http://www.metacafe.com/watch/%s/' % video_id)

From bce878a7c1678ac698ecd556b2c77a1e2f2306df Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Jaime=20Marqui=CC=81nez=20Ferra=CC=81ndiz?=
 <jaime.marquinez.ferrandiz@gmail.com>
Date: Wed, 10 Apr 2013 14:32:03 +0200
Subject: [PATCH 063/221] Implement the playlist/start options in
 FileDownloader

It makes it available for all the InfoExtractors
---
 youtube_dl/FileDownloader.py | 21 ++++++++++++++++++---
 youtube_dl/InfoExtractors.py | 34 ----------------------------------
 2 files changed, 18 insertions(+), 37 deletions(-)

diff --git a/youtube_dl/FileDownloader.py b/youtube_dl/FileDownloader.py
index 58be5caee..5a5141ba5 100644
--- a/youtube_dl/FileDownloader.py
+++ b/youtube_dl/FileDownloader.py
@@ -485,10 +485,25 @@ class FileDownloader(object):
             #We process each entry in the playlist
             playlist = ie_result.get('title', None) or ie_result.get('id', None)
             self.to_screen(u'[download] Downloading playlist: %s'  % playlist)
-            n_videos = len(ie_result['entries'])
+
             playlist_results = []
-            for i,entry in enumerate(ie_result['entries'],1):
-                self.to_screen(u'[download] Downloading video #%s of %s' %(i, n_videos))
+
+            n_all_entries = len(ie_result['entries'])
+            playliststart = self.params.get('playliststart', 1) - 1
+            playlistend = self.params.get('playlistend', -1)
+
+            if playlistend == -1:
+                entries = ie_result['entries'][playliststart:]
+            else:
+                entries = ie_result['entries'][playliststart:playlistend]
+
+            n_entries = len(entries)
+
+            self.to_screen(u"[%s] playlist '%s': Collected %d video ids (downloading %d of them)" %
+                (ie_result['extractor'], playlist, n_all_entries, n_entries))
+
+            for i,entry in enumerate(entries,1):
+                self.to_screen(u'[download] Downloading video #%s of %s' %(i, n_entries))
                 entry_result = self.process_ie_result(entry, False)
                 entry_result['playlist'] = playlist
                 #We must do the download here to correctly set the 'playlist' key
diff --git a/youtube_dl/InfoExtractors.py b/youtube_dl/InfoExtractors.py
index b7371365a..a7fdf1607 100755
--- a/youtube_dl/InfoExtractors.py
+++ b/youtube_dl/InfoExtractors.py
@@ -1806,19 +1806,6 @@ class YoutubePlaylistIE(InfoExtractor):
             page_num += 1
 
         videos = [v[1] for v in sorted(videos)]
-        total = len(videos)
-
-        playliststart = self._downloader.params.get('playliststart', 1) - 1
-        playlistend = self._downloader.params.get('playlistend', -1)
-        if playlistend == -1:
-            videos = videos[playliststart:]
-        else:
-            videos = videos[playliststart:playlistend]
-
-        if len(videos) == total:
-            self._downloader.to_screen(u'[youtube] PL %s: Found %i videos' % (playlist_id, total))
-        else:
-            self._downloader.to_screen(u'[youtube] PL %s: Found %i videos, downloading %i' % (playlist_id, total, len(videos)))
 
         url_results = [self.url_result(url) for url in videos]
         return [self.playlist_result(url_results, playlist_id)]
@@ -1943,18 +1930,6 @@ class YoutubeUserIE(InfoExtractor):
 
             pagenum += 1
 
-        all_ids_count = len(video_ids)
-        playliststart = self._downloader.params.get('playliststart', 1) - 1
-        playlistend = self._downloader.params.get('playlistend', -1)
-
-        if playlistend == -1:
-            video_ids = video_ids[playliststart:]
-        else:
-            video_ids = video_ids[playliststart:playlistend]
-
-        self._downloader.to_screen(u"[youtube] user %s: Collected %d video ids (downloading %d of them)" %
-                (username, all_ids_count, len(video_ids)))
-
         urls = ['http://www.youtube.com/watch?v=%s' % video_id for video_id in video_ids]
         url_results = [self.url_result(url) for url in urls]
         return [self.playlist_result(url_results, playlist_title = username)]
@@ -2035,15 +2010,6 @@ class BlipTVUserIE(InfoExtractor):
 
             pagenum += 1
 
-        all_ids_count = len(video_ids)
-        playliststart = self._downloader.params.get('playliststart', 1) - 1
-        playlistend = self._downloader.params.get('playlistend', -1)
-
-        if playlistend == -1:
-            video_ids = video_ids[playliststart:]
-        else:
-            video_ids = video_ids[playliststart:playlistend]
-
         self._downloader.to_screen(u"[%s] user %s: Collected %d video ids (downloading %d of them)" %
                 (self.IE_NAME, username, all_ids_count, len(video_ids)))
 

From dc36bc943499e42fac7873bc55ab573eb573e25d Mon Sep 17 00:00:00 2001
From: Adam Mesha <adam@mesha.org>
Date: Thu, 11 Apr 2013 07:27:04 +0300
Subject: [PATCH 064/221] Fix bug when the vimeo description is empty on Python
 2.x.

---
 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 aa8074a9e..82ba63449 100755
--- a/youtube_dl/InfoExtractors.py
+++ b/youtube_dl/InfoExtractors.py
@@ -1130,7 +1130,7 @@ class VimeoIE(InfoExtractor):
         # Extract video description
         video_description = get_element_by_attribute("itemprop", "description", webpage)
         if video_description: video_description = clean_html(video_description)
-        else: video_description = ''
+        else: video_description = u''
 
         # Extract upload date
         video_upload_date = None

From 87439741894443fcf6e10fce221b4e6d6911b6b8 Mon Sep 17 00:00:00 2001
From: Adam Mesha <adam@mesha.org>
Date: Thu, 11 Apr 2013 07:33:18 +0300
Subject: [PATCH 065/221] Resolve the symlink if __main__.py is invoke as a
 symlink.

---
 youtube_dl/__main__.py | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/youtube_dl/__main__.py b/youtube_dl/__main__.py
index 7022ea4be..3fe29c91f 100755
--- a/youtube_dl/__main__.py
+++ b/youtube_dl/__main__.py
@@ -9,7 +9,8 @@ import sys
 if __package__ is None and not hasattr(sys, "frozen"):
     # direct call of __main__.py
     import os.path
-    sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+    path = os.path.realpath(os.path.abspath(__file__))
+    sys.path.append(os.path.dirname(os.path.dirname(path)))
 
 import youtube_dl
 

From b03d65c2370d812f4bb141e6d9599553267c07ac Mon Sep 17 00:00:00 2001
From: Philipp Hagemeister <phihag@phihag.de>
Date: Thu, 11 Apr 2013 10:47:21 +0200
Subject: [PATCH 066/221] Minor improvements for ARD IE

---
 test/tests.json              | 10 ++++++++++
 youtube_dl/InfoExtractors.py | 16 ++++++++++------
 2 files changed, 20 insertions(+), 6 deletions(-)

diff --git a/test/tests.json b/test/tests.json
index 0c94c65bd..0c3b24054 100644
--- a/test/tests.json
+++ b/test/tests.json
@@ -328,5 +328,15 @@
     "info_dict": {
         "title": "Video: KO Of The Week: MMA Fighter Gets Knocked Out By Swift Head Kick! "
     }
+  },
+  {
+    "name": "ARD",
+    "url": "http://www.ardmediathek.de/das-erste/tagesschau-in-100-sek?documentId=14077640",
+    "file": "14077640.mp4",
+    "md5": "6ca8824255460c787376353f9e20bbd8",
+    "info_dict": {
+        "title": "11.04.2013 09:23 Uhr - Tagesschau in 100 Sekunden"
+    }
   }
+
 ]
diff --git a/youtube_dl/InfoExtractors.py b/youtube_dl/InfoExtractors.py
index 3d8145e16..51aca5497 100755
--- a/youtube_dl/InfoExtractors.py
+++ b/youtube_dl/InfoExtractors.py
@@ -4357,15 +4357,19 @@ class LiveLeakIE(InfoExtractor):
         return [info]
 
 class ARDIE(InfoExtractor):
-    IE_NAME = 'ard'
-    _VALID_URL = r'^(?:http?://)?mediathek\.daserste\.de/(?:.*/)(?P<video_id>[^/\?]+)(?:\?.*)?'
-    _TITLE = r'<h1 class="boxTopHeadline">(?P<title>.*)</h1>'
+    _VALID_URL = r'^(?:https?://)?(?:(?:www\.)?ardmediathek\.de|mediathek\.daserste\.de)/(?:.*/)(?P<video_id>[^/\?]+)(?:\?.*)?'
+    _TITLE = r'<h1(?: class="boxTopHeadline")?>(?P<title>.*)</h1>'
     _MEDIA_STREAM = r'mediaCollection\.addMediaStream\((?P<media_type>\d+), (?P<quality>\d+), "(?P<rtmp_url>[^"]*)", "(?P<video_url>[^"]*)", "[^"]*"\)'
 
     def _real_extract(self, url):
         # determine video id from url
         m = re.match(self._VALID_URL, url)
-        video_id = m.group('video_id')
+
+        numid = re.search(r'documentId=([0-9]+)', url)
+        if numid:
+            video_id = numid.group(1)
+        else:
+            video_id = m.group('video_id')
 
         # determine title and media streams from webpage
         html = self._download_webpage(url, video_id)
@@ -4377,8 +4381,8 @@ class ARDIE(InfoExtractor):
             return
 
         # choose default media type and highest quality for now
-        stream = max([s for s in streams if int(s["media_type"]) == 0], key=lambda s: int(s["quality"]))
-        #stream = streams[-1]
+        stream = max([s for s in streams if int(s["media_type"]) == 0],
+                     key=lambda s: int(s["quality"]))
 
         # there's two possibilities: RTMP stream or HTTP download
         info = {'id': video_id, 'title': title, 'ext': 'mp4'}

From e8600d69fdab95668acc443d639c5cd460d45b91 Mon Sep 17 00:00:00 2001
From: Philipp Hagemeister <phihag@phihag.de>
Date: Thu, 11 Apr 2013 10:48:37 +0200
Subject: [PATCH 067/221] Credit @catch22 for ARD IE

---
 youtube_dl/__init__.py | 1 +
 1 file changed, 1 insertion(+)

diff --git a/youtube_dl/__init__.py b/youtube_dl/__init__.py
index 807b73541..6a1a9bb52 100644
--- a/youtube_dl/__init__.py
+++ b/youtube_dl/__init__.py
@@ -24,6 +24,7 @@ __authors__  = (
     'Jaime Marquínez Ferrándiz',
     'Jeff Crouse',
     'Osama Khalid',
+    'Michael Walter',
     )
 
 __license__ = 'Public Domain'

From 213c31ae16641ed2df61f0abbd7ea032267b2222 Mon Sep 17 00:00:00 2001
From: Stanislav Kupryakhin <st.kupr@gmail.com>
Date: Tue, 2 Apr 2013 11:40:07 +0700
Subject: [PATCH 068/221] Added option --autonumber-size:   Specifies the
 number of digits in %(autonumber)s when it is present in output filename
 template or --autonumber option is given

---
 youtube_dl/FileDownloader.py | 4 +++-
 youtube_dl/__init__.py       | 6 ++++++
 2 files changed, 9 insertions(+), 1 deletion(-)

diff --git a/youtube_dl/FileDownloader.py b/youtube_dl/FileDownloader.py
index e801db00a..7731db17f 100644
--- a/youtube_dl/FileDownloader.py
+++ b/youtube_dl/FileDownloader.py
@@ -388,7 +388,9 @@ class FileDownloader(object):
             template_dict = dict(info_dict)
 
             template_dict['epoch'] = int(time.time())
-            template_dict['autonumber'] = u'%05d' % self._num_downloads
+            autonumber_size = self.params.get('autonumber_size', 5)
+            autonumber_templ = u'%0' + str(autonumber_size) + u'd'
+            template_dict['autonumber'] = autonumber_templ % self._num_downloads
 
             sanitize = lambda k,v: sanitize_filename(
                 u'NA' if v is None else compat_str(v),
diff --git a/youtube_dl/__init__.py b/youtube_dl/__init__.py
index 6a1a9bb52..6ca0ab674 100644
--- a/youtube_dl/__init__.py
+++ b/youtube_dl/__init__.py
@@ -236,6 +236,9 @@ def parseOpts():
             help='number downloaded files starting from 00000', default=False)
     filesystem.add_option('-o', '--output',
             dest='outtmpl', metavar='TEMPLATE', help='output filename template. Use %(title)s to get the title, %(uploader)s for the uploader name, %(uploader_id)s for the uploader nickname if different, %(autonumber)s to get an automatically incremented number, %(ext)s for the filename extension, %(upload_date)s for the upload date (YYYYMMDD), %(extractor)s for the provider (youtube, metacafe, etc), %(id)s for the video id and %% for a literal percent. Use - to output to stdout. Can also be used to download to a different directory, for example with -o \'/my/downloads/%(uploader)s/%(title)s-%(id)s.%(ext)s\' .')
+    filesystem.add_option('--autonumber-size',
+            dest='autonumber_size', metavar='NUMBER',
+            help='Specifies the number of digits in %(autonumber)s when it is present in output filename template or --autonumber option is given')
     filesystem.add_option('--restrict-filenames',
             action='store_true', dest='restrictfilenames',
             help='Restrict filenames to only ASCII characters, and avoid "&" and spaces in filenames', default=False)
@@ -300,6 +303,8 @@ def parseOpts():
         print(u'[debug] System config: ' + repr(systemConf))
         print(u'[debug] User config: ' + repr(userConf))
         print(u'[debug] Command-line args: ' + repr(commandLineConf))
+        print(u'[debug] opts: ' + repr(opts))
+        print(u'[debug] args: ' + repr(args))
 
     return parser, opts, args
 
@@ -452,6 +457,7 @@ def _real_main():
         'format_limit': opts.format_limit,
         'listformats': opts.listformats,
         'outtmpl': outtmpl,
+        'autonumber_size': opts.autonumber_size,
         'restrictfilenames': opts.restrictfilenames,
         'ignoreerrors': opts.ignoreerrors,
         'ratelimit': opts.ratelimit,

From 844d1f9fa199395b6ae6abd50c50859c9fd524e3 Mon Sep 17 00:00:00 2001
From: Philipp Hagemeister <phihag@phihag.de>
Date: Thu, 11 Apr 2013 10:54:37 +0200
Subject: [PATCH 069/221] Removed overly verbose options and arguments (Should
 be obvious from the previous lines)

---
 youtube_dl/__init__.py | 2 --
 1 file changed, 2 deletions(-)

diff --git a/youtube_dl/__init__.py b/youtube_dl/__init__.py
index 6ca0ab674..489f8948a 100644
--- a/youtube_dl/__init__.py
+++ b/youtube_dl/__init__.py
@@ -303,8 +303,6 @@ def parseOpts():
         print(u'[debug] System config: ' + repr(systemConf))
         print(u'[debug] User config: ' + repr(userConf))
         print(u'[debug] Command-line args: ' + repr(commandLineConf))
-        print(u'[debug] opts: ' + repr(opts))
-        print(u'[debug] args: ' + repr(args))
 
     return parser, opts, args
 

From e0fee250c30969b73685bbf9d3e6ad0d7917a0a6 Mon Sep 17 00:00:00 2001
From: Philipp Hagemeister <phihag@phihag.de>
Date: Thu, 11 Apr 2013 17:07:55 +0200
Subject: [PATCH 070/221] Fix default for variable-size autonumbering

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

diff --git a/youtube_dl/FileDownloader.py b/youtube_dl/FileDownloader.py
index 7731db17f..d4f9cc621 100644
--- a/youtube_dl/FileDownloader.py
+++ b/youtube_dl/FileDownloader.py
@@ -388,7 +388,9 @@ class FileDownloader(object):
             template_dict = dict(info_dict)
 
             template_dict['epoch'] = int(time.time())
-            autonumber_size = self.params.get('autonumber_size', 5)
+            autonumber_size = self.params.get('autonumber_size')
+            if autonumber_size is None:
+                autonumber_size = 5
             autonumber_templ = u'%0' + str(autonumber_size) + u'd'
             template_dict['autonumber'] = autonumber_templ % self._num_downloads
 

From af9ad45cd43c67f6110c449de00c7d11237add78 Mon Sep 17 00:00:00 2001
From: Philipp Hagemeister <phihag@phihag.de>
Date: Thu, 11 Apr 2013 17:20:05 +0200
Subject: [PATCH 071/221] Re-enable Stanford OC test

---
 test/tests.json | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/test/tests.json b/test/tests.json
index 0c3b24054..23cccb7d8 100644
--- a/test/tests.json
+++ b/test/tests.json
@@ -76,8 +76,7 @@
     "name": "StanfordOpenClassroom",
     "md5":  "544a9468546059d4e80d76265b0443b8",
     "url":  "http://openclassroom.stanford.edu/MainFolder/VideoPage.php?course=PracticalUnix&video=intro-environment&speed=100",
-    "file":  "PracticalUnix_intro-environment.mp4",
-    "skip": "Currently offline"
+    "file":  "PracticalUnix_intro-environment.mp4"
   },
   {
     "name": "XNXX",

From 0ba994e9e323f4162ed12542beb079df1f4b2825 Mon Sep 17 00:00:00 2001
From: Philipp Hagemeister <phihag@phihag.de>
Date: Thu, 11 Apr 2013 17:20:17 +0200
Subject: [PATCH 072/221] Skip ARD test as it requires rtmpdump

---
 test/tests.json | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/test/tests.json b/test/tests.json
index 23cccb7d8..7808a07de 100644
--- a/test/tests.json
+++ b/test/tests.json
@@ -335,7 +335,8 @@
     "md5": "6ca8824255460c787376353f9e20bbd8",
     "info_dict": {
         "title": "11.04.2013 09:23 Uhr - Tagesschau in 100 Sekunden"
-    }
+    },
+    "skip": "Requires rtmpdump"
   }
 
 ]

From 927c8c49246bb7ae98596b3cf518425d46f39100 Mon Sep 17 00:00:00 2001
From: Philipp Hagemeister <phihag@phihag.de>
Date: Thu, 11 Apr 2013 18:18:15 +0200
Subject: [PATCH 073/221] Use download_webpage in youtube IE

---
 youtube_dl/InfoExtractors.py | 21 +++++++++------------
 1 file changed, 9 insertions(+), 12 deletions(-)

diff --git a/youtube_dl/InfoExtractors.py b/youtube_dl/InfoExtractors.py
index 080730660..c1c206a8a 100755
--- a/youtube_dl/InfoExtractors.py
+++ b/youtube_dl/InfoExtractors.py
@@ -115,7 +115,8 @@ class InfoExtractor(object):
         """ Returns the response handle """
         if note is None:
             note = u'Downloading video webpage'
-        self._downloader.to_screen(u'[%s] %s: %s' % (self.IE_NAME, video_id, note))
+        if note is not False:
+            self._downloader.to_screen(u'[%s] %s: %s' % (self.IE_NAME, video_id, note))
         try:
             return compat_urllib_request.urlopen(url_or_request)
         except (compat_urllib_error.URLError, compat_http_client.HTTPException, socket.error) as err:
@@ -463,18 +464,14 @@ class YoutubeIE(InfoExtractor):
         # Get video info
         self.report_video_info_webpage_download(video_id)
         for el_type in ['&el=embedded', '&el=detailpage', '&el=vevo', '']:
-            video_info_url = ('http://www.youtube.com/get_video_info?&video_id=%s%s&ps=default&eurl=&gl=US&hl=en'
+            video_info_url = ('https://www.youtube.com/get_video_info?&video_id=%s%s&ps=default&eurl=&gl=US&hl=en'
                     % (video_id, el_type))
-            request = compat_urllib_request.Request(video_info_url)
-            try:
-                video_info_webpage_bytes = compat_urllib_request.urlopen(request).read()
-                video_info_webpage = video_info_webpage_bytes.decode('utf-8', 'ignore')
-                video_info = compat_parse_qs(video_info_webpage)
-                if 'token' in video_info:
-                    break
-            except (compat_urllib_error.URLError, compat_http_client.HTTPException, socket.error) as err:
-                self._downloader.report_error(u'unable to download video info webpage: %s' % compat_str(err))
-                return
+            video_info_webpage = self._download_webpage(video_info_url, video_id,
+                                    note=False,
+                                    errnote='unable to download video info webpage')
+            video_info = compat_parse_qs(video_info_webpage)
+            if 'token' in video_info:
+                break
         if 'token' not in video_info:
             if 'reason' in video_info:
                 self._downloader.report_error(u'YouTube said: %s' % video_info['reason'][0])

From 855703e55e46f3e070d9837a2eda1e6eb8a27301 Mon Sep 17 00:00:00 2001
From: Philipp Hagemeister <phihag@phihag.de>
Date: Thu, 11 Apr 2013 18:31:35 +0200
Subject: [PATCH 074/221] Option to dump intermediate pages

---
 youtube_dl/InfoExtractors.py | 8 ++++++++
 youtube_dl/__init__.py       | 4 ++++
 2 files changed, 12 insertions(+)

diff --git a/youtube_dl/InfoExtractors.py b/youtube_dl/InfoExtractors.py
index c1c206a8a..94e4451ed 100755
--- a/youtube_dl/InfoExtractors.py
+++ b/youtube_dl/InfoExtractors.py
@@ -134,6 +134,14 @@ class InfoExtractor(object):
         else:
             encoding = 'utf-8'
         webpage_bytes = urlh.read()
+        if self._downloader.params.get('dump_intermediate_pages', False):
+            try:
+                url = url_or_request.get_full_url()
+            except AttributeError:
+                url = url_or_request
+            self._downloader.to_screen(u'Dumping request to ' + url)
+            dump = base64.b64encode(webpage_bytes).decode('ascii')
+            self._downloader.to_screen(dump)
         return webpage_bytes.decode(encoding, 'replace')
 
 
diff --git a/youtube_dl/__init__.py b/youtube_dl/__init__.py
index 489f8948a..f46143e01 100644
--- a/youtube_dl/__init__.py
+++ b/youtube_dl/__init__.py
@@ -224,6 +224,9 @@ def parseOpts():
             help='display progress in console titlebar', default=False)
     verbosity.add_option('-v', '--verbose',
             action='store_true', dest='verbose', help='print various debugging information', default=False)
+    verbosity.add_option('--dump-intermediate-pages',
+            action='store_true', dest='dump_intermediate_pages', default=False,
+            help='print downloaded pages to debug problems(very verbose)')
 
     filesystem.add_option('-t', '--title',
             action='store_true', dest='usetitle', help='use title in file name', default=False)
@@ -485,6 +488,7 @@ def _real_main():
         'max_downloads': opts.max_downloads,
         'prefer_free_formats': opts.prefer_free_formats,
         'verbose': opts.verbose,
+        'dump_intermediate_pages': opts.dump_intermediate_pages,
         'test': opts.test,
         'keepvideo': opts.keepvideo,
         'min_filesize': opts.min_filesize,

From 744435f2a420c2d734b70e302ca881a176a447ed Mon Sep 17 00:00:00 2001
From: Philipp Hagemeister <phihag@phihag.de>
Date: Thu, 11 Apr 2013 18:38:43 +0200
Subject: [PATCH 075/221] Show whole diff in error cases

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

diff --git a/test/test_download.py b/test/test_download.py
index 59a6e1498..e3513efba 100644
--- a/test/test_download.py
+++ b/test/test_download.py
@@ -58,6 +58,7 @@ with io.open(PARAMETERS_FILE, encoding='utf-8') as pf:
 
 
 class TestDownload(unittest.TestCase):
+    maxDiff = None
     def setUp(self):
         self.parameters = parameters
         self.defs = defs

From f4381ab88a5bebc241d6f089719720049014ced9 Mon Sep 17 00:00:00 2001
From: Philipp Hagemeister <phihag@phihag.de>
Date: Thu, 11 Apr 2013 18:39:13 +0200
Subject: [PATCH 076/221] Fix keek title extraction

---
 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 94e4451ed..7deb488a9 100755
--- a/youtube_dl/InfoExtractors.py
+++ b/youtube_dl/InfoExtractors.py
@@ -4136,7 +4136,7 @@ class KeekIE(InfoExtractor):
         video_url = u'http://cdn.keek.com/keek/video/%s' % video_id
         thumbnail = u'http://cdn.keek.com/keek/thumbnail/%s/w100/h75' % video_id
         webpage = self._download_webpage(url, video_id)
-        m = re.search(r'<meta property="og:title" content="(?P<title>.+)"', webpage)
+        m = re.search(r'<meta property="og:title" content="(?P<title>.*?)"', webpage)
         title = unescapeHTML(m.group('title'))
         m = re.search(r'<div class="user-name-and-bio">[\S\s]+?<h2>(?P<uploader>.+?)</h2>', webpage)
         uploader = clean_html(m.group('uploader'))

From b625bc2c31e9434135e077c00d96eb8f05f80a3e Mon Sep 17 00:00:00 2001
From: Philipp Hagemeister <phihag@phihag.de>
Date: Thu, 11 Apr 2013 18:42:57 +0200
Subject: [PATCH 077/221] release 2013.04.11

---
 README.md             | 208 ++++++++++++++++++++++--------------------
 youtube_dl/version.py |   2 +-
 2 files changed, 108 insertions(+), 102 deletions(-)

diff --git a/README.md b/README.md
index 338b6133f..cf95187e6 100644
--- a/README.md
+++ b/README.md
@@ -14,119 +14,125 @@ your Unix box, on Windows or on Mac OS X. It is released to the public domain,
 which means you can modify it, redistribute it or use it however you like.
 
 # OPTIONS
-    -h, --help               print this help text and exit
-    --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   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)
-    --no-resize-buffer       do not automatically adjust the buffer size. By
-                             default, the buffer size is automatically resized
-                             from an initial value of SIZE.
-    --dump-user-agent        display the current browser identification
-    --user-agent UA          specify a custom user agent
-    --list-extractors        List all supported extractors and the URLs they
-                             would handle
+    -h, --help                 print this help text and exit
+    --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     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)
+    --no-resize-buffer         do not automatically adjust the buffer size. By
+                               default, the buffer size is automatically resized
+                               from an initial value of SIZE.
+    --dump-user-agent          display the current browser identification
+    --user-agent UA            specify a custom user agent
+    --list-extractors          List all supported extractors and the URLs they
+                               would handle
 
 ## Video Selection:
-    --playlist-start NUMBER  playlist video to start at (default is 1)
-    --playlist-end NUMBER    playlist video to end at (default is last)
-    --match-title REGEX      download only matching titles (regex or caseless
-                             sub-string)
-    --reject-title REGEX     skip download for matching titles (regex or
-                             caseless sub-string)
-    --max-downloads NUMBER   Abort after downloading NUMBER files
-    --min-filesize SIZE      Do not download any videos smaller than SIZE (e.g.
-                             50k or 44.6m)
-    --max-filesize SIZE      Do not download any videos larger than SIZE (e.g.
-                             50k or 44.6m)
+    --playlist-start NUMBER    playlist video to start at (default is 1)
+    --playlist-end NUMBER      playlist video to end at (default is last)
+    --match-title REGEX        download only matching titles (regex or caseless
+                               sub-string)
+    --reject-title REGEX       skip download for matching titles (regex or
+                               caseless sub-string)
+    --max-downloads NUMBER     Abort after downloading NUMBER files
+    --min-filesize SIZE        Do not download any videos smaller than SIZE
+                               (e.g. 50k or 44.6m)
+    --max-filesize SIZE        Do not download any videos larger than SIZE (e.g.
+                               50k or 44.6m)
 
 ## Filesystem Options:
-    -t, --title              use title in file name
-    --id                     use video ID in file name
-    -l, --literal            [deprecated] alias of --title
-    -A, --auto-number        number downloaded files starting from 00000
-    -o, --output TEMPLATE    output filename template. Use %(title)s to get the
-                             title, %(uploader)s for the uploader name,
-                             %(uploader_id)s for the uploader nickname if
-                             different, %(autonumber)s to get an automatically
-                             incremented number, %(ext)s for the filename
-                             extension, %(upload_date)s for the upload date
-                             (YYYYMMDD), %(extractor)s for the provider
-                             (youtube, metacafe, etc), %(id)s for the video id
-                             and %% for a literal percent. Use - to output to
-                             stdout. Can also be used to download to a different
-                             directory, for example with -o '/my/downloads/%(upl
-                             oader)s/%(title)s-%(id)s.%(ext)s' .
-    --restrict-filenames     Restrict filenames to only ASCII characters, and
-                             avoid "&" and spaces in filenames
-    -a, --batch-file FILE    file containing URLs to download ('-' for stdin)
-    -w, --no-overwrites      do not overwrite files
-    -c, --continue           resume partially downloaded files
-    --no-continue            do not resume partially downloaded files (restart
-                             from beginning)
-    --cookies FILE           file to read cookies from and dump cookie jar in
-    --no-part                do not use .part files
-    --no-mtime               do not use the Last-modified header to set the file
-                             modification time
-    --write-description      write video description to a .description file
-    --write-info-json        write video metadata to a .info.json file
+    -t, --title                use title in file name
+    --id                       use video ID in file name
+    -l, --literal              [deprecated] alias of --title
+    -A, --auto-number          number downloaded files starting from 00000
+    -o, --output TEMPLATE      output filename template. Use %(title)s to get
+                               the title, %(uploader)s for the uploader name,
+                               %(uploader_id)s for the uploader nickname if
+                               different, %(autonumber)s to get an automatically
+                               incremented number, %(ext)s for the filename
+                               extension, %(upload_date)s for the upload date
+                               (YYYYMMDD), %(extractor)s for the provider
+                               (youtube, metacafe, etc), %(id)s for the video id
+                               and %% for a literal percent. Use - to output to
+                               stdout. Can also be used to download to a
+                               different directory, for example with -o '/my/dow
+                               nloads/%(uploader)s/%(title)s-%(id)s.%(ext)s' .
+    --autonumber-size NUMBER   Specifies the number of digits in %(autonumber)s
+                               when it is present in output filename template or
+                               --autonumber option is given
+    --restrict-filenames       Restrict filenames to only ASCII characters, and
+                               avoid "&" and spaces in filenames
+    -a, --batch-file FILE      file containing URLs to download ('-' for stdin)
+    -w, --no-overwrites        do not overwrite files
+    -c, --continue             resume partially downloaded files
+    --no-continue              do not resume partially downloaded files (restart
+                               from beginning)
+    --cookies FILE             file to read cookies from and dump cookie jar in
+    --no-part                  do not use .part files
+    --no-mtime                 do not use the Last-modified header to set the
+                               file modification time
+    --write-description        write video description to a .description file
+    --write-info-json          write video metadata to a .info.json file
 
 ## Verbosity / Simulation Options:
-    -q, --quiet              activates quiet mode
-    -s, --simulate           do not download the video and do not write anything
-                             to disk
-    --skip-download          do not download the video
-    -g, --get-url            simulate, quiet but print URL
-    -e, --get-title          simulate, quiet but print title
-    --get-thumbnail          simulate, quiet but print thumbnail URL
-    --get-description        simulate, quiet but print video description
-    --get-filename           simulate, quiet but print output filename
-    --get-format             simulate, quiet but print output format
-    --newline                output progress bar as new lines
-    --no-progress            do not print progress bar
-    --console-title          display progress in console titlebar
-    -v, --verbose            print various debugging information
+    -q, --quiet                activates quiet mode
+    -s, --simulate             do not download the video and do not write
+                               anything to disk
+    --skip-download            do not download the video
+    -g, --get-url              simulate, quiet but print URL
+    -e, --get-title            simulate, quiet but print title
+    --get-thumbnail            simulate, quiet but print thumbnail URL
+    --get-description          simulate, quiet but print video description
+    --get-filename             simulate, quiet but print output filename
+    --get-format               simulate, quiet but print output format
+    --newline                  output progress bar as new lines
+    --no-progress              do not print progress bar
+    --console-title            display progress in console titlebar
+    -v, --verbose              print various debugging information
+    --dump-intermediate-pages  print downloaded pages to debug problems(very
+                               verbose)
 
 ## Video Format Options:
-    -f, --format FORMAT      video format code
-    --all-formats            download all available video formats
-    --prefer-free-formats    prefer free video formats unless a specific one is
-                             requested
-    --max-quality FORMAT     highest quality format to download
-    -F, --list-formats       list all available formats (currently youtube only)
-    --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)
-    --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'
+    -f, --format FORMAT        video format code
+    --all-formats              download all available video formats
+    --prefer-free-formats      prefer free video formats unless a specific one
+                               is requested
+    --max-quality FORMAT       highest quality format to download
+    -F, --list-formats         list all available formats (currently youtube
+                               only)
+    --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)
+    --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
-    -p, --password PASSWORD  account password
-    -n, --netrc              use .netrc authentication data
+    -u, --username USERNAME    account username
+    -p, --password PASSWORD    account password
+    -n, --netrc                use .netrc authentication data
 
 ## Post-processing Options:
-    -x, --extract-audio      convert video files to audio-only files (requires
-                             ffmpeg or avconv and ffprobe or avprobe)
-    --audio-format FORMAT    "best", "aac", "vorbis", "mp3", "m4a", "opus", or
-                             "wav"; best by default
-    --audio-quality QUALITY  ffmpeg/avconv audio quality specification, insert a
-                             value between 0 (better) and 9 (worse) for VBR or a
-                             specific bitrate like 128K (default 5)
-    --recode-video FORMAT    Encode the video to another format if necessary
-                             (currently supported: mp4|flv|ogg|webm)
-    -k, --keep-video         keeps the video file on disk after the post-
-                             processing; the video is erased by default
-    --no-post-overwrites     do not overwrite post-processed files; the post-
-                             processed files are overwritten by default
+    -x, --extract-audio        convert video files to audio-only files (requires
+                               ffmpeg or avconv and ffprobe or avprobe)
+    --audio-format FORMAT      "best", "aac", "vorbis", "mp3", "m4a", "opus", or
+                               "wav"; best by default
+    --audio-quality QUALITY    ffmpeg/avconv audio quality specification, insert
+                               a value between 0 (better) and 9 (worse) for VBR
+                               or a specific bitrate like 128K (default 5)
+    --recode-video FORMAT      Encode the video to another format if necessary
+                               (currently supported: mp4|flv|ogg|webm)
+    -k, --keep-video           keeps the video file on disk after the post-
+                               processing; the video is erased by default
+    --no-post-overwrites       do not overwrite post-processed files; the post-
+                               processed files are overwritten by default
 
 # CONFIGURATION
 
diff --git a/youtube_dl/version.py b/youtube_dl/version.py
index c433e2eaa..3535e61d4 100644
--- a/youtube_dl/version.py
+++ b/youtube_dl/version.py
@@ -1,2 +1,2 @@
 
-__version__ = '2013.04.03'
+__version__ = '2013.04.11'

From d281274bf250065f876bb4f75fb6f711e1a26eba Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Jaime=20Marqui=CC=81nez=20Ferra=CC=81ndiz?=
 <jaime.marquinez.ferrandiz@gmail.com>
Date: Tue, 16 Apr 2013 15:13:29 +0200
Subject: [PATCH 078/221] Add a playlist_index key to the info_dict, can be
 used in the output template

---
 README.md                    | 1 +
 youtube_dl/FileDownloader.py | 4 ++++
 2 files changed, 5 insertions(+)

diff --git a/README.md b/README.md
index c8d28db3c..e2958a9b0 100644
--- a/README.md
+++ b/README.md
@@ -145,6 +145,7 @@ The `-o` option allows users to indicate a template for the output file names. T
  - `epoch`: The sequence will be replaced by the Unix epoch when creating the file.
  - `autonumber`: The sequence will be replaced by a five-digit number that will be increased with each download, starting at zero.
  - `playlist`: The name or the id of the playlist that contains the video.
+ - `playlist_index`: The index of the video in the playlist, a five-digit number.
 
 The current default template is `%(id)s.%(ext)s`, but that will be switchted to `%(title)s-%(id)s.%(ext)s` (which can be requested with `-t` at the moment).
 
diff --git a/youtube_dl/FileDownloader.py b/youtube_dl/FileDownloader.py
index 5a5141ba5..4dabbb440 100644
--- a/youtube_dl/FileDownloader.py
+++ b/youtube_dl/FileDownloader.py
@@ -389,6 +389,8 @@ class FileDownloader(object):
 
             template_dict['epoch'] = int(time.time())
             template_dict['autonumber'] = u'%05d' % self._num_downloads
+            if template_dict['playlist_index'] is not None:
+                template_dict['playlist_index'] = u'%05d' % template_dict['playlist_index']
 
             sanitize = lambda k,v: sanitize_filename(
                 u'NA' if v is None else compat_str(v),
@@ -473,6 +475,7 @@ class FileDownloader(object):
             if 'playlist' not in ie_result:
                 #It isn't part of a playlist
                 ie_result['playlist'] = None
+                ie_result['playlist_index'] = None
             if download:
                 #Do the download:
                 self.process_info(ie_result)
@@ -506,6 +509,7 @@ class FileDownloader(object):
                 self.to_screen(u'[download] Downloading video #%s of %s' %(i, n_entries))
                 entry_result = self.process_ie_result(entry, False)
                 entry_result['playlist'] = playlist
+                entry_result['playlist_index'] = i + playliststart
                 #We must do the download here to correctly set the 'playlist' key
                 if download:
                     self.process_info(entry_result)

From b8ad4f02a2124c9e08570bfb2ab05f2024cb2fb7 Mon Sep 17 00:00:00 2001
From: Finn Petersen <4peterse@googlemail.com>
Date: Tue, 16 Apr 2013 19:26:48 +0200
Subject: [PATCH 079/221] Arguments as parameter to function _real_main so it
 can be used programmatically

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

diff --git a/youtube_dl/__init__.py b/youtube_dl/__init__.py
index f46143e01..b339427e8 100644
--- a/youtube_dl/__init__.py
+++ b/youtube_dl/__init__.py
@@ -47,7 +47,7 @@ from .FileDownloader import *
 from .InfoExtractors import gen_extractors
 from .PostProcessor import *
 
-def parseOpts():
+def parseOpts(arguments):
     def _readOptions(filename_bytes):
         try:
             optionf = open(filename_bytes)
@@ -298,8 +298,8 @@ def parseOpts():
         userConfFile = os.path.join(os.path.expanduser('~'), '.config', 'youtube-dl.conf')
     systemConf = _readOptions('/etc/youtube-dl.conf')
     userConf = _readOptions(userConfFile)
-    commandLineConf = sys.argv[1:]
-    argv = systemConf + userConf + commandLineConf
+    commandLineConf = sys.argv[1:] 
+    argv = systemConf + userConf + commandLineConf if not arguments else arguments
     opts, args = parser.parse_args(argv)
 
     if opts.verbose:
@@ -309,8 +309,8 @@ def parseOpts():
 
     return parser, opts, args
 
-def _real_main():
-    parser, opts, args = parseOpts()
+def _real_main(argv=None):
+    parser, opts, args = parseOpts(argv)
 
     # Open appropriate CookieJar
     if opts.cookiefile is None:
@@ -544,9 +544,9 @@ def _real_main():
 
     sys.exit(retcode)
 
-def main():
+def main(argv=None):
     try:
-        _real_main()
+        _real_main(argv)
     except DownloadError:
         sys.exit(1)
     except SameFileError:

From a60b854d9099e5a286accf8065d1dc9e00a4bfe6 Mon Sep 17 00:00:00 2001
From: Filippo Valsorda <filippo.valsorda@gmail.com>
Date: Wed, 17 Apr 2013 19:48:35 +0200
Subject: [PATCH 080/221] disable YT ratelimit; this should enable to max out
 the connection bandwidth

---
 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 7deb488a9..e1d71ccb7 100755
--- a/youtube_dl/InfoExtractors.py
+++ b/youtube_dl/InfoExtractors.py
@@ -581,7 +581,7 @@ class YoutubeIE(InfoExtractor):
             url_data_strs = video_info['url_encoded_fmt_stream_map'][0].split(',')
             url_data = [compat_parse_qs(uds) for uds in url_data_strs]
             url_data = [ud for ud in url_data if 'itag' in ud and 'url' in ud]
-            url_map = dict((ud['itag'][0], ud['url'][0] + '&signature=' + ud['sig'][0]) for ud in url_data)
+            url_map = dict((ud['itag'][0], ud['url'][0] + '&signature=' + ud['sig'][0] + '&ratebypass=yes') for ud in url_data)
 
             format_limit = self._downloader.params.get('format_limit', None)
             available_formats = self._available_formats_prefer_free if self._downloader.params.get('prefer_free_formats', False) else self._available_formats

From c8c5443bb50644bfd784044860092f95cb4616b5 Mon Sep 17 00:00:00 2001
From: Philipp Hagemeister <phihag@phihag.de>
Date: Wed, 17 Apr 2013 23:21:58 +0200
Subject: [PATCH 081/221] Revert "disable YT ratelimit; this should enable to
 max out the connection bandwidth"

Although cool, that seems to break a lot of youtube videos.

This reverts commit a60b854d9099e5a286accf8065d1dc9e00a4bfe6.
---
 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 e1d71ccb7..7deb488a9 100755
--- a/youtube_dl/InfoExtractors.py
+++ b/youtube_dl/InfoExtractors.py
@@ -581,7 +581,7 @@ class YoutubeIE(InfoExtractor):
             url_data_strs = video_info['url_encoded_fmt_stream_map'][0].split(',')
             url_data = [compat_parse_qs(uds) for uds in url_data_strs]
             url_data = [ud for ud in url_data if 'itag' in ud and 'url' in ud]
-            url_map = dict((ud['itag'][0], ud['url'][0] + '&signature=' + ud['sig'][0] + '&ratebypass=yes') for ud in url_data)
+            url_map = dict((ud['itag'][0], ud['url'][0] + '&signature=' + ud['sig'][0]) for ud in url_data)
 
             format_limit = self._downloader.params.get('format_limit', None)
             available_formats = self._available_formats_prefer_free if self._downloader.params.get('prefer_free_formats', False) else self._available_formats

From 32c96387c1837103b5cdde4b4c39b9653f2e0181 Mon Sep 17 00:00:00 2001
From: Philipp Hagemeister <phihag@phihag.de>
Date: Thu, 18 Apr 2013 04:41:48 +0200
Subject: [PATCH 082/221] Fix facebook IE

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

diff --git a/youtube_dl/InfoExtractors.py b/youtube_dl/InfoExtractors.py
index 7deb488a9..306d96774 100755
--- a/youtube_dl/InfoExtractors.py
+++ b/youtube_dl/InfoExtractors.py
@@ -2161,7 +2161,7 @@ class FacebookIE(InfoExtractor):
         url = 'https://www.facebook.com/video/video.php?v=%s' % video_id
         webpage = self._download_webpage(url, video_id)
 
-        BEFORE = '[["allowFullScreen","true"],["allowScriptAccess","always"],["salign","tl"],["scale","noscale"],["wmode","opaque"]].forEach(function(param) {swf.addParam(param[0], param[1]);});\n'
+        BEFORE = '{swf.addParam(param[0], param[1]);});\n'
         AFTER = '.forEach(function(variable) {swf.addVariable(variable[0], variable[1]);});'
         m = re.search(re.escape(BEFORE) + '(.*?)' + re.escape(AFTER), webpage)
         if not m:
@@ -2169,12 +2169,14 @@ class FacebookIE(InfoExtractor):
         data = dict(json.loads(m.group(1)))
         params_raw = compat_urllib_parse.unquote(data['params'])
         params = json.loads(params_raw)
-        video_url = params['hd_src']
+        video_data = params['video_data'][0]
+        video_url = video_data.get('hd_src')
         if not video_url:
-            video_url = params['sd_src']
+            video_url = video_data['sd_src']
         if not video_url:
             raise ExtractorError(u'Cannot find video URL')
-        video_duration = int(params['video_duration'])
+        video_duration = int(video_data['video_duration'])
+        thumbnail = video_data['thumbnail_src']
 
         m = re.search('<h2 class="uiHeaderTitle">([^<]+)</h2>', webpage)
         if not m:
@@ -2187,7 +2189,7 @@ class FacebookIE(InfoExtractor):
             'url': video_url,
             'ext': 'mp4',
             'duration': video_duration,
-            'thumbnail': params['thumbnail_src'],
+            'thumbnail': thumbnail,
         }
         return [info]
 

From bfdf4692955b3ea300b8f6ae30b8b69127922f7e Mon Sep 17 00:00:00 2001
From: Philipp Hagemeister <phihag@phihag.de>
Date: Thu, 18 Apr 2013 06:21:46 +0200
Subject: [PATCH 083/221] Fix FunnyOrDie extraction for a special video (#789)

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

diff --git a/youtube_dl/InfoExtractors.py b/youtube_dl/InfoExtractors.py
index 306d96774..cf31970ef 100755
--- a/youtube_dl/InfoExtractors.py
+++ b/youtube_dl/InfoExtractors.py
@@ -3704,7 +3704,9 @@ class FunnyOrDieIE(InfoExtractor):
 
         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')
+            m = re.search(r'<title>(?P<title>[^<]+?)</title>', webpage)
+            if not m:
+                self._downloader.trouble(u'Cannot find video title')
         title = clean_html(m.group('title'))
 
         m = re.search(r'<meta property="og:description" content="(?P<desc>.*?)"', webpage)

From 0599ef8c0827068184f78745a299d043927db4d9 Mon Sep 17 00:00:00 2001
From: Philipp Hagemeister <phihag@phihag.de>
Date: Thu, 18 Apr 2013 06:27:11 +0200
Subject: [PATCH 084/221] Limit titles to 200 characters (Closes #789)

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

diff --git a/youtube_dl/FileDownloader.py b/youtube_dl/FileDownloader.py
index d4f9cc621..96da754fb 100644
--- a/youtube_dl/FileDownloader.py
+++ b/youtube_dl/FileDownloader.py
@@ -426,6 +426,10 @@ class FileDownloader(object):
     def process_info(self, info_dict):
         """Process a single dictionary returned by an InfoExtractor."""
 
+        info_dict['fulltitle'] = info_dict['title']
+        if len(info_dict['title']) > 200:
+            info_dict['title'] = info_dict['title'][:197] + u'...'
+
         # Keep for backwards compatibility
         info_dict['stitle'] = info_dict['title']
 

From d22f65413af51b24166de20d85d69f7525a70e25 Mon Sep 17 00:00:00 2001
From: Philipp Hagemeister <phihag@phihag.de>
Date: Thu, 18 Apr 2013 06:29:32 +0200
Subject: [PATCH 085/221] release 2013.04.18

---
 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 3535e61d4..2fd5f40c8 100644
--- a/youtube_dl/version.py
+++ b/youtube_dl/version.py
@@ -1,2 +1,2 @@
 
-__version__ = '2013.04.11'
+__version__ = '2013.04.18'

From feba604e9256b48972dfe4b5658ada4b300581cd Mon Sep 17 00:00:00 2001
From: Philipp Hagemeister <phihag@phihag.de>
Date: Thu, 18 Apr 2013 07:28:24 +0200
Subject: [PATCH 086/221] =?UTF-8?q?Fix=20playlists=20with=20size=2050i=20?=
 =?UTF-8?q?=E2=88=80=20i=E2=88=89=E2=84=95=20(Closes=20#782)?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

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

diff --git a/youtube_dl/InfoExtractors.py b/youtube_dl/InfoExtractors.py
index cf31970ef..bac3a747d 100755
--- a/youtube_dl/InfoExtractors.py
+++ b/youtube_dl/InfoExtractors.py
@@ -1778,9 +1778,13 @@ class YoutubePlaylistIE(InfoExtractor):
                 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']:
+            if 'feed' not in response:
                 self._downloader.report_error(u'Got a malformed response from YouTube API')
                 return
+            if 'entry' not in response['feed']:
+                # Number of videos is a multiple of self._MAX_RESULTS
+                break
+
             videos += [ (entry['yt$position']['$t'], entry['content']['src'])
                         for entry in response['feed']['entry']
                         if 'content' in entry ]

From 5a8d13199cd6bd73d7ace023a528c02e12fd2954 Mon Sep 17 00:00:00 2001
From: ispedals <supronitbat@xynl.at>
Date: Fri, 19 Apr 2013 18:05:35 -0400
Subject: [PATCH 087/221] Fix YoutubeChannelIE

- urls with query parameters now match
- fixes regex for identifying videos
- fixes pagination
---
 youtube_dl/InfoExtractors.py | 64 ++++++++++++++++++++++++------------
 1 file changed, 43 insertions(+), 21 deletions(-)

diff --git a/youtube_dl/InfoExtractors.py b/youtube_dl/InfoExtractors.py
index ae36558d7..e0a26eb58 100755
--- a/youtube_dl/InfoExtractors.py
+++ b/youtube_dl/InfoExtractors.py
@@ -1823,15 +1823,23 @@ class YoutubePlaylistIE(InfoExtractor):
 class YoutubeChannelIE(InfoExtractor):
     """Information Extractor for YouTube channels."""
 
-    _VALID_URL = r"^(?:https?://)?(?:youtu\.be|(?:\w+\.)?youtube(?:-nocookie)?\.com)/channel/([0-9A-Za-z_-]+)(?:/.*)?$"
+    _VALID_URL = r"^(?:https?://)?(?:youtu\.be|(?:\w+\.)?youtube(?:-nocookie)?\.com)/channel/([0-9A-Za-z_-]+)"
     _TEMPLATE_URL = 'http://www.youtube.com/channel/%s/videos?sort=da&flow=list&view=0&page=%s&gl=US&hl=en'
-    _MORE_PAGES_INDICATOR = u"Next \N{RIGHT-POINTING DOUBLE ANGLE QUOTATION MARK}"
+    _MORE_PAGES_INDICATOR = 'yt-uix-load-more'
+    _MORE_PAGES_URL = 'http://www.youtube.com/channel_ajax?action_load_more_videos=1&flow=list&paging=%s&view=0&sort=da&channel_id=%s'
     IE_NAME = u'youtube:channel'
 
     def report_download_page(self, channel_id, pagenum):
         """Report attempt to download channel page with given number."""
         self._downloader.to_screen(u'[youtube] Channel %s: Downloading page #%s' % (channel_id, pagenum))
 
+    def extract_videos_from_page(self, page):
+        ids_in_page = []
+        for mobj in re.finditer(r'href="/watch\?v=([0-9A-Za-z_-]+)&?', page):
+            if mobj.group(1) not in ids_in_page:
+                ids_in_page.append(mobj.group(1))
+        return ids_in_page
+
     def _real_extract(self, url):
         # Extract channel id
         mobj = re.match(self._VALID_URL, url)
@@ -1839,31 +1847,45 @@ class YoutubeChannelIE(InfoExtractor):
             self._downloader.report_error(u'invalid url: %s' % url)
             return
 
-        # Download channel pages
+        # Download channel page
         channel_id = mobj.group(1)
         video_ids = []
         pagenum = 1
 
-        while True:
-            self.report_download_page(channel_id, pagenum)
-            url = self._TEMPLATE_URL % (channel_id, pagenum)
-            request = compat_urllib_request.Request(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.report_error(u'unable to download webpage: %s' % compat_str(err))
-                return
+        self.report_download_page(channel_id, pagenum)
+        url = self._TEMPLATE_URL % (channel_id, pagenum)
+        request = compat_urllib_request.Request(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.report_error(u'unable to download webpage: %s' % compat_str(err))
+            return
 
-            # Extract video identifiers
-            ids_in_page = []
-            for mobj in re.finditer(r'href="/watch\?v=([0-9A-Za-z_-]+)&', page):
-                if mobj.group(1) not in ids_in_page:
-                    ids_in_page.append(mobj.group(1))
-            video_ids.extend(ids_in_page)
+        # Extract video identifiers
+        ids_in_page = self.extract_videos_from_page(page)
+        video_ids.extend(ids_in_page)
 
-            if self._MORE_PAGES_INDICATOR not in page:
-                break
-            pagenum = pagenum + 1
+        # Download any subsequent channel pages using the json-based channel_ajax query
+        if self._MORE_PAGES_INDICATOR in page:
+            while True:
+                pagenum = pagenum + 1
+
+                self.report_download_page(channel_id, pagenum)
+                url = self._MORE_PAGES_URL % (pagenum, channel_id)
+                request = compat_urllib_request.Request(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.report_error(u'unable to download webpage: %s' % compat_str(err))
+                    return
+
+                page = json.loads(page)
+
+                ids_in_page = self.extract_videos_from_page(page['content_html'])
+                video_ids.extend(ids_in_page)
+
+                if self._MORE_PAGES_INDICATOR  not in page['load_more_widget_html']:
+                    break
 
         self._downloader.to_screen(u'[youtube] Channel %s: Found %i videos' % (channel_id, len(video_ids)))
 

From fb6c319904b2bd626af534d3d8fb0726b91081c6 Mon Sep 17 00:00:00 2001
From: ispedals <supronitbat@xynl.at>
Date: Fri, 19 Apr 2013 18:06:28 -0400
Subject: [PATCH 088/221] Add tests for YoutubeChannelIE

- tests for identifying channel urls
- test retrieval of paginated channel
- test retrieval of autogenerated channel
---
 test/test_all_urls.py      |  7 ++++++-
 test/test_youtube_lists.py | 12 +++++++++---
 2 files changed, 15 insertions(+), 4 deletions(-)

diff --git a/test/test_all_urls.py b/test/test_all_urls.py
index 69717b3fc..a40360122 100644
--- a/test/test_all_urls.py
+++ b/test/test_all_urls.py
@@ -7,7 +7,7 @@ import unittest
 import os
 sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
 
-from youtube_dl.InfoExtractors import YoutubeIE, YoutubePlaylistIE
+from youtube_dl.InfoExtractors import YoutubeIE, YoutubePlaylistIE, YoutubeChannelIE
 
 class TestAllURLsMatching(unittest.TestCase):
     def test_youtube_playlist_matching(self):
@@ -24,6 +24,11 @@ class TestAllURLsMatching(unittest.TestCase):
         self.assertTrue(YoutubeIE.suitable(u'PLtS2H6bU1M'))
         self.assertFalse(YoutubeIE.suitable(u'https://www.youtube.com/watch?v=AV6J6_AeFEQ&playnext=1&list=PL4023E734DA416012')) #668
 
+    def test_youtube_channel_matching(self):
+        self.assertTrue(YoutubeChannelIE.suitable('https://www.youtube.com/channel/HCtnHdj3df7iM'))
+        self.assertTrue(YoutubeChannelIE.suitable('https://www.youtube.com/channel/HCtnHdj3df7iM?feature=gb_ch_rec'))
+        self.assertTrue(YoutubeChannelIE.suitable('https://www.youtube.com/channel/HCtnHdj3df7iM/videos'))
+
     def test_youtube_extract(self):
         self.assertEqual(YoutubeIE()._extract_id('http://www.youtube.com/watch?&v=BaW_jenozKc'), 'BaW_jenozKc')
         self.assertEqual(YoutubeIE()._extract_id('https://www.youtube.com/watch?&v=BaW_jenozKc'), 'BaW_jenozKc')
diff --git a/test/test_youtube_lists.py b/test/test_youtube_lists.py
index 9e91484f8..c5b22a5c4 100644
--- a/test/test_youtube_lists.py
+++ b/test/test_youtube_lists.py
@@ -8,7 +8,7 @@ import json
 import os
 sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
 
-from youtube_dl.InfoExtractors import YoutubeUserIE, YoutubePlaylistIE, YoutubeIE
+from youtube_dl.InfoExtractors import YoutubeUserIE, YoutubePlaylistIE, YoutubeIE, YoutubeChannelIE
 from youtube_dl.utils import *
 from youtube_dl.FileDownloader import FileDownloader
 
@@ -81,8 +81,14 @@ class TestYoutubeLists(unittest.TestCase):
         self.assertEqual(YoutubeIE()._extract_id(entries[-1]['url']), 'rYefUsYuEp0')
 
     def test_youtube_channel(self):
-        # I give up, please find a channel that does paginate and test this like test_youtube_playlist_long
-        pass # TODO
+        dl = FakeDownloader()
+        ie = YoutubeChannelIE(dl)
+        #test paginated channel
+        result = ie.extract('https://www.youtube.com/channel/UCKfVa3S1e4PHvxWcwyMMg8w')[0]
+        self.assertTrue(len(result['entries']) > 90)
+        #test autogenerated channel
+        result = ie.extract('https://www.youtube.com/channel/HCtnHdj3df7iM/videos')[0]
+        self.assertTrue(len(result['entries']) > 20)
 
     def test_youtube_user(self):
         dl = FakeDownloader()

From 49da66e459e116e896625765d0b579de77acb218 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Jaime=20Marqui=CC=81nez=20Ferra=CC=81ndiz?=
 <jaime.marquinez.ferrandiz@gmail.com>
Date: Sat, 20 Apr 2013 10:39:02 +0200
Subject: [PATCH 089/221] The test video for subtitles has added a new language

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

diff --git a/test/test_youtube_subtitles.py b/test/test_youtube_subtitles.py
index 30f2246dd..b4909091b 100644
--- a/test/test_youtube_subtitles.py
+++ b/test/test_youtube_subtitles.py
@@ -80,7 +80,7 @@ class TestYoutubeSubtitles(unittest.TestCase):
         IE = YoutubeIE(DL)
         info_dict = IE.extract('QRS8MkLhQmM')
         subtitles = info_dict[0]['subtitles']
-        self.assertEqual(len(subtitles), 12)
+        self.assertEqual(len(subtitles), 13)
     def test_youtube_subtitles_format(self):
         DL = FakeDownloader()
         DL.params['writesubtitles'] = True

From c8056d866aa5522f8caf4a8661c3112888e28ba4 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Jaime=20Marqui=CC=81nez=20Ferra=CC=81ndiz?=
 <jaime.marquinez.ferrandiz@gmail.com>
Date: Sat, 20 Apr 2013 11:17:03 +0200
Subject: [PATCH 090/221] Add myself to travis notifications

---
 .travis.yml | 1 +
 1 file changed, 1 insertion(+)

diff --git a/.travis.yml b/.travis.yml
index 0687c8957..7f1fa8a3c 100644
--- a/.travis.yml
+++ b/.travis.yml
@@ -8,6 +8,7 @@ notifications:
   email:
     - filippo.valsorda@gmail.com
     - phihag@phihag.de
+    - jaime.marquinez.ferrandiz+travis@gmail.com
 #  irc:
 #    channels:
 #      - "irc.freenode.org#youtube-dl"

From 089e843b0f9ae9f99be6406896829dc591f80122 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Jaime=20Marqui=CC=81nez=20Ferra=CC=81ndiz?=
 <jaime.marquinez.ferrandiz@gmail.com>
Date: Sat, 20 Apr 2013 11:40:05 +0200
Subject: [PATCH 091/221] Use _download_webpage in MetacafeIE

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

diff --git a/youtube_dl/InfoExtractors.py b/youtube_dl/InfoExtractors.py
index e0a26eb58..5052f3ec8 100755
--- a/youtube_dl/InfoExtractors.py
+++ b/youtube_dl/InfoExtractors.py
@@ -732,12 +732,7 @@ class MetacafeIE(InfoExtractor):
 
         # Retrieve video webpage to extract further information
         request = compat_urllib_request.Request('http://www.metacafe.com/watch/%s/' % video_id)
-        try:
-            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.report_error(u'unable retrieve video webpage: %s' % compat_str(err))
-            return
+        webpage = self._download_webpage(request, video_id)
 
         # Extract URL, uploader and title from webpage
         self.report_extraction(video_id)

From f7a9721e16139ba3e7bce76d04c3b43ff932f698 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Jaime=20Marqui=CC=81nez=20Ferra=CC=81ndiz?=
 <jaime.marquinez.ferrandiz@gmail.com>
Date: Sat, 20 Apr 2013 12:06:58 +0200
Subject: [PATCH 092/221] Fix some metacafe videos, closes #562

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

diff --git a/youtube_dl/InfoExtractors.py b/youtube_dl/InfoExtractors.py
index 5052f3ec8..8bfb2809b 100755
--- a/youtube_dl/InfoExtractors.py
+++ b/youtube_dl/InfoExtractors.py
@@ -731,8 +731,7 @@ class MetacafeIE(InfoExtractor):
             return [self.url_result('http://www.youtube.com/watch?v=%s' % mobj2.group(1))]
 
         # Retrieve video webpage to extract further information
-        request = compat_urllib_request.Request('http://www.metacafe.com/watch/%s/' % video_id)
-        webpage = self._download_webpage(request, video_id)
+        webpage = self._download_webpage('http://www.metacafe.com/watch/%s/' % video_id, video_id)
 
         # Extract URL, uploader and title from webpage
         self.report_extraction(video_id)
@@ -757,13 +756,13 @@ class MetacafeIE(InfoExtractor):
             if 'mediaData' not in vardict:
                 self._downloader.report_error(u'unable to extract media URL')
                 return
-            mobj = re.search(r'"mediaURL":"(http.*?)","key":"(.*?)"', vardict['mediaData'][0])
+            mobj = re.search(r'"mediaURL":"(?P<mediaURL>http.*?)",(.*?)"key":"(?P<key>.*?)"', vardict['mediaData'][0])
             if mobj is None:
                 self._downloader.report_error(u'unable to extract media URL')
                 return
-            mediaURL = mobj.group(1).replace('\\/', '/')
+            mediaURL = mobj.group('mediaURL').replace('\\/', '/')
             video_extension = mediaURL[-3:]
-            video_url = '%s?__gda__=%s' % (mediaURL, mobj.group(2))
+            video_url = '%s?__gda__=%s' % (mediaURL, mobj.group('key'))
 
         mobj = re.search(r'(?im)<title>(.*) - Video</title>', webpage)
         if mobj is None:

From 93412126422b1324e920dc5097ee57c3ad11371b Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Jaime=20Marqui=CC=81nez=20Ferra=CC=81ndiz?=
 <jaime.marquinez.ferrandiz@gmail.com>
Date: Sat, 20 Apr 2013 12:42:57 +0200
Subject: [PATCH 093/221] Create a function in InfoExtractors that returns the
 InfoExtractor class with the given name

---
 test/test_download.py        | 2 +-
 youtube_dl/InfoExtractors.py | 4 ++++
 2 files changed, 5 insertions(+), 1 deletion(-)

diff --git a/test/test_download.py b/test/test_download.py
index e3513efba..cf8028718 100644
--- a/test/test_download.py
+++ b/test/test_download.py
@@ -67,7 +67,7 @@ class TestDownload(unittest.TestCase):
 def generator(test_case):
 
     def test_template(self):
-        ie = getattr(youtube_dl.InfoExtractors, test_case['name'] + 'IE')
+        ie = youtube_dl.InfoExtractors.get_info_extractor(test_case['name'])#getattr(youtube_dl.InfoExtractors, test_case['name'] + 'IE')
         if not ie._WORKING:
             print('Skipping: IE marked as not _WORKING')
             return
diff --git a/youtube_dl/InfoExtractors.py b/youtube_dl/InfoExtractors.py
index 8bfb2809b..eeedcf792 100755
--- a/youtube_dl/InfoExtractors.py
+++ b/youtube_dl/InfoExtractors.py
@@ -4469,3 +4469,7 @@ def gen_extractors():
         ARDIE(),
         GenericIE()
     ]
+
+def get_info_extractor(ie_name):
+    """Returns the info extractor class with the given ie_name"""
+    return globals()[ie_name+'IE']

From 6de8f1afb72d35560396817cbc2ed96180daa019 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Jaime=20Marqui=CC=81nez=20Ferra=CC=81ndiz?=
 <jaime.marquinez.ferrandiz@gmail.com>
Date: Sat, 20 Apr 2013 12:50:14 +0200
Subject: [PATCH 094/221] Allows to specify which IE should be used for
 extracting info for a result of type url

---
 youtube_dl/FileDownloader.py | 17 ++++++++++++++---
 youtube_dl/InfoExtractors.py | 16 +++++++---------
 2 files changed, 21 insertions(+), 12 deletions(-)

diff --git a/youtube_dl/FileDownloader.py b/youtube_dl/FileDownloader.py
index 03346ab04..9c0c42f8d 100644
--- a/youtube_dl/FileDownloader.py
+++ b/youtube_dl/FileDownloader.py
@@ -17,6 +17,7 @@ if os.name == 'nt':
     import ctypes
 
 from .utils import *
+from .InfoExtractors import get_info_extractor
 
 
 class FileDownloader(object):
@@ -425,13 +426,23 @@ class FileDownloader(object):
                 return u'"' + title + '" title matched reject pattern "' + rejecttitle + '"'
         return None
         
-    def extract_info(self, url, download = True):
+    def extract_info(self, url, download = True, ie_name = None):
         '''
         Returns a list with a dictionary for each video we find.
         If 'download', also downloads the videos.
          '''
         suitable_found = False
-        for ie in self._ies:
+        
+        #We copy the original list
+        ies = list(self._ies)
+
+        if ie_name is not None:
+            #We put in the first place the given info extractor
+            first_ie = get_info_extractor(ie_name)()
+            first_ie.set_downloader(self)
+            ies.insert(0, first_ie)
+
+        for ie in ies:
             # Go to next InfoExtractor if not suitable
             if not ie.suitable(url):
                 continue
@@ -486,7 +497,7 @@ class FileDownloader(object):
             return ie_result
         elif result_type == 'url':
             #We get the video pointed by the url
-            result = self.extract_info(ie_result['url'], download)[0]
+            result = self.extract_info(ie_result['url'], download, ie_name = ie_result['ie_key'])[0]
             return result
         elif result_type == 'playlist':
             #We process each entry in the playlist
diff --git a/youtube_dl/InfoExtractors.py b/youtube_dl/InfoExtractors.py
index eeedcf792..e47d8b85d 100755
--- a/youtube_dl/InfoExtractors.py
+++ b/youtube_dl/InfoExtractors.py
@@ -154,7 +154,8 @@ class InfoExtractor(object):
         """Returns a url that points to a page that should be processed"""
         #TODO: ie should be the class used for getting the info
         video_info = {'_type': 'url',
-                      'url': url}
+                      'url': url,
+                      'ie_key': ie}
         return video_info
     def playlist_result(self, entries, playlist_id=None, playlist_title=None):
         """Returns a playlist"""
@@ -728,7 +729,7 @@ class MetacafeIE(InfoExtractor):
         # Check if video comes from YouTube
         mobj2 = re.match(r'^yt-(.*)$', video_id)
         if mobj2 is not None:
-            return [self.url_result('http://www.youtube.com/watch?v=%s' % mobj2.group(1))]
+            return [self.url_result('http://www.youtube.com/watch?v=%s' % mobj2.group(1), 'Youtube')]
 
         # Retrieve video webpage to extract further information
         webpage = self._download_webpage('http://www.metacafe.com/watch/%s/' % video_id, video_id)
@@ -1810,7 +1811,7 @@ class YoutubePlaylistIE(InfoExtractor):
 
         videos = [v[1] for v in sorted(videos)]
 
-        url_results = [self.url_result(url) for url in videos]
+        url_results = [self.url_result(url, 'Youtube') for url in videos]
         return [self.playlist_result(url_results, playlist_id)]
 
 
@@ -1884,7 +1885,7 @@ class YoutubeChannelIE(InfoExtractor):
         self._downloader.to_screen(u'[youtube] Channel %s: Found %i videos' % (channel_id, len(video_ids)))
 
         urls = ['http://www.youtube.com/watch?v=%s' % id for id in video_ids]
-        url_entries = [self.url_result(url) for url in urls]
+        url_entries = [self.url_result(url, 'Youtube') for url in urls]
         return [self.playlist_result(url_entries, channel_id)]
 
 
@@ -1956,7 +1957,7 @@ class YoutubeUserIE(InfoExtractor):
             pagenum += 1
 
         urls = ['http://www.youtube.com/watch?v=%s' % video_id for video_id in video_ids]
-        url_results = [self.url_result(url) for url in urls]
+        url_results = [self.url_result(url, 'Youtube') for url in urls]
         return [self.playlist_result(url_results, playlist_title = username)]
 
 
@@ -2035,11 +2036,8 @@ class BlipTVUserIE(InfoExtractor):
 
             pagenum += 1
 
-        self._downloader.to_screen(u"[%s] user %s: Collected %d video ids (downloading %d of them)" %
-                (self.IE_NAME, username, all_ids_count, len(video_ids)))
-
         urls = [u'http://blip.tv/%s' % video_id for video_id in video_ids]
-        url_entries = [self.url_result(url) for url in urls]
+        url_entries = [self.url_result(url, 'BlipTV') for url in urls]
         return [self.playlist_result(url_entries, playlist_title = username)]
 
 

From e905b6f80ef276900160af87c89644d95f669d9c Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Jaime=20Marqui=CC=81nez=20Ferra=CC=81ndiz?=
 <jaime.marquinez.ferrandiz@gmail.com>
Date: Sat, 20 Apr 2013 13:31:21 +0200
Subject: [PATCH 095/221] TEDIE can now return a playlist

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

diff --git a/youtube_dl/InfoExtractors.py b/youtube_dl/InfoExtractors.py
index e47d8b85d..b20e6b46d 100755
--- a/youtube_dl/InfoExtractors.py
+++ b/youtube_dl/InfoExtractors.py
@@ -4183,7 +4183,7 @@ class TEDIE(InfoExtractor):
             playlist_id=m.group('playlist_id')
             name=m.group('name')
             self._downloader.to_screen(u'[%s] Getting info of playlist %s: "%s"' % (self.IE_NAME,playlist_id,name))
-            return self._playlist_videos_info(url,name,playlist_id)
+            return [self._playlist_videos_info(url,name,playlist_id)]
 
     def _talk_video_link(self,mediaSlug):
         '''Returns the video link for that mediaSlug'''
@@ -4200,12 +4200,17 @@ class TEDIE(InfoExtractor):
         webpage=self._download_webpage(url, playlist_id, 'Downloading playlist webpage')
         m_videos=re.finditer(video_RE,webpage,re.VERBOSE)
         m_names=re.finditer(video_name_RE,webpage)
-        info=[]
+
+        playlist_RE = r'div class="headline">(\s*?)<h1>(\s*?)<span>(?P<playlist_title>.*?)</span>'
+        m_playlist = re.search(playlist_RE, webpage)
+        playlist_title = m_playlist.group('playlist_title')
+
+        playlist_entries = []
         for m_video, m_name in zip(m_videos,m_names):
             video_id=m_video.group('video_id')
             talk_url='http://www.ted.com%s' % m_name.group('talk_url')
-            info.append(self._talk_info(talk_url,video_id))
-        return info
+            playlist_entries.append(self.url_result(talk_url, 'TED'))
+        return self.playlist_result(playlist_entries, playlist_id = playlist_id, playlist_title = playlist_title)
 
     def _talk_info(self, url, video_id=0):
         """Return the video for the talk in the url"""

From c72938240e8edd75296c1dbe262769e5002ce811 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Jaime=20Marqui=CC=81nez=20Ferra=CC=81ndiz?=
 <jaime.marquinez.ferrandiz@gmail.com>
Date: Sat, 20 Apr 2013 18:57:05 +0200
Subject: [PATCH 096/221] Get the title of Youtube playlists

---
 test/test_youtube_lists.py   | 2 ++
 youtube_dl/InfoExtractors.py | 4 +++-
 2 files changed, 5 insertions(+), 1 deletion(-)

diff --git a/test/test_youtube_lists.py b/test/test_youtube_lists.py
index c5b22a5c4..c7f00af32 100644
--- a/test/test_youtube_lists.py
+++ b/test/test_youtube_lists.py
@@ -45,6 +45,7 @@ class TestYoutubeLists(unittest.TestCase):
         ie = YoutubePlaylistIE(dl)
         result = ie.extract('https://www.youtube.com/playlist?list=PLwiyx1dc3P2JR9N8gQaQN_BCvlSlap7re')[0]
         self.assertIsPlaylist(result)
+        self.assertEqual(result['title'], 'ytdl test PL')
         ytie_results = [YoutubeIE()._extract_id(url['url']) for url in result['entries']]
         self.assertEqual(ytie_results, [ 'bV9L5Ht9LgY', 'FXxLjLQi3Fg', 'tU3Bgo5qJZE'])
 
@@ -52,6 +53,7 @@ class TestYoutubeLists(unittest.TestCase):
         dl = FakeDownloader()
         ie = YoutubePlaylistIE(dl)
         result = ie.extract('PLBB231211A4F62143')[0]
+        self.assertEqual(result['title'], 'Team Fortress 2')
         self.assertTrue(len(result['entries']) > 40)
 
     def test_youtube_playlist_long(self):
diff --git a/youtube_dl/InfoExtractors.py b/youtube_dl/InfoExtractors.py
index b20e6b46d..c50052a73 100755
--- a/youtube_dl/InfoExtractors.py
+++ b/youtube_dl/InfoExtractors.py
@@ -1801,6 +1801,8 @@ class YoutubePlaylistIE(InfoExtractor):
                 # Number of videos is a multiple of self._MAX_RESULTS
                 break
 
+            playlist_title = response['feed']['title']['$t']
+
             videos += [ (entry['yt$position']['$t'], entry['content']['src'])
                         for entry in response['feed']['entry']
                         if 'content' in entry ]
@@ -1812,7 +1814,7 @@ class YoutubePlaylistIE(InfoExtractor):
         videos = [v[1] for v in sorted(videos)]
 
         url_results = [self.url_result(url, 'Youtube') for url in videos]
-        return [self.playlist_result(url_results, playlist_id)]
+        return [self.playlist_result(url_results, playlist_id, playlist_title)]
 
 
 class YoutubeChannelIE(InfoExtractor):

From 8c416ad29a43bb1a73a0a29b82c0e1baef1ee90a Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Jaime=20Marqui=CC=81nez=20Ferra=CC=81ndiz?=
 <jaime.marquinez.ferrandiz@gmail.com>
Date: Sat, 20 Apr 2013 19:22:45 +0200
Subject: [PATCH 097/221] Remove calls to _downloader.download in Youtube
 searchs

Instead, return the urls of the videos.
---
 youtube_dl/InfoExtractors.py | 21 ++++++++-------------
 1 file changed, 8 insertions(+), 13 deletions(-)

diff --git a/youtube_dl/InfoExtractors.py b/youtube_dl/InfoExtractors.py
index c50052a73..86a8ca511 100755
--- a/youtube_dl/InfoExtractors.py
+++ b/youtube_dl/InfoExtractors.py
@@ -1510,11 +1510,9 @@ class YoutubeSearchIE(InfoExtractor):
         prefix = prefix[8:]
         query = query.encode('utf-8')
         if prefix == '':
-            self._download_n_results(query, 1)
-            return
+            return self._get_n_results(query, 1)
         elif prefix == 'all':
-            self._download_n_results(query, self._max_youtube_results)
-            return
+            self._get_n_results(query, self._max_youtube_results)
         else:
             try:
                 n = int(prefix)
@@ -1524,14 +1522,12 @@ class YoutubeSearchIE(InfoExtractor):
                 elif n > self._max_youtube_results:
                     self._downloader.report_warning(u'ytsearch returns max %i results (you requested %i)' % (self._max_youtube_results, n))
                     n = self._max_youtube_results
-                self._download_n_results(query, n)
-                return
+                return self._get_n_results(query, n)
             except ValueError: # parsing prefix as integer fails
-                self._download_n_results(query, 1)
-                return
+                return self._get_n_results(query, 1)
 
-    def _download_n_results(self, query, n):
-        """Downloads a specified number of results for a query"""
+    def _get_n_results(self, query, n):
+        """Get a specified number of results for a query"""
 
         video_ids = []
         pagenum = 0
@@ -1560,9 +1556,8 @@ class YoutubeSearchIE(InfoExtractor):
 
         if len(video_ids) > n:
             video_ids = video_ids[:n]
-        for id in video_ids:
-            self._downloader.download(['http://www.youtube.com/watch?v=%s' % id])
-        return
+        videos = [self.url_result('http://www.youtube.com/watch?v=%s' % id, 'Youtube') for id in video_ids]
+        return videos
 
 
 class GoogleSearchIE(InfoExtractor):

From f17ce13a9260919c4d8cb652467023373c783bd2 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Jaime=20Marqui=CC=81nez=20Ferra=CC=81ndiz?=
 <jaime.marquinez.ferrandiz@gmail.com>
Date: Sat, 20 Apr 2013 19:35:49 +0200
Subject: [PATCH 098/221] Write the method to_screen in InfoExtractor (related
 #608)

Except the ones in youtube subtypes (user, channels ..) all calls to _downloader.to_screen has been changed.
The calls not prefixed with the IE name hasn't been touched.
---
 youtube_dl/InfoExtractors.py | 156 ++++++++++++++++++-----------------
 1 file changed, 80 insertions(+), 76 deletions(-)

diff --git a/youtube_dl/InfoExtractors.py b/youtube_dl/InfoExtractors.py
index 86a8ca511..d444e21d9 100755
--- a/youtube_dl/InfoExtractors.py
+++ b/youtube_dl/InfoExtractors.py
@@ -116,7 +116,7 @@ class InfoExtractor(object):
         if note is None:
             note = u'Downloading video webpage'
         if note is not False:
-            self._downloader.to_screen(u'[%s] %s: %s' % (self.IE_NAME, video_id, note))
+            self.to_screen(u'%s: %s' % (video_id, note))
         try:
             return compat_urllib_request.urlopen(url_or_request)
         except (compat_urllib_error.URLError, compat_http_client.HTTPException, socket.error) as err:
@@ -139,11 +139,15 @@ class InfoExtractor(object):
                 url = url_or_request.get_full_url()
             except AttributeError:
                 url = url_or_request
-            self._downloader.to_screen(u'Dumping request to ' + url)
+            self.to_screen(u'Dumping request to ' + url)
             dump = base64.b64encode(webpage_bytes).decode('ascii')
             self._downloader.to_screen(dump)
         return webpage_bytes.decode(encoding, 'replace')
-        
+
+    def to_screen(self, msg):
+        """Print msg to screen, prefixing it with '[ie_name]'"""
+        self._downloader.to_screen(u'[%s] %s' % (self.IE_NAME, msg))
+
     #Methods for following #608
     #They set the correct value of the '_type' key
     def video_result(self, video_info):
@@ -236,48 +240,48 @@ class YoutubeIE(InfoExtractor):
 
     def report_lang(self):
         """Report attempt to set language."""
-        self._downloader.to_screen(u'[youtube] Setting language')
+        self.to_screen(u'Setting language')
 
     def report_login(self):
         """Report attempt to log in."""
-        self._downloader.to_screen(u'[youtube] Logging in')
+        self.to_screen(u'Logging in')
 
     def report_age_confirmation(self):
         """Report attempt to confirm age."""
-        self._downloader.to_screen(u'[youtube] Confirming age')
+        self.to_screen(u'Confirming age')
 
     def report_video_webpage_download(self, video_id):
         """Report attempt to download video webpage."""
-        self._downloader.to_screen(u'[youtube] %s: Downloading video webpage' % video_id)
+        self.to_screen(u'%s: Downloading video webpage' % video_id)
 
     def report_video_info_webpage_download(self, video_id):
         """Report attempt to download video info webpage."""
-        self._downloader.to_screen(u'[youtube] %s: Downloading video info webpage' % video_id)
+        self.to_screen(u'%s: Downloading video info webpage' % video_id)
 
     def report_video_subtitles_download(self, video_id):
         """Report attempt to download video info webpage."""
-        self._downloader.to_screen(u'[youtube] %s: Checking available subtitles' % video_id)
+        self.to_screen(u'%s: Checking available subtitles' % video_id)
 
     def report_video_subtitles_request(self, video_id, sub_lang, format):
         """Report attempt to download video info webpage."""
-        self._downloader.to_screen(u'[youtube] %s: Downloading video subtitles for %s.%s' % (video_id, sub_lang, format))
+        self.to_screen(u'%s: Downloading video subtitles for %s.%s' % (video_id, sub_lang, format))
 
     def report_video_subtitles_available(self, video_id, sub_lang_list):
         """Report available subtitles."""
         sub_lang = ",".join(list(sub_lang_list.keys()))
-        self._downloader.to_screen(u'[youtube] %s: Available subtitles for video: %s' % (video_id, sub_lang))
+        self.to_screen(u'%s: Available subtitles for video: %s' % (video_id, sub_lang))
 
     def report_information_extraction(self, video_id):
         """Report attempt to extract video information."""
-        self._downloader.to_screen(u'[youtube] %s: Extracting video information' % video_id)
+        self.to_screen(u'%s: Extracting video information' % video_id)
 
     def report_unavailable_format(self, video_id, format):
         """Report extracted video URL."""
-        self._downloader.to_screen(u'[youtube] %s: Format %s not available' % (video_id, format))
+        self.to_screen(u'%s: Format %s not available' % (video_id, format))
 
     def report_rtmp_download(self):
         """Indicate the download will use the RTMP protocol."""
-        self._downloader.to_screen(u'[youtube] RTMP download detected')
+        self.to_screen(u'RTMP download detected')
 
     def _get_available_subtitles(self, video_id):
         self.report_video_subtitles_download(video_id)
@@ -680,19 +684,19 @@ class MetacafeIE(InfoExtractor):
 
     def report_disclaimer(self):
         """Report disclaimer retrieval."""
-        self._downloader.to_screen(u'[metacafe] Retrieving disclaimer')
+        self.to_screen(u'Retrieving disclaimer')
 
     def report_age_confirmation(self):
         """Report attempt to confirm age."""
-        self._downloader.to_screen(u'[metacafe] Confirming age')
+        self.to_screen(u'Confirming age')
 
     def report_download_webpage(self, video_id):
         """Report webpage download."""
-        self._downloader.to_screen(u'[metacafe] %s: Downloading webpage' % video_id)
+        self.to_screen(u'%s: Downloading webpage' % video_id)
 
     def report_extraction(self, video_id):
         """Report information extraction."""
-        self._downloader.to_screen(u'[metacafe] %s: Extracting information' % video_id)
+        self.to_screen(u'%s: Extracting information' % video_id)
 
     def _real_initialize(self):
         # Retrieve disclaimer
@@ -799,7 +803,7 @@ class DailymotionIE(InfoExtractor):
 
     def report_extraction(self, video_id):
         """Report information extraction."""
-        self._downloader.to_screen(u'[dailymotion] %s: Extracting information' % video_id)
+        self.to_screen(u'%s: Extracting information' % video_id)
 
     def _real_extract(self, url):
         # Extract id and simplified title from URL
@@ -828,7 +832,7 @@ class DailymotionIE(InfoExtractor):
         for key in ['hd1080URL', 'hd720URL', 'hqURL', 'sdURL', 'ldURL', 'video_url']:
             if key in flashvars:
                 max_quality = key
-                self._downloader.to_screen(u'[dailymotion] Using %s' % key)
+                self.to_screen(u'Using %s' % key)
                 break
         else:
             self._downloader.report_error(u'unable to extract video URL')
@@ -887,11 +891,11 @@ class PhotobucketIE(InfoExtractor):
 
     def report_download_webpage(self, video_id):
         """Report webpage download."""
-        self._downloader.to_screen(u'[photobucket] %s: Downloading webpage' % video_id)
+        self.to_screen(u'%s: Downloading webpage' % video_id)
 
     def report_extraction(self, video_id):
         """Report information extraction."""
-        self._downloader.to_screen(u'[photobucket] %s: Extracting information' % video_id)
+        self.to_screen(u'%s: Extracting information' % video_id)
 
     def _real_extract(self, url):
         # Extract id from URL
@@ -956,11 +960,11 @@ class YahooIE(InfoExtractor):
 
     def report_download_webpage(self, video_id):
         """Report webpage download."""
-        self._downloader.to_screen(u'[video.yahoo] %s: Downloading webpage' % video_id)
+        self.to_screen(u'%s: Downloading webpage' % video_id)
 
     def report_extraction(self, video_id):
         """Report information extraction."""
-        self._downloader.to_screen(u'[video.yahoo] %s: Extracting information' % video_id)
+        self.to_screen(u'%s: Extracting information' % video_id)
 
     def _real_extract(self, url, new_video=True):
         # Extract ID from URL
@@ -1096,11 +1100,11 @@ class VimeoIE(InfoExtractor):
 
     def report_download_webpage(self, video_id):
         """Report webpage download."""
-        self._downloader.to_screen(u'[vimeo] %s: Downloading webpage' % video_id)
+        self.to_screen(u'%s: Downloading webpage' % video_id)
 
     def report_extraction(self, video_id):
         """Report information extraction."""
-        self._downloader.to_screen(u'[vimeo] %s: Extracting information' % video_id)
+        self.to_screen(u'%s: Extracting information' % video_id)
 
     def _real_extract(self, url, new_video=True):
         # Extract ID from URL
@@ -1182,7 +1186,7 @@ class VimeoIE(InfoExtractor):
                 video_quality = files[quality][0][2]
                 video_codec = files[quality][0][0]
                 video_extension = files[quality][0][1]
-                self._downloader.to_screen(u'[vimeo] %s: Downloading %s file at %s quality' % (video_id, video_codec.upper(), video_quality))
+                self.to_screen(u'%s: Downloading %s file at %s quality' % (video_id, video_codec.upper(), video_quality))
                 break
         else:
             self._downloader.report_error(u'no known codec found')
@@ -1217,11 +1221,11 @@ class ArteTvIE(InfoExtractor):
 
     def report_download_webpage(self, video_id):
         """Report webpage download."""
-        self._downloader.to_screen(u'[arte.tv] %s: Downloading webpage' % video_id)
+        self.to_screen(u'%s: Downloading webpage' % video_id)
 
     def report_extraction(self, video_id):
         """Report information extraction."""
-        self._downloader.to_screen(u'[arte.tv] %s: Extracting information' % video_id)
+        self.to_screen(u'%s: Extracting information' % video_id)
 
     def fetch_webpage(self, url):
         request = compat_urllib_request.Request(url)
@@ -1352,12 +1356,12 @@ class GenericIE(InfoExtractor):
     def report_download_webpage(self, video_id):
         """Report webpage download."""
         if not self._downloader.params.get('test', False):
-            self._downloader.to_screen(u'WARNING: Falling back on generic information extractor.')
-        self._downloader.to_screen(u'[generic] %s: Downloading webpage' % video_id)
+            self._downloader.report_warning(u'Falling back on generic information extractor.')
+        self.to_screen(u'%s: Downloading webpage' % video_id)
 
     def report_extraction(self, video_id):
         """Report information extraction."""
-        self._downloader.to_screen(u'[generic] %s: Extracting information' % video_id)
+        self.to_screen(u'%s: Extracting information' % video_id)
 
     def report_following_redirect(self, new_url):
         """Report information extraction."""
@@ -1575,7 +1579,7 @@ class GoogleSearchIE(InfoExtractor):
     def report_download_page(self, query, pagenum):
         """Report attempt to download playlist page with given number."""
         query = query.decode(preferredencoding())
-        self._downloader.to_screen(u'[video.google] query "%s": Downloading page %s' % (query, pagenum))
+        self.to_screen(u'query "%s": Downloading page %s' % (query, pagenum))
 
     def _real_extract(self, query):
         mobj = re.match(self._VALID_URL, query)
@@ -1659,7 +1663,7 @@ class YahooSearchIE(InfoExtractor):
     def report_download_page(self, query, pagenum):
         """Report attempt to download playlist page with given number."""
         query = query.decode(preferredencoding())
-        self._downloader.to_screen(u'[video.yahoo] query "%s": Downloading page %s' % (query, pagenum))
+        self.to_screen(u'query "%s": Downloading page %s' % (query, pagenum))
 
     def _real_extract(self, query):
         mobj = re.match(self._VALID_URL, query)
@@ -1970,8 +1974,8 @@ class BlipTVUserIE(InfoExtractor):
 
     def report_download_page(self, username, pagenum):
         """Report attempt to download user page."""
-        self._downloader.to_screen(u'[%s] user %s: Downloading video ids from page %d' %
-                (self.IE_NAME, username, pagenum))
+        self.to_screen(u'user %s: Downloading video ids from page %d' %
+                (username, pagenum))
 
     def _real_extract(self, url):
         # Extract username
@@ -2045,11 +2049,11 @@ class DepositFilesIE(InfoExtractor):
 
     def report_download_webpage(self, file_id):
         """Report webpage download."""
-        self._downloader.to_screen(u'[DepositFiles] %s: Downloading webpage' % file_id)
+        self.to_screen(u'%s: Downloading webpage' % file_id)
 
     def report_extraction(self, file_id):
         """Report information extraction."""
-        self._downloader.to_screen(u'[DepositFiles] %s: Extracting information' % file_id)
+        self.to_screen(u'%s: Extracting information' % file_id)
 
     def _real_extract(self, url):
         file_id = url.split('/')[-1]
@@ -2108,7 +2112,7 @@ class FacebookIE(InfoExtractor):
 
     def report_login(self):
         """Report attempt to log in."""
-        self._downloader.to_screen(u'[%s] Logging in' % self.IE_NAME)
+        self.to_screen(u'Logging in')
 
     def _real_initialize(self):
         if self._downloader is None:
@@ -2206,11 +2210,11 @@ class BlipTVIE(InfoExtractor):
 
     def report_extraction(self, file_id):
         """Report information extraction."""
-        self._downloader.to_screen(u'[%s] %s: Extracting information' % (self.IE_NAME, file_id))
+        self.to_screen(u'%s: Extracting information' % file_id)
 
     def report_direct_download(self, title):
         """Report information extraction."""
-        self._downloader.to_screen(u'[%s] %s: Direct download detected' % (self.IE_NAME, title))
+        self.to_screen(u'%s: Direct download detected' % title)
 
     def _real_extract(self, url):
         mobj = re.match(self._VALID_URL, url)
@@ -2310,7 +2314,7 @@ class MyVideoIE(InfoExtractor):
 
     def report_extraction(self, video_id):
         """Report information extraction."""
-        self._downloader.to_screen(u'[myvideo] %s: Extracting information' % video_id)
+        self.to_screen(u'%s: Extracting information' % video_id)
 
     def _real_extract(self,url):
         mobj = re.match(self._VALID_URL, url)
@@ -2390,13 +2394,13 @@ class ComedyCentralIE(InfoExtractor):
         return re.match(cls._VALID_URL, url, re.VERBOSE) is not None
 
     def report_extraction(self, episode_id):
-        self._downloader.to_screen(u'[comedycentral] %s: Extracting information' % episode_id)
+        self.to_screen(u'%s: Extracting information' % episode_id)
 
     def report_config_download(self, episode_id, media_id):
-        self._downloader.to_screen(u'[comedycentral] %s: Downloading configuration for %s' % (episode_id, media_id))
+        self.to_screen(u'%s: Downloading configuration for %s' % (episode_id, media_id))
 
     def report_index_download(self, episode_id):
-        self._downloader.to_screen(u'[comedycentral] %s: Downloading show index' % episode_id)
+        self.to_screen(u'%s: Downloading show index' % episode_id)
 
     def _print_formats(self, formats):
         print('Available formats:')
@@ -2551,10 +2555,10 @@ class EscapistIE(InfoExtractor):
     IE_NAME = u'escapist'
 
     def report_extraction(self, showName):
-        self._downloader.to_screen(u'[escapist] %s: Extracting information' % showName)
+        self.to_screen(u'%s: Extracting information' % showName)
 
     def report_config_download(self, showName):
-        self._downloader.to_screen(u'[escapist] %s: Downloading configuration' % showName)
+        self.to_screen(u'%s: Downloading configuration' % showName)
 
     def _real_extract(self, url):
         mobj = re.match(self._VALID_URL, url)
@@ -2627,11 +2631,11 @@ class CollegeHumorIE(InfoExtractor):
 
     def report_manifest(self, video_id):
         """Report information extraction."""
-        self._downloader.to_screen(u'[%s] %s: Downloading XML manifest' % (self.IE_NAME, video_id))
+        self.to_screen(u'%s: Downloading XML manifest' % video_id)
 
     def report_extraction(self, video_id):
         """Report information extraction."""
-        self._downloader.to_screen(u'[%s] %s: Extracting information' % (self.IE_NAME, video_id))
+        self.to_screen(u'%s: Extracting information' % video_id)
 
     def _real_extract(self, url):
         mobj = re.match(self._VALID_URL, url)
@@ -2698,7 +2702,7 @@ class XVideosIE(InfoExtractor):
 
     def report_extraction(self, video_id):
         """Report information extraction."""
-        self._downloader.to_screen(u'[%s] %s: Extracting information' % (self.IE_NAME, video_id))
+        self.to_screen(u'%s: Extracting information' % video_id)
 
     def _real_extract(self, url):
         mobj = re.match(self._VALID_URL, url)
@@ -2766,11 +2770,11 @@ class SoundcloudIE(InfoExtractor):
 
     def report_resolve(self, video_id):
         """Report information extraction."""
-        self._downloader.to_screen(u'[%s] %s: Resolving id' % (self.IE_NAME, video_id))
+        self.to_screen(u'%s: Resolving id' % 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))
+        self.to_screen(u'%s: Retrieving stream' % video_id)
 
     def _real_extract(self, url):
         mobj = re.match(self._VALID_URL, url)
@@ -2839,11 +2843,11 @@ class SoundcloudSetIE(InfoExtractor):
 
     def report_resolve(self, video_id):
         """Report information extraction."""
-        self._downloader.to_screen(u'[%s] %s: Resolving id' % (self.IE_NAME, video_id))
+        self.to_screen(u'%s: Resolving id' % 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))
+        self.to_screen(u'%s: Retrieving stream' % video_id)
 
     def _real_extract(self, url):
         mobj = re.match(self._VALID_URL, url)
@@ -2910,7 +2914,7 @@ class InfoQIE(InfoExtractor):
 
     def report_extraction(self, video_id):
         """Report information extraction."""
-        self._downloader.to_screen(u'[%s] %s: Extracting information' % (self.IE_NAME, video_id))
+        self.to_screen(u'%s: Extracting information' % video_id)
 
     def _real_extract(self, url):
         mobj = re.match(self._VALID_URL, url)
@@ -2970,11 +2974,11 @@ class MixcloudIE(InfoExtractor):
 
     def report_download_json(self, file_id):
         """Report JSON download."""
-        self._downloader.to_screen(u'[%s] Downloading json' % self.IE_NAME)
+        self.to_screen(u'Downloading json')
 
     def report_extraction(self, file_id):
         """Report information extraction."""
-        self._downloader.to_screen(u'[%s] %s: Extracting information' % (self.IE_NAME, file_id))
+        self.to_screen(u'%s: Extracting information' % file_id)
 
     def get_urls(self, jsonData, fmt, bitrate='best'):
         """Get urls from 'audio_formats' section in json"""
@@ -3081,11 +3085,11 @@ class StanfordOpenClassroomIE(InfoExtractor):
 
     def report_download_webpage(self, objid):
         """Report information extraction."""
-        self._downloader.to_screen(u'[%s] %s: Downloading webpage' % (self.IE_NAME, objid))
+        self.to_screen(u'%s: Downloading webpage' % objid)
 
     def report_extraction(self, video_id):
         """Report information extraction."""
-        self._downloader.to_screen(u'[%s] %s: Extracting information' % (self.IE_NAME, video_id))
+        self.to_screen(u'%s: Extracting information' % video_id)
 
     def _real_extract(self, url):
         mobj = re.match(self._VALID_URL, url)
@@ -3193,7 +3197,7 @@ class MTVIE(InfoExtractor):
 
     def report_extraction(self, video_id):
         """Report information extraction."""
-        self._downloader.to_screen(u'[%s] %s: Extracting information' % (self.IE_NAME, video_id))
+        self.to_screen(u'%s: Extracting information' % video_id)
 
     def _real_extract(self, url):
         mobj = re.match(self._VALID_URL, url)
@@ -3271,11 +3275,11 @@ class YoukuIE(InfoExtractor):
 
     def report_download_webpage(self, file_id):
         """Report webpage download."""
-        self._downloader.to_screen(u'[%s] %s: Downloading webpage' % (self.IE_NAME, file_id))
+        self.to_screen(u'%s: Downloading webpage' % file_id)
 
     def report_extraction(self, file_id):
         """Report information extraction."""
-        self._downloader.to_screen(u'[%s] %s: Extracting information' % (self.IE_NAME, file_id))
+        self.to_screen(u'%s: Extracting information' % file_id)
 
     def _gen_sid(self):
         nowTime = int(time.time() * 1000)
@@ -3388,11 +3392,11 @@ class XNXXIE(InfoExtractor):
 
     def report_webpage(self, video_id):
         """Report information extraction"""
-        self._downloader.to_screen(u'[%s] %s: Downloading webpage' % (self.IE_NAME, video_id))
+        self.to_screen(u'%s: Downloading webpage' % video_id)
 
     def report_extraction(self, video_id):
         """Report information extraction"""
-        self._downloader.to_screen(u'[%s] %s: Extracting information' % (self.IE_NAME, video_id))
+        self.to_screen(u'%s: Extracting information' % video_id)
 
     def _real_extract(self, url):
         mobj = re.match(self._VALID_URL, url)
@@ -3452,23 +3456,23 @@ class GooglePlusIE(InfoExtractor):
 
     def report_extract_entry(self, url):
         """Report downloading extry"""
-        self._downloader.to_screen(u'[plus.google] Downloading entry: %s' % url)
+        self.to_screen(u'Downloading entry: %s' % url)
 
     def report_date(self, upload_date):
         """Report downloading extry"""
-        self._downloader.to_screen(u'[plus.google] Entry date: %s' % upload_date)
+        self.to_screen(u'Entry date: %s' % upload_date)
 
     def report_uploader(self, uploader):
         """Report downloading extry"""
-        self._downloader.to_screen(u'[plus.google] Uploader: %s' % uploader)
+        self.to_screen(u'Uploader: %s' % uploader)
 
     def report_title(self, video_title):
         """Report downloading extry"""
-        self._downloader.to_screen(u'[plus.google] Title: %s' % video_title)
+        self.to_screen(u'Title: %s' % video_title)
 
     def report_extract_vid_page(self, video_page):
         """Report information extraction."""
-        self._downloader.to_screen(u'[plus.google] Extracting video page: %s' % video_page)
+        self.to_screen(u'Extracting video page: %s' % video_page)
 
     def _real_extract(self, url):
         # Extract id from URL
@@ -3614,12 +3618,12 @@ class JustinTVIE(InfoExtractor):
 
     def report_extraction(self, file_id):
         """Report information extraction."""
-        self._downloader.to_screen(u'[%s] %s: Extracting information' % (self.IE_NAME, file_id))
+        self.to_screen(u'%s: Extracting information' % file_id)
 
     def report_download_page(self, channel, offset):
         """Report attempt to download a single page of videos."""
-        self._downloader.to_screen(u'[%s] %s: Downloading video information from %d to %d' %
-                (self.IE_NAME, channel, offset, offset + self._JUSTIN_PAGE_LIMIT))
+        self.to_screen(u'%s: Downloading video information from %d to %d' %
+                (channel, offset, offset + self._JUSTIN_PAGE_LIMIT))
 
     # Return count of items, list of *valid* items
     def _parse_page(self, url):
@@ -3948,7 +3952,7 @@ class YouPornIE(InfoExtractor):
         if(len(links) == 0):
             raise ExtractorError(u'ERROR: no known formats available for video')
 
-        self._downloader.to_screen(u'[youporn] Links found: %d' % len(links))
+        self.to_screen(u'Links found: %d' % len(links))
 
         formats = []
         for link in links:
@@ -3984,7 +3988,7 @@ class YouPornIE(InfoExtractor):
             return
 
         req_format = self._downloader.params.get('format', None)
-        self._downloader.to_screen(u'[youporn] Format: %s' % req_format)
+        self.to_screen(u'Format: %s' % req_format)
 
         if req_format is None or req_format == 'best':
             return [formats[0]]
@@ -4179,7 +4183,7 @@ class TEDIE(InfoExtractor):
         else :
             playlist_id=m.group('playlist_id')
             name=m.group('name')
-            self._downloader.to_screen(u'[%s] Getting info of playlist %s: "%s"' % (self.IE_NAME,playlist_id,name))
+            self.to_screen(u'Getting info of playlist %s: "%s"' % (playlist_id,name))
             return [self._playlist_videos_info(url,name,playlist_id)]
 
     def _talk_video_link(self,mediaSlug):
@@ -4404,7 +4408,7 @@ class ARDIE(InfoExtractor):
         # there's two possibilities: RTMP stream or HTTP download
         info = {'id': video_id, 'title': title, 'ext': 'mp4'}
         if stream['rtmp_url']:
-            self._downloader.to_screen(u'[%s] RTMP download detected' % self.IE_NAME)
+            self.to_screen(u'RTMP download detected')
             assert stream['video_url'].startswith('mp4:')
             info["url"] = stream["rtmp_url"]
             info["play_path"] = stream['video_url']

From 41a6eb949a625983c55cdae0c06410392f3a3110 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Jaime=20Marqui=CC=81nez=20Ferra=CC=81ndiz?=
 <jaime.marquinez.ferrandiz@gmail.com>
Date: Sat, 20 Apr 2013 21:12:29 +0200
Subject: [PATCH 099/221] Clean duplicate method report_extraction in
 InfoExtractors

A lot of IEs had implemented the method in the same way.
---
 youtube_dl/InfoExtractors.py | 94 ++----------------------------------
 1 file changed, 4 insertions(+), 90 deletions(-)

diff --git a/youtube_dl/InfoExtractors.py b/youtube_dl/InfoExtractors.py
index d444e21d9..7c9f09f77 100755
--- a/youtube_dl/InfoExtractors.py
+++ b/youtube_dl/InfoExtractors.py
@@ -148,6 +148,10 @@ class InfoExtractor(object):
         """Print msg to screen, prefixing it with '[ie_name]'"""
         self._downloader.to_screen(u'[%s] %s' % (self.IE_NAME, msg))
 
+    def report_extraction(self, id_or_name):
+        """Report information extraction."""
+        self.to_screen(u'%s: Extracting information' % id_or_name)
+
     #Methods for following #608
     #They set the correct value of the '_type' key
     def video_result(self, video_info):
@@ -694,10 +698,6 @@ class MetacafeIE(InfoExtractor):
         """Report webpage download."""
         self.to_screen(u'%s: Downloading webpage' % video_id)
 
-    def report_extraction(self, video_id):
-        """Report information extraction."""
-        self.to_screen(u'%s: Extracting information' % video_id)
-
     def _real_initialize(self):
         # Retrieve disclaimer
         request = compat_urllib_request.Request(self._DISCLAIMER)
@@ -801,10 +801,6 @@ class DailymotionIE(InfoExtractor):
     def __init__(self, downloader=None):
         InfoExtractor.__init__(self, downloader)
 
-    def report_extraction(self, video_id):
-        """Report information extraction."""
-        self.to_screen(u'%s: Extracting information' % video_id)
-
     def _real_extract(self, url):
         # Extract id and simplified title from URL
         mobj = re.match(self._VALID_URL, url)
@@ -893,10 +889,6 @@ class PhotobucketIE(InfoExtractor):
         """Report webpage download."""
         self.to_screen(u'%s: Downloading webpage' % video_id)
 
-    def report_extraction(self, video_id):
-        """Report information extraction."""
-        self.to_screen(u'%s: Extracting information' % video_id)
-
     def _real_extract(self, url):
         # Extract id from URL
         mobj = re.match(self._VALID_URL, url)
@@ -962,10 +954,6 @@ class YahooIE(InfoExtractor):
         """Report webpage download."""
         self.to_screen(u'%s: Downloading webpage' % video_id)
 
-    def report_extraction(self, video_id):
-        """Report information extraction."""
-        self.to_screen(u'%s: Extracting information' % video_id)
-
     def _real_extract(self, url, new_video=True):
         # Extract ID from URL
         mobj = re.match(self._VALID_URL, url)
@@ -1102,10 +1090,6 @@ class VimeoIE(InfoExtractor):
         """Report webpage download."""
         self.to_screen(u'%s: Downloading webpage' % video_id)
 
-    def report_extraction(self, video_id):
-        """Report information extraction."""
-        self.to_screen(u'%s: Extracting information' % video_id)
-
     def _real_extract(self, url, new_video=True):
         # Extract ID from URL
         mobj = re.match(self._VALID_URL, url)
@@ -1223,10 +1207,6 @@ class ArteTvIE(InfoExtractor):
         """Report webpage download."""
         self.to_screen(u'%s: Downloading webpage' % video_id)
 
-    def report_extraction(self, video_id):
-        """Report information extraction."""
-        self.to_screen(u'%s: Extracting information' % video_id)
-
     def fetch_webpage(self, url):
         request = compat_urllib_request.Request(url)
         try:
@@ -1359,10 +1339,6 @@ class GenericIE(InfoExtractor):
             self._downloader.report_warning(u'Falling back on generic information extractor.')
         self.to_screen(u'%s: Downloading webpage' % video_id)
 
-    def report_extraction(self, video_id):
-        """Report information extraction."""
-        self.to_screen(u'%s: Extracting information' % video_id)
-
     def report_following_redirect(self, new_url):
         """Report information extraction."""
         self._downloader.to_screen(u'[redirect] Following redirect to %s' % new_url)
@@ -2051,10 +2027,6 @@ class DepositFilesIE(InfoExtractor):
         """Report webpage download."""
         self.to_screen(u'%s: Downloading webpage' % file_id)
 
-    def report_extraction(self, file_id):
-        """Report information extraction."""
-        self.to_screen(u'%s: Extracting information' % file_id)
-
     def _real_extract(self, url):
         file_id = url.split('/')[-1]
         # Rebuild url in english locale
@@ -2208,10 +2180,6 @@ class BlipTVIE(InfoExtractor):
     _URL_EXT = r'^.*\.([a-z0-9]+)$'
     IE_NAME = u'blip.tv'
 
-    def report_extraction(self, file_id):
-        """Report information extraction."""
-        self.to_screen(u'%s: Extracting information' % file_id)
-
     def report_direct_download(self, title):
         """Report information extraction."""
         self.to_screen(u'%s: Direct download detected' % title)
@@ -2312,10 +2280,6 @@ class MyVideoIE(InfoExtractor):
     def __init__(self, downloader=None):
         InfoExtractor.__init__(self, downloader)
 
-    def report_extraction(self, video_id):
-        """Report information extraction."""
-        self.to_screen(u'%s: Extracting information' % video_id)
-
     def _real_extract(self,url):
         mobj = re.match(self._VALID_URL, url)
         if mobj is None:
@@ -2393,9 +2357,6 @@ class ComedyCentralIE(InfoExtractor):
         """Receives a URL and returns True if suitable for this IE."""
         return re.match(cls._VALID_URL, url, re.VERBOSE) is not None
 
-    def report_extraction(self, episode_id):
-        self.to_screen(u'%s: Extracting information' % episode_id)
-
     def report_config_download(self, episode_id, media_id):
         self.to_screen(u'%s: Downloading configuration for %s' % (episode_id, media_id))
 
@@ -2554,9 +2515,6 @@ class EscapistIE(InfoExtractor):
     _VALID_URL = r'^(https?://)?(www\.)?escapistmagazine\.com/videos/view/(?P<showname>[^/]+)/(?P<episode>[^/?]+)[/?]?.*$'
     IE_NAME = u'escapist'
 
-    def report_extraction(self, showName):
-        self.to_screen(u'%s: Extracting information' % showName)
-
     def report_config_download(self, showName):
         self.to_screen(u'%s: Downloading configuration' % showName)
 
@@ -2633,10 +2591,6 @@ class CollegeHumorIE(InfoExtractor):
         """Report information extraction."""
         self.to_screen(u'%s: Downloading XML manifest' % video_id)
 
-    def report_extraction(self, video_id):
-        """Report information extraction."""
-        self.to_screen(u'%s: Extracting information' % video_id)
-
     def _real_extract(self, url):
         mobj = re.match(self._VALID_URL, url)
         if mobj is None:
@@ -2700,10 +2654,6 @@ class XVideosIE(InfoExtractor):
     _VALID_URL = r'^(?:https?://)?(?:www\.)?xvideos\.com/video([0-9]+)(?:.*)'
     IE_NAME = u'xvideos'
 
-    def report_extraction(self, video_id):
-        """Report information extraction."""
-        self.to_screen(u'%s: Extracting information' % video_id)
-
     def _real_extract(self, url):
         mobj = re.match(self._VALID_URL, url)
         if mobj is None:
@@ -2772,10 +2722,6 @@ class SoundcloudIE(InfoExtractor):
         """Report information extraction."""
         self.to_screen(u'%s: Resolving id' % video_id)
 
-    def report_extraction(self, video_id):
-        """Report information extraction."""
-        self.to_screen(u'%s: Retrieving stream' % video_id)
-
     def _real_extract(self, url):
         mobj = re.match(self._VALID_URL, url)
         if mobj is None:
@@ -2845,10 +2791,6 @@ class SoundcloudSetIE(InfoExtractor):
         """Report information extraction."""
         self.to_screen(u'%s: Resolving id' % video_id)
 
-    def report_extraction(self, video_id):
-        """Report information extraction."""
-        self.to_screen(u'%s: Retrieving stream' % video_id)
-
     def _real_extract(self, url):
         mobj = re.match(self._VALID_URL, url)
         if mobj is None:
@@ -2912,10 +2854,6 @@ class InfoQIE(InfoExtractor):
     """Information extractor for infoq.com"""
     _VALID_URL = r'^(?:https?://)?(?:www\.)?infoq\.com/[^/]+/[^/]+$'
 
-    def report_extraction(self, video_id):
-        """Report information extraction."""
-        self.to_screen(u'%s: Extracting information' % video_id)
-
     def _real_extract(self, url):
         mobj = re.match(self._VALID_URL, url)
         if mobj is None:
@@ -2976,10 +2914,6 @@ class MixcloudIE(InfoExtractor):
         """Report JSON download."""
         self.to_screen(u'Downloading json')
 
-    def report_extraction(self, file_id):
-        """Report information extraction."""
-        self.to_screen(u'%s: Extracting information' % file_id)
-
     def get_urls(self, jsonData, fmt, bitrate='best'):
         """Get urls from 'audio_formats' section in json"""
         file_url = None
@@ -3087,10 +3021,6 @@ class StanfordOpenClassroomIE(InfoExtractor):
         """Report information extraction."""
         self.to_screen(u'%s: Downloading webpage' % objid)
 
-    def report_extraction(self, video_id):
-        """Report information extraction."""
-        self.to_screen(u'%s: Extracting information' % video_id)
-
     def _real_extract(self, url):
         mobj = re.match(self._VALID_URL, url)
         if mobj is None:
@@ -3195,10 +3125,6 @@ class MTVIE(InfoExtractor):
     _VALID_URL = r'^(?P<proto>https?://)?(?:www\.)?mtv\.com/videos/[^/]+/(?P<videoid>[0-9]+)/[^/]+$'
     IE_NAME = u'mtv'
 
-    def report_extraction(self, video_id):
-        """Report information extraction."""
-        self.to_screen(u'%s: Extracting information' % video_id)
-
     def _real_extract(self, url):
         mobj = re.match(self._VALID_URL, url)
         if mobj is None:
@@ -3277,10 +3203,6 @@ class YoukuIE(InfoExtractor):
         """Report webpage download."""
         self.to_screen(u'%s: Downloading webpage' % file_id)
 
-    def report_extraction(self, file_id):
-        """Report information extraction."""
-        self.to_screen(u'%s: Extracting information' % file_id)
-
     def _gen_sid(self):
         nowTime = int(time.time() * 1000)
         random1 = random.randint(1000,1998)
@@ -3394,10 +3316,6 @@ class XNXXIE(InfoExtractor):
         """Report information extraction"""
         self.to_screen(u'%s: Downloading webpage' % video_id)
 
-    def report_extraction(self, video_id):
-        """Report information extraction"""
-        self.to_screen(u'%s: Extracting information' % video_id)
-
     def _real_extract(self, url):
         mobj = re.match(self._VALID_URL, url)
         if mobj is None:
@@ -3616,10 +3534,6 @@ class JustinTVIE(InfoExtractor):
     _JUSTIN_PAGE_LIMIT = 100
     IE_NAME = u'justin.tv'
 
-    def report_extraction(self, file_id):
-        """Report information extraction."""
-        self.to_screen(u'%s: Extracting information' % file_id)
-
     def report_download_page(self, channel, offset):
         """Report attempt to download a single page of videos."""
         self.to_screen(u'%s: Downloading video information from %d to %d' %

From b0936ef42365ce7f2bd5b49e39d0ed42c4c3684e Mon Sep 17 00:00:00 2001
From: Alexander van Gessel <AI0867@gmail.com>
Date: Sun, 21 Apr 2013 02:38:37 +0300
Subject: [PATCH 100/221] Use standard unit symbols in format_bytes

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

diff --git a/youtube_dl/FileDownloader.py b/youtube_dl/FileDownloader.py
index 9c0c42f8d..19766153c 100644
--- a/youtube_dl/FileDownloader.py
+++ b/youtube_dl/FileDownloader.py
@@ -121,7 +121,7 @@ class FileDownloader(object):
             exponent = 0
         else:
             exponent = int(math.log(bytes, 1024.0))
-        suffix = 'bkMGTPEZY'[exponent]
+        suffix = ['B','KiB','MiB','GiB','TiB','PiB','EiB','ZiB','YiB'][exponent]
         converted = float(bytes) / float(1024 ** exponent)
         return '%.2f%s' % (converted, suffix)
 

From c04bca6f604ba84995ef29a0361d85b1bc180fee Mon Sep 17 00:00:00 2001
From: Philipp Hagemeister <phihag@phihag.de>
Date: Sun, 21 Apr 2013 12:52:45 +0200
Subject: [PATCH 101/221] release 2013.04.21

---
 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 2fd5f40c8..33696b54b 100644
--- a/youtube_dl/version.py
+++ b/youtube_dl/version.py
@@ -1,2 +1,2 @@
 
-__version__ = '2013.04.18'
+__version__ = '2013.04.21'

From e11eb11906e7054e8dc14c86073546935acacae0 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Jaime=20Marqui=CC=81nez=20Ferra=CC=81ndiz?=
 <jaime.marquinez.ferrandiz@gmail.com>
Date: Sun, 21 Apr 2013 21:56:13 +0200
Subject: [PATCH 102/221] Allow to download videos with age check from Steam

Also move method report_age_confirmation to the base IE class.
---
 youtube_dl/InfoExtractors.py | 15 ++++++---------
 1 file changed, 6 insertions(+), 9 deletions(-)

diff --git a/youtube_dl/InfoExtractors.py b/youtube_dl/InfoExtractors.py
index 7c9f09f77..6ff0d49d7 100755
--- a/youtube_dl/InfoExtractors.py
+++ b/youtube_dl/InfoExtractors.py
@@ -152,6 +152,10 @@ class InfoExtractor(object):
         """Report information extraction."""
         self.to_screen(u'%s: Extracting information' % id_or_name)
 
+    def report_age_confirmation(self):
+        """Report attempt to confirm age."""
+        self.to_screen(u'Confirming age')
+
     #Methods for following #608
     #They set the correct value of the '_type' key
     def video_result(self, video_info):
@@ -250,10 +254,6 @@ class YoutubeIE(InfoExtractor):
         """Report attempt to log in."""
         self.to_screen(u'Logging in')
 
-    def report_age_confirmation(self):
-        """Report attempt to confirm age."""
-        self.to_screen(u'Confirming age')
-
     def report_video_webpage_download(self, video_id):
         """Report attempt to download video webpage."""
         self.to_screen(u'%s: Downloading video webpage' % video_id)
@@ -690,10 +690,6 @@ class MetacafeIE(InfoExtractor):
         """Report disclaimer retrieval."""
         self.to_screen(u'Retrieving disclaimer')
 
-    def report_age_confirmation(self):
-        """Report attempt to confirm age."""
-        self.to_screen(u'Confirming age')
-
     def report_download_webpage(self, video_id):
         """Report webpage download."""
         self.to_screen(u'%s: Downloading webpage' % video_id)
@@ -3661,7 +3657,8 @@ class SteamIE(InfoExtractor):
         m = re.match(self._VALID_URL, url, re.VERBOSE)
         urlRE = r"'movie_(?P<videoID>\d+)': \{\s*FILENAME: \"(?P<videoURL>[\w:/\.\?=]+)\"(,\s*MOVIE_NAME: \"(?P<videoName>[\w:/\.\?=\+-]+)\")?\s*\},"
         gameID = m.group('gameID')
-        videourl = 'http://store.steampowered.com/video/%s/' % gameID
+        videourl = 'http://store.steampowered.com/agecheck/video/%s/?snr=1_agecheck_agecheck__age-gate&ageDay=1&ageMonth=January&ageYear=1970' % gameID
+        self.report_age_confirmation()
         webpage = self._download_webpage(videourl, gameID)
         mweb = re.finditer(urlRE, webpage)
         namesRE = r'<span class="title">(?P<videoName>.+?)</span>'

From 9e1cf0c2004563015d69c5a01aa419c4b70ad696 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Jaime=20Marqui=CC=81nez=20Ferra=CC=81ndiz?=
 <jaime.marquinez.ferrandiz@gmail.com>
Date: Sun, 21 Apr 2013 22:05:21 +0200
Subject: [PATCH 103/221] SteamIE returns a playlist

With the game name as title.
---
 youtube_dl/InfoExtractors.py | 6 ++++--
 1 file changed, 4 insertions(+), 2 deletions(-)

diff --git a/youtube_dl/InfoExtractors.py b/youtube_dl/InfoExtractors.py
index 6ff0d49d7..14a1d6523 100755
--- a/youtube_dl/InfoExtractors.py
+++ b/youtube_dl/InfoExtractors.py
@@ -3655,11 +3655,13 @@ class SteamIE(InfoExtractor):
 
     def _real_extract(self, url):
         m = re.match(self._VALID_URL, url, re.VERBOSE)
-        urlRE = r"'movie_(?P<videoID>\d+)': \{\s*FILENAME: \"(?P<videoURL>[\w:/\.\?=]+)\"(,\s*MOVIE_NAME: \"(?P<videoName>[\w:/\.\?=\+-]+)\")?\s*\},"
         gameID = m.group('gameID')
         videourl = 'http://store.steampowered.com/agecheck/video/%s/?snr=1_agecheck_agecheck__age-gate&ageDay=1&ageMonth=January&ageYear=1970' % gameID
         self.report_age_confirmation()
         webpage = self._download_webpage(videourl, gameID)
+        game_title = re.search(r'<h2 class="pageheader">(?P<game_title>.*?)</h2>', webpage).group('game_title')
+        
+        urlRE = r"'movie_(?P<videoID>\d+)': \{\s*FILENAME: \"(?P<videoURL>[\w:/\.\?=]+)\"(,\s*MOVIE_NAME: \"(?P<videoName>[\w:/\.\?=\+-]+)\")?\s*\},"
         mweb = re.finditer(urlRE, webpage)
         namesRE = r'<span class="title">(?P<videoName>.+?)</span>'
         titles = re.finditer(namesRE, webpage)
@@ -3681,7 +3683,7 @@ class SteamIE(InfoExtractor):
                 'thumbnail': video_thumb
                   }
             videos.append(info)
-        return videos
+        return [self.playlist_result(videos, gameID, game_title)]
 
 class UstreamIE(InfoExtractor):
     _VALID_URL = r'https?://www\.ustream\.tv/recorded/(?P<videoID>\d+)'

From 74e3452b9e15cb377984a1bf4764f2228c150717 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Jaime=20Marqui=CC=81nez=20Ferra=CC=81ndiz?=
 <jaime.marquinez.ferrandiz@gmail.com>
Date: Mon, 22 Apr 2013 10:06:07 +0200
Subject: [PATCH 104/221] Add playlist and playlist_index to the help string
 for the output option

Also split the help string in different lines to make editing easier.
---
 youtube_dl/__init__.py | 11 ++++++++++-
 1 file changed, 10 insertions(+), 1 deletion(-)

diff --git a/youtube_dl/__init__.py b/youtube_dl/__init__.py
index f46143e01..bac359ac7 100644
--- a/youtube_dl/__init__.py
+++ b/youtube_dl/__init__.py
@@ -238,7 +238,16 @@ def parseOpts():
             action='store_true', dest='autonumber',
             help='number downloaded files starting from 00000', default=False)
     filesystem.add_option('-o', '--output',
-            dest='outtmpl', metavar='TEMPLATE', help='output filename template. Use %(title)s to get the title, %(uploader)s for the uploader name, %(uploader_id)s for the uploader nickname if different, %(autonumber)s to get an automatically incremented number, %(ext)s for the filename extension, %(upload_date)s for the upload date (YYYYMMDD), %(extractor)s for the provider (youtube, metacafe, etc), %(id)s for the video id and %% for a literal percent. Use - to output to stdout. Can also be used to download to a different directory, for example with -o \'/my/downloads/%(uploader)s/%(title)s-%(id)s.%(ext)s\' .')
+            dest='outtmpl', metavar='TEMPLATE',
+            help=('output filename template. Use %(title)s to get the title, '
+                  '%(uploader)s for the uploader name, %(uploader_id)s for the uploader nickname if different, '
+                  '%(autonumber)s to get an automatically incremented number, '
+                  '%(ext)s for the filename extension, %(upload_date)s for the upload date (YYYYMMDD), '
+                  '%(extractor)s for the provider (youtube, metacafe, etc), '
+                  '%(id)s for the video id , %(playlist)s for the playlist the video is in, '
+                  '%(playlist_index)s for the position in the playlist and %% for a literal percent. '
+                  'Use - to output to stdout. Can also be used to download to a different directory, '
+                  'for example with -o \'/my/downloads/%(uploader)s/%(title)s-%(id)s.%(ext)s\' .'))
     filesystem.add_option('--autonumber-size',
             dest='autonumber_size', metavar='NUMBER',
             help='Specifies the number of digits in %(autonumber)s when it is present in output filename template or --autonumber option is given')

From 30f2999962ef411abc7c191e66b4c40ed5b86db5 Mon Sep 17 00:00:00 2001
From: Finn Petersen <4peterse@googlemail.com>
Date: Mon, 22 Apr 2013 10:15:58 +0200
Subject: [PATCH 105/221] Added parenthesis for explicity

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

diff --git a/youtube_dl/__init__.py b/youtube_dl/__init__.py
index b339427e8..87d3f222a 100644
--- a/youtube_dl/__init__.py
+++ b/youtube_dl/__init__.py
@@ -299,7 +299,7 @@ def parseOpts(arguments):
     systemConf = _readOptions('/etc/youtube-dl.conf')
     userConf = _readOptions(userConfFile)
     commandLineConf = sys.argv[1:] 
-    argv = systemConf + userConf + commandLineConf if not arguments else arguments
+    argv = (systemConf + userConf + commandLineConf) if not arguments else arguments
     opts, args = parser.parse_args(argv)
 
     if opts.verbose:

From c681a03918a8f67f25e3ae7cc4140b76d6a73578 Mon Sep 17 00:00:00 2001
From: Philipp Hagemeister <phihag@phihag.de>
Date: Mon, 22 Apr 2013 19:51:42 +0200
Subject: [PATCH 106/221] Fix --list-formats (Closes #799)

---
 youtube_dl/FileDownloader.py | 2 ++
 youtube_dl/InfoExtractors.py | 9 +++------
 2 files changed, 5 insertions(+), 6 deletions(-)

diff --git a/youtube_dl/FileDownloader.py b/youtube_dl/FileDownloader.py
index 9c0c42f8d..7139adf6b 100644
--- a/youtube_dl/FileDownloader.py
+++ b/youtube_dl/FileDownloader.py
@@ -458,6 +458,8 @@ class FileDownloader(object):
             # Extract information from URL and process it
             try:
                 ie_results = ie.extract(url)
+                if ie_results is None: # Finished already (backwards compatibility; listformats and friends should be moved here)
+                    break
                 results = []
                 for ie_result in ie_results:
                     if not 'extractor' in ie_result:
diff --git a/youtube_dl/InfoExtractors.py b/youtube_dl/InfoExtractors.py
index 14a1d6523..ff1f07e9b 100755
--- a/youtube_dl/InfoExtractors.py
+++ b/youtube_dl/InfoExtractors.py
@@ -622,8 +622,7 @@ class YoutubeIE(InfoExtractor):
                 format_list = available_formats
             existing_formats = [x for x in format_list if x in url_map]
             if len(existing_formats) == 0:
-                self._downloader.report_error(u'no known formats available for video')
-                return
+                raise ExtractorError(u'no known formats available for video')
             if self._downloader.params.get('listformats', None):
                 self._print_formats(existing_formats)
                 return
@@ -643,11 +642,9 @@ class YoutubeIE(InfoExtractor):
                         video_url_list = [(rf, url_map[rf])]
                         break
                 if video_url_list is None:
-                    self._downloader.report_error(u'requested format not available')
-                    return
+                    raise ExtractorError(u'requested format not available')
         else:
-            self._downloader.report_error(u'no conn or url_encoded_fmt_stream_map information found in video info')
-            return
+            raise ExtractorError(u'no conn or url_encoded_fmt_stream_map information found in video info')
 
         results = []
         for format_param, video_real_url in video_url_list:

From 8cb94542f407a748d75e39a0f7730c68f02d23cf Mon Sep 17 00:00:00 2001
From: Philipp Hagemeister <phihag@phihag.de>
Date: Mon, 22 Apr 2013 20:01:56 +0200
Subject: [PATCH 107/221] release 2013.04.22

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

diff --git a/README.md b/README.md
index d42aab44a..5c7d8b66a 100644
--- a/README.md
+++ b/README.md
@@ -56,10 +56,12 @@ which means you can modify it, redistribute it or use it however you like.
                                extension, %(upload_date)s for the upload date
                                (YYYYMMDD), %(extractor)s for the provider
                                (youtube, metacafe, etc), %(id)s for the video id
-                               and %% for a literal percent. Use - to output to
-                               stdout. Can also be used to download to a
-                               different directory, for example with -o '/my/dow
-                               nloads/%(uploader)s/%(title)s-%(id)s.%(ext)s' .
+                               , %(playlist)s for the playlist the video is in,
+                               %(playlist_index)s for the position in the
+                               playlist and %% for a literal percent. Use - to
+                               output to stdout. Can also be used to download to
+                               a different directory, for example with -o '/my/d
+                               ownloads/%(uploader)s/%(title)s-%(id)s.%(ext)s' .
     --autonumber-size NUMBER   Specifies the number of digits in %(autonumber)s
                                when it is present in output filename template or
                                --autonumber option is given
diff --git a/youtube_dl/version.py b/youtube_dl/version.py
index 33696b54b..ac8a05ab5 100644
--- a/youtube_dl/version.py
+++ b/youtube_dl/version.py
@@ -1,2 +1,2 @@
 
-__version__ = '2013.04.21'
+__version__ = '2013.04.22'

From c15e024141727e5eed8056d3b2732f4f7553b2b4 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Jaime=20Marqui=CC=81nez=20Ferra=CC=81ndiz?=
 <jaime.marquinez.ferrandiz@gmail.com>
Date: Mon, 22 Apr 2013 21:07:49 +0200
Subject: [PATCH 108/221] TumblrIE

I haven't found many videos to test, so it may not work for all.
---
 test/tests.json              |  9 +++++++++
 youtube_dl/InfoExtractors.py | 35 +++++++++++++++++++++++++++++++++++
 2 files changed, 44 insertions(+)

diff --git a/test/tests.json b/test/tests.json
index 7808a07de..2b56738a0 100644
--- a/test/tests.json
+++ b/test/tests.json
@@ -337,6 +337,15 @@
         "title": "11.04.2013 09:23 Uhr - Tagesschau in 100 Sekunden"
     },
     "skip": "Requires rtmpdump"
+  },
+  {
+    "name": "Tumblr",
+    "url": "http://birthdayproject2012.tumblr.com/post/17258355236/a-sample-video-from-leeann-if-you-need-an-idea",
+    "file": "17258355236.mp4",
+    "md5": "7c6a514d691b034ccf8567999e9e88a3",
+    "info_dict": {
+        "title": "A sample video from LeeAnn. (If you need an idea..."
+    }
   }
 
 ]
diff --git a/youtube_dl/InfoExtractors.py b/youtube_dl/InfoExtractors.py
index ff1f07e9b..6a6545c9b 100755
--- a/youtube_dl/InfoExtractors.py
+++ b/youtube_dl/InfoExtractors.py
@@ -4327,6 +4327,40 @@ class ARDIE(InfoExtractor):
             info["url"] = stream["video_url"]
         return [info]
 
+class TumblrIE(InfoExtractor):
+    _VALID_URL = r'http://(?P<blog_name>.*?).tumblr.com/((post)|(video))/(?P<id>\d*)/(.*?)'
+
+    def _real_extract(self, url):
+        m_url = re.match(self._VALID_URL, url)
+        video_id = m_url.group('id')
+        blog = m_url.group('blog_name')
+
+        url = 'http://%s.tumblr.com/post/%s/' % (blog, video_id)
+        webpage = self._download_webpage(url, video_id)
+
+        re_video = r'src=\\x22(?P<video_url>http://%s.tumblr.com/video_file/%s/(.*?))\\x22 type=\\x22video/(?P<ext>.*?)\\x22' % (blog, video_id)
+        video = re.search(re_video, webpage)
+        if video is None:
+            self.to_screen("No video founded")
+            return []
+        video_url = video.group('video_url')
+        ext = video.group('ext')
+
+        re_thumb = r'posters(.*?)\[\\x22(?P<thumb>.*?)\\x22'  # We pick the first poster
+        thumb = re.search(re_thumb, webpage).group('thumb').replace('\\', '')
+
+        # The only place where you can get a title, it's not complete,
+        # but searching in other places doesn't work for all videos
+        re_title = r'<title>(.*?) - (?P<title>.*?)</title>'
+        title = unescapeHTML(re.search(re_title, webpage).group('title'))
+
+        return [{'id': video_id,
+                 'url': video_url,
+                 'title': title,
+                 'thumbnail': thumb,
+                 'ext': ext
+                 }]
+
 
 def gen_extractors():
     """ Return a list of an instance of every supported extractor.
@@ -4381,6 +4415,7 @@ def gen_extractors():
         SpiegelIE(),
         LiveLeakIE(),
         ARDIE(),
+        TumblrIE(),
         GenericIE()
     ]
 

From 75b5c590a8470b40f5bba869be09393757182ddf Mon Sep 17 00:00:00 2001
From: Philipp Hagemeister <phihag@phihag.de>
Date: Mon, 22 Apr 2013 23:05:05 +0200
Subject: [PATCH 109/221] Do not read configuration files if explicit arguments
 are given by a host program (#792)

---
 youtube_dl/__init__.py | 25 +++++++++++++++----------
 1 file changed, 15 insertions(+), 10 deletions(-)

diff --git a/youtube_dl/__init__.py b/youtube_dl/__init__.py
index 8ec7435ca..f60fb841e 100644
--- a/youtube_dl/__init__.py
+++ b/youtube_dl/__init__.py
@@ -47,7 +47,7 @@ from .FileDownloader import *
 from .InfoExtractors import gen_extractors
 from .PostProcessor import *
 
-def parseOpts(arguments):
+def parseOpts(overrideArguments=None):
     def _readOptions(filename_bytes):
         try:
             optionf = open(filename_bytes)
@@ -300,16 +300,21 @@ def parseOpts(arguments):
     parser.add_option_group(authentication)
     parser.add_option_group(postproc)
 
-    xdg_config_home = os.environ.get('XDG_CONFIG_HOME')
-    if xdg_config_home:
-        userConfFile = os.path.join(xdg_config_home, 'youtube-dl.conf')
+    if overrideArguments is not None:
+        opts, args = parser.parse_args(overrideArguments)
+        if opts.verbose:
+            print(u'[debug] Override config: ' + repr(overrideArguments))
     else:
-        userConfFile = os.path.join(os.path.expanduser('~'), '.config', 'youtube-dl.conf')
-    systemConf = _readOptions('/etc/youtube-dl.conf')
-    userConf = _readOptions(userConfFile)
-    commandLineConf = sys.argv[1:] 
-    argv = (systemConf + userConf + commandLineConf) if not arguments else arguments
-    opts, args = parser.parse_args(argv)
+        xdg_config_home = os.environ.get('XDG_CONFIG_HOME')
+        if xdg_config_home:
+            userConfFile = os.path.join(xdg_config_home, 'youtube-dl.conf')
+        else:
+            userConfFile = os.path.join(os.path.expanduser('~'), '.config', 'youtube-dl.conf')
+        systemConf = _readOptions('/etc/youtube-dl.conf')
+        userConf = _readOptions(userConfFile)
+        commandLineConf = sys.argv[1:] 
+        argv = systemConf + userConf + commandLineConf
+        opts, args = parser.parse_args(argv)
 
     if opts.verbose:
         print(u'[debug] System config: ' + repr(systemConf))

From c76cb6d54843695a5221ea314f399eb9cdc61442 Mon Sep 17 00:00:00 2001
From: Philipp Hagemeister <phihag@phihag.de>
Date: Mon, 22 Apr 2013 23:15:05 +0200
Subject: [PATCH 110/221] Correct indentation

---
 youtube_dl/__init__.py | 9 ++++-----
 1 file changed, 4 insertions(+), 5 deletions(-)

diff --git a/youtube_dl/__init__.py b/youtube_dl/__init__.py
index f60fb841e..7df297d02 100644
--- a/youtube_dl/__init__.py
+++ b/youtube_dl/__init__.py
@@ -315,11 +315,10 @@ def parseOpts(overrideArguments=None):
         commandLineConf = sys.argv[1:] 
         argv = systemConf + userConf + commandLineConf
         opts, args = parser.parse_args(argv)
-
-    if opts.verbose:
-        print(u'[debug] System config: ' + repr(systemConf))
-        print(u'[debug] User config: ' + repr(userConf))
-        print(u'[debug] Command-line args: ' + repr(commandLineConf))
+        if opts.verbose:
+            print(u'[debug] System config: ' + repr(systemConf))
+            print(u'[debug] User config: ' + repr(userConf))
+            print(u'[debug] Command-line args: ' + repr(commandLineConf))
 
     return parser, opts, args
 

From f4b659f782b65fbc52348c034bfc13ba1f7994ed Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Jaime=20Marqui=CC=81nez=20Ferra=CC=81ndiz?=
 <jaime.marquinez.ferrandiz@gmail.com>
Date: Tue, 23 Apr 2013 10:33:54 +0200
Subject: [PATCH 111/221] Document order of preference for format selection
 (closes #798)

---
 README.md              | 3 ++-
 youtube_dl/__init__.py | 3 ++-
 2 files changed, 4 insertions(+), 2 deletions(-)

diff --git a/README.md b/README.md
index 5c7d8b66a..0ab4b660c 100644
--- a/README.md
+++ b/README.md
@@ -98,7 +98,8 @@ which means you can modify it, redistribute it or use it however you like.
                                verbose)
 
 ## Video Format Options:
-    -f, --format FORMAT        video format code
+    -f, --format FORMAT        video format code, specifiy the order of
+                               preference using slashes: "-f 22/17/18"
     --all-formats              download all available video formats
     --prefer-free-formats      prefer free video formats unless a specific one
                                is requested
diff --git a/youtube_dl/__init__.py b/youtube_dl/__init__.py
index 7df297d02..74375175d 100644
--- a/youtube_dl/__init__.py
+++ b/youtube_dl/__init__.py
@@ -165,7 +165,8 @@ def parseOpts(overrideArguments=None):
 
 
     video_format.add_option('-f', '--format',
-            action='store', dest='format', metavar='FORMAT', help='video format code')
+            action='store', dest='format', metavar='FORMAT',
+            help='video format code, specifiy the order of preference using slashes: "-f 22/17/18"')
     video_format.add_option('--all-formats',
             action='store_const', dest='format', help='download all available video formats', const='all')
     video_format.add_option('--prefer-free-formats',

From 9edb0916f414d1686e2288c1d544ca7ce2eb280e Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Jaime=20Marqui=CC=81nez=20Ferra=CC=81ndiz?=
 <jaime.marquinez.ferrandiz@gmail.com>
Date: Tue, 23 Apr 2013 11:09:22 +0200
Subject: [PATCH 112/221] Disable colored messages in Windows (related #794)

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

diff --git a/youtube_dl/FileDownloader.py b/youtube_dl/FileDownloader.py
index 100779756..30ab68278 100644
--- a/youtube_dl/FileDownloader.py
+++ b/youtube_dl/FileDownloader.py
@@ -254,7 +254,7 @@ class FileDownloader(object):
         Print the message to stderr, it will be prefixed with 'WARNING:'
         If stderr is a tty file the 'WARNING:' will be colored
         '''
-        if sys.stderr.isatty():
+        if sys.stderr.isatty() and os.name != 'nt':
             _msg_header=u'\033[0;33mWARNING:\033[0m'
         else:
             _msg_header=u'WARNING:'
@@ -266,7 +266,7 @@ class FileDownloader(object):
         Do the same as trouble, but prefixes the message with 'ERROR:', colored
         in red if stderr is a tty file.
         '''
-        if sys.stderr.isatty():
+        if sys.stderr.isatty() and os.name != 'nt':
             _msg_header = u'\033[0;31mERROR:\033[0m'
         else:
             _msg_header = u'ERROR:'

From 613bf66939c7bbba42f8b80b499661e79f33449c Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Jaime=20Marqui=CC=81nez=20Ferra=CC=81ndiz?=
 <jaime.marquinez.ferrandiz@gmail.com>
Date: Tue, 23 Apr 2013 11:31:37 +0200
Subject: [PATCH 113/221] More calls to trouble changed to report_error

---
 youtube_dl/FileDownloader.py | 14 ++++++------
 youtube_dl/InfoExtractors.py | 42 ++++++++++++++++++------------------
 2 files changed, 28 insertions(+), 28 deletions(-)

diff --git a/youtube_dl/FileDownloader.py b/youtube_dl/FileDownloader.py
index 30ab68278..d0378fb14 100644
--- a/youtube_dl/FileDownloader.py
+++ b/youtube_dl/FileDownloader.py
@@ -406,10 +406,10 @@ class FileDownloader(object):
             filename = self.params['outtmpl'] % template_dict
             return filename
         except KeyError as err:
-            self.trouble(u'ERROR: Erroneous output template')
+            self.report_error(u'Erroneous output template')
             return None
         except ValueError as err:
-            self.trouble(u'ERROR: Insufficient system charset ' + repr(preferredencoding()))
+            self.report_error(u'Insufficient system charset ' + repr(preferredencoding()))
             return None
 
     def _match_entry(self, info_dict):
@@ -468,16 +468,16 @@ class FileDownloader(object):
                     results.append(self.process_ie_result(ie_result, download))
                 return results
             except ExtractorError as de: # An error we somewhat expected
-                self.trouble(u'ERROR: ' + compat_str(de), de.format_traceback())
+                self.report_error(compat_str(de), de.format_traceback())
                 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(compat_str(e), tb=compat_str(traceback.format_exc()))
                     break
                 else:
                     raise
         if not suitable_found:
-                self.trouble(u'ERROR: no suitable InfoExtractor: %s' % url)
+                self.report_error(u'no suitable InfoExtractor: %s' % url)
         
     def process_ie_result(self, ie_result, download = True):
         """
@@ -636,7 +636,7 @@ class FileDownloader(object):
                         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)
+                        self.report_error(u'Cannot write subtitles file ' + descfn)
                         return
             if self.params.get('onlysubtitles', False):
                 return 
@@ -683,7 +683,7 @@ class FileDownloader(object):
                 #It also downloads the videos
                 videos = self.extract_info(url)
             except UnavailableVideoError:
-                self.trouble(u'\nERROR: unable to download video')
+                self.report_error(u'unable to download video')
             except MaxDownloadsReached:
                 self.to_screen(u'[info] Maximum number of downloaded files reached.')
                 raise
diff --git a/youtube_dl/InfoExtractors.py b/youtube_dl/InfoExtractors.py
index 6a6545c9b..5cc0e9195 100755
--- a/youtube_dl/InfoExtractors.py
+++ b/youtube_dl/InfoExtractors.py
@@ -1224,7 +1224,7 @@ class ArteTvIE(InfoExtractor):
 
         for (i, key, err) in matchTuples:
             if mobj.group(i) is None:
-                self._downloader.trouble(err)
+                self._downloader.report_error(err)
                 return
             else:
                 info[key] = mobj.group(i)
@@ -1238,7 +1238,7 @@ class ArteTvIE(InfoExtractor):
             r'src="(.*?/videothek_js.*?\.js)',
             0,
             [
-                (1, 'url', u'ERROR: Invalid URL: %s' % url)
+                (1, 'url', u'Invalid URL: %s' % url)
             ]
         )
         http_host = url.split('/')[2]
@@ -1250,9 +1250,9 @@ class ArteTvIE(InfoExtractor):
                 '(rtmp://.*?)\'',
             re.DOTALL,
             [
-                (1, 'path',   u'ERROR: could not extract video path: %s' % url),
-                (2, 'player', u'ERROR: could not extract video player: %s' % url),
-                (3, 'url',    u'ERROR: could not extract video url: %s' % url)
+                (1, 'path',   u'could not extract video path: %s' % url),
+                (2, 'player', u'could not extract video player: %s' % url),
+                (3, 'url',    u'could not extract video url: %s' % url)
             ]
         )
         video_url = u'%s/%s' % (info.get('url'), info.get('path'))
@@ -1264,7 +1264,7 @@ class ArteTvIE(InfoExtractor):
             r'param name="movie".*?videorefFileUrl=(http[^\'"&]*)',
             0,
             [
-                (1, 'url', u'ERROR: Invalid URL: %s' % url)
+                (1, 'url', u'Invalid URL: %s' % url)
             ]
         )
         next_url = compat_urllib_parse.unquote(info.get('url'))
@@ -1273,7 +1273,7 @@ class ArteTvIE(InfoExtractor):
             r'<video lang="%s" ref="(http[^\'"&]*)' % video_lang,
             0,
             [
-                (1, 'url', u'ERROR: Could not find <video> tag: %s' % url)
+                (1, 'url', u'Could not find <video> tag: %s' % url)
             ]
         )
         next_url = compat_urllib_parse.unquote(info.get('url'))
@@ -1286,10 +1286,10 @@ class ArteTvIE(InfoExtractor):
                 '<url quality="hd">(.*?)</url>',
             re.DOTALL,
             [
-                (1, 'id',    u'ERROR: could not extract video id: %s' % url),
-                (2, 'title', u'ERROR: could not extract video title: %s' % url),
-                (3, 'date',  u'ERROR: could not extract video date: %s' % url),
-                (4, 'url',   u'ERROR: could not extract video url: %s' % url)
+                (1, 'id',    u'could not extract video id: %s' % url),
+                (2, 'title', u'could not extract video title: %s' % url),
+                (3, 'date',  u'could not extract video date: %s' % url),
+                (4, 'url',   u'could not extract video url: %s' % url)
             ]
         )
 
@@ -1518,7 +1518,7 @@ class YoutubeSearchIE(InfoExtractor):
             api_response = json.loads(data)['data']
 
             if not 'items' in api_response:
-                self._downloader.trouble(u'[youtube] No video results')
+                self._downloader.report_error(u'[youtube] No video results')
                 return
 
             new_ids = list(video['id'] for video in api_response['items'])
@@ -2787,7 +2787,7 @@ class SoundcloudSetIE(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
 
         # extract uploader (which is in the url)
@@ -2805,14 +2805,14 @@ class SoundcloudSetIE(InfoExtractor):
             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
 
         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']))
+                self._downloader.report_error(u'unable to download video webpage: %s' % compat_str(err['error_message']))
             return
 
         for track in info['tracks']:
@@ -2825,7 +2825,7 @@ class SoundcloudSetIE(InfoExtractor):
                 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)
@@ -3173,7 +3173,7 @@ class MTVIE(InfoExtractor):
             format = ext + '-' + rendition.attrib['width'] + 'x' + rendition.attrib['height'] + '_' + rendition.attrib['bitrate']
             video_url = rendition.find('./src').text
         except KeyError:
-            self._downloader.trouble('Invalid rendition field.')
+            self._downloader.report_error('Invalid rendition field.')
             return
 
         info = {
@@ -3620,7 +3620,7 @@ class FunnyOrDieIE(InfoExtractor):
         if not m:
             m = re.search(r'<title>(?P<title>[^<]+?)</title>', webpage)
             if not m:
-                self._downloader.trouble(u'Cannot find video title')
+                self._downloader.report_error(u'Cannot find video title')
         title = clean_html(m.group('title'))
 
         m = re.search(r'<meta property="og:description" content="(?P<desc>.*?)"', webpage)
@@ -3726,7 +3726,7 @@ class WorldStarHipHopIE(InfoExtractor):
             else:
                 ext = 'flv'
         else:
-            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)
             return
 
         _title = r"""<title>(.*)</title>"""
@@ -4246,7 +4246,7 @@ class LiveLeakIE(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('video_id')
@@ -4261,7 +4261,7 @@ class LiveLeakIE(InfoExtractor):
 
         m = re.search(r'<meta property="og:title" content="(?P<title>.*?)"', webpage)
         if not m:
-            self._downloader.trouble(u'Cannot find video title')
+            self._downloader.report_error(u'Cannot find video title')
         title = unescapeHTML(m.group('title')).replace('LiveLeak.com -', '').strip()
 
         m = re.search(r'<meta property="og:description" content="(?P<desc>.*?)"', webpage)

From 69fc019f268116a4b5dcccca00ddf9153748c305 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Jaime=20Marqui=CC=81nez=20Ferra=CC=81ndiz?=
 <jaime.marquinez.ferrandiz@gmail.com>
Date: Tue, 23 Apr 2013 12:24:08 +0200
Subject: [PATCH 114/221] YoutubeIE when no description is found use an empty
 unicode string (closes #800)

---
 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 5cc0e9195..208b44887 100755
--- a/youtube_dl/InfoExtractors.py
+++ b/youtube_dl/InfoExtractors.py
@@ -570,7 +570,7 @@ class YoutubeIE(InfoExtractor):
         if video_description:
             video_description = clean_html(video_description)
         else:
-            video_description = ''
+            video_description = u''
 
         # subtitles
         video_subtitles = None

From 7b670a4483d589af822e7fc061d1d3d3aafd36f0 Mon Sep 17 00:00:00 2001
From: Philipp Hagemeister <phihag@phihag.de>
Date: Tue, 23 Apr 2013 13:54:17 +0200
Subject: [PATCH 115/221] YouTube: Fall back to <meta> description if video is
 rated (Fixes #800)

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

diff --git a/youtube_dl/InfoExtractors.py b/youtube_dl/InfoExtractors.py
index 208b44887..d5876ad34 100755
--- a/youtube_dl/InfoExtractors.py
+++ b/youtube_dl/InfoExtractors.py
@@ -570,7 +570,11 @@ class YoutubeIE(InfoExtractor):
         if video_description:
             video_description = clean_html(video_description)
         else:
-            video_description = u''
+            fd_mobj = re.search(r'<meta name="description" content="([^"]+)"', video_webpage)
+            if fd_mobj:
+                video_description = unescapeHTML(fd_mobj.group(1))
+            else:
+                video_description = u''
 
         # subtitles
         video_subtitles = None

From 28535652abe5d78df3ad84aa9930b3585d35edc8 Mon Sep 17 00:00:00 2001
From: Bjorn Heesakkers <bjorn@expleo.nl>
Date: Wed, 24 Apr 2013 13:56:04 +0200
Subject: [PATCH 116/221] Adds support for passing a referer.

---
 youtube_dl/__init__.py | 6 ++++++
 1 file changed, 6 insertions(+)

diff --git a/youtube_dl/__init__.py b/youtube_dl/__init__.py
index 74375175d..16e74785f 100644
--- a/youtube_dl/__init__.py
+++ b/youtube_dl/__init__.py
@@ -140,6 +140,8 @@ def parseOpts(overrideArguments=None):
             help='display the current browser identification', default=False)
     general.add_option('--user-agent',
             dest='user_agent', help='specify a custom user agent', metavar='UA')
+    general.add_option('--referer',
+            dest='referer', help='specify a custom referer', metavar='REF', default=None)
     general.add_option('--list-extractors',
             action='store_true', dest='list_extractors',
             help='List all supported extractors and the URLs they would handle', default=False)
@@ -342,6 +344,10 @@ def _real_main(argv=None):
     # Set user agent
     if opts.user_agent is not None:
         std_headers['User-Agent'] = opts.user_agent
+    
+    # Set referer
+    if opts.referer is not None:
+        std_headers['Referer'] = opts.referer
 
     # Dump user agent
     if opts.dump_user_agent:

From 59cc5d9380ee6ffc9032c9a3873b006a824ae934 Mon Sep 17 00:00:00 2001
From: Bjorn Heesakkers <bjorn@expleo.nl>
Date: Wed, 24 Apr 2013 14:12:33 +0200
Subject: [PATCH 117/221] Updated README

---
 README.md | 1 +
 1 file changed, 1 insertion(+)

diff --git a/README.md b/README.md
index 0ab4b660c..ffb321ff9 100644
--- a/README.md
+++ b/README.md
@@ -27,6 +27,7 @@ which means you can modify it, redistribute it or use it however you like.
                                from an initial value of SIZE.
     --dump-user-agent          display the current browser identification
     --user-agent UA            specify a custom user agent
+    --referer REF              specify a custom referer
     --list-extractors          List all supported extractors and the URLs they
                                would handle
 

From a3d689cfb3b8d6320104bb70725679bc2d336f77 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Jaime=20Marqui=CC=81nez=20Ferra=CC=81ndiz?=
 <jaime.marquinez.ferrandiz@gmail.com>
Date: Wed, 24 Apr 2013 21:16:10 +0200
Subject: [PATCH 118/221] Fix InfoQ

---
 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 d5876ad34..53d65c02e 100755
--- a/youtube_dl/InfoExtractors.py
+++ b/youtube_dl/InfoExtractors.py
@@ -2861,7 +2861,7 @@ class InfoQIE(InfoExtractor):
         self.report_extraction(url)
 
         # Extract video URL
-        mobj = re.search(r"jsclassref='([^']*)'", webpage)
+        mobj = re.search(r"jsclassref ?= ?'([^']*)'", webpage)
         if mobj is None:
             self._downloader.report_error(u'unable to extract video url')
             return

From 320e26a0af46dcefd53ba06656c986def933bc6b Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Jaime=20Marqui=CC=81nez=20Ferra=CC=81ndiz?=
 <jaime.marquinez.ferrandiz@gmail.com>
Date: Wed, 24 Apr 2013 22:02:20 +0200
Subject: [PATCH 119/221] Clean duplicate method report_download_webpage in
 InfoExtractors

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

diff --git a/youtube_dl/InfoExtractors.py b/youtube_dl/InfoExtractors.py
index 53d65c02e..d71e1a90e 100755
--- a/youtube_dl/InfoExtractors.py
+++ b/youtube_dl/InfoExtractors.py
@@ -152,6 +152,10 @@ class InfoExtractor(object):
         """Report information extraction."""
         self.to_screen(u'%s: Extracting information' % id_or_name)
 
+    def report_download_webpage(self, video_id):
+        """Report webpage download."""
+        self.to_screen(u'%s: Downloading webpage' % video_id)
+
     def report_age_confirmation(self):
         """Report attempt to confirm age."""
         self.to_screen(u'Confirming age')
@@ -691,10 +695,6 @@ class MetacafeIE(InfoExtractor):
         """Report disclaimer retrieval."""
         self.to_screen(u'Retrieving disclaimer')
 
-    def report_download_webpage(self, video_id):
-        """Report webpage download."""
-        self.to_screen(u'%s: Downloading webpage' % video_id)
-
     def _real_initialize(self):
         # Retrieve disclaimer
         request = compat_urllib_request.Request(self._DISCLAIMER)
@@ -882,10 +882,6 @@ class PhotobucketIE(InfoExtractor):
     def __init__(self, downloader=None):
         InfoExtractor.__init__(self, downloader)
 
-    def report_download_webpage(self, video_id):
-        """Report webpage download."""
-        self.to_screen(u'%s: Downloading webpage' % video_id)
-
     def _real_extract(self, url):
         # Extract id from URL
         mobj = re.match(self._VALID_URL, url)
@@ -947,10 +943,6 @@ class YahooIE(InfoExtractor):
     def __init__(self, downloader=None):
         InfoExtractor.__init__(self, downloader)
 
-    def report_download_webpage(self, video_id):
-        """Report webpage download."""
-        self.to_screen(u'%s: Downloading webpage' % video_id)
-
     def _real_extract(self, url, new_video=True):
         # Extract ID from URL
         mobj = re.match(self._VALID_URL, url)
@@ -1083,10 +1075,6 @@ class VimeoIE(InfoExtractor):
     def __init__(self, downloader=None):
         InfoExtractor.__init__(self, downloader)
 
-    def report_download_webpage(self, video_id):
-        """Report webpage download."""
-        self.to_screen(u'%s: Downloading webpage' % video_id)
-
     def _real_extract(self, url, new_video=True):
         # Extract ID from URL
         mobj = re.match(self._VALID_URL, url)
@@ -1200,10 +1188,6 @@ class ArteTvIE(InfoExtractor):
     def __init__(self, downloader=None):
         InfoExtractor.__init__(self, downloader)
 
-    def report_download_webpage(self, video_id):
-        """Report webpage download."""
-        self.to_screen(u'%s: Downloading webpage' % video_id)
-
     def fetch_webpage(self, url):
         request = compat_urllib_request.Request(url)
         try:
@@ -2020,10 +2004,6 @@ class DepositFilesIE(InfoExtractor):
 
     _VALID_URL = r'(?:http://)?(?:\w+\.)?depositfiles\.com/(?:../(?#locale))?files/(.+)'
 
-    def report_download_webpage(self, file_id):
-        """Report webpage download."""
-        self.to_screen(u'%s: Downloading webpage' % file_id)
-
     def _real_extract(self, url):
         file_id = url.split('/')[-1]
         # Rebuild url in english locale
@@ -3014,10 +2994,6 @@ class StanfordOpenClassroomIE(InfoExtractor):
     _VALID_URL = r'^(?:https?://)?openclassroom.stanford.edu(?P<path>/?|(/MainFolder/(?:HomePage|CoursePage|VideoPage)\.php([?]course=(?P<course>[^&]+)(&video=(?P<video>[^&]+))?(&.*)?)?))$'
     IE_NAME = u'stanfordoc'
 
-    def report_download_webpage(self, objid):
-        """Report information extraction."""
-        self.to_screen(u'%s: Downloading webpage' % objid)
-
     def _real_extract(self, url):
         mobj = re.match(self._VALID_URL, url)
         if mobj is None:
@@ -3196,10 +3172,6 @@ class MTVIE(InfoExtractor):
 class YoukuIE(InfoExtractor):
     _VALID_URL =  r'(?:http://)?v\.youku\.com/v_show/id_(?P<ID>[A-Za-z0-9]+)\.html'
 
-    def report_download_webpage(self, file_id):
-        """Report webpage download."""
-        self.to_screen(u'%s: Downloading webpage' % file_id)
-
     def _gen_sid(self):
         nowTime = int(time.time() * 1000)
         random1 = random.randint(1000,1998)
@@ -3309,10 +3281,6 @@ class XNXXIE(InfoExtractor):
     VIDEO_TITLE_RE = r'<title>(.*?)\s+-\s+XNXX.COM'
     VIDEO_THUMB_RE = r'url_bigthumb=(.*?)&amp;'
 
-    def report_webpage(self, video_id):
-        """Report information extraction"""
-        self.to_screen(u'%s: Downloading webpage' % video_id)
-
     def _real_extract(self, url):
         mobj = re.match(self._VALID_URL, url)
         if mobj is None:
@@ -3320,7 +3288,7 @@ class XNXXIE(InfoExtractor):
             return
         video_id = mobj.group(1)
 
-        self.report_webpage(video_id)
+        self.report_download_webpage(video_id)
 
         # Get webpage content
         try:

From 0d173446ff5edacdfa9419dcb6a7f44aaad09a5b Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Jaime=20Marqui=CC=81nez=20Ferra=CC=81ndiz?=
 <jaime.marquinez.ferrandiz@gmail.com>
Date: Wed, 24 Apr 2013 22:11:57 +0200
Subject: [PATCH 120/221] InfoExtractors: use report_download_webpage in
 _request_webpage

Allows to show the warning when falling back on GenericIE
---
 youtube_dl/InfoExtractors.py | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/youtube_dl/InfoExtractors.py b/youtube_dl/InfoExtractors.py
index d71e1a90e..f5e29af94 100755
--- a/youtube_dl/InfoExtractors.py
+++ b/youtube_dl/InfoExtractors.py
@@ -114,8 +114,8 @@ class InfoExtractor(object):
     def _request_webpage(self, url_or_request, video_id, note=None, errnote=None):
         """ Returns the response handle """
         if note is None:
-            note = u'Downloading video webpage'
-        if note is not False:
+            self.report_download_webpage(video_id)
+        elif note is not False:
             self.to_screen(u'%s: %s' % (video_id, note))
         try:
             return compat_urllib_request.urlopen(url_or_request)
@@ -1318,7 +1318,7 @@ class GenericIE(InfoExtractor):
         """Report webpage download."""
         if not self._downloader.params.get('test', False):
             self._downloader.report_warning(u'Falling back on generic information extractor.')
-        self.to_screen(u'%s: Downloading webpage' % video_id)
+        super(GenericIE, self).report_download_webpage(video_id)
 
     def report_following_redirect(self, new_url):
         """Report information extraction."""

From fa70605db287fd74f7d32b966ecca56260c651a0 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Jaime=20Marqui=CC=81nez=20Ferra=CC=81ndiz?=
 <jaime.marquinez.ferrandiz@gmail.com>
Date: Wed, 24 Apr 2013 23:05:43 +0200
Subject: [PATCH 121/221] IEs: clean __init__ methods

They are not needed
---
 youtube_dl/InfoExtractors.py | 54 ------------------------------------
 1 file changed, 54 deletions(-)

diff --git a/youtube_dl/InfoExtractors.py b/youtube_dl/InfoExtractors.py
index f5e29af94..4d145dfa1 100755
--- a/youtube_dl/InfoExtractors.py
+++ b/youtube_dl/InfoExtractors.py
@@ -688,9 +688,6 @@ class MetacafeIE(InfoExtractor):
     _FILTER_POST = 'http://www.metacafe.com/f/index.php?inputType=filter&controllerGroup=user'
     IE_NAME = u'metacafe'
 
-    def __init__(self, downloader=None):
-        InfoExtractor.__init__(self, downloader)
-
     def report_disclaimer(self):
         """Report disclaimer retrieval."""
         self.to_screen(u'Retrieving disclaimer')
@@ -795,9 +792,6 @@ class DailymotionIE(InfoExtractor):
     IE_NAME = u'dailymotion'
     _WORKING = False
 
-    def __init__(self, downloader=None):
-        InfoExtractor.__init__(self, downloader)
-
     def _real_extract(self, url):
         # Extract id and simplified title from URL
         mobj = re.match(self._VALID_URL, url)
@@ -879,9 +873,6 @@ class PhotobucketIE(InfoExtractor):
     _VALID_URL = r'(?:http://)?(?:[a-z0-9]+\.)?photobucket\.com/.*[\?\&]current=(.*\.flv)'
     IE_NAME = u'photobucket'
 
-    def __init__(self, downloader=None):
-        InfoExtractor.__init__(self, downloader)
-
     def _real_extract(self, url):
         # Extract id from URL
         mobj = re.match(self._VALID_URL, url)
@@ -940,9 +931,6 @@ class YahooIE(InfoExtractor):
     _VPAGE_URL = r'(?:http://)?video\.yahoo\.com/watch/([0-9]+)/([0-9]+)(?:[#\?].*)?'
     IE_NAME = u'video.yahoo'
 
-    def __init__(self, downloader=None):
-        InfoExtractor.__init__(self, downloader)
-
     def _real_extract(self, url, new_video=True):
         # Extract ID from URL
         mobj = re.match(self._VALID_URL, url)
@@ -1072,9 +1060,6 @@ class VimeoIE(InfoExtractor):
     _VALID_URL = r'(?P<proto>https?://)?(?:(?:www|player)\.)?vimeo\.com/(?:(?:groups|album)/[^/]+/)?(?P<direct_link>play_redirect_hls\?clip_id=)?(?:videos?/)?(?P<id>[0-9]+)'
     IE_NAME = u'vimeo'
 
-    def __init__(self, downloader=None):
-        InfoExtractor.__init__(self, downloader)
-
     def _real_extract(self, url, new_video=True):
         # Extract ID from URL
         mobj = re.match(self._VALID_URL, url)
@@ -1185,9 +1170,6 @@ class ArteTvIE(InfoExtractor):
 
     IE_NAME = u'arte.tv'
 
-    def __init__(self, downloader=None):
-        InfoExtractor.__init__(self, downloader)
-
     def fetch_webpage(self, url):
         request = compat_urllib_request.Request(url)
         try:
@@ -1311,9 +1293,6 @@ class GenericIE(InfoExtractor):
     _VALID_URL = r'.*'
     IE_NAME = u'generic'
 
-    def __init__(self, downloader=None):
-        InfoExtractor.__init__(self, downloader)
-
     def report_download_webpage(self, video_id):
         """Report webpage download."""
         if not self._downloader.params.get('test', False):
@@ -1453,9 +1432,6 @@ class YoutubeSearchIE(InfoExtractor):
     _max_youtube_results = 1000
     IE_NAME = u'youtube:search'
 
-    def __init__(self, downloader=None):
-        InfoExtractor.__init__(self, downloader)
-
     def report_download_page(self, query, pagenum):
         """Report attempt to download search page with given number."""
         query = query.decode(preferredencoding())
@@ -1530,9 +1506,6 @@ class GoogleSearchIE(InfoExtractor):
     _max_google_results = 1000
     IE_NAME = u'video.google:search'
 
-    def __init__(self, downloader=None):
-        InfoExtractor.__init__(self, downloader)
-
     def report_download_page(self, query, pagenum):
         """Report attempt to download playlist page with given number."""
         query = query.decode(preferredencoding())
@@ -1614,9 +1587,6 @@ class YahooSearchIE(InfoExtractor):
     _max_yahoo_results = 1000
     IE_NAME = u'video.yahoo:search'
 
-    def __init__(self, downloader=None):
-        InfoExtractor.__init__(self, downloader)
-
     def report_download_page(self, query, pagenum):
         """Report attempt to download playlist page with given number."""
         query = query.decode(preferredencoding())
@@ -1710,9 +1680,6 @@ class YoutubePlaylistIE(InfoExtractor):
     _MAX_RESULTS = 50
     IE_NAME = u'youtube:playlist'
 
-    def __init__(self, downloader=None):
-        InfoExtractor.__init__(self, downloader)
-
     @classmethod
     def suitable(cls, url):
         """Receives a URL and returns True if suitable for this IE."""
@@ -1857,9 +1824,6 @@ class YoutubeUserIE(InfoExtractor):
     _VIDEO_INDICATOR = r'/watch\?v=(.+?)[\<&]'
     IE_NAME = u'youtube:user'
 
-    def __init__(self, downloader=None):
-        InfoExtractor.__init__(self, downloader)
-
     def report_download_page(self, username, start_index):
         """Report attempt to download user page."""
         self._downloader.to_screen(u'[youtube] user %s: Downloading video ids from %d to %d' %
@@ -1926,9 +1890,6 @@ class BlipTVUserIE(InfoExtractor):
     _PAGE_SIZE = 12
     IE_NAME = u'blip.tv:user'
 
-    def __init__(self, downloader=None):
-        InfoExtractor.__init__(self, downloader)
-
     def report_download_page(self, username, pagenum):
         """Report attempt to download user page."""
         self.to_screen(u'user %s: Downloading video ids from page %d' %
@@ -2254,9 +2215,6 @@ class MyVideoIE(InfoExtractor):
     _VALID_URL = r'(?:http://)?(?:www\.)?myvideo\.de/watch/([0-9]+)/([^?/]+).*'
     IE_NAME = u'myvideo'
 
-    def __init__(self, downloader=None):
-        InfoExtractor.__init__(self, downloader)
-
     def _real_extract(self,url):
         mobj = re.match(self._VALID_URL, url)
         if mobj is None:
@@ -2692,9 +2650,6 @@ class SoundcloudIE(InfoExtractor):
     _VALID_URL = r'^(?:https?://)?(?:www\.)?soundcloud\.com/([\w\d-]+)/([\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.to_screen(u'%s: Resolving id' % video_id)
@@ -2761,9 +2716,6 @@ class SoundcloudSetIE(InfoExtractor):
     _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.to_screen(u'%s: Resolving id' % video_id)
@@ -2884,9 +2836,6 @@ class MixcloudIE(InfoExtractor):
     _VALID_URL = r'^(?:https?://)?(?:www\.)?mixcloud\.com/([\w\d-]+)/([\w\d-]+)'
     IE_NAME = u'mixcloud'
 
-    def __init__(self, downloader=None):
-        InfoExtractor.__init__(self, downloader)
-
     def report_download_json(self, file_id):
         """Report JSON download."""
         self.to_screen(u'Downloading json')
@@ -3334,9 +3283,6 @@ class GooglePlusIE(InfoExtractor):
     _VALID_URL = r'(?:https://)?plus\.google\.com/(?:[^/]+/)*?posts/(\w+)'
     IE_NAME = u'plus.google'
 
-    def __init__(self, downloader=None):
-        InfoExtractor.__init__(self, downloader)
-
     def report_extract_entry(self, url):
         """Report downloading extry"""
         self.to_screen(u'Downloading entry: %s' % url)

From e74c504f91a982b36fc27229b13d3aac8d624278 Mon Sep 17 00:00:00 2001
From: Joe Frambach <joe@framba.ch>
Date: Wed, 24 Apr 2013 21:59:10 +0000
Subject: [PATCH 122/221] Dont delete source file when source file and
 post-processed file are the same

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

diff --git a/youtube_dl/PostProcessor.py b/youtube_dl/PostProcessor.py
index 70dc01004..0c6885dda 100644
--- a/youtube_dl/PostProcessor.py
+++ b/youtube_dl/PostProcessor.py
@@ -188,6 +188,11 @@ class FFmpegExtractAudioPP(FFmpegPostProcessor):
 
         prefix, sep, ext = path.rpartition(u'.') # not os.path.splitext, since the latter does not work on unicode in all setups
         new_path = prefix + sep + extension
+
+        # If we download foo.mp3 and convert it to... foo.mp3, then don't delete foo.mp3, silly.
+        if new_path == path:
+            self._nopostoverwrites = True
+
         try:
             if self._nopostoverwrites and os.path.exists(encodeFilename(new_path)):
                 self._downloader.to_screen(u'[youtube] Post-process file %s exists, skipping' % new_path)
@@ -210,7 +215,7 @@ class FFmpegExtractAudioPP(FFmpegPostProcessor):
                 self._downloader.to_stderr(u'WARNING: Cannot update utime of audio file')
 
         information['filepath'] = new_path
-        return False,information
+        return self._nopostoverwrites,information
 
 class FFmpegVideoConvertor(FFmpegPostProcessor):
     def __init__(self, downloader=None,preferedformat=None):

From aba8df23edf4f1078b163b490174c2d766432b55 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Jaime=20Marqui=CC=81nez=20Ferra=CC=81ndiz?=
 <jaime.marquinez.ferrandiz@gmail.com>
Date: Sat, 27 Apr 2013 10:41:52 +0200
Subject: [PATCH 123/221] YoutubePlaylistIE: don't crash with empty lists
 (related #808)

The playlist_title wasn't initialized.
---
 test/test_youtube_lists.py   | 7 +++++++
 youtube_dl/InfoExtractors.py | 3 +--
 2 files changed, 8 insertions(+), 2 deletions(-)

diff --git a/test/test_youtube_lists.py b/test/test_youtube_lists.py
index c7f00af32..b11e6ccaa 100644
--- a/test/test_youtube_lists.py
+++ b/test/test_youtube_lists.py
@@ -71,6 +71,13 @@ class TestYoutubeLists(unittest.TestCase):
         ytie_results = [YoutubeIE()._extract_id(url['url']) for url in result['entries']]
         self.assertFalse('pElCt5oNDuI' in ytie_results)
         self.assertFalse('KdPEApIVdWM' in ytie_results)
+        
+    def test_youtube_playlist_empty(self):
+        dl = FakeDownloader()
+        ie = YoutubePlaylistIE(dl)
+        result = ie.extract('https://www.youtube.com/playlist?list=PLtPgu7CB4gbZDA7i_euNxn75ISqxwZPYx')[0]
+        self.assertIsPlaylist(result)
+        self.assertEqual(len(result['entries']), 0)
 
     def test_youtube_course(self):
         dl = FakeDownloader()
diff --git a/youtube_dl/InfoExtractors.py b/youtube_dl/InfoExtractors.py
index 3450f0d17..967f6a100 100755
--- a/youtube_dl/InfoExtractors.py
+++ b/youtube_dl/InfoExtractors.py
@@ -1723,12 +1723,11 @@ class YoutubePlaylistIE(InfoExtractor):
             if 'feed' not in response:
                 self._downloader.report_error(u'Got a malformed response from YouTube API')
                 return
+            playlist_title = response['feed']['title']['$t']
             if 'entry' not in response['feed']:
                 # Number of videos is a multiple of self._MAX_RESULTS
                 break
 
-            playlist_title = response['feed']['title']['$t']
-
             videos += [ (entry['yt$position']['$t'], entry['content']['src'])
                         for entry in response['feed']['entry']
                         if 'content' in entry ]

From 4c9f7a9988f296eeedd0843cded5cbcec3392adb Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Jaime=20Marqui=CC=81nez=20Ferra=CC=81ndiz?=
 <jaime.marquinez.ferrandiz@gmail.com>
Date: Sat, 27 Apr 2013 11:03:34 +0200
Subject: [PATCH 124/221] SteamIE: accept urls with agecheck

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

diff --git a/youtube_dl/InfoExtractors.py b/youtube_dl/InfoExtractors.py
index 967f6a100..936af9cb4 100755
--- a/youtube_dl/InfoExtractors.py
+++ b/youtube_dl/InfoExtractors.py
@@ -3560,6 +3560,7 @@ class FunnyOrDieIE(InfoExtractor):
 
 class SteamIE(InfoExtractor):
     _VALID_URL = r"""http://store.steampowered.com/
+                (agecheck/)?
                 (?P<urltype>video|app)/ #If the page is only for videos or for a game
                 (?P<gameID>\d+)/?
                 (?P<videoID>\d*)(?P<extra>\??) #For urltype == video we sometimes get the videoID

From bd55852517a40d011b303559f4cd78773a2f3de5 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Jaime=20Marqui=CC=81nez=20Ferra=CC=81ndiz?=
 <jaime.marquinez.ferrandiz@gmail.com>
Date: Sat, 27 Apr 2013 14:01:55 +0200
Subject: [PATCH 125/221] Allow to select videos to download by their upload
 dates (related #137)

Only absolute dates.
---
 test/test_utils.py           |  9 +++++++++
 youtube_dl/FileDownloader.py |  6 ++++++
 youtube_dl/__init__.py       | 10 +++++++++-
 youtube_dl/utils.py          | 30 ++++++++++++++++++++++++++++++
 4 files changed, 54 insertions(+), 1 deletion(-)

diff --git a/test/test_utils.py b/test/test_utils.py
index eeaaa7fad..f9d58268b 100644
--- a/test/test_utils.py
+++ b/test/test_utils.py
@@ -14,6 +14,7 @@ from youtube_dl.utils import timeconvert
 from youtube_dl.utils import sanitize_filename
 from youtube_dl.utils import unescapeHTML
 from youtube_dl.utils import orderedSet
+from youtube_dl.utils import DateRange
 
 if sys.version_info < (3, 0):
     _compat_str = lambda b: b.decode('unicode-escape')
@@ -95,6 +96,14 @@ class TestUtil(unittest.TestCase):
 
     def test_unescape_html(self):
         self.assertEqual(unescapeHTML(_compat_str('%20;')), _compat_str('%20;'))
+        
+    def test_daterange(self):
+        _20century = DateRange("19000101","20000101")
+        self.assertFalse("17890714" in _20century)
+        _ac = DateRange("00010101")
+        self.assertTrue("19690721" in _ac)
+        _firstmilenium = DateRange(end="10000101")
+        self.assertTrue("07110427" in _firstmilenium)
 
 if __name__ == '__main__':
     unittest.main()
diff --git a/youtube_dl/FileDownloader.py b/youtube_dl/FileDownloader.py
index d0378fb14..2db686d62 100644
--- a/youtube_dl/FileDownloader.py
+++ b/youtube_dl/FileDownloader.py
@@ -89,6 +89,7 @@ class FileDownloader(object):
     keepvideo:         Keep the video file after post-processing
     min_filesize:      Skip files smaller than this size
     max_filesize:      Skip files larger than this size
+    daterange:         A DateRange object, download only if the upload_date is in the range.
     """
 
     params = None
@@ -424,6 +425,11 @@ class FileDownloader(object):
         if rejecttitle:
             if re.search(rejecttitle, title, re.IGNORECASE):
                 return u'"' + title + '" title matched reject pattern "' + rejecttitle + '"'
+        date = info_dict.get('upload_date', None)
+        if date is not None:
+            dateRange = self.params.get('daterange', DateRange())
+            if date not in dateRange:
+                return u'[download] %s upload date is not in range %s' % (date_from_str(date).isoformat(), dateRange)
         return None
         
     def extract_info(self, url, download = True, ie_name = None):
diff --git a/youtube_dl/__init__.py b/youtube_dl/__init__.py
index d491402c6..ce754ffd3 100644
--- a/youtube_dl/__init__.py
+++ b/youtube_dl/__init__.py
@@ -157,6 +157,9 @@ def parseOpts(overrideArguments=None):
     selection.add_option('--max-downloads', metavar='NUMBER', dest='max_downloads', help='Abort after downloading NUMBER files', default=None)
     selection.add_option('--min-filesize', metavar='SIZE', dest='min_filesize', help="Do not download any videos smaller than SIZE (e.g. 50k or 44.6m)", default=None)
     selection.add_option('--max-filesize', metavar='SIZE', dest='max_filesize', help="Do not download any videos larger than SIZE (e.g. 50k or 44.6m)", default=None)
+    selection.add_option('--date', metavar='DATE', dest='date', help='download only videos uploaded in this date', default=None)
+    selection.add_option('--datebefore', metavar='DATE', dest='datebefore', help='download only videos uploaded before this date', default=None)
+    selection.add_option('--dateafter', metavar='DATE', dest='dateafter', help='download only videos uploaded after this date', default=None)
 
 
     authentication.add_option('-u', '--username',
@@ -447,6 +450,10 @@ def _real_main(argv=None):
     if opts.recodevideo is not None:
         if opts.recodevideo not in ['mp4', 'flv', 'webm', 'ogg']:
             parser.error(u'invalid video recode format specified')
+    if opts.date is not None:
+        date = DateRange.day(opts.date)
+    else:
+        date = DateRange(opts.dateafter, opts.datebefore)
 
     if sys.version_info < (3,):
         # In Python 2, sys.argv is a bytestring (also note http://bugs.python.org/issue2128 for Windows systems)
@@ -513,7 +520,8 @@ def _real_main(argv=None):
         'test': opts.test,
         'keepvideo': opts.keepvideo,
         'min_filesize': opts.min_filesize,
-        'max_filesize': opts.max_filesize
+        'max_filesize': opts.max_filesize,
+        'daterange': date
         })
 
     if opts.verbose:
diff --git a/youtube_dl/utils.py b/youtube_dl/utils.py
index 017f06c42..e5d756b8b 100644
--- a/youtube_dl/utils.py
+++ b/youtube_dl/utils.py
@@ -12,6 +12,7 @@ import traceback
 import zlib
 import email.utils
 import json
+import datetime
 
 try:
     import urllib.request as compat_urllib_request
@@ -568,3 +569,32 @@ class YoutubeDLHandler(compat_urllib_request.HTTPHandler):
 
     https_request = http_request
     https_response = http_response
+    
+def date_from_str(date_str):
+    """Return a datetime object from a string in the format YYYYMMDD"""
+    return datetime.datetime.strptime(date_str, "%Y%m%d").date()
+    
+class DateRange(object):
+    """Represents a time interval between two dates"""
+    def __init__(self, start=None, end=None):
+        """start and end must be strings in the format accepted by date"""
+        if start is not None:
+            self.start = date_from_str(start)
+        else:
+            self.start = datetime.datetime.min.date()
+        if end is not None:
+            self.end = date_from_str(end)
+        else:
+            self.end = datetime.datetime.max.date()
+        if self.start >= self.end:
+            raise ValueError('Date range: "%s" , the start date must be before the end date' % self)
+    @classmethod
+    def day(cls, day):
+        """Returns a range that only contains the given day"""
+        return cls(day,day)
+    def __contains__(self, date):
+        """Check if the date is in the range"""
+        date = date_from_str(date)
+        return self.start <= date and date <= self.end
+    def __str__(self):
+        return '%s - %s' % ( self.start.isoformat(), self.end.isoformat())

From bf50b0383e4d6728bbbf1d0ee70cf586a90efb40 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Jaime=20Marqui=CC=81nez=20Ferra=CC=81ndiz?=
 <jaime.marquinez.ferrandiz@gmail.com>
Date: Sat, 27 Apr 2013 15:14:20 +0200
Subject: [PATCH 126/221] Fix some IEs that didn't return the uploade_date in
 the YYYYMMDD format

Create a function unified_strdate in utils.py to fix these problems
---
 test/test_utils.py           |  7 +++++++
 youtube_dl/InfoExtractors.py | 16 ++++++----------
 youtube_dl/utils.py          | 17 ++++++++++++++++-
 3 files changed, 29 insertions(+), 11 deletions(-)

diff --git a/test/test_utils.py b/test/test_utils.py
index f9d58268b..343409a7a 100644
--- a/test/test_utils.py
+++ b/test/test_utils.py
@@ -15,6 +15,7 @@ from youtube_dl.utils import sanitize_filename
 from youtube_dl.utils import unescapeHTML
 from youtube_dl.utils import orderedSet
 from youtube_dl.utils import DateRange
+from youtube_dl.utils import unified_strdate
 
 if sys.version_info < (3, 0):
     _compat_str = lambda b: b.decode('unicode-escape')
@@ -104,6 +105,12 @@ class TestUtil(unittest.TestCase):
         self.assertTrue("19690721" in _ac)
         _firstmilenium = DateRange(end="10000101")
         self.assertTrue("07110427" in _firstmilenium)
+        
+    def test_unified_dates(self):
+        self.assertEqual(unified_strdate('December 21, 2010'), '20101221')
+        self.assertEqual(unified_strdate('8/7/2009'), '20090708')
+        self.assertEqual(unified_strdate('Dec 14, 2012'), '20121214')
+        self.assertEqual(unified_strdate('2012/10/11 01:56:38 +0000'), '20121011')
 
 if __name__ == '__main__':
     unittest.main()
diff --git a/youtube_dl/InfoExtractors.py b/youtube_dl/InfoExtractors.py
index 936af9cb4..88ea567f8 100755
--- a/youtube_dl/InfoExtractors.py
+++ b/youtube_dl/InfoExtractors.py
@@ -562,12 +562,7 @@ class YoutubeIE(InfoExtractor):
         mobj = re.search(r'id="eow-date.*?>(.*?)</span>', video_webpage, re.DOTALL)
         if mobj is not None:
             upload_date = ' '.join(re.sub(r'[/,-]', r' ', mobj.group(1)).split())
-            format_expressions = ['%d %B %Y', '%B %d %Y', '%b %d %Y']
-            for expression in format_expressions:
-                try:
-                    upload_date = datetime.datetime.strptime(upload_date, expression).strftime('%Y%m%d')
-                except:
-                    pass
+            upload_date = unified_strdate(upload_date)
 
         # description
         video_description = get_element_by_id("eow-description", video_webpage)
@@ -2385,7 +2380,7 @@ class ComedyCentralIE(InfoExtractor):
             shortMediaId = mediaId.split(':')[-1]
             showId = mediaId.split(':')[-2].replace('.com', '')
             officialTitle = itemEl.findall('./title')[0].text
-            officialDate = itemEl.findall('./pubDate')[0].text
+            officialDate = unified_strdate(itemEl.findall('./pubDate')[0].text)
 
             configUrl = ('http://www.comedycentral.com/global/feeds/entertainment/media/mediaGenEntertainment.jhtml?' +
                         compat_urllib_parse.urlencode({'uri': mediaId}))
@@ -2695,12 +2690,13 @@ class SoundcloudIE(InfoExtractor):
 
         streams = json.loads(stream_json)
         mediaURL = streams['http_mp3_128_url']
+        upload_date = unified_strdate(info['created_at'])
 
         return [{
             'id':       info['id'],
             'url':      mediaURL,
             'uploader': info['user']['username'],
-            'upload_date':  info['created_at'],
+            'upload_date': upload_date,
             'title':    info['title'],
             'ext':      u'mp3',
             'description': info['description'],
@@ -3759,7 +3755,7 @@ class YouPornIE(InfoExtractor):
             self._downloader.report_warning(u'unable to extract video date')
             upload_date = None
         else:
-            upload_date = result.group('date').strip()
+            upload_date = unified_strdate(result.group('date').strip())
 
         # Get the video uploader
         result = re.search(r'Submitted:</label>(?P<uploader>.*)</li>', webpage)
@@ -3866,7 +3862,7 @@ class PornotubeIE(InfoExtractor):
         if result is None:
             self._downloader.report_error(u'unable to extract video title')
             return
-        upload_date = result.group('date')
+        upload_date = unified_strdate(result.group('date'))
 
         info = {'id': video_id,
                 'url': video_url,
diff --git a/youtube_dl/utils.py b/youtube_dl/utils.py
index e5d756b8b..3a2f0022f 100644
--- a/youtube_dl/utils.py
+++ b/youtube_dl/utils.py
@@ -569,7 +569,22 @@ class YoutubeDLHandler(compat_urllib_request.HTTPHandler):
 
     https_request = http_request
     https_response = http_response
-    
+
+def unified_strdate(date_str):
+    """Return a string with the date in the format YYYYMMDD"""
+    upload_date = None
+    #Replace commas
+    date_str = date_str.replace(',',' ')
+    # %z (UTC offset) is only supported in python>=3.2
+    date_str = re.sub(r' (\+|-)[\d]*$', '', date_str)
+    format_expressions = ['%d %B %Y', '%B %d %Y', '%b %d %Y', '%Y-%m-%d', '%d/%m/%Y', '%Y/%m/%d %H:%M:%S']
+    for expression in format_expressions:
+        try:
+            upload_date = datetime.datetime.strptime(date_str, expression).strftime('%Y%m%d')
+        except:
+            pass
+    return upload_date
+
 def date_from_str(date_str):
     """Return a datetime object from a string in the format YYYYMMDD"""
     return datetime.datetime.strptime(date_str, "%Y%m%d").date()

From 50f6412eb86dfd215e1be8de12207e1cf055be23 Mon Sep 17 00:00:00 2001
From: Philipp Hagemeister <phihag@phihag.de>
Date: Sat, 27 Apr 2013 20:12:46 +0200
Subject: [PATCH 127/221] Rename soundcloud to soundcloud:set

---
 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 3450f0d17..0e2c7795d 100755
--- a/youtube_dl/InfoExtractors.py
+++ b/youtube_dl/InfoExtractors.py
@@ -2717,7 +2717,7 @@ class SoundcloudSetIE(InfoExtractor):
      """
 
     _VALID_URL = r'^(?:https?://)?(?:www\.)?soundcloud\.com/([\w\d-]+)/sets/([\w\d-]+)'
-    IE_NAME = u'soundcloud'
+    IE_NAME = u'soundcloud:set'
 
     def report_resolve(self, video_id):
         """Report information extraction."""

From a11ea50319c5dc5d01098e28122617391c97d555 Mon Sep 17 00:00:00 2001
From: Philipp Hagemeister <phihag@phihag.de>
Date: Sat, 27 Apr 2013 21:53:21 +0200
Subject: [PATCH 128/221] Re-enable Dailymotion (tests pass)

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

diff --git a/youtube_dl/InfoExtractors.py b/youtube_dl/InfoExtractors.py
index 620cce189..6d8e7be10 100755
--- a/youtube_dl/InfoExtractors.py
+++ b/youtube_dl/InfoExtractors.py
@@ -785,7 +785,6 @@ class DailymotionIE(InfoExtractor):
 
     _VALID_URL = r'(?i)(?:https?://)?(?:www\.)?dailymotion\.[a-z]{2,3}/video/([^/]+)'
     IE_NAME = u'dailymotion'
-    _WORKING = False
 
     def _real_extract(self, url):
         # Extract id and simplified title from URL

From 37254abc36695692649348099fae0ed8f73fd3d1 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Jaime=20Marqui=CC=81nez=20Ferra=CC=81ndiz?=
 <jaime.marquinez.ferrandiz@gmail.com>
Date: Sun, 28 Apr 2013 11:39:37 +0200
Subject: [PATCH 129/221] Allow to use relative dates in the format
 (now|today)[+-][0-9](day|week|month|year)(s)? (Closes #137)

Also fix DateRange not accepting ranges of one day.
---
 test/test_utils.py  |  2 +-
 youtube_dl/utils.py | 31 +++++++++++++++++++++++++++----
 2 files changed, 28 insertions(+), 5 deletions(-)

diff --git a/test/test_utils.py b/test/test_utils.py
index 343409a7a..c4b71362e 100644
--- a/test/test_utils.py
+++ b/test/test_utils.py
@@ -105,7 +105,7 @@ class TestUtil(unittest.TestCase):
         self.assertTrue("19690721" in _ac)
         _firstmilenium = DateRange(end="10000101")
         self.assertTrue("07110427" in _firstmilenium)
-        
+
     def test_unified_dates(self):
         self.assertEqual(unified_strdate('December 21, 2010'), '20101221')
         self.assertEqual(unified_strdate('8/7/2009'), '20090708')
diff --git a/youtube_dl/utils.py b/youtube_dl/utils.py
index 3a2f0022f..6c5b5df4c 100644
--- a/youtube_dl/utils.py
+++ b/youtube_dl/utils.py
@@ -586,7 +586,29 @@ def unified_strdate(date_str):
     return upload_date
 
 def date_from_str(date_str):
-    """Return a datetime object from a string in the format YYYYMMDD"""
+    """
+    Return a datetime object from a string in the format YYYYMMDD or
+    (now|today)[+-][0-9](day|week|month|year)(s)?"""
+    today = datetime.date.today()
+    if date_str == 'now'or date_str == 'today':
+        return today
+    match = re.match('(now|today)(?P<sign>[+-])(?P<time>\d+)(?P<unit>day|week|month|year)(s)?', date_str)
+    if match is not None:
+        sign = match.group('sign')
+        time = int(match.group('time'))
+        if sign == '-':
+            time = -time
+        unit = match.group('unit')
+        #A bad aproximation?
+        if unit == 'month':
+            unit = 'day'
+            time *= 30
+        elif unit == 'year':
+            unit = 'day'
+            time *= 365
+        unit += 's'
+        delta = datetime.timedelta(**{unit: time})
+        return today + delta
     return datetime.datetime.strptime(date_str, "%Y%m%d").date()
     
 class DateRange(object):
@@ -601,7 +623,7 @@ class DateRange(object):
             self.end = date_from_str(end)
         else:
             self.end = datetime.datetime.max.date()
-        if self.start >= self.end:
+        if self.start > self.end:
             raise ValueError('Date range: "%s" , the start date must be before the end date' % self)
     @classmethod
     def day(cls, day):
@@ -609,7 +631,8 @@ class DateRange(object):
         return cls(day,day)
     def __contains__(self, date):
         """Check if the date is in the range"""
-        date = date_from_str(date)
-        return self.start <= date and date <= self.end
+        if not isinstance(date, datetime.date):
+            date = date_from_str(date)
+        return self.start <= date <= self.end
     def __str__(self):
         return '%s - %s' % ( self.start.isoformat(), self.end.isoformat())

From e31852aba934f5d53c50002ff832e290b72d8844 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Jaime=20Marqui=CC=81nez=20Ferra=CC=81ndiz?=
 <jaime.marquinez.ferrandiz@gmail.com>
Date: Sun, 28 Apr 2013 12:02:30 +0200
Subject: [PATCH 130/221] Document the video selection using the upload date

---
 README.md | 13 +++++++++++++
 1 file changed, 13 insertions(+)

diff --git a/README.md b/README.md
index d3073e641..e4281ec58 100644
--- a/README.md
+++ b/README.md
@@ -167,6 +167,19 @@ In some cases, you don't want special characters such as 中, spaces, or &, such
     $ youtube-dl --get-filename -o "%(title)s.%(ext)s" BaW_jenozKc --restrict-filenames
     youtube-dl_test_video_.mp4          # A simple file name
 
+# VIDEO SELECTION
+
+Videos can be filtered by their upload date using the options `--date`, `--datebefore` or `--dateafter`, they accept dates in two formats:
+
+ - Absolute dates: Dates in the format `YYYYMMDD`.
+ - Relative dates: Dates in the format `(now|today)[+-][0-9](day|week|month|year)(s)?`
+ 
+Examples:
+
+	$ youtube-dl --dateafter now-6months #will only download the videos uploaded in the last 6 months
+	$ youtube-dl --date 19700101 #will only download the videos uploaded in January 1, 1970
+	$ youtube-dl --dateafter 20000101 --datebefore 20100101 #will only download the videos uploaded between 2000 and 2010
+
 # FAQ
 
 ### Can you please put the -b option back?

From 434aca5b143fe358ae46688196391307834168fa Mon Sep 17 00:00:00 2001
From: Philipp Hagemeister <phihag@phihag.de>
Date: Sun, 28 Apr 2013 15:41:05 +0200
Subject: [PATCH 131/221] Automatically set HTTPS proxy if given (Fixes #805)

---
 youtube_dl/__init__.py | 6 +++++-
 1 file changed, 5 insertions(+), 1 deletion(-)

diff --git a/youtube_dl/__init__.py b/youtube_dl/__init__.py
index ce754ffd3..2639df818 100644
--- a/youtube_dl/__init__.py
+++ b/youtube_dl/__init__.py
@@ -376,7 +376,11 @@ def _real_main(argv=None):
 
     # General configuration
     cookie_processor = compat_urllib_request.HTTPCookieProcessor(jar)
-    proxy_handler = compat_urllib_request.ProxyHandler()
+    proxies = compat_urllib_request.getproxies()
+    # Set HTTPS proxy to HTTP one if given (https://github.com/rg3/youtube-dl/issues/805)
+    if 'http' in proxies and 'https' not in proxies:
+        proxies['https'] = proxies['http']
+    proxy_handler = compat_urllib_request.ProxyHandler(proxies)
     opener = compat_urllib_request.build_opener(proxy_handler, cookie_processor, YoutubeDLHandler())
     compat_urllib_request.install_opener(opener)
     socket.setdefaulttimeout(300) # 5 minutes should be enough (famous last words)

From 9665577802a622827fa5fcacc737668b574f7cfc Mon Sep 17 00:00:00 2001
From: Philipp Hagemeister <phihag@phihag.de>
Date: Sun, 28 Apr 2013 15:50:29 +0200
Subject: [PATCH 132/221] Adapt tests to changes in youtube's "Most Popular"
 channel

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

diff --git a/test/test_youtube_lists.py b/test/test_youtube_lists.py
index b11e6ccaa..3722ff5ba 100644
--- a/test/test_youtube_lists.py
+++ b/test/test_youtube_lists.py
@@ -97,7 +97,7 @@ class TestYoutubeLists(unittest.TestCase):
         self.assertTrue(len(result['entries']) > 90)
         #test autogenerated channel
         result = ie.extract('https://www.youtube.com/channel/HCtnHdj3df7iM/videos')[0]
-        self.assertTrue(len(result['entries']) > 20)
+        self.assertTrue(len(result['entries']) >= 18)
 
     def test_youtube_user(self):
         dl = FakeDownloader()

From fc63faf070b35d66eacd64fac85fc4dccbf26dc9 Mon Sep 17 00:00:00 2001
From: Philipp Hagemeister <phihag@phihag.de>
Date: Sun, 28 Apr 2013 15:53:14 +0200
Subject: [PATCH 133/221] release 2013.04.27

---
 README.md             | 3 +++
 youtube_dl/version.py | 2 +-
 2 files changed, 4 insertions(+), 1 deletion(-)

diff --git a/README.md b/README.md
index e4281ec58..af3ca58ea 100644
--- a/README.md
+++ b/README.md
@@ -44,6 +44,9 @@ which means you can modify it, redistribute it or use it however you like.
                                (e.g. 50k or 44.6m)
     --max-filesize SIZE        Do not download any videos larger than SIZE (e.g.
                                50k or 44.6m)
+    --date DATE                download only videos uploaded in this date
+    --datebefore DATE          download only videos uploaded before this date
+    --dateafter DATE           download only videos uploaded after this date
 
 ## Filesystem Options:
     -t, --title                use title in file name
diff --git a/youtube_dl/version.py b/youtube_dl/version.py
index ac8a05ab5..c6160359e 100644
--- a/youtube_dl/version.py
+++ b/youtube_dl/version.py
@@ -1,2 +1,2 @@
 
-__version__ = '2013.04.22'
+__version__ = '2013.04.27'

From 46a127eecbd3aac52b063ff11813cc7994160e27 Mon Sep 17 00:00:00 2001
From: Philipp Hagemeister <phihag@phihag.de>
Date: Sun, 28 Apr 2013 16:19:37 +0200
Subject: [PATCH 134/221] Fix print_notes

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

diff --git a/youtube_dl/update.py b/youtube_dl/update.py
index d6e293875..eab8417a5 100644
--- a/youtube_dl/update.py
+++ b/youtube_dl/update.py
@@ -78,7 +78,7 @@ def update_self(to_screen, verbose, filename):
     to_screen(u'Updating to version ' + versions_info['latest'] + '...')
     version = versions_info['versions'][versions_info['latest']]
 
-    print_notes(versions_info['versions'])
+    print_notes(to_screen, versions_info['versions'])
 
     if not os.access(filename, os.W_OK):
         to_screen(u'ERROR: no write permissions on %s' % filename)
@@ -157,11 +157,15 @@ del "%s"
 
     to_screen(u'Updated youtube-dl. Restart youtube-dl to use the new version.')
 
-def print_notes(versions, fromVersion=__version__):
+def get_notes(versions, fromVersion):
     notes = []
     for v,vdata in sorted(versions.items()):
         if v > fromVersion:
             notes.extend(vdata.get('notes', []))
+    return notes
+
+def print_notes(to_screen, versions, fromVersion=__version__):
+    notes = get_notes(versions, fromVersion)
     if notes:
         to_screen(u'PLEASE NOTE:')
         for note in notes:

From 08b2ac745a7991b58d17e3e8cb2c51e96b18534a Mon Sep 17 00:00:00 2001
From: Philipp Hagemeister <phihag@phihag.de>
Date: Sun, 28 Apr 2013 16:26:11 +0200
Subject: [PATCH 135/221] Default to --title (Fixes #499)

---
 youtube_dl/__init__.py | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/youtube_dl/__init__.py b/youtube_dl/__init__.py
index 2639df818..fcce891bc 100644
--- a/youtube_dl/__init__.py
+++ b/youtube_dl/__init__.py
@@ -236,9 +236,9 @@ def parseOpts(overrideArguments=None):
             help='print downloaded pages to debug problems(very verbose)')
 
     filesystem.add_option('-t', '--title',
-            action='store_true', dest='usetitle', help='use title in file name', default=False)
+            action='store_true', dest='usetitle', help='use title in file name (default)', default=False)
     filesystem.add_option('--id',
-            action='store_true', dest='useid', help='use video ID in file name', default=False)
+            action='store_true', dest='useid', help='use only video ID in file name', default=False)
     filesystem.add_option('-l', '--literal',
             action='store_true', dest='usetitle', help='[deprecated] alias of --title', default=False)
     filesystem.add_option('-A', '--auto-number',
@@ -470,7 +470,7 @@ def _real_main(argv=None):
             or (opts.usetitle and u'%(title)s-%(id)s.%(ext)s')
             or (opts.useid and u'%(id)s.%(ext)s')
             or (opts.autonumber and u'%(autonumber)s-%(id)s.%(ext)s')
-            or u'%(id)s.%(ext)s')
+            or u'%(title)s-%(id)s.%(ext)s')
 
     # File downloader
     fd = FileDownloader({

From 6ce533a2205eec9cd94e12a6a8d281ed852b5091 Mon Sep 17 00:00:00 2001
From: Philipp Hagemeister <phihag@phihag.de>
Date: Sun, 28 Apr 2013 16:32:05 +0200
Subject: [PATCH 136/221] release 2013.04.28

---
 README.md             | 4 ++--
 youtube_dl/version.py | 2 +-
 2 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/README.md b/README.md
index af3ca58ea..cc21a06d3 100644
--- a/README.md
+++ b/README.md
@@ -49,8 +49,8 @@ which means you can modify it, redistribute it or use it however you like.
     --dateafter DATE           download only videos uploaded after this date
 
 ## Filesystem Options:
-    -t, --title                use title in file name
-    --id                       use video ID in file name
+    -t, --title                use title in file name (default)
+    --id                       use only video ID in file name
     -l, --literal              [deprecated] alias of --title
     -A, --auto-number          number downloaded files starting from 00000
     -o, --output TEMPLATE      output filename template. Use %(title)s to get
diff --git a/youtube_dl/version.py b/youtube_dl/version.py
index c6160359e..d4f21e04b 100644
--- a/youtube_dl/version.py
+++ b/youtube_dl/version.py
@@ -1,2 +1,2 @@
 
-__version__ = '2013.04.27'
+__version__ = '2013.04.28'

From 767e00277f379410288476ecd05622968eec1d1b Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Jaime=20Marqui=CC=81nez=20Ferra=CC=81ndiz?=
 <jaime.marquinez.ferrandiz@gmail.com>
Date: Sun, 28 Apr 2013 17:12:07 +0200
Subject: [PATCH 137/221] Use report_warning when a not working IE will be uses

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

diff --git a/youtube_dl/FileDownloader.py b/youtube_dl/FileDownloader.py
index 2db686d62..80c2546ea 100644
--- a/youtube_dl/FileDownloader.py
+++ b/youtube_dl/FileDownloader.py
@@ -455,7 +455,7 @@ class FileDownloader(object):
 
             # Warn if the _WORKING attribute is False
             if not ie.working():
-                self.to_stderr(u'WARNING: the program functionality for this site has been marked as broken, '
+                self.report_warning(u'the program functionality for this site has been marked as broken, '
                                u'and will probably not work. If you want to go on, use the -i option.')
 
             # Suitable InfoExtractor found

From fe348844d9586ab7c19514f33a4bf2995152959e Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Jaime=20Marqui=CC=81nez=20Ferra=CC=81ndiz?=
 <jaime.marquinez.ferrandiz@gmail.com>
Date: Mon, 29 Apr 2013 23:57:36 +0200
Subject: [PATCH 138/221] SoundcloudSetIE: Use upload_date in the unified
 format (fixes #812)

---
 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 6d8e7be10..e430069d5 100755
--- a/youtube_dl/InfoExtractors.py
+++ b/youtube_dl/InfoExtractors.py
@@ -2768,7 +2768,7 @@ class SoundcloudSetIE(InfoExtractor):
                 'id':       video_id,
                 'url':      mediaURL,
                 'uploader': track['user']['username'],
-                'upload_date':  track['created_at'],
+                'upload_date':  unified_strdate(track['created_at']),
                 'title':    track['title'],
                 'ext':      u'mp3',
                 'description': track['description'],

From ba7c775a04604b302956faeb0923efe0053ef004 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Jaime=20Marqui=CC=81nez=20Ferra=CC=81ndiz?=
 <jaime.marquinez.ferrandiz@gmail.com>
Date: Tue, 30 Apr 2013 14:21:46 +0200
Subject: [PATCH 139/221] Remove a commented line I forgot.

[ci skip]
---
 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 cf8028718..3eca333f2 100644
--- a/test/test_download.py
+++ b/test/test_download.py
@@ -67,7 +67,7 @@ class TestDownload(unittest.TestCase):
 def generator(test_case):
 
     def test_template(self):
-        ie = youtube_dl.InfoExtractors.get_info_extractor(test_case['name'])#getattr(youtube_dl.InfoExtractors, test_case['name'] + 'IE')
+        ie = youtube_dl.InfoExtractors.get_info_extractor(test_case['name'])
         if not ie._WORKING:
             print('Skipping: IE marked as not _WORKING')
             return

From 5fb16555afcde763842b5a5ab8845ee1173d7a65 Mon Sep 17 00:00:00 2001
From: Philipp Hagemeister <phihag@phihag.de>
Date: Tue, 30 Apr 2013 17:57:13 +0200
Subject: [PATCH 140/221] --proxy option

---
 youtube_dl/__init__.py | 12 ++++++++----
 1 file changed, 8 insertions(+), 4 deletions(-)

diff --git a/youtube_dl/__init__.py b/youtube_dl/__init__.py
index fcce891bc..a56da8e3d 100644
--- a/youtube_dl/__init__.py
+++ b/youtube_dl/__init__.py
@@ -146,6 +146,7 @@ def parseOpts(overrideArguments=None):
     general.add_option('--list-extractors',
             action='store_true', dest='list_extractors',
             help='List all supported extractors and the URLs they would handle', default=False)
+    general.add_option('--proxy', dest='proxy', default=None, help='Use the specified HTTP/HTTPS proxy')
     general.add_option('--test', action='store_true', dest='test', default=False, help=optparse.SUPPRESS_HELP)
 
     selection.add_option('--playlist-start',
@@ -376,10 +377,13 @@ def _real_main(argv=None):
 
     # General configuration
     cookie_processor = compat_urllib_request.HTTPCookieProcessor(jar)
-    proxies = compat_urllib_request.getproxies()
-    # Set HTTPS proxy to HTTP one if given (https://github.com/rg3/youtube-dl/issues/805)
-    if 'http' in proxies and 'https' not in proxies:
-        proxies['https'] = proxies['http']
+    if opts.proxy:
+        proxies = {'http': opts.proxy, 'https': opts.proxy}
+    else:
+        proxies = compat_urllib_request.getproxies()
+        # Set HTTPS proxy to HTTP one if given (https://github.com/rg3/youtube-dl/issues/805)
+        if 'http' in proxies and 'https' not in proxies:
+            proxies['https'] = proxies['http']
     proxy_handler = compat_urllib_request.ProxyHandler(proxies)
     opener = compat_urllib_request.build_opener(proxy_handler, cookie_processor, YoutubeDLHandler())
     compat_urllib_request.install_opener(opener)

From b1d2ef9255528040b61ac44324645e82a7416174 Mon Sep 17 00:00:00 2001
From: Philipp Hagemeister <phihag@phihag.de>
Date: Tue, 30 Apr 2013 18:00:56 +0200
Subject: [PATCH 141/221] release 2013.04.30

---
 README.md             | 1 +
 youtube_dl/version.py | 2 +-
 2 files changed, 2 insertions(+), 1 deletion(-)

diff --git a/README.md b/README.md
index cc21a06d3..5e4c13dc7 100644
--- a/README.md
+++ b/README.md
@@ -31,6 +31,7 @@ which means you can modify it, redistribute it or use it however you like.
                                is restricted to one domain
     --list-extractors          List all supported extractors and the URLs they
                                would handle
+    --proxy None               Use the specified HTTP/HTTPS proxy
 
 ## Video Selection:
     --playlist-start NUMBER    playlist video to start at (default is 1)
diff --git a/youtube_dl/version.py b/youtube_dl/version.py
index d4f21e04b..dc863ca88 100644
--- a/youtube_dl/version.py
+++ b/youtube_dl/version.py
@@ -1,2 +1,2 @@
 
-__version__ = '2013.04.28'
+__version__ = '2013.04.30'

From dbc50fdf82610abecc5fb9ab40817534f0dae972 Mon Sep 17 00:00:00 2001
From: Philipp Hagemeister <phihag@phihag.de>
Date: Tue, 30 Apr 2013 18:27:54 +0200
Subject: [PATCH 142/221] Fix help for --proxy

---
 README.md              | 2 +-
 youtube_dl/__init__.py | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/README.md b/README.md
index 5e4c13dc7..7288f4dd3 100644
--- a/README.md
+++ b/README.md
@@ -31,7 +31,7 @@ which means you can modify it, redistribute it or use it however you like.
                                is restricted to one domain
     --list-extractors          List all supported extractors and the URLs they
                                would handle
-    --proxy None               Use the specified HTTP/HTTPS proxy
+    --proxy URL                Use the specified HTTP/HTTPS proxy
 
 ## Video Selection:
     --playlist-start NUMBER    playlist video to start at (default is 1)
diff --git a/youtube_dl/__init__.py b/youtube_dl/__init__.py
index a56da8e3d..27f36c6ad 100644
--- a/youtube_dl/__init__.py
+++ b/youtube_dl/__init__.py
@@ -146,7 +146,7 @@ def parseOpts(overrideArguments=None):
     general.add_option('--list-extractors',
             action='store_true', dest='list_extractors',
             help='List all supported extractors and the URLs they would handle', default=False)
-    general.add_option('--proxy', dest='proxy', default=None, help='Use the specified HTTP/HTTPS proxy')
+    general.add_option('--proxy', dest='proxy', default=None, help='Use the specified HTTP/HTTPS proxy', metavar='URL')
     general.add_option('--test', action='store_true', dest='test', default=False, help=optparse.SUPPRESS_HELP)
 
     selection.add_option('--playlist-start',

From 8749b7127391948f9a71148c5ae00adcfbb24a33 Mon Sep 17 00:00:00 2001
From: Philipp Hagemeister <phihag@phihag.de>
Date: Tue, 30 Apr 2013 18:48:45 +0200
Subject: [PATCH 143/221] Fix FakeDownloaders

---
 test/test_youtube_lists.py     | 2 +-
 test/test_youtube_subtitles.py | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/test/test_youtube_lists.py b/test/test_youtube_lists.py
index 3722ff5ba..78657b51c 100644
--- a/test/test_youtube_lists.py
+++ b/test/test_youtube_lists.py
@@ -29,7 +29,7 @@ class FakeDownloader(FileDownloader):
         self.params = parameters
     def to_screen(self, s):
         print(s)
-    def trouble(self, s):
+    def trouble(self, s, tb=None):
         raise Exception(s)
     def extract_info(self, url):
         self.result.append(url)
diff --git a/test/test_youtube_subtitles.py b/test/test_youtube_subtitles.py
index b4909091b..5b3f289af 100644
--- a/test/test_youtube_subtitles.py
+++ b/test/test_youtube_subtitles.py
@@ -30,7 +30,7 @@ class FakeDownloader(object):
         self.params = parameters
     def to_screen(self, s):
         print(s)
-    def trouble(self, s):
+    def trouble(self, s, tb=None):
         raise Exception(s)
     def download(self, x):
         self.result.append(x)

From 4ae9e558221ca9be553c7f3fdf5290cd12505283 Mon Sep 17 00:00:00 2001
From: Philipp Hagemeister <phihag@phihag.de>
Date: Tue, 30 Apr 2013 19:42:58 +0200
Subject: [PATCH 144/221] Correctly clear the line before writing a new status
 line

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

diff --git a/youtube_dl/FileDownloader.py b/youtube_dl/FileDownloader.py
index 80c2546ea..a67d3c902 100644
--- a/youtube_dl/FileDownloader.py
+++ b/youtube_dl/FileDownloader.py
@@ -345,12 +345,13 @@ class FileDownloader(object):
         """Report download progress."""
         if self.params.get('noprogress', False):
             return
+        clear_line = (u'\x1b[K' if sys.stderr.isatty() and os.name != 'nt' else u'')
         if self.params.get('progress_with_newline', False):
             self.to_screen(u'[download] %s of %s at %s ETA %s' %
                 (percent_str, data_len_str, speed_str, eta_str))
         else:
-            self.to_screen(u'\r[download] %s of %s at %s ETA %s' %
-                (percent_str, data_len_str, speed_str, eta_str), skip_eol=True)
+            self.to_screen(u'\r%s[download] %s of %s at %s ETA %s' %
+                (clear_line, percent_str, data_len_str, speed_str, eta_str), skip_eol=True)
         self.to_cons_title(u'youtube-dl - %s of %s at %s ETA %s' %
                 (percent_str.strip(), data_len_str.strip(), speed_str.strip(), eta_str.strip()))
 

From 6cd657f9f213faf9dc21d55f581f86a453b6e2c2 Mon Sep 17 00:00:00 2001
From: Philipp Hagemeister <phihag@phihag.de>
Date: Tue, 30 Apr 2013 19:50:20 +0200
Subject: [PATCH 145/221] release 2013.04.31

---
 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 dc863ca88..26d56abc4 100644
--- a/youtube_dl/version.py
+++ b/youtube_dl/version.py
@@ -1,2 +1,2 @@
 
-__version__ = '2013.04.30'
+__version__ = '2013.04.31'

From 34c29ba1d70ce860d6c08fc8451b795546bb9dff Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Jaime=20Marqui=CC=81nez=20Ferra=CC=81ndiz?=
 <jaime.marquinez.ferrandiz@gmail.com>
Date: Tue, 30 Apr 2013 21:23:38 +0200
Subject: [PATCH 146/221] Add test for SoundcloudSet

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

diff --git a/test/tests.json b/test/tests.json
index 2b56738a0..4735373a8 100644
--- a/test/tests.json
+++ b/test/tests.json
@@ -346,6 +346,54 @@
     "info_dict": {
         "title": "A sample video from LeeAnn. (If you need an idea..."
     }
+  },
+  {
+    "name": "SoundcloudSet",
+    "url":"https://soundcloud.com/the-concept-band/sets/the-royal-concept-ep",
+    "playlist":[
+      {
+        "file":"30510138.mp3",
+        "md5":"f9136bf103901728f29e419d2c70f55d",
+        "info_dict": {
+          "title":"D-D-Dance"
+        }
+      },
+      {
+        "file":"47127625.mp3",
+        "md5":"09b6758a018470570f8fd423c9453dd8",
+        "info_dict": {
+          "title":"The Royal Concept - Gimme Twice"
+        }
+      },
+      {
+        "file":"47127627.mp3",
+        "md5":"154abd4e418cea19c3b901f1e1306d9c",
+        "info_dict": {
+          "title":"Goldrushed"
+        }
+      },
+      {
+        "file":"47127629.mp3",
+        "md5":"2f5471edc79ad3f33a683153e96a79c1",
+        "info_dict": {
+          "title":"In the End"
+        }
+      },
+      {
+        "file":"47127631.mp3",
+        "md5":"f9ba87aa940af7213f98949254f1c6e2",
+        "info_dict": {
+          "title":"Knocked Up"
+        }
+      },
+      {
+        "file":"75206121.mp3",
+        "md5":"f9d1fe9406717e302980c30de4af9353",
+        "info_dict": {
+          "title":"World On Fire"
+        }
+      }
+    ]
   }
 
 ]

From 11d9224e3b472621e56d0862e600cd5133bd3fd1 Mon Sep 17 00:00:00 2001
From: Philipp Hagemeister <phihag@phihag.de>
Date: Wed, 1 May 2013 14:04:33 +0200
Subject: [PATCH 147/221] add --write-thumbnail option to download thumbnail
 (Suggested by `)

---
 youtube_dl/FileDownloader.py | 16 ++++++++++++++++
 youtube_dl/__init__.py       |  6 +++++-
 2 files changed, 21 insertions(+), 1 deletion(-)

diff --git a/youtube_dl/FileDownloader.py b/youtube_dl/FileDownloader.py
index a67d3c902..574863e7c 100644
--- a/youtube_dl/FileDownloader.py
+++ b/youtube_dl/FileDownloader.py
@@ -7,6 +7,7 @@ import math
 import io
 import os
 import re
+import shutil
 import socket
 import subprocess
 import sys
@@ -79,6 +80,7 @@ class FileDownloader(object):
     updatetime:        Use the Last-modified header to set output file timestamps.
     writedescription:  Write the video description to a .description file
     writeinfojson:     Write the video description to a .info.json file
+    writethumbnail:    Write the thumbnail image to a file
     writesubtitles:    Write the video subtitles to a file
     onlysubtitles:     Downloads only the subtitles of the video
     allsubtitles:      Downloads all the subtitles of the video
@@ -658,6 +660,20 @@ class FileDownloader(object):
                 self.report_error(u'Cannot write metadata to JSON file ' + infofn)
                 return
 
+        if self.params.get('writethumbnail', False):
+            if 'thumbnail' in info_dict:
+                thumb_format = info_dict['thumbnail'].rpartition(u'/')[2].rpartition(u'.')[2]
+                if not thumb_format:
+                    thumb_format = 'jpg'
+                thumb_filename = filename.rpartition('.')[0] + u'.' + thumb_format
+                self.to_screen(u'[%s] %s: Downloading thumbnail ...' %
+                               (info_dict['extractor'], info_dict['id']))
+                uf = compat_urllib_request.urlopen(info_dict['thumbnail'])
+                with open(thumb_filename, 'wb') as thumbf:
+                    shutil.copyfileobj(uf, thumbf)
+                self.to_screen(u'[%s] %s: Writing thumbnail to: %s' %
+                               (info_dict['extractor'], info_dict['id'], thumb_filename))
+
         if not self.params.get('skip_download', False):
             if self.params.get('nooverwrites', False) and os.path.exists(encodeFilename(filename)):
                 success = True
diff --git a/youtube_dl/__init__.py b/youtube_dl/__init__.py
index 27f36c6ad..808d4a8c2 100644
--- a/youtube_dl/__init__.py
+++ b/youtube_dl/__init__.py
@@ -284,6 +284,9 @@ def parseOpts(overrideArguments=None):
     filesystem.add_option('--write-info-json',
             action='store_true', dest='writeinfojson',
             help='write video metadata to a .info.json file', default=False)
+    filesystem.add_option('--write-thumbnail',
+            action='store_true', dest='writethumbnail',
+            help='write thumbnail image to disk', default=False)
 
 
     postproc.add_option('-x', '--extract-audio', action='store_true', dest='extractaudio', default=False,
@@ -513,6 +516,7 @@ def _real_main(argv=None):
         'updatetime': opts.updatetime,
         'writedescription': opts.writedescription,
         'writeinfojson': opts.writeinfojson,
+        'writethumbnail': opts.writethumbnail,
         'writesubtitles': opts.writesubtitles,
         'onlysubtitles': opts.onlysubtitles,
         'allsubtitles': opts.allsubtitles,
@@ -529,7 +533,7 @@ def _real_main(argv=None):
         'keepvideo': opts.keepvideo,
         'min_filesize': opts.min_filesize,
         'max_filesize': opts.max_filesize,
-        'daterange': date
+        'daterange': date,
         })
 
     if opts.verbose:

From d496a75d0a5388a664168d6af027d34a694e3e09 Mon Sep 17 00:00:00 2001
From: Philipp Hagemeister <phihag@phihag.de>
Date: Wed, 1 May 2013 14:07:23 +0200
Subject: [PATCH 148/221] release 2013.05.01

---
 README.md             | 1 +
 youtube_dl/version.py | 2 +-
 2 files changed, 2 insertions(+), 1 deletion(-)

diff --git a/README.md b/README.md
index 7288f4dd3..232cc2205 100644
--- a/README.md
+++ b/README.md
@@ -84,6 +84,7 @@ which means you can modify it, redistribute it or use it however you like.
                                file modification time
     --write-description        write video description to a .description file
     --write-info-json          write video metadata to a .info.json file
+    --write-thumbnail          write thumbnail image to disk
 
 ## Verbosity / Simulation Options:
     -q, --quiet                activates quiet mode
diff --git a/youtube_dl/version.py b/youtube_dl/version.py
index 26d56abc4..f8316b801 100644
--- a/youtube_dl/version.py
+++ b/youtube_dl/version.py
@@ -1,2 +1,2 @@
 
-__version__ = '2013.04.31'
+__version__ = '2013.05.01'

From aed523ecc15febe787d919bba8f4ca3cb8c1abf2 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Jaime=20Marqui=CC=81nez=20Ferra=CC=81ndiz?=
 <jaime.marquinez.ferrandiz@gmail.com>
Date: Wed, 1 May 2013 15:55:46 +0200
Subject: [PATCH 149/221] Add BandcampIE (closes #568)

---
 test/tests.json              |  9 +++++++
 youtube_dl/InfoExtractors.py | 47 ++++++++++++++++++++++++++++++++++++
 2 files changed, 56 insertions(+)

diff --git a/test/tests.json b/test/tests.json
index 4735373a8..4eba27846 100644
--- a/test/tests.json
+++ b/test/tests.json
@@ -394,6 +394,15 @@
         }
       }
     ]
+  },
+  {
+    "name":"Bandcamp",
+    "url":"http://youtube-dl.bandcamp.com/track/youtube-dl-test-song",
+    "file":"1812978515.mp3",
+    "md5":"cdeb30cdae1921719a3cbcab696ef53c",
+    "info_dict": {
+      "title":"youtube-dl test song \"'/\\ä↭"
+    }
   }
 
 ]
diff --git a/youtube_dl/InfoExtractors.py b/youtube_dl/InfoExtractors.py
index e430069d5..110ec834c 100755
--- a/youtube_dl/InfoExtractors.py
+++ b/youtube_dl/InfoExtractors.py
@@ -4277,6 +4277,52 @@ class TumblrIE(InfoExtractor):
                  'ext': ext
                  }]
 
+class BandcampIE(InfoExtractor):
+    _VALID_URL = r'http://.*?.bandcamp.com/track/(?P<title>.*)'
+
+    def _real_extract(self, url):
+        mobj = re.match(self._VALID_URL, url)
+        title = mobj.group('title')
+        webpage = self._download_webpage(url, title)
+        # We get the link to the free download page
+        m_download = re.search(r'freeDownloadPage: "(.*?)"', webpage)
+        if m_download is None:
+            self._downloader.report_error('No free songs founded')
+            return
+        download_link = m_download.group(1)
+        id = re.search(r'var TralbumData = {(.*?)id: (?P<id>\d*?)$', 
+                       webpage, re.MULTILINE|re.DOTALL).group('id')
+
+        download_webpage = self._download_webpage(download_link, id,
+                                                  'Downloading free downloads page')
+        # We get the dictionary of the track from some javascrip code
+        info = re.search(r'items: (.*?),$',
+                         download_webpage, re.MULTILINE).group(1)
+        info = json.loads(info)[0]
+        # We pick mp3-320 for now, until format selection can be easily implemented.
+        mp3_info = info[u'downloads'][u'mp3-320']
+        # If we try to use this url it says the link has expired
+        initial_url = mp3_info[u'url']
+        re_url = r'(?P<server>http://(.*?).bandcamp.com)/download/track\?enc=mp3-320&fsig=(?P<fsig>.*?)&id=(?P<id>.*?)&ts=(?P<ts>.*)$'
+        m_url = re.match(re_url, initial_url)
+        #We build the url we will use to get the final track url
+        # This url is build in Bandcamp in the script download_bunde_*.js
+        request_url = '%s/statdownload/track?enc=mp3-320&fsig=%s&id=%s&ts=%s&.rand=665028774616&.vrs=1' % (m_url.group('server'), m_url.group('fsig'), id, m_url.group('ts'))
+        final_url_webpage = self._download_webpage(request_url, id, 'Requesting download url')
+        # If we could correctly generate the .rand field the url would be
+        #in the "download_url" key
+        final_url = re.search(r'"retry_url":"(.*?)"', final_url_webpage).group(1)
+
+        track_info = {'id':id,
+                      'title' : info[u'title'],
+                      'ext' : 'mp3',
+                      'url' : final_url,
+                      'thumbnail' : info[u'thumb_url'],
+                      'uploader' : info[u'artist']
+                      }
+
+        return [track_info]
+
 
 def gen_extractors():
     """ Return a list of an instance of every supported extractor.
@@ -4332,6 +4378,7 @@ def gen_extractors():
         LiveLeakIE(),
         ARDIE(),
         TumblrIE(),
+        BandcampIE(),
         GenericIE()
     ]
 

From 6ccff79594231da6583505728eeaf51ced133f3e Mon Sep 17 00:00:00 2001
From: Johny Mo Swag <johnymo@me.com>
Date: Wed, 1 May 2013 20:30:14 -0700
Subject: [PATCH 150/221] Small update for additon of new video source links

---
 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 110ec834c..3cd50d023 100755
--- a/youtube_dl/InfoExtractors.py
+++ b/youtube_dl/InfoExtractors.py
@@ -3625,7 +3625,7 @@ class WorldStarHipHopIE(InfoExtractor):
     IE_NAME = u'WorldStarHipHop'
 
     def _real_extract(self, url):
-        _src_url = r"""(http://hw-videos.*(?:mp4|flv))"""
+        _src_url = r"""(http://(hw-videos|hw-post1).*(?:mp4|flv))"""
 
         webpage_src = compat_urllib_request.urlopen(url).read()
         webpage_src = webpage_src.decode('utf-8')

From 104ccdb8b4acaf071c17b22bc8cb9561dff4ebe5 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Jaime=20Marqui=CC=81nez=20Ferra=CC=81ndiz?=
 <jaime.marquinez.ferrandiz@gmail.com>
Date: Thu, 2 May 2013 13:12:41 +0200
Subject: [PATCH 151/221] TumblrIE: fix title matching

---
 test/tests.json              | 2 +-
 youtube_dl/InfoExtractors.py | 4 ++--
 2 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/test/tests.json b/test/tests.json
index 4eba27846..2765b5ba0 100644
--- a/test/tests.json
+++ b/test/tests.json
@@ -344,7 +344,7 @@
     "file": "17258355236.mp4",
     "md5": "7c6a514d691b034ccf8567999e9e88a3",
     "info_dict": {
-        "title": "A sample video from LeeAnn. (If you need an idea..."
+        "title": "Calling all Pris! - A sample video from LeeAnn. (If you need an idea..."
     }
   },
   {
diff --git a/youtube_dl/InfoExtractors.py b/youtube_dl/InfoExtractors.py
index 110ec834c..7e2992748 100755
--- a/youtube_dl/InfoExtractors.py
+++ b/youtube_dl/InfoExtractors.py
@@ -4267,8 +4267,8 @@ class TumblrIE(InfoExtractor):
 
         # The only place where you can get a title, it's not complete,
         # but searching in other places doesn't work for all videos
-        re_title = r'<title>(.*?) - (?P<title>.*?)</title>'
-        title = unescapeHTML(re.search(re_title, webpage).group('title'))
+        re_title = r'<title>(?P<title>.*?)</title>'
+        title = unescapeHTML(re.search(re_title, webpage, re.DOTALL).group('title'))
 
         return [{'id': video_id,
                  'url': video_url,

From feecf2251190ef7969ba58146f058e87fa237abb Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Jaime=20Marqui=CC=81nez=20Ferra=CC=81ndiz?=
 <jaime.marquinez.ferrandiz@gmail.com>
Date: Thu, 2 May 2013 13:39:56 +0200
Subject: [PATCH 152/221] InfoExtractors: fix some regular expressions where
 dots weren't escaped

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

diff --git a/youtube_dl/InfoExtractors.py b/youtube_dl/InfoExtractors.py
index 7dfd0c5c7..1f66cc5a5 100755
--- a/youtube_dl/InfoExtractors.py
+++ b/youtube_dl/InfoExtractors.py
@@ -3554,7 +3554,7 @@ class FunnyOrDieIE(InfoExtractor):
         return [info]
 
 class SteamIE(InfoExtractor):
-    _VALID_URL = r"""http://store.steampowered.com/
+    _VALID_URL = r"""http://store\.steampowered\.com/
                 (agecheck/)?
                 (?P<urltype>video|app)/ #If the page is only for videos or for a game
                 (?P<gameID>\d+)/?
@@ -3988,7 +3988,7 @@ class KeekIE(InfoExtractor):
         return [info]
 
 class TEDIE(InfoExtractor):
-    _VALID_URL=r'''http://www.ted.com/
+    _VALID_URL=r'''http://www\.ted\.com/
                    (
                         ((?P<type_playlist>playlists)/(?P<playlist_id>\d+)) # We have a playlist
                         |
@@ -4244,7 +4244,7 @@ class ARDIE(InfoExtractor):
         return [info]
 
 class TumblrIE(InfoExtractor):
-    _VALID_URL = r'http://(?P<blog_name>.*?).tumblr.com/((post)|(video))/(?P<id>\d*)/(.*?)'
+    _VALID_URL = r'http://(?P<blog_name>.*?)\.tumblr\.com/((post)|(video))/(?P<id>\d*)/(.*?)'
 
     def _real_extract(self, url):
         m_url = re.match(self._VALID_URL, url)
@@ -4254,7 +4254,7 @@ class TumblrIE(InfoExtractor):
         url = 'http://%s.tumblr.com/post/%s/' % (blog, video_id)
         webpage = self._download_webpage(url, video_id)
 
-        re_video = r'src=\\x22(?P<video_url>http://%s.tumblr.com/video_file/%s/(.*?))\\x22 type=\\x22video/(?P<ext>.*?)\\x22' % (blog, video_id)
+        re_video = r'src=\\x22(?P<video_url>http://%s\.tumblr\.com/video_file/%s/(.*?))\\x22 type=\\x22video/(?P<ext>.*?)\\x22' % (blog, video_id)
         video = re.search(re_video, webpage)
         if video is None:
             self.to_screen("No video founded")
@@ -4278,7 +4278,7 @@ class TumblrIE(InfoExtractor):
                  }]
 
 class BandcampIE(InfoExtractor):
-    _VALID_URL = r'http://.*?.bandcamp.com/track/(?P<title>.*)'
+    _VALID_URL = r'http://.*?\.bandcamp\.com/track/(?P<title>.*)'
 
     def _real_extract(self, url):
         mobj = re.match(self._VALID_URL, url)
@@ -4303,7 +4303,7 @@ class BandcampIE(InfoExtractor):
         mp3_info = info[u'downloads'][u'mp3-320']
         # If we try to use this url it says the link has expired
         initial_url = mp3_info[u'url']
-        re_url = r'(?P<server>http://(.*?).bandcamp.com)/download/track\?enc=mp3-320&fsig=(?P<fsig>.*?)&id=(?P<id>.*?)&ts=(?P<ts>.*)$'
+        re_url = r'(?P<server>http://(.*?)\.bandcamp\.com)/download/track\?enc=mp3-320&fsig=(?P<fsig>.*?)&id=(?P<id>.*?)&ts=(?P<ts>.*)$'
         m_url = re.match(re_url, initial_url)
         #We build the url we will use to get the final track url
         # This url is build in Bandcamp in the script download_bunde_*.js

From 46bfb422584b46462ab4859f400758e0e7e977ad Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Jaime=20Marqui=CC=81nez=20Ferra=CC=81ndiz?=
 <jaime.marquinez.ferrandiz@gmail.com>
Date: Thu, 2 May 2013 18:18:27 +0200
Subject: [PATCH 153/221] InfoExtractors: use _download_webpage in more IEs

IEs without tests are intact.
---
 test/tests.json              |   2 +-
 youtube_dl/InfoExtractors.py | 242 ++++++++---------------------------
 2 files changed, 52 insertions(+), 192 deletions(-)

diff --git a/test/tests.json b/test/tests.json
index 2765b5ba0..3c84dcf15 100644
--- a/test/tests.json
+++ b/test/tests.json
@@ -112,7 +112,7 @@
   {
     "name": "Escapist",
     "url": "http://www.escapistmagazine.com/videos/view/the-escapist-presents/6618-Breaking-Down-Baldurs-Gate",
-    "file": "6618-Breaking-Down-Baldurs-Gate.flv",
+    "file": "6618-Breaking-Down-Baldurs-Gate.mp4",
     "md5": "c6793dbda81388f4264c1ba18684a74d",
     "skip": "Fails with timeout on Travis"
   },
diff --git a/youtube_dl/InfoExtractors.py b/youtube_dl/InfoExtractors.py
index 1f66cc5a5..e0c50c402 100755
--- a/youtube_dl/InfoExtractors.py
+++ b/youtube_dl/InfoExtractors.py
@@ -1069,13 +1069,7 @@ class VimeoIE(InfoExtractor):
 
         # Retrieve video webpage to extract further information
         request = compat_urllib_request.Request(url, None, std_headers)
-        try:
-            self.report_download_webpage(video_id)
-            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.report_error(u'Unable to retrieve video webpage: %s' % compat_str(err))
-            return
+        webpage = self._download_webpage(request, video_id)
 
         # Now we begin extracting as much information as we can from what we
         # retrieved. First we extract the information common to all extractors,
@@ -1682,10 +1676,6 @@ class YoutubePlaylistIE(InfoExtractor):
         """Receives a URL and returns True if suitable for this IE."""
         return re.match(cls._VALID_URL, url, re.VERBOSE) is not None
 
-    def report_download_page(self, playlist_id, pagenum):
-        """Report attempt to download playlist page with given number."""
-        self._downloader.to_screen(u'[youtube] PL %s: Downloading page #%s' % (playlist_id, pagenum))
-
     def _real_extract(self, url):
         # Extract playlist id
         mobj = re.match(self._VALID_URL, url, re.VERBOSE)
@@ -1699,14 +1689,8 @@ class YoutubePlaylistIE(InfoExtractor):
         videos = []
 
         while True:
-            self.report_download_page(playlist_id, page_num)
-
             url = self._TEMPLATE_URL % (playlist_id, self._MAX_RESULTS, self._MAX_RESULTS * (page_num - 1) + 1)
-            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.report_error(u'unable to download webpage: %s' % compat_str(err))
-                return
+            page = self._download_webpage(url, playlist_id, u'Downloading page #%s' % page_num)
 
             try:
                 response = json.loads(page)
@@ -1745,10 +1729,6 @@ class YoutubeChannelIE(InfoExtractor):
     _MORE_PAGES_URL = 'http://www.youtube.com/channel_ajax?action_load_more_videos=1&flow=list&paging=%s&view=0&sort=da&channel_id=%s'
     IE_NAME = u'youtube:channel'
 
-    def report_download_page(self, channel_id, pagenum):
-        """Report attempt to download channel page with given number."""
-        self._downloader.to_screen(u'[youtube] Channel %s: Downloading page #%s' % (channel_id, pagenum))
-
     def extract_videos_from_page(self, page):
         ids_in_page = []
         for mobj in re.finditer(r'href="/watch\?v=([0-9A-Za-z_-]+)&?', page):
@@ -1768,14 +1748,9 @@ class YoutubeChannelIE(InfoExtractor):
         video_ids = []
         pagenum = 1
 
-        self.report_download_page(channel_id, pagenum)
         url = self._TEMPLATE_URL % (channel_id, pagenum)
-        request = compat_urllib_request.Request(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.report_error(u'unable to download webpage: %s' % compat_str(err))
-            return
+        page = self._download_webpage(url, channel_id,
+                                      u'Downloading page #%s' % pagenum)
 
         # Extract video identifiers
         ids_in_page = self.extract_videos_from_page(page)
@@ -1786,14 +1761,9 @@ class YoutubeChannelIE(InfoExtractor):
             while True:
                 pagenum = pagenum + 1
 
-                self.report_download_page(channel_id, pagenum)
                 url = self._MORE_PAGES_URL % (pagenum, channel_id)
-                request = compat_urllib_request.Request(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.report_error(u'unable to download webpage: %s' % compat_str(err))
-                    return
+                page = self._download_webpage(url, channel_id,
+                                              u'Downloading page #%s' % pagenum)
 
                 page = json.loads(page)
 
@@ -1820,11 +1790,6 @@ class YoutubeUserIE(InfoExtractor):
     _VIDEO_INDICATOR = r'/watch\?v=(.+?)[\<&]'
     IE_NAME = u'youtube:user'
 
-    def report_download_page(self, username, start_index):
-        """Report attempt to download user page."""
-        self._downloader.to_screen(u'[youtube] user %s: Downloading video ids from %d to %d' %
-                (username, start_index, start_index + self._GDATA_PAGE_SIZE))
-
     def _real_extract(self, url):
         # Extract username
         mobj = re.match(self._VALID_URL, url)
@@ -1844,15 +1809,10 @@ class YoutubeUserIE(InfoExtractor):
 
         while True:
             start_index = pagenum * self._GDATA_PAGE_SIZE + 1
-            self.report_download_page(username, start_index)
 
-            request = compat_urllib_request.Request(self._GDATA_URL % (username, self._GDATA_PAGE_SIZE, start_index))
-
-            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.report_error(u'unable to download webpage: %s' % compat_str(err))
-                return
+            gdata_url = self._GDATA_URL % (username, self._GDATA_PAGE_SIZE, start_index)
+            page = self._download_webpage(gdata_url, username,
+                                          u'Downloading video ids from %d to %d' % (start_index, start_index + self._GDATA_PAGE_SIZE))
 
             # Extract video identifiers
             ids_in_page = []
@@ -1886,11 +1846,6 @@ class BlipTVUserIE(InfoExtractor):
     _PAGE_SIZE = 12
     IE_NAME = u'blip.tv:user'
 
-    def report_download_page(self, username, pagenum):
-        """Report attempt to download user page."""
-        self.to_screen(u'user %s: Downloading video ids from page %d' %
-                (username, pagenum))
-
     def _real_extract(self, url):
         # Extract username
         mobj = re.match(self._VALID_URL, url)
@@ -1902,15 +1857,9 @@ class BlipTVUserIE(InfoExtractor):
 
         page_base = 'http://m.blip.tv/pr/show_get_full_episode_list?users_id=%s&lite=0&esi=1'
 
-        request = compat_urllib_request.Request(url)
-
-        try:
-            page = compat_urllib_request.urlopen(request).read().decode('utf-8')
-            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.report_error(u'unable to download webpage: %s' % compat_str(err))
-            return
+        page = self._download_webpage(url, username, u'Downloading user page')
+        mobj = re.search(r'data-users-id="([^"]+)"', page)
+        page_base = page_base % mobj.group(1)
 
 
         # Download video ids using BlipTV Ajax calls. Result size per
@@ -1922,14 +1871,9 @@ class BlipTVUserIE(InfoExtractor):
         pagenum = 1
 
         while True:
-            self.report_download_page(username, pagenum)
             url = page_base + "&page=" + str(pagenum)
-            request = compat_urllib_request.Request( 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.report_error(u'unable to download webpage: %s' % str(err))
-                return
+            page = self._download_webpage(url, username,
+                                          u'Downloading video ids from page %d' % pagenum)
 
             # Extract video identifiers
             ids_in_page = []
@@ -2288,12 +2232,6 @@ class ComedyCentralIE(InfoExtractor):
         """Receives a URL and returns True if suitable for this IE."""
         return re.match(cls._VALID_URL, url, re.VERBOSE) is not None
 
-    def report_config_download(self, episode_id, media_id):
-        self.to_screen(u'%s: Downloading configuration for %s' % (episode_id, media_id))
-
-    def report_index_download(self, episode_id):
-        self.to_screen(u'%s: Downloading show index' % episode_id)
-
     def _print_formats(self, formats):
         print('Available formats:')
         for x in formats:
@@ -2327,15 +2265,8 @@ class ComedyCentralIE(InfoExtractor):
             else:
                 epTitle = mobj.group('episode')
 
-        req = compat_urllib_request.Request(url)
         self.report_extraction(epTitle)
-        try:
-            htmlHandle = compat_urllib_request.urlopen(req)
-            html = htmlHandle.read()
-            webpage = html.decode('utf-8')
-        except (compat_urllib_error.URLError, compat_http_client.HTTPException, socket.error) as err:
-            self._downloader.report_error(u'unable to download webpage: %s' % compat_str(err))
-            return
+        webpage = self._download_webpage(url, epTitle)
         if dlNewest:
             url = htmlHandle.geturl()
             mobj = re.match(self._VALID_URL, url, re.VERBOSE)
@@ -2363,12 +2294,9 @@ class ComedyCentralIE(InfoExtractor):
 
         uri = mMovieParams[0][1]
         indexUrl = 'http://shadow.comedycentral.com/feeds/video_player/mrss/?' + compat_urllib_parse.urlencode({'uri': uri})
-        self.report_index_download(epTitle)
-        try:
-            indexXml = compat_urllib_request.urlopen(indexUrl).read()
-        except (compat_urllib_error.URLError, compat_http_client.HTTPException, socket.error) as err:
-            self._downloader.report_error(u'unable to download episode index: ' + compat_str(err))
-            return
+        indexXml = self._download_webpage(indexUrl, epTitle,
+                                          u'Downloading show index',
+                                          u'unable to download episode index')
 
         results = []
 
@@ -2383,13 +2311,8 @@ class ComedyCentralIE(InfoExtractor):
 
             configUrl = ('http://www.comedycentral.com/global/feeds/entertainment/media/mediaGenEntertainment.jhtml?' +
                         compat_urllib_parse.urlencode({'uri': mediaId}))
-            configReq = compat_urllib_request.Request(configUrl)
-            self.report_config_download(epTitle, shortMediaId)
-            try:
-                configXml = compat_urllib_request.urlopen(configReq).read()
-            except (compat_urllib_error.URLError, compat_http_client.HTTPException, socket.error) as err:
-                self._downloader.report_error(u'unable to download webpage: %s' % compat_str(err))
-                return
+            configXml = self._download_webpage(configUrl, epTitle,
+                                               u'Downloading configuration for %s' % shortMediaId)
 
             cdoc = xml.etree.ElementTree.fromstring(configXml)
             turls = []
@@ -2446,9 +2369,6 @@ class EscapistIE(InfoExtractor):
     _VALID_URL = r'^(https?://)?(www\.)?escapistmagazine\.com/videos/view/(?P<showname>[^/]+)/(?P<episode>[^/?]+)[/?]?.*$'
     IE_NAME = u'escapist'
 
-    def report_config_download(self, showName):
-        self.to_screen(u'%s: Downloading configuration' % showName)
-
     def _real_extract(self, url):
         mobj = re.match(self._VALID_URL, url)
         if mobj is None:
@@ -2458,14 +2378,7 @@ class EscapistIE(InfoExtractor):
         videoId = mobj.group('episode')
 
         self.report_extraction(showName)
-        try:
-            webPage = compat_urllib_request.urlopen(url)
-            webPageBytes = webPage.read()
-            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.report_error(u'unable to download webpage: ' + compat_str(err))
-            return
+        webPage = self._download_webpage(url, showName)
 
         descMatch = re.search('<meta name="description" content="([^"]*)"', webPage)
         description = unescapeHTML(descMatch.group(1))
@@ -2476,14 +2389,9 @@ class EscapistIE(InfoExtractor):
         configUrlMatch = re.search('config=(.*)$', playerUrl)
         configUrl = compat_urllib_parse.unquote(configUrlMatch.group(1))
 
-        self.report_config_download(showName)
-        try:
-            configJSON = compat_urllib_request.urlopen(configUrl)
-            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.report_error(u'unable to download configuration: ' + compat_str(err))
-            return
+        configJSON = self._download_webpage(configUrl, showName,
+                                            u'Downloading configuration',
+                                            u'unable to download configuration')
 
         # Technically, it's JavaScript, not JSON
         configJSON = configJSON.replace("'", '"')
@@ -2661,31 +2569,22 @@ class SoundcloudIE(InfoExtractor):
         # extract simple title (uploader + slug of song title)
         slug_title =  mobj.group(2)
         simple_title = uploader + u'-' + slug_title
+        full_title = '%s/%s' % (uploader, slug_title)
 
-        self.report_resolve('%s/%s' % (uploader, slug_title))
+        self.report_resolve(full_title)
 
         url = 'http://soundcloud.com/%s/%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.report_error(u'unable to download video webpage: %s' % compat_str(err))
-            return
+        info_json = self._download_webpage(resolv_url, full_title, u'Downloading info JSON')
 
         info = json.loads(info_json)
         video_id = info['id']
-        self.report_extraction('%s/%s' % (uploader, slug_title))
+        self.report_extraction(full_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.report_error(u'unable to download stream definitions: %s' % compat_str(err))
-            return
+        stream_json = self._download_webpage(streams_url, full_title,
+                                             u'Downloading stream definitions',
+                                             u'unable to download stream definitions')
 
         streams = json.loads(stream_json)
         mediaURL = streams['http_mp3_128_url']
@@ -2728,18 +2627,13 @@ class SoundcloudSetIE(InfoExtractor):
         # extract simple title (uploader + slug of song title)
         slug_title =  mobj.group(2)
         simple_title = uploader + u'-' + slug_title
+        full_title = '%s/sets/%s' % (uploader, slug_title)
 
-        self.report_resolve('%s/sets/%s' % (uploader, slug_title))
+        self.report_resolve(full_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.report_error(u'unable to download video webpage: %s' % compat_str(err))
-            return
+        info_json = self._download_webpage(resolv_url, full_title)
 
         videos = []
         info = json.loads(info_json)
@@ -2748,19 +2642,14 @@ class SoundcloudSetIE(InfoExtractor):
                 self._downloader.report_error(u'unable to download video webpage: %s' % compat_str(err['error_message']))
             return
 
+        self.report_extraction(full_title)
         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.report_error(u'unable to download stream definitions: %s' % compat_str(err))
-                return
+            stream_json = self._download_webpage(streams_url, video_id, u'Downloading track info JSON')
 
+            self.report_extraction(video_id)
             streams = json.loads(stream_json)
             mediaURL = streams['http_mp3_128_url']
 
@@ -3155,18 +3044,11 @@ class YoukuIE(InfoExtractor):
 
         info_url = 'http://v.youku.com/player/getPlayList/VideoIDS/' + video_id
 
-        request = compat_urllib_request.Request(info_url, None, std_headers)
-        try:
-            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.report_error(u'Unable to retrieve video webpage: %s' % compat_str(err))
-            return
+        jsondata = self._download_webpage(info_url, video_id)
 
         self.report_extraction(video_id)
         try:
-            jsonstr = jsondata.decode('utf-8')
-            config = json.loads(jsonstr)
+            config = json.loads(jsondata)
 
             video_title =  config['data'][0]['title']
             seed = config['data'][0]['seed']
@@ -3234,15 +3116,8 @@ class XNXXIE(InfoExtractor):
             return
         video_id = mobj.group(1)
 
-        self.report_download_webpage(video_id)
-
         # Get webpage content
-        try:
-            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.report_error(u'unable to download video webpage: %s' % err)
-            return
+        webpage = self._download_webpage(url, video_id)
 
         result = re.search(self.VIDEO_URL_RE, webpage)
         if result is None:
@@ -3314,12 +3189,7 @@ class GooglePlusIE(InfoExtractor):
 
         # Step 1, Retrieve post webpage to extract further information
         self.report_extract_entry(post_url)
-        request = compat_urllib_request.Request(post_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.report_error(u'Unable to retrieve entry webpage: %s' % compat_str(err))
-            return
+        webpage = self._download_webpage(post_url, video_id, u'Downloading entry webpage')
 
         # Extract update date
         upload_date = None
@@ -3356,12 +3226,7 @@ class GooglePlusIE(InfoExtractor):
             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.report_error(u'Unable to retrieve video webpage: %s' % compat_str(err))
-            return
+        webpage = self._download_webpage(video_page, video_id, u'Downloading video page')
         self.report_extract_vid_page(video_page)
 
 
@@ -3448,14 +3313,10 @@ class JustinTVIE(InfoExtractor):
                 (channel, offset, offset + self._JUSTIN_PAGE_LIMIT))
 
     # Return count of items, list of *valid* items
-    def _parse_page(self, url):
-        try:
-            urlh = compat_urllib_request.urlopen(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.report_error(u'unable to download video info JSON: %s' % compat_str(err))
-            return
+    def _parse_page(self, url, video_id):
+        webpage = self._download_webpage(url, video_id,
+                                         u'Downloading video info JSON',
+                                         u'unable to download video info JSON')
 
         response = json.loads(webpage)
         if type(response) != list:
@@ -3507,7 +3368,7 @@ class JustinTVIE(InfoExtractor):
             if paged:
                 self.report_download_page(video_id, offset)
             page_url = api + ('?offset=%d&limit=%d' % (offset, limit))
-            page_count, page_info = self._parse_page(page_url)
+            page_count, page_info = self._parse_page(page_url, video_id)
             info.extend(page_info)
             if not paged or page_count != limit:
                 break
@@ -3627,14 +3488,13 @@ class WorldStarHipHopIE(InfoExtractor):
     def _real_extract(self, url):
         _src_url = r"""(http://(hw-videos|hw-post1).*(?:mp4|flv))"""
 
-        webpage_src = compat_urllib_request.urlopen(url).read()
-        webpage_src = webpage_src.decode('utf-8')
-
-        mobj = re.search(_src_url, webpage_src)
-
         m = re.match(self._VALID_URL, url)
         video_id = m.group('id')
 
+        webpage_src = self._download_webpage(url, video_id) 
+
+        mobj = re.search(_src_url, webpage_src)
+
         if mobj is not None:
             video_url = mobj.group()
             if 'mp4' in video_url:

From 2e2038dc352de8a10525eb103bd9f6a6ae5b43f9 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Jaime=20Marqui=CC=81nez=20Ferra=CC=81ndiz?=
 <jaime.marquinez.ferrandiz@gmail.com>
Date: Thu, 2 May 2013 18:28:07 +0200
Subject: [PATCH 154/221] TEDIE: report the correct talk title when a link with
 the language code is given

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

diff --git a/youtube_dl/InfoExtractors.py b/youtube_dl/InfoExtractors.py
index e0c50c402..33dbaa3de 100755
--- a/youtube_dl/InfoExtractors.py
+++ b/youtube_dl/InfoExtractors.py
@@ -3854,6 +3854,7 @@ class TEDIE(InfoExtractor):
                         |
                         ((?P<type_talk>talks)) # We have a simple talk
                    )
+                   (/lang/(.*?))? # The url may contain the language
                    /(?P<name>\w+) # Here goes the name and then ".html"
                    '''
 

From b86174e7a38cebf9deb8e4e08d89849c2cc1b9bd Mon Sep 17 00:00:00 2001
From: "M.Yasoob Ullah Khalid" <yasoob.khld@gmail.com>
Date: Fri, 3 May 2013 22:40:56 +0600
Subject: [PATCH 155/221] added test for redtube.com

I just added the test for redtube.com
---
 test/tests.json | 7 ++++++-
 1 file changed, 6 insertions(+), 1 deletion(-)

diff --git a/test/tests.json b/test/tests.json
index 3c84dcf15..19bb225c3 100644
--- a/test/tests.json
+++ b/test/tests.json
@@ -403,6 +403,11 @@
     "info_dict": {
       "title":"youtube-dl test song \"'/\\ä↭"
     }
+  },
+  {
+    "name": "Redtube",
+    "url": "http://www.redtube.com/279577",
+    "file": "Public invasion-279577.mp4",
+    "md5": "432d85211d178e06a62d049c4ca1c3e4"
   }
-
 ]

From ecd5fb49c572d2fbf21f75d4513e80524b10750b Mon Sep 17 00:00:00 2001
From: "M.Yasoob Ullah Khalid" <yasoob.khld@gmail.com>
Date: Fri, 3 May 2013 22:44:34 +0600
Subject: [PATCH 156/221] added redtube.com in InfoExtractors (2nd pull request
 with the required amindments)

added redtube.com in InfoExtractors (2nd pull request with the required amindments). Now this script can also download redtube.com videos
---
 youtube_dl/InfoExtractors.py | 33 +++++++++++++++++++++++++++++++++
 1 file changed, 33 insertions(+)

diff --git a/youtube_dl/InfoExtractors.py b/youtube_dl/InfoExtractors.py
index 33dbaa3de..79c4f4b9e 100755
--- a/youtube_dl/InfoExtractors.py
+++ b/youtube_dl/InfoExtractors.py
@@ -779,6 +779,38 @@ class MetacafeIE(InfoExtractor):
             'ext':      video_extension.decode('utf-8'),
         }]
 
+class RedtubeIE(InfoExtractor):
+    """Information Extractor for redtube"""
+    _VALID_URL = r'(?:http://)?(?:www\.)?redtube\.com/(?P<id>[0-9]+)'
+    IE_NAME = u'redtube'
+
+    def _real_extract(self,url):
+        mobj = re.match(self._VALID_URL, url)
+        if mobj is None:
+            self._downloader.report_error(u'invalid URL: %s' % url)
+            return
+        video_id = mobj.group('id')
+        video_extension = 'mp4'        
+        webpage = self._download_webpage(url, video_id)
+        self.report_extraction(video_id)
+        mobj = re.search(r'<source src="'+'(.+)'+'" type="video/mp4">',webpage)
+        if mobj is not None:
+            video_url = mobj.group(1)
+        else:
+            self._downloader.report_error(u'unable to extract media URL')
+            return
+        mobj = re.search('<h1 class="videoTitle slidePanelMovable">'+r'(.+)'+r'</h1>',webpage)
+        if mobj is not None:
+            video_title = mobj.group(1)
+        else:
+            video_title = 'Redtube - %s' % time.ctime()
+
+        return [{
+            'id':       video_id,
+            'url':      video_url,
+            'ext':      video_extension,
+            'title':    video_title,
+        }]
 
 class DailymotionIE(InfoExtractor):
     """Information Extractor for Dailymotion"""
@@ -4236,6 +4268,7 @@ def gen_extractors():
         TEDIE(),
         MySpassIE(),
         SpiegelIE(),
+        RedtubeIE(),
         LiveLeakIE(),
         ARDIE(),
         TumblrIE(),

From 815dd2ffa8564d6b709f2f12e4a528bfd166a50a Mon Sep 17 00:00:00 2001
From: "M.Yasoob Ullah Khalid" <yasoob.khld@gmail.com>
Date: Fri, 3 May 2013 23:51:27 +0600
Subject: [PATCH 157/221] Redtube test now works

I just did a little makeover by changing redtube tests. Now they are passed.
---
 test/tests.json | 9 ++++++---
 1 file changed, 6 insertions(+), 3 deletions(-)

diff --git a/test/tests.json b/test/tests.json
index 19bb225c3..6013a13ab 100644
--- a/test/tests.json
+++ b/test/tests.json
@@ -406,8 +406,11 @@
   },
   {
     "name": "Redtube",
-    "url": "http://www.redtube.com/279577",
-    "file": "Public invasion-279577.mp4",
-    "md5": "432d85211d178e06a62d049c4ca1c3e4"
+    "url": "http://www.redtube.com/66418",
+    "file": "66418.mp4",
+    "md5": "7b8c22b5e7098a3e1c09709df1126d2d",
+    "info_dict":{
+      "title":"Sucked on a toilet"
+    }
   }
 ]

From 5e34d2ebbf9906bded4201d7bd8bb82e9353de9f Mon Sep 17 00:00:00 2001
From: "M.Yasoob Ullah Khalid" <yasoob.khld@gmail.com>
Date: Fri, 3 May 2013 23:57:16 +0600
Subject: [PATCH 158/221] Moved redtube info extractor to the end

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

diff --git a/youtube_dl/InfoExtractors.py b/youtube_dl/InfoExtractors.py
index 79c4f4b9e..8b2442bac 100755
--- a/youtube_dl/InfoExtractors.py
+++ b/youtube_dl/InfoExtractors.py
@@ -779,39 +779,6 @@ class MetacafeIE(InfoExtractor):
             'ext':      video_extension.decode('utf-8'),
         }]
 
-class RedtubeIE(InfoExtractor):
-    """Information Extractor for redtube"""
-    _VALID_URL = r'(?:http://)?(?:www\.)?redtube\.com/(?P<id>[0-9]+)'
-    IE_NAME = u'redtube'
-
-    def _real_extract(self,url):
-        mobj = re.match(self._VALID_URL, url)
-        if mobj is None:
-            self._downloader.report_error(u'invalid URL: %s' % url)
-            return
-        video_id = mobj.group('id')
-        video_extension = 'mp4'        
-        webpage = self._download_webpage(url, video_id)
-        self.report_extraction(video_id)
-        mobj = re.search(r'<source src="'+'(.+)'+'" type="video/mp4">',webpage)
-        if mobj is not None:
-            video_url = mobj.group(1)
-        else:
-            self._downloader.report_error(u'unable to extract media URL')
-            return
-        mobj = re.search('<h1 class="videoTitle slidePanelMovable">'+r'(.+)'+r'</h1>',webpage)
-        if mobj is not None:
-            video_title = mobj.group(1)
-        else:
-            video_title = 'Redtube - %s' % time.ctime()
-
-        return [{
-            'id':       video_id,
-            'url':      video_url,
-            'ext':      video_extension,
-            'title':    video_title,
-        }]
-
 class DailymotionIE(InfoExtractor):
     """Information Extractor for Dailymotion"""
 
@@ -4216,6 +4183,39 @@ class BandcampIE(InfoExtractor):
 
         return [track_info]
 
+class RedtubeIE(InfoExtractor):
+    """Information Extractor for redtube"""
+    _VALID_URL = r'(?:http://)?(?:www\.)?redtube\.com/(?P<id>[0-9]+)'
+    IE_NAME = u'redtube'
+
+    def _real_extract(self,url):
+        mobj = re.match(self._VALID_URL, url)
+        if mobj is None:
+            self._downloader.report_error(u'invalid URL: %s' % url)
+            return
+        video_id = mobj.group('id')
+        video_extension = 'mp4'        
+        webpage = self._download_webpage(url, video_id)
+        self.report_extraction(video_id)
+        mobj = re.search(r'<source src="'+'(.+)'+'" type="video/mp4">',webpage)
+        if mobj is not None:
+            video_url = mobj.group(1)
+        else:
+            self._downloader.report_error(u'unable to extract media URL')
+            return
+        mobj = re.search('<h1 class="videoTitle slidePanelMovable">'+r'(.+)'+r'</h1>',webpage)
+        if mobj is not None:
+            video_title = mobj.group(1)
+        else:
+            video_title = 'Redtube - %s' % time.ctime()
+
+        return [{
+            'id':       video_id,
+            'url':      video_url,
+            'ext':      video_extension,
+            'title':    video_title,
+        }]
+
 
 def gen_extractors():
     """ Return a list of an instance of every supported extractor.
@@ -4268,11 +4268,11 @@ def gen_extractors():
         TEDIE(),
         MySpassIE(),
         SpiegelIE(),
-        RedtubeIE(),
         LiveLeakIE(),
         ARDIE(),
         TumblrIE(),
         BandcampIE(),
+        RedtubeIE(),
         GenericIE()
     ]
 

From c34407d16c18df0e5045d00b46bfdc692329dcfd Mon Sep 17 00:00:00 2001
From: Philipp Hagemeister <phihag@phihag.de>
Date: Fri, 3 May 2013 20:07:35 +0200
Subject: [PATCH 159/221] Simplify RedTube

---
 test/tests.json              |  2 +-
 youtube_dl/InfoExtractors.py | 28 +++++++++++++---------------
 youtube_dl/__init__.py       |  3 ++-
 3 files changed, 16 insertions(+), 17 deletions(-)

diff --git a/test/tests.json b/test/tests.json
index 6013a13ab..2d49495d2 100644
--- a/test/tests.json
+++ b/test/tests.json
@@ -405,7 +405,7 @@
     }
   },
   {
-    "name": "Redtube",
+    "name": "RedTube",
     "url": "http://www.redtube.com/66418",
     "file": "66418.mp4",
     "md5": "7b8c22b5e7098a3e1c09709df1126d2d",
diff --git a/youtube_dl/InfoExtractors.py b/youtube_dl/InfoExtractors.py
index 8b2442bac..7d4a60cc8 100755
--- a/youtube_dl/InfoExtractors.py
+++ b/youtube_dl/InfoExtractors.py
@@ -4183,31 +4183,29 @@ class BandcampIE(InfoExtractor):
 
         return [track_info]
 
-class RedtubeIE(InfoExtractor):
+class RedTubeIE(InfoExtractor):
     """Information Extractor for redtube"""
     _VALID_URL = r'(?:http://)?(?:www\.)?redtube\.com/(?P<id>[0-9]+)'
-    IE_NAME = u'redtube'
 
     def _real_extract(self,url):
         mobj = re.match(self._VALID_URL, url)
         if mobj is None:
-            self._downloader.report_error(u'invalid URL: %s' % url)
-            return
+            raise ExtractorError(u'Invalid URL: %s' % url)
+
         video_id = mobj.group('id')
         video_extension = 'mp4'        
         webpage = self._download_webpage(url, video_id)
         self.report_extraction(video_id)
         mobj = re.search(r'<source src="'+'(.+)'+'" type="video/mp4">',webpage)
-        if mobj is not None:
-            video_url = mobj.group(1)
-        else:
-            self._downloader.report_error(u'unable to extract media URL')
-            return
-        mobj = re.search('<h1 class="videoTitle slidePanelMovable">'+r'(.+)'+r'</h1>',webpage)
-        if mobj is not None:
-            video_title = mobj.group(1)
-        else:
-            video_title = 'Redtube - %s' % time.ctime()
+
+        if mobj is None:
+            raise ExtractorError(u'Unable to extract media URL')
+
+        video_url = mobj.group(1)
+        mobj = re.search('<h1 class="videoTitle slidePanelMovable">(.+)</h1>',webpage)
+        if mobj is None:
+            raise ExtractorError(u'Unable to extract title')
+        video_title = mobj.group(1)
 
         return [{
             'id':       video_id,
@@ -4272,7 +4270,7 @@ def gen_extractors():
         ARDIE(),
         TumblrIE(),
         BandcampIE(),
-        RedtubeIE(),
+        RedTubeIE(),
         GenericIE()
     ]
 
diff --git a/youtube_dl/__init__.py b/youtube_dl/__init__.py
index 808d4a8c2..823ca63a4 100644
--- a/youtube_dl/__init__.py
+++ b/youtube_dl/__init__.py
@@ -388,7 +388,8 @@ def _real_main(argv=None):
         if 'http' in proxies and 'https' not in proxies:
             proxies['https'] = proxies['http']
     proxy_handler = compat_urllib_request.ProxyHandler(proxies)
-    opener = compat_urllib_request.build_opener(proxy_handler, cookie_processor, YoutubeDLHandler())
+    https_handler = compat_urllib_request.HTTPSHandler()
+    opener = compat_urllib_request.build_opener(https_handler, proxy_handler, cookie_processor, YoutubeDLHandler())
     compat_urllib_request.install_opener(opener)
     socket.setdefaulttimeout(300) # 5 minutes should be enough (famous last words)
 

From 95464f14d11d9441b48a55c6b9d96750f9a260fd Mon Sep 17 00:00:00 2001
From: Philipp Hagemeister <phihag@phihag.de>
Date: Fri, 3 May 2013 20:08:16 +0200
Subject: [PATCH 160/221] Credit @yasoob for IE

---
 youtube_dl/__init__.py | 1 +
 1 file changed, 1 insertion(+)

diff --git a/youtube_dl/__init__.py b/youtube_dl/__init__.py
index 823ca63a4..dfcaccafa 100644
--- a/youtube_dl/__init__.py
+++ b/youtube_dl/__init__.py
@@ -25,6 +25,7 @@ __authors__  = (
     'Jeff Crouse',
     'Osama Khalid',
     'Michael Walter',
+    'M. Yasoob Ullah Khalid',
     )
 
 __license__ = 'Public Domain'

From 480b6c1e8be96c3769727390f23689857a365135 Mon Sep 17 00:00:00 2001
From: Philipp Hagemeister <phihag@phihag.de>
Date: Sat, 4 May 2013 02:53:26 +0200
Subject: [PATCH 161/221] Fix comedycentral: newest

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

diff --git a/youtube_dl/InfoExtractors.py b/youtube_dl/InfoExtractors.py
index 7d4a60cc8..f07d588c0 100755
--- a/youtube_dl/InfoExtractors.py
+++ b/youtube_dl/InfoExtractors.py
@@ -124,8 +124,8 @@ class InfoExtractor(object):
                 errnote = u'Unable to download webpage'
             raise ExtractorError(u'%s: %s' % (errnote, compat_str(err)), sys.exc_info()[2])
 
-    def _download_webpage(self, url_or_request, video_id, note=None, errnote=None):
-        """ Returns the data of the page as a string """
+    def _download_webpage_handle(self, url_or_request, video_id, note=None, errnote=None):
+        """ Returns a tuple (page content as string, URL handle) """
         urlh = self._request_webpage(url_or_request, video_id, note, errnote)
         content_type = urlh.headers.get('Content-Type', '')
         m = re.match(r'[a-zA-Z0-9_.-]+/[a-zA-Z0-9_.-]+\s*;\s*charset=(.+)', content_type)
@@ -142,7 +142,12 @@ class InfoExtractor(object):
             self.to_screen(u'Dumping request to ' + url)
             dump = base64.b64encode(webpage_bytes).decode('ascii')
             self._downloader.to_screen(dump)
-        return webpage_bytes.decode(encoding, 'replace')
+        content = webpage_bytes.decode(encoding, 'replace')
+        return (content, urlh)
+
+    def _download_webpage(self, url_or_request, video_id, note=None, errnote=None):
+        """ Returns the data of the page as a string """
+        return self._download_webpage_handle(url_or_request, video_id, note, errnote)[0]
 
     def to_screen(self, msg):
         """Print msg to screen, prefixing it with '[ie_name]'"""
@@ -2265,16 +2270,14 @@ class ComedyCentralIE(InfoExtractor):
                 epTitle = mobj.group('episode')
 
         self.report_extraction(epTitle)
-        webpage = self._download_webpage(url, epTitle)
+        webpage,htmlHandle = self._download_webpage_handle(url, epTitle)
         if dlNewest:
             url = htmlHandle.geturl()
             mobj = re.match(self._VALID_URL, url, re.VERBOSE)
             if mobj is None:
-                self._downloader.report_error(u'Invalid redirected URL: ' + url)
-                return
+                raise ExtractorError(u'Invalid redirected URL: ' + url)
             if mobj.group('episode') == '':
-                self._downloader.report_error(u'Redirected URL is still not specific: ' + url)
-                return
+                raise ExtractorError(u'Redirected URL is still not specific: ' + url)
             epTitle = mobj.group('episode')
 
         mMovieParams = re.findall('(?:<param name="movie" value="|var url = ")(http://media.mtvnservices.com/([^"]*(?:episode|video).*?:.*?))"', webpage)
@@ -2286,8 +2289,7 @@ class ComedyCentralIE(InfoExtractor):
 
             altMovieParams = re.findall('data-mgid="([^"]*(?:episode|video).*?:.*?)"', webpage)
             if len(altMovieParams) == 0:
-                self._downloader.report_error(u'unable to find Flash URL in webpage ' + url)
-                return
+                raise ExtractorError(u'unable to find Flash URL in webpage ' + url)
             else:
                 mMovieParams = [("http://media.mtvnservices.com/" + altMovieParams[0], altMovieParams[0])]
 

From 0d94f2474c9fa280b3ae2d6827bac0adf0d2d597 Mon Sep 17 00:00:00 2001
From: Philipp Hagemeister <phihag@phihag.de>
Date: Sat, 4 May 2013 07:09:50 +0200
Subject: [PATCH 162/221] Work around a Python bug on Windows with UTF-8
 configuration (#820)

---
 youtube_dl/__init__.py | 6 ++++++
 1 file changed, 6 insertions(+)

diff --git a/youtube_dl/__init__.py b/youtube_dl/__init__.py
index dfcaccafa..b8a82f932 100644
--- a/youtube_dl/__init__.py
+++ b/youtube_dl/__init__.py
@@ -30,6 +30,7 @@ __authors__  = (
 
 __license__ = 'Public Domain'
 
+import codecs
 import getpass
 import optparse
 import os
@@ -335,6 +336,11 @@ def parseOpts(overrideArguments=None):
     return parser, opts, args
 
 def _real_main(argv=None):
+    # Compatibility fixes for Windows
+    if sys.platform == 'win32':
+        # https://github.com/rg3/youtube-dl/issues/820
+        codecs.register(lambda name: codecs.lookup('utf-8') if name == 'cp65001' else None)
+
     parser, opts, args = parseOpts(argv)
 
     # Open appropriate CookieJar

From 1f995112100ddf2a52b47716ec83415edd24cde1 Mon Sep 17 00:00:00 2001
From: Philipp Hagemeister <phihag@phihag.de>
Date: Sat, 4 May 2013 07:12:33 +0200
Subject: [PATCH 163/221] release 2013.05.04

---
 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 f8316b801..bd440540f 100644
--- a/youtube_dl/version.py
+++ b/youtube_dl/version.py
@@ -1,2 +1,2 @@
 
-__version__ = '2013.05.01'
+__version__ = '2013.05.04'

From 84e4682f0eb2e67da23645e94abfa08e79ffc0df Mon Sep 17 00:00:00 2001
From: Philipp Hagemeister <phihag@phihag.de>
Date: Sat, 4 May 2013 07:49:25 +0200
Subject: [PATCH 164/221] Always use HTTPS for youtube (Fixes #691)

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

diff --git a/youtube_dl/InfoExtractors.py b/youtube_dl/InfoExtractors.py
index f07d588c0..ea89638e0 100755
--- a/youtube_dl/InfoExtractors.py
+++ b/youtube_dl/InfoExtractors.py
@@ -211,7 +211,7 @@ class YoutubeIE(InfoExtractor):
                      ([0-9A-Za-z_-]+)                                         # here is it! the YouTube video ID
                      (?(1).+)?                                                # if we found the ID, everything can follow
                      $"""
-    _LANG_URL = r'http://www.youtube.com/?hl=en&persist_hl=1&gl=US&persist_gl=1&opt_out_ackd=1'
+    _LANG_URL = r'https://www.youtube.com/?hl=en&persist_hl=1&gl=US&persist_gl=1&opt_out_ackd=1'
     _LOGIN_URL = 'https://accounts.google.com/ServiceLogin'
     _AGE_URL = 'http://www.youtube.com/verify_age?next_url=/&gl=US&hl=en'
     _NEXT_URL_RE = r'[\?&]next_url=([^&]+)'
@@ -427,7 +427,7 @@ class YoutubeIE(InfoExtractor):
 
         # Log in
         login_form_strs = {
-                u'continue': u'http://www.youtube.com/signin?action_handle_signin=true&feature=sign_in_button&hl=en_US&nomobiletemp=1',
+                u'continue': u'https://www.youtube.com/signin?action_handle_signin=true&feature=sign_in_button&hl=en_US&nomobiletemp=1',
                 u'Email': username,
                 u'GALX': galx,
                 u'Passwd': password,
@@ -487,12 +487,12 @@ class YoutubeIE(InfoExtractor):
         # Extract original video URL from URL with redirection, like age verification, using next_url parameter
         mobj = re.search(self._NEXT_URL_RE, url)
         if mobj:
-            url = 'http://www.youtube.com/' + compat_urllib_parse.unquote(mobj.group(1)).lstrip('/')
+            url = 'https://www.youtube.com/' + compat_urllib_parse.unquote(mobj.group(1)).lstrip('/')
         video_id = self._extract_id(url)
 
         # Get video webpage
         self.report_video_webpage_download(video_id)
-        url = 'http://www.youtube.com/watch?v=%s&gl=US&hl=en&has_verified=1' % video_id
+        url = 'https://www.youtube.com/watch?v=%s&gl=US&hl=en&has_verified=1' % video_id
         request = compat_urllib_request.Request(url)
         try:
             video_webpage_bytes = compat_urllib_request.urlopen(request).read()

From f23a03a89bdc1628fa2af9e30b33feb4e4b467af Mon Sep 17 00:00:00 2001
From: Johny Mo Swag <johnymo@me.com>
Date: Thu, 2 May 2013 11:51:12 -0700
Subject: [PATCH 165/221] updated regular experssion for possible future
 updates to source 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 ea89638e0..41b9aea0b 100755
--- a/youtube_dl/InfoExtractors.py
+++ b/youtube_dl/InfoExtractors.py
@@ -3487,7 +3487,7 @@ class WorldStarHipHopIE(InfoExtractor):
     IE_NAME = u'WorldStarHipHop'
 
     def _real_extract(self, url):
-        _src_url = r"""(http://(hw-videos|hw-post1).*(?:mp4|flv))"""
+        _src_url = r"""(http://(hw-videos|hw-post)[0-9]*.*(?:mp4|flv))"""
 
         m = re.match(self._VALID_URL, url)
         video_id = m.group('id')

From 7da5556ac2985c246de0f0e4df982585577f44ba Mon Sep 17 00:00:00 2001
From: Johny Mo Swag <johnymo@me.com>
Date: Thu, 2 May 2013 13:37:26 -0700
Subject: [PATCH 166/221] Better fix for getting source url's

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

diff --git a/youtube_dl/InfoExtractors.py b/youtube_dl/InfoExtractors.py
index 41b9aea0b..325c5ecd4 100755
--- a/youtube_dl/InfoExtractors.py
+++ b/youtube_dl/InfoExtractors.py
@@ -3487,7 +3487,7 @@ class WorldStarHipHopIE(InfoExtractor):
     IE_NAME = u'WorldStarHipHop'
 
     def _real_extract(self, url):
-        _src_url = r"""(http://(hw-videos|hw-post)[0-9]*.*(?:mp4|flv))"""
+        _src_url = r'so\.addVariable\("file","(.*?)"\)'
 
         m = re.match(self._VALID_URL, url)
         video_id = m.group('id')
@@ -3497,7 +3497,7 @@ class WorldStarHipHopIE(InfoExtractor):
         mobj = re.search(_src_url, webpage_src)
 
         if mobj is not None:
-            video_url = mobj.group()
+            video_url = mobj.group(1)
             if 'mp4' in video_url:
                 ext = 'mp4'
             else:

From 180e689f7e590e2987c00dee684ec205bc6b9933 Mon Sep 17 00:00:00 2001
From: Philipp Hagemeister <phihag@phihag.de>
Date: Sat, 4 May 2013 08:06:56 +0200
Subject: [PATCH 167/221] Simplify WorldStarHipHop

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

diff --git a/youtube_dl/InfoExtractors.py b/youtube_dl/InfoExtractors.py
index 325c5ecd4..79182208d 100755
--- a/youtube_dl/InfoExtractors.py
+++ b/youtube_dl/InfoExtractors.py
@@ -3483,7 +3483,7 @@ class UstreamIE(InfoExtractor):
         return [info]
 
 class WorldStarHipHopIE(InfoExtractor):
-    _VALID_URL = r'http://(?:www|m)\.worldstar(?:candy|hiphop)\.com/videos/video\.php\?v=(?P<id>.*)'
+    _VALID_URL = r'https?://(?:www|m)\.worldstar(?:candy|hiphop)\.com/videos/video\.php\?v=(?P<id>.*)'
     IE_NAME = u'WorldStarHipHop'
 
     def _real_extract(self, url):
@@ -3503,21 +3503,15 @@ class WorldStarHipHopIE(InfoExtractor):
             else:
                 ext = 'flv'
         else:
-            self._downloader.report_error(u'Cannot find video url for %s' % video_id)
-            return
+            raise ExtractorError(u'Cannot find video url for %s' % video_id)
 
-        _title = r"""<title>(.*)</title>"""
+        mobj = re.search(r"<title>(.*)</title>", webpage_src)
 
-        mobj = re.search(_title, webpage_src)
-
-        if mobj is not None:
-            title = mobj.group(1)
-        else:
-            title = 'World Start Hip Hop - %s' % time.ctime()
-
-        _thumbnail = r"""rel="image_src" href="(.*)" />"""
-        mobj = re.search(_thumbnail, webpage_src)
+        if mobj is None:
+            raise ExtractorError(u'Cannot determine title')
+        title = mobj.group(1)
 
+        mobj = re.search(r'rel="image_src" href="(.*)" />', webpage_src)
         # Getting thumbnail and if not thumbnail sets correct title for WSHH candy video.
         if mobj is not None:
             thumbnail = mobj.group(1)

From decd1d17372093f8a607e16232fe633a6559dab1 Mon Sep 17 00:00:00 2001
From: Philipp Hagemeister <phihag@phihag.de>
Date: Sat, 4 May 2013 08:38:28 +0200
Subject: [PATCH 168/221] raise ExtractorError instead of calling back

---
 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 79182208d..568bca702 100755
--- a/youtube_dl/InfoExtractors.py
+++ b/youtube_dl/InfoExtractors.py
@@ -3322,8 +3322,7 @@ class JustinTVIE(InfoExtractor):
         response = json.loads(webpage)
         if type(response) != list:
             error_text = response.get('error', 'unknown error')
-            self._downloader.report_error(u'Justin.tv API: %s' % error_text)
-            return
+            raise ExtractorError(u'Justin.tv API: %s' % error_text)
         info = []
         for clip in response:
             video_url = clip['video_file_url']
@@ -3382,8 +3381,7 @@ class FunnyOrDieIE(InfoExtractor):
     def _real_extract(self, url):
         mobj = re.match(self._VALID_URL, url)
         if mobj is None:
-            self._downloader.report_error(u'invalid URL: %s' % url)
-            return
+            raise ExtractorError(u'invalid URL: %s' % url)
 
         video_id = mobj.group('id')
         webpage = self._download_webpage(url, video_id)

From 09dd418f5318a071aa80b82f6c9efeada9608584 Mon Sep 17 00:00:00 2001
From: Philipp Hagemeister <phihag@phihag.de>
Date: Sat, 4 May 2013 09:11:38 +0200
Subject: [PATCH 169/221] Experimentally whitelist Escapist test

---
 test/tests.json | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/test/tests.json b/test/tests.json
index 2d49495d2..b4d511dd8 100644
--- a/test/tests.json
+++ b/test/tests.json
@@ -113,8 +113,7 @@
     "name": "Escapist",
     "url": "http://www.escapistmagazine.com/videos/view/the-escapist-presents/6618-Breaking-Down-Baldurs-Gate",
     "file": "6618-Breaking-Down-Baldurs-Gate.mp4",
-    "md5": "c6793dbda81388f4264c1ba18684a74d",
-    "skip": "Fails with timeout on Travis"
+    "md5": "c6793dbda81388f4264c1ba18684a74d"
   },
   {
     "name": "GooglePlus",

From 0e16f0947492ea7bfbae4d5f56452f0a0b93b7ab Mon Sep 17 00:00:00 2001
From: Philipp Hagemeister <phihag@phihag.de>
Date: Sat, 4 May 2013 10:33:34 +0200
Subject: [PATCH 170/221] Work on twitch.tv chapters (#810)

---
 youtube_dl/InfoExtractors.py | 49 +++++++++++++++++++++++++++++-------
 1 file changed, 40 insertions(+), 9 deletions(-)

diff --git a/youtube_dl/InfoExtractors.py b/youtube_dl/InfoExtractors.py
index 568bca702..1c985272f 100755
--- a/youtube_dl/InfoExtractors.py
+++ b/youtube_dl/InfoExtractors.py
@@ -3304,7 +3304,13 @@ class JustinTVIE(InfoExtractor):
     # starts at 1 and increases. Can we treat all parts as one video?
 
     _VALID_URL = r"""(?x)^(?:http://)?(?:www\.)?(?:twitch|justin)\.tv/
-        ([^/]+)(?:/b/([^/]+))?/?(?:\#.*)?$"""
+        (?:
+            (?P<channelid>[^/]+)|
+            (?:(?:[^/]+)/b/(?P<videoid>[^/]+))|
+            (?:(?:[^/]+)/c/(?P<chapterid>[^/]+))
+        )
+        /?(?:\#.*)?$
+        """
     _JUSTIN_PAGE_LIMIT = 100
     IE_NAME = u'justin.tv'
 
@@ -3346,18 +3352,43 @@ class JustinTVIE(InfoExtractor):
     def _real_extract(self, url):
         mobj = re.match(self._VALID_URL, url)
         if mobj is None:
-            self._downloader.report_error(u'invalid URL: %s' % url)
-            return
+            raise ExtractorError(u'invalid URL: %s' % url)
 
-        api = 'http://api.justin.tv'
-        video_id = mobj.group(mobj.lastindex)
+        api_base = 'http://api.justin.tv'
         paged = False
-        if mobj.lastindex == 1:
+        if mobj.group('channelid'):
             paged = True
-            api += '/channel/archives/%s.json'
+            video_id = mobj.group('channelid')
+            api = api_base + '/channel/archives/%s.json' % video_id
+        elif mobj.group('chapterid'):
+            chapter_id = mobj.group('chapterid')
+            #  youtube-dl -v http://www.twitch.tv/firmbelief/c/1757457
+
+            webpage = self._download_webpage(url, chapter_id)
+            m = re.search(r'PP\.archive_id = "([0-9]+)";', webpage)
+            if not m:
+                raise ExtractorError('Cannot find archive of a chapter')
+            archive_id = m.group(1)
+
+            api = api_base + '/broadcast/by_chapter/%s.json' % chapter_id
+            chapter_info_json = self._download_webpage(api, chapter_id,
+                                             note='Downloading chapter information',
+                                             errnote='Chapter information download failed')
+            chapter_info = json.loads(chapter_info_json)
+            video_info = filter(lambda ci: str(ci['id']) == archive_id, chapter_info)
+
+            video_url = 'TODO:SERVER_NAME' + '/archives/' + vi['file_name'] + '?start=TODO:startid'
+
+            # Result: http://store36.media36.justin.tv/archives/2012-12-2/live_user_firmbelief_1354484906.flv?start=51670615
+            # (this may not be playable, may need to craft some additional headers)
+            # TODO: title ("GOD", from webpage?)
+            # TODO: ext (from vi['file_name'])
+            # print(json.dumps(video_info, indent=2))
+            # return
+            raise NotImplementedError('twitch.tv chapters are not yet supported, sorry (See https://github.com/rg3/youtube-dl/issues/810 )')
         else:
-            api += '/broadcast/by_archive/%s.json'
-        api = api % (video_id,)
+            video_id = mobj.group('videoid')
+            api = api_base + '/broadcast/by_archive/%s.json' % video_id
 
         self.report_extraction(video_id)
 

From f4f316881d6328aa235900eb9f8e5c853dc7781e Mon Sep 17 00:00:00 2001
From: Philipp Hagemeister <phihag@phihag.de>
Date: Sat, 4 May 2013 11:27:39 +0200
Subject: [PATCH 171/221] Improve Twitch.tv chapter support (#810)

---
 youtube_dl/InfoExtractors.py | 45 +++++++++++++++++++++++-------------
 1 file changed, 29 insertions(+), 16 deletions(-)

diff --git a/youtube_dl/InfoExtractors.py b/youtube_dl/InfoExtractors.py
index 1c985272f..eacb5eb27 100755
--- a/youtube_dl/InfoExtractors.py
+++ b/youtube_dl/InfoExtractors.py
@@ -3362,30 +3362,43 @@ class JustinTVIE(InfoExtractor):
             api = api_base + '/channel/archives/%s.json' % video_id
         elif mobj.group('chapterid'):
             chapter_id = mobj.group('chapterid')
-            #  youtube-dl -v http://www.twitch.tv/firmbelief/c/1757457
 
             webpage = self._download_webpage(url, chapter_id)
             m = re.search(r'PP\.archive_id = "([0-9]+)";', webpage)
             if not m:
-                raise ExtractorError('Cannot find archive of a chapter')
+                raise ExtractorError(u'Cannot find archive of a chapter')
             archive_id = m.group(1)
+            m = re.search(r"<h2 class='js-title'>([^<]*)</h2>", webpage)
+            if not m:
+                raise ExtractorError(u'Cannot find chapter title')
+            video_title = m.group(1)
 
-            api = api_base + '/broadcast/by_chapter/%s.json' % chapter_id
-            chapter_info_json = self._download_webpage(api, chapter_id,
-                                             note='Downloading chapter information',
-                                             errnote='Chapter information download failed')
-            chapter_info = json.loads(chapter_info_json)
-            video_info = filter(lambda ci: str(ci['id']) == archive_id, chapter_info)
+            api = api_base + '/broadcast/by_chapter/%s.xml' % chapter_id
+            chapter_info_xml = self._download_webpage(api, chapter_id,
+                                             note=u'Downloading chapter information',
+                                             errnote=u'Chapter information download failed')
+            doc = xml.etree.ElementTree.fromstring(chapter_info_xml)
+            for a in doc.findall('.//archive'):
+                if archive_id == a.find('./id').text:
+                    break
+            else:
+                raise ExtractorError(u'Could not find chapter in chapter information')
 
-            video_url = 'TODO:SERVER_NAME' + '/archives/' + vi['file_name'] + '?start=TODO:startid'
+            video_url = a.find('./video_file_url').text
+            video_ext = video_url.rpartition('.')[2] or u'flv'
 
-            # Result: http://store36.media36.justin.tv/archives/2012-12-2/live_user_firmbelief_1354484906.flv?start=51670615
-            # (this may not be playable, may need to craft some additional headers)
-            # TODO: title ("GOD", from webpage?)
-            # TODO: ext (from vi['file_name'])
-            # print(json.dumps(video_info, indent=2))
-            # return
-            raise NotImplementedError('twitch.tv chapters are not yet supported, sorry (See https://github.com/rg3/youtube-dl/issues/810 )')
+            # TODO determine start (and probably fix up file)
+            #  youtube-dl -v http://www.twitch.tv/firmbelief/c/1757457
+            #video_url += u'?start=' + a.find('./start_timestamp').text
+            self._downloader.report_warning(u'Chapter detected, but we do not know how to calculate start position. Downloading the whole file ... (See https://github.com/rg3/youtube-dl/issues/810 )')
+
+            info = {
+                'id': u'c' + chapter_id,
+                'url': video_url,
+                'ext': video_ext,
+                'title': video_title,
+            }
+            return [info]
         else:
             video_id = mobj.group('videoid')
             api = api_base + '/broadcast/by_archive/%s.json' % video_id

From db8fd71ca976e9e4e79d79ca86fa359ca547f06b Mon Sep 17 00:00:00 2001
From: Philipp Hagemeister <phihag@phihag.de>
Date: Sat, 4 May 2013 11:42:44 +0200
Subject: [PATCH 172/221] twitch.tv chapters: Use API for title and other
 metadata

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

diff --git a/youtube_dl/InfoExtractors.py b/youtube_dl/InfoExtractors.py
index eacb5eb27..737bf7aa0 100755
--- a/youtube_dl/InfoExtractors.py
+++ b/youtube_dl/InfoExtractors.py
@@ -3368,10 +3368,6 @@ class JustinTVIE(InfoExtractor):
             if not m:
                 raise ExtractorError(u'Cannot find archive of a chapter')
             archive_id = m.group(1)
-            m = re.search(r"<h2 class='js-title'>([^<]*)</h2>", webpage)
-            if not m:
-                raise ExtractorError(u'Cannot find chapter title')
-            video_title = m.group(1)
 
             api = api_base + '/broadcast/by_chapter/%s.xml' % chapter_id
             chapter_info_xml = self._download_webpage(api, chapter_id,
@@ -3387,6 +3383,12 @@ class JustinTVIE(InfoExtractor):
             video_url = a.find('./video_file_url').text
             video_ext = video_url.rpartition('.')[2] or u'flv'
 
+            chapter_api_url = u'https://api.twitch.tv/kraken/videos/c' + chapter_id
+            chapter_info_json = self._download_webpage(chapter_api_url, video_id,
+                                   note='Downloading chapter metadata',
+                                   errnote='Download of chapter metadata failed')
+            chapter_info = json.loads(chapter_info_json)
+
             # TODO determine start (and probably fix up file)
             #  youtube-dl -v http://www.twitch.tv/firmbelief/c/1757457
             #video_url += u'?start=' + a.find('./start_timestamp').text
@@ -3396,7 +3398,9 @@ class JustinTVIE(InfoExtractor):
                 'id': u'c' + chapter_id,
                 'url': video_url,
                 'ext': video_ext,
-                'title': video_title,
+                'title': chapter_info['title'],
+                'thumbnail': chapter_info['preview'],
+                'description': chapter_info['description'],
             }
             return [info]
         else:

From c43e57242e10eae327d4348390cfb9e574fad5dd Mon Sep 17 00:00:00 2001
From: Philipp Hagemeister <phihag@phihag.de>
Date: Sat, 4 May 2013 11:44:27 +0200
Subject: [PATCH 173/221] twitch.tv chapters: Include uploader (#810)

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

diff --git a/youtube_dl/InfoExtractors.py b/youtube_dl/InfoExtractors.py
index 737bf7aa0..96c597396 100755
--- a/youtube_dl/InfoExtractors.py
+++ b/youtube_dl/InfoExtractors.py
@@ -3384,11 +3384,12 @@ class JustinTVIE(InfoExtractor):
             video_ext = video_url.rpartition('.')[2] or u'flv'
 
             chapter_api_url = u'https://api.twitch.tv/kraken/videos/c' + chapter_id
-            chapter_info_json = self._download_webpage(chapter_api_url, video_id,
+            chapter_info_json = self._download_webpage(chapter_api_url, u'c' + chapter_id,
                                    note='Downloading chapter metadata',
                                    errnote='Download of chapter metadata failed')
             chapter_info = json.loads(chapter_info_json)
 
+
             # TODO determine start (and probably fix up file)
             #  youtube-dl -v http://www.twitch.tv/firmbelief/c/1757457
             #video_url += u'?start=' + a.find('./start_timestamp').text
@@ -3401,6 +3402,8 @@ class JustinTVIE(InfoExtractor):
                 'title': chapter_info['title'],
                 'thumbnail': chapter_info['preview'],
                 'description': chapter_info['description'],
+                'uploader': chapter_info['channel']['display_name'],
+                'uploader_id': chapter_info['channel']['name'],
             }
             return [info]
         else:

From 4539dd30e6c00a50760094e7a41744843d659cb1 Mon Sep 17 00:00:00 2001
From: Philipp Hagemeister <phihag@phihag.de>
Date: Sat, 4 May 2013 12:02:18 +0200
Subject: [PATCH 174/221] twitch.tv chapters (#810): print out start and end
 time

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

diff --git a/youtube_dl/InfoExtractors.py b/youtube_dl/InfoExtractors.py
index 96c597396..36343882b 100755
--- a/youtube_dl/InfoExtractors.py
+++ b/youtube_dl/InfoExtractors.py
@@ -3389,11 +3389,15 @@ class JustinTVIE(InfoExtractor):
                                    errnote='Download of chapter metadata failed')
             chapter_info = json.loads(chapter_info_json)
 
+            bracket_start = int(doc.find('.//bracket_start').text)
+            bracket_end = int(doc.find('.//bracket_end').text)
 
             # TODO determine start (and probably fix up file)
             #  youtube-dl -v http://www.twitch.tv/firmbelief/c/1757457
-            #video_url += u'?start=' + a.find('./start_timestamp').text
-            self._downloader.report_warning(u'Chapter detected, but we do not know how to calculate start position. Downloading the whole file ... (See https://github.com/rg3/youtube-dl/issues/810 )')
+            #video_url += u'?start=' + TODO:start_timestamp
+            # bracket_start is 13290, but we want 51670615
+            self._downloader.report_warning(u'Chapter detected, but we can just download the whole file. '
+                                            u'Chapter starts at %s and ends at %s' % (formatSeconds(bracket_start), formatSeconds(bracket_end)))
 
             info = {
                 'id': u'c' + chapter_id,
diff --git a/youtube_dl/utils.py b/youtube_dl/utils.py
index 6c5b5df4c..4ec0ebfe1 100644
--- a/youtube_dl/utils.py
+++ b/youtube_dl/utils.py
@@ -430,6 +430,14 @@ def decodeOption(optval):
     assert isinstance(optval, compat_str)
     return optval
 
+def formatSeconds(secs):
+    if secs > 3600:
+        return '%d:%02d:%02d' % (secs // 3600, (secs % 3600) // 60, secs % 60)
+    elif secs > 60:
+        return '%d:%02d' % (secs // 60, secs % 60)
+    else:
+        return '%d' % secs
+
 class ExtractorError(Exception):
     """Error during info extraction."""
     def __init__(self, msg, tb=None):

From ea6d901e51c71714eb0f1c34594e2f50e20c7d0d Mon Sep 17 00:00:00 2001
From: Philipp Hagemeister <phihag@phihag.de>
Date: Sat, 4 May 2013 12:19:02 +0200
Subject: [PATCH 175/221] Add --no-check-certificate (#814)

---
 youtube_dl/__init__.py |  3 ++-
 youtube_dl/utils.py    | 14 ++++++++++++++
 2 files changed, 16 insertions(+), 1 deletion(-)

diff --git a/youtube_dl/__init__.py b/youtube_dl/__init__.py
index b8a82f932..05cb6e36a 100644
--- a/youtube_dl/__init__.py
+++ b/youtube_dl/__init__.py
@@ -149,6 +149,7 @@ def parseOpts(overrideArguments=None):
             action='store_true', dest='list_extractors',
             help='List all supported extractors and the URLs they would handle', default=False)
     general.add_option('--proxy', dest='proxy', default=None, help='Use the specified HTTP/HTTPS proxy', metavar='URL')
+    general.add_option('--no-check-certificate', action='store_true', dest='no_check_certificate', default=False, help='Suppress HTTPS certificate validation.')
     general.add_option('--test', action='store_true', dest='test', default=False, help=optparse.SUPPRESS_HELP)
 
     selection.add_option('--playlist-start',
@@ -395,7 +396,7 @@ def _real_main(argv=None):
         if 'http' in proxies and 'https' not in proxies:
             proxies['https'] = proxies['http']
     proxy_handler = compat_urllib_request.ProxyHandler(proxies)
-    https_handler = compat_urllib_request.HTTPSHandler()
+    https_handler = make_HTTPS_handler(opts)
     opener = compat_urllib_request.build_opener(https_handler, proxy_handler, cookie_processor, YoutubeDLHandler())
     compat_urllib_request.install_opener(opener)
     socket.setdefaulttimeout(300) # 5 minutes should be enough (famous last words)
diff --git a/youtube_dl/utils.py b/youtube_dl/utils.py
index 4ec0ebfe1..f2342b10a 100644
--- a/youtube_dl/utils.py
+++ b/youtube_dl/utils.py
@@ -438,6 +438,20 @@ def formatSeconds(secs):
     else:
         return '%d' % secs
 
+def make_HTTPS_handler(opts):
+    if sys.version_info < (3,2):
+        # Python's 2.x handler is very simplistic
+        return compat_urllib_request.HTTPSHandler()
+    else:
+        import ssl
+        context = ssl.SSLContext(ssl.PROTOCOL_SSLv23)
+        context.set_default_verify_paths()
+        
+        context.verify_mode = (ssl.CERT_NONE
+                               if opts.no_check_certificate
+                               else ssl.CERT_REQUIRED)
+        return compat_urllib_request.HTTPSHandler(context=context)
+
 class ExtractorError(Exception):
     """Error during info extraction."""
     def __init__(self, msg, tb=None):

From 891629c84aae0ec81cf748dddbb77c54969667a1 Mon Sep 17 00:00:00 2001
From: Philipp Hagemeister <phihag@phihag.de>
Date: Sat, 4 May 2013 12:31:17 +0200
Subject: [PATCH 176/221] release 2013.05.05

---
 README.md             | 1 +
 youtube_dl/version.py | 2 +-
 2 files changed, 2 insertions(+), 1 deletion(-)

diff --git a/README.md b/README.md
index 232cc2205..c95201c3f 100644
--- a/README.md
+++ b/README.md
@@ -32,6 +32,7 @@ which means you can modify it, redistribute it or use it however you like.
     --list-extractors          List all supported extractors and the URLs they
                                would handle
     --proxy URL                Use the specified HTTP/HTTPS proxy
+    --no-check-certificate     Suppress HTTPS certificate validation.
 
 ## Video Selection:
     --playlist-start NUMBER    playlist video to start at (default is 1)
diff --git a/youtube_dl/version.py b/youtube_dl/version.py
index bd440540f..f7227d0ad 100644
--- a/youtube_dl/version.py
+++ b/youtube_dl/version.py
@@ -1,2 +1,2 @@
 
-__version__ = '2013.05.04'
+__version__ = '2013.05.05'

From 0c021ad171231c91e554c76d62e7fc749caf87bc Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Jaime=20Marqui=CC=81nez=20Ferra=CC=81ndiz?=
 <jaime.marquinez.ferrandiz@gmail.com>
Date: Sat, 4 May 2013 14:23:16 +0200
Subject: [PATCH 177/221] More callbacks changed to raise ExtractorError

---
 youtube_dl/InfoExtractors.py | 382 ++++++++++++-----------------------
 1 file changed, 129 insertions(+), 253 deletions(-)

diff --git a/youtube_dl/InfoExtractors.py b/youtube_dl/InfoExtractors.py
index 36343882b..0c544d747 100755
--- a/youtube_dl/InfoExtractors.py
+++ b/youtube_dl/InfoExtractors.py
@@ -472,14 +472,12 @@ class YoutubeIE(InfoExtractor):
             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.report_error(u'unable to confirm age: %s' % compat_str(err))
-            return
+            raise ExtractorError(u'Unable to confirm age: %s' % compat_str(err))
 
     def _extract_id(self, url):
         mobj = re.match(self._VALID_URL, url, re.VERBOSE)
         if mobj is None:
-            self._downloader.report_error(u'invalid URL: %s' % url)
-            return
+            raise ExtractorError(u'Invalid URL: %s' % url)
         video_id = mobj.group(2)
         return video_id
 
@@ -497,8 +495,7 @@ class YoutubeIE(InfoExtractor):
         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.report_error(u'unable to download video webpage: %s' % compat_str(err))
-            return
+            raise ExtractorError(u'Unable to download video webpage: %s' % compat_str(err))
 
         video_webpage = video_webpage_bytes.decode('utf-8', 'ignore')
 
@@ -522,23 +519,20 @@ class YoutubeIE(InfoExtractor):
                 break
         if 'token' not in video_info:
             if 'reason' in video_info:
-                self._downloader.report_error(u'YouTube said: %s' % video_info['reason'][0])
+                raise ExtractorError(u'YouTube said: %s' % video_info['reason'][0])
             else:
-                self._downloader.report_error(u'"token" parameter not in video info for unknown reason')
-            return
+                raise ExtractorError(u'"token" parameter not in video info for unknown reason')
 
         # Check for "rental" videos
         if 'ypc_video_rental_bar_text' in video_info and 'author' not in video_info:
-            self._downloader.report_error(u'"rental" videos not supported')
-            return
+            raise ExtractorError(u'"rental" videos not supported')
 
         # Start extracting information
         self.report_information_extraction(video_id)
 
         # uploader
         if 'author' not in video_info:
-            self._downloader.report_error(u'unable to extract uploader name')
-            return
+            raise ExtractorError(u'Unable to extract uploader name')
         video_uploader = compat_urllib_parse.unquote_plus(video_info['author'][0])
 
         # uploader_id
@@ -551,8 +545,7 @@ class YoutubeIE(InfoExtractor):
 
         # title
         if 'title' not in video_info:
-            self._downloader.report_error(u'unable to extract video title')
-            return
+            raise ExtractorError(u'Unable to extract video title')
         video_title = compat_urllib_parse.unquote_plus(video_info['title'][0])
 
         # thumbnail image
@@ -699,8 +692,7 @@ class MetacafeIE(InfoExtractor):
             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.report_error(u'unable to retrieve disclaimer: %s' % compat_str(err))
-            return
+            raise ExtractorError(u'Unable to retrieve disclaimer: %s' % compat_str(err))
 
         # Confirm age
         disclaimer_form = {
@@ -712,15 +704,13 @@ class MetacafeIE(InfoExtractor):
             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.report_error(u'unable to confirm age: %s' % compat_str(err))
-            return
+            raise ExtractorError(u'Unable to confirm age: %s' % compat_str(err))
 
     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.report_error(u'invalid URL: %s' % url)
-            return
+            raise ExtractorError(u'Invalid URL: %s' % url)
 
         video_id = mobj.group(1)
 
@@ -749,30 +739,25 @@ class MetacafeIE(InfoExtractor):
         else:
             mobj = re.search(r' name="flashvars" value="(.*?)"', webpage)
             if mobj is None:
-                self._downloader.report_error(u'unable to extract media URL')
-                return
+                raise ExtractorError(u'Unable to extract media URL')
             vardict = compat_parse_qs(mobj.group(1))
             if 'mediaData' not in vardict:
-                self._downloader.report_error(u'unable to extract media URL')
-                return
+                raise ExtractorError(u'Unable to extract media URL')
             mobj = re.search(r'"mediaURL":"(?P<mediaURL>http.*?)",(.*?)"key":"(?P<key>.*?)"', vardict['mediaData'][0])
             if mobj is None:
-                self._downloader.report_error(u'unable to extract media URL')
-                return
+                raise ExtractorError(u'Unable to extract media URL')
             mediaURL = mobj.group('mediaURL').replace('\\/', '/')
             video_extension = mediaURL[-3:]
             video_url = '%s?__gda__=%s' % (mediaURL, mobj.group('key'))
 
         mobj = re.search(r'(?im)<title>(.*) - Video</title>', webpage)
         if mobj is None:
-            self._downloader.report_error(u'unable to extract title')
-            return
+            raise ExtractorError(u'Unable to extract title')
         video_title = mobj.group(1).decode('utf-8')
 
         mobj = re.search(r'submitter=(.*?);', webpage)
         if mobj is None:
-            self._downloader.report_error(u'unable to extract uploader nickname')
-            return
+            raise ExtractorError(u'Unable to extract uploader nickname')
         video_uploader = mobj.group(1)
 
         return [{
@@ -794,8 +779,7 @@ class DailymotionIE(InfoExtractor):
         # Extract id and simplified title from URL
         mobj = re.match(self._VALID_URL, url)
         if mobj is None:
-            self._downloader.report_error(u'invalid URL: %s' % url)
-            return
+            raise ExtractorError(u'Invalid URL: %s' % url)
 
         video_id = mobj.group(1).split('_')[0].split('?')[0]
 
@@ -810,8 +794,7 @@ class DailymotionIE(InfoExtractor):
         self.report_extraction(video_id)
         mobj = re.search(r'\s*var flashvars = (.*)', webpage)
         if mobj is None:
-            self._downloader.report_error(u'unable to extract media URL')
-            return
+            raise ExtractorError(u'Unable to extract media URL')
         flashvars = compat_urllib_parse.unquote(mobj.group(1))
 
         for key in ['hd1080URL', 'hd720URL', 'hqURL', 'sdURL', 'ldURL', 'video_url']:
@@ -820,13 +803,11 @@ class DailymotionIE(InfoExtractor):
                 self.to_screen(u'Using %s' % key)
                 break
         else:
-            self._downloader.report_error(u'unable to extract video URL')
-            return
+            raise ExtractorError(u'Unable to extract video URL')
 
         mobj = re.search(r'"' + max_quality + r'":"(.+?)"', flashvars)
         if mobj is None:
-            self._downloader.report_error(u'unable to extract video URL')
-            return
+            raise ExtractorError(u'Unable to extract video URL')
 
         video_url = compat_urllib_parse.unquote(mobj.group(1)).replace('\\/', '/')
 
@@ -834,8 +815,7 @@ class DailymotionIE(InfoExtractor):
 
         mobj = re.search(r'<meta property="og:title" content="(?P<title>[^"]*)" />', webpage)
         if mobj is None:
-            self._downloader.report_error(u'unable to extract title')
-            return
+            raise ExtractorError(u'Unable to extract title')
         video_title = unescapeHTML(mobj.group('title'))
 
         video_uploader = None
@@ -875,8 +855,7 @@ class PhotobucketIE(InfoExtractor):
         # Extract id from URL
         mobj = re.match(self._VALID_URL, url)
         if mobj is None:
-            self._downloader.report_error(u'Invalid URL: %s' % url)
-            return
+            raise ExtractorError(u'Invalid URL: %s' % url)
 
         video_id = mobj.group(1)
 
@@ -888,23 +867,20 @@ class PhotobucketIE(InfoExtractor):
             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.report_error(u'Unable to retrieve video webpage: %s' % compat_str(err))
-            return
+            raise ExtractorError(u'Unable to retrieve video webpage: %s' % compat_str(err))
 
         # 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.report_error(u'unable to extract media URL')
-            return
+            raise ExtractorError(u'Unable to extract media URL')
         mediaURL = compat_urllib_parse.unquote(mobj.group(1))
 
         video_url = mediaURL
 
         mobj = re.search(r'<title>(.*) video by (.*) - Photobucket</title>', webpage)
         if mobj is None:
-            self._downloader.report_error(u'unable to extract title')
-            return
+            raise ExtractorError(u'Unable to extract title')
         video_title = mobj.group(1).decode('utf-8')
 
         video_uploader = mobj.group(2).decode('utf-8')
@@ -933,8 +909,7 @@ class YahooIE(InfoExtractor):
         # Extract ID from URL
         mobj = re.match(self._VALID_URL, url)
         if mobj is None:
-            self._downloader.report_error(u'Invalid URL: %s' % url)
-            return
+            raise ExtractorError(u'Invalid URL: %s' % url)
 
         video_id = mobj.group(2)
         video_extension = 'flv'
@@ -946,19 +921,16 @@ class YahooIE(InfoExtractor):
             try:
                 webpage = compat_urllib_request.urlopen(request).read()
             except (compat_urllib_error.URLError, compat_http_client.HTTPException, socket.error) as err:
-                self._downloader.report_error(u'Unable to retrieve video webpage: %s' % compat_str(err))
-                return
+                raise ExtractorError(u'Unable to retrieve video webpage: %s' % compat_str(err))
 
             mobj = re.search(r'\("id", "([0-9]+)"\);', webpage)
             if mobj is None:
-                self._downloader.report_error(u'Unable to extract id field')
-                return
+                raise ExtractorError(u'Unable to extract id field')
             yahoo_id = mobj.group(1)
 
             mobj = re.search(r'\("vid", "([0-9]+)"\);', webpage)
             if mobj is None:
-                self._downloader.report_error(u'Unable to extract vid field')
-                return
+                raise ExtractorError(u'Unable to extract vid field')
             yahoo_vid = mobj.group(1)
 
             url = 'http://video.yahoo.com/watch/%s/%s' % (yahoo_vid, yahoo_id)
@@ -970,35 +942,30 @@ class YahooIE(InfoExtractor):
             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.report_error(u'Unable to retrieve video webpage: %s' % compat_str(err))
-            return
+            raise ExtractorError(u'Unable to retrieve video webpage: %s' % compat_str(err))
 
         # 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.report_error(u'unable to extract video title')
-            return
+            raise ExtractorError(u'Unable to extract video title')
         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.report_error(u'unable to extract video uploader')
-            return
+            raise ExtractorError(u'Unable to extract video uploader')
         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.report_error(u'unable to extract video thumbnail')
-            return
+            raise ExtractorError(u'Unable to extract video thumbnail')
         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.report_error(u'unable to extract video description')
-            return
+            raise ExtractorError(u'Unable to extract video description')
         video_description = mobj.group(1).decode('utf-8')
         if not video_description:
             video_description = 'No description available.'
@@ -1006,14 +973,12 @@ class YahooIE(InfoExtractor):
         # Extract video height and width
         mobj = re.search(r'<meta name="video_height" content="([0-9]+)" />', webpage)
         if mobj is None:
-            self._downloader.report_error(u'unable to extract video height')
-            return
+            raise ExtractorError(u'Unable to extract video height')
         yv_video_height = mobj.group(1)
 
         mobj = re.search(r'<meta name="video_width" content="([0-9]+)" />', webpage)
         if mobj is None:
-            self._downloader.report_error(u'unable to extract video width')
-            return
+            raise ExtractorError(u'Unable to extract video width')
         yv_video_width = mobj.group(1)
 
         # Retrieve video playlist to extract media URL
@@ -1028,14 +993,12 @@ class YahooIE(InfoExtractor):
             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.report_error(u'Unable to retrieve video webpage: %s' % compat_str(err))
-            return
+            raise ExtractorError(u'Unable to retrieve video webpage: %s' % compat_str(err))
 
         # Extract media URL from playlist XML
         mobj = re.search(r'<STREAM APP="(http://.*)" FULLPATH="/?(/.*\.flv\?[^"]*)"', webpage)
         if mobj is None:
-            self._downloader.report_error(u'Unable to extract media URL')
-            return
+            raise ExtractorError(u'Unable to extract media URL')
         video_url = compat_urllib_parse.unquote(mobj.group(1) + mobj.group(2)).decode('utf-8')
         video_url = unescapeHTML(video_url)
 
@@ -1062,8 +1025,7 @@ class VimeoIE(InfoExtractor):
         # Extract ID from URL
         mobj = re.match(self._VALID_URL, url)
         if mobj is None:
-            self._downloader.report_error(u'Invalid URL: %s' % url)
-            return
+            raise ExtractorError(u'Invalid URL: %s' % url)
 
         video_id = mobj.group('id')
         if not mobj.group('proto'):
@@ -1086,10 +1048,9 @@ class VimeoIE(InfoExtractor):
             config = json.loads(config)
         except:
             if re.search('The creator of this video has not given you permission to embed it on this domain.', webpage):
-                self._downloader.report_error(u'The author has restricted the access to this video, try with the "--referer" option')
+                raise ExtractorError(u'The author has restricted the access to this video, try with the "--referer" option')
             else:
-                self._downloader.report_error(u'unable to extract info section')
-            return
+                raise ExtractorError(u'Unable to extract info section')
 
         # Extract title
         video_title = config["video"]["title"]
@@ -1138,8 +1099,7 @@ class VimeoIE(InfoExtractor):
                 self.to_screen(u'%s: Downloading %s file at %s quality' % (video_id, video_codec.upper(), video_quality))
                 break
         else:
-            self._downloader.report_error(u'no known codec found')
-            return
+            raise ExtractorError(u'No known codec found')
 
         video_url = "http://player.vimeo.com/play_redirect?clip_id=%s&sig=%s&time=%s&quality=%s&codecs=%s&type=moogaloop_local&embed_location=" \
                     %(video_id, sig, timestamp, video_quality, video_codec.upper())
@@ -1171,11 +1131,9 @@ class ArteTvIE(InfoExtractor):
             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.report_error(u'Unable to retrieve video webpage: %s' % compat_str(err))
-            return
+            raise ExtractorError(u'Unable to retrieve video webpage: %s' % compat_str(err))
         except ValueError as err:
-            self._downloader.report_error(u'Invalid URL: %s' % url)
-            return
+            raise ExtractorError(u'Invalid URL: %s' % url)
         return webpage
 
     def grep_webpage(self, url, regex, regexFlags, matchTuples):
@@ -1184,13 +1142,11 @@ class ArteTvIE(InfoExtractor):
         info = {}
 
         if mobj is None:
-            self._downloader.report_error(u'Invalid URL: %s' % url)
-            return
+            raise ExtractorError(u'Invalid URL: %s' % url)
 
         for (i, key, err) in matchTuples:
             if mobj.group(i) is None:
-                self._downloader.report_error(err)
-                return
+                raise ExtractorError(err)
             else:
                 info[key] = mobj.group(i)
 
@@ -1362,8 +1318,7 @@ class GenericIE(InfoExtractor):
         except ValueError as err:
             # since this is the last-resort InfoExtractor, if
             # this error is thrown, it'll be thrown here
-            self._downloader.report_error(u'Invalid URL: %s' % url)
-            return
+            raise ExtractorError(u'Invalid URL: %s' % url)
 
         self.report_extraction(video_id)
         # Start with something easy: JW Player in SWFObject
@@ -1375,14 +1330,12 @@ class GenericIE(InfoExtractor):
             # 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.report_error(u'Invalid URL: %s' % url)
-            return
+            raise ExtractorError(u'Invalid URL: %s' % url)
 
         # It's possible that one of the regexes
         # matched, but returned an empty group:
         if mobj.group(1) is None:
-            self._downloader.report_error(u'Invalid URL: %s' % url)
-            return
+            raise ExtractorError(u'Invalid URL: %s' % url)
 
         video_url = compat_urllib_parse.unquote(mobj.group(1))
         video_id = os.path.basename(video_url)
@@ -1399,15 +1352,13 @@ class GenericIE(InfoExtractor):
         # and so on and so forth; it's just not practical
         mobj = re.search(r'<title>(.*)</title>', webpage)
         if mobj is None:
-            self._downloader.report_error(u'unable to extract title')
-            return
+            raise ExtractorError(u'Unable to extract title')
         video_title = mobj.group(1)
 
         # video uploader is domain name
         mobj = re.match(r'(?:https?://)?([^/]*)/.*', url)
         if mobj is None:
-            self._downloader.report_error(u'unable to extract title')
-            return
+            raise ExtractorError(u'Unable to extract title')
         video_uploader = mobj.group(1)
 
         return [{
@@ -1435,8 +1386,7 @@ class YoutubeSearchIE(InfoExtractor):
     def _real_extract(self, query):
         mobj = re.match(self._VALID_URL, query)
         if mobj is None:
-            self._downloader.report_error(u'invalid search query "%s"' % query)
-            return
+            raise ExtractorError(u'Invalid search query "%s"' % query)
 
         prefix, query = query.split(':')
         prefix = prefix[8:]
@@ -1449,8 +1399,7 @@ class YoutubeSearchIE(InfoExtractor):
             try:
                 n = int(prefix)
                 if n <= 0:
-                    self._downloader.report_error(u'invalid download number %s for query "%s"' % (n, query))
-                    return
+                    raise ExtractorError(u'Invalid download number %s for query "%s"' % (n, query))
                 elif n > self._max_youtube_results:
                     self._downloader.report_warning(u'ytsearch returns max %i results (you requested %i)' % (self._max_youtube_results, n))
                     n = self._max_youtube_results
@@ -1472,13 +1421,11 @@ class YoutubeSearchIE(InfoExtractor):
             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.report_error(u'unable to download API page: %s' % compat_str(err))
-                return
+                raise ExtractorError(u'Unable to download API page: %s' % compat_str(err))
             api_response = json.loads(data)['data']
 
             if not 'items' in api_response:
-                self._downloader.report_error(u'[youtube] No video results')
-                return
+                raise ExtractorError(u'[youtube] No video results')
 
             new_ids = list(video['id'] for video in api_response['items'])
             video_ids += new_ids
@@ -1509,8 +1456,7 @@ class GoogleSearchIE(InfoExtractor):
     def _real_extract(self, query):
         mobj = re.match(self._VALID_URL, query)
         if mobj is None:
-            self._downloader.report_error(u'invalid search query "%s"' % query)
-            return
+            raise ExtractorError(u'Invalid search query "%s"' % query)
 
         prefix, query = query.split(':')
         prefix = prefix[8:]
@@ -1525,8 +1471,7 @@ class GoogleSearchIE(InfoExtractor):
             try:
                 n = int(prefix)
                 if n <= 0:
-                    self._downloader.report_error(u'invalid download number %s for query "%s"' % (n, query))
-                    return
+                    raise ExtractorError(u'Invalid download number %s for query "%s"' % (n, query))
                 elif n > self._max_google_results:
                     self._downloader.report_warning(u'gvsearch returns max %i results (you requested %i)' % (self._max_google_results, n))
                     n = self._max_google_results
@@ -1549,8 +1494,7 @@ class GoogleSearchIE(InfoExtractor):
             try:
                 page = compat_urllib_request.urlopen(request).read()
             except (compat_urllib_error.URLError, compat_http_client.HTTPException, socket.error) as err:
-                self._downloader.report_error(u'unable to download webpage: %s' % compat_str(err))
-                return
+                raise ExtractorError(u'Unable to download webpage: %s' % compat_str(err))
 
             # Extract video identifiers
             for mobj in re.finditer(self._VIDEO_INDICATOR, page):
@@ -1590,8 +1534,7 @@ class YahooSearchIE(InfoExtractor):
     def _real_extract(self, query):
         mobj = re.match(self._VALID_URL, query)
         if mobj is None:
-            self._downloader.report_error(u'invalid search query "%s"' % query)
-            return
+            raise ExtractorError(u'Invalid search query "%s"' % query)
 
         prefix, query = query.split(':')
         prefix = prefix[8:]
@@ -1606,8 +1549,7 @@ class YahooSearchIE(InfoExtractor):
             try:
                 n = int(prefix)
                 if n <= 0:
-                    self._downloader.report_error(u'invalid download number %s for query "%s"' % (n, query))
-                    return
+                    raise ExtractorError(u'Invalid download number %s for query "%s"' % (n, query))
                 elif n > self._max_yahoo_results:
                     self._downloader.report_warning(u'yvsearch returns max %i results (you requested %i)' % (self._max_yahoo_results, n))
                     n = self._max_yahoo_results
@@ -1631,8 +1573,7 @@ class YahooSearchIE(InfoExtractor):
             try:
                 page = compat_urllib_request.urlopen(request).read()
             except (compat_urllib_error.URLError, compat_http_client.HTTPException, socket.error) as err:
-                self._downloader.report_error(u'unable to download webpage: %s' % compat_str(err))
-                return
+                raise ExtractorError(u'Unable to download webpage: %s' % compat_str(err))
 
             # Extract video identifiers
             for mobj in re.finditer(self._VIDEO_INDICATOR, page):
@@ -1684,8 +1625,7 @@ class YoutubePlaylistIE(InfoExtractor):
         # Extract playlist id
         mobj = re.match(self._VALID_URL, url, re.VERBOSE)
         if mobj is None:
-            self._downloader.report_error(u'invalid url: %s' % url)
-            return
+            raise ExtractorError(u'Invalid URL: %s' % url)
 
         # Download playlist videos from API
         playlist_id = mobj.group(1) or mobj.group(2)
@@ -1699,12 +1639,10 @@ class YoutubePlaylistIE(InfoExtractor):
             try:
                 response = json.loads(page)
             except ValueError as err:
-                self._downloader.report_error(u'Invalid JSON in API response: ' + compat_str(err))
-                return
+                raise ExtractorError(u'Invalid JSON in API response: ' + compat_str(err))
 
             if 'feed' not in response:
-                self._downloader.report_error(u'Got a malformed response from YouTube API')
-                return
+                raise ExtractorError(u'Got a malformed response from YouTube API')
             playlist_title = response['feed']['title']['$t']
             if 'entry' not in response['feed']:
                 # Number of videos is a multiple of self._MAX_RESULTS
@@ -1744,8 +1682,7 @@ class YoutubeChannelIE(InfoExtractor):
         # Extract channel id
         mobj = re.match(self._VALID_URL, url)
         if mobj is None:
-            self._downloader.report_error(u'invalid url: %s' % url)
-            return
+            raise ExtractorError(u'Invalid URL: %s' % url)
 
         # Download channel page
         channel_id = mobj.group(1)
@@ -1798,8 +1735,7 @@ class YoutubeUserIE(InfoExtractor):
         # Extract username
         mobj = re.match(self._VALID_URL, url)
         if mobj is None:
-            self._downloader.report_error(u'invalid url: %s' % url)
-            return
+            raise ExtractorError(u'Invalid URL: %s' % url)
 
         username = mobj.group(1)
 
@@ -1854,8 +1790,7 @@ class BlipTVUserIE(InfoExtractor):
         # Extract username
         mobj = re.match(self._VALID_URL, url)
         if mobj is None:
-            self._downloader.report_error(u'invalid url: %s' % url)
-            return
+            raise ExtractorError(u'Invalid URL: %s' % url)
 
         username = mobj.group(1)
 
@@ -1921,8 +1856,7 @@ class DepositFilesIE(InfoExtractor):
             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.report_error(u'Unable to retrieve file webpage: %s' % compat_str(err))
-            return
+            raise ExtractorError(u'Unable to retrieve file webpage: %s' % compat_str(err))
 
         # Search for the real file URL
         mobj = re.search(r'<form action="(http://fileshare.+?)"', webpage)
@@ -1931,10 +1865,9 @@ class DepositFilesIE(InfoExtractor):
             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.report_error(u'%s' % restriction_message)
+                raise ExtractorError(u'%s' % restriction_message)
             else:
-                self._downloader.report_error(u'unable to extract download URL from: %s' % url)
-            return
+                raise ExtractorError(u'Unable to extract download URL from: %s' % url)
 
         file_url = mobj.group(1)
         file_extension = os.path.splitext(file_url)[1][1:]
@@ -1942,8 +1875,7 @@ class DepositFilesIE(InfoExtractor):
         # Search for file title
         mobj = re.search(r'<b title="(.*?)">', webpage)
         if mobj is None:
-            self._downloader.report_error(u'unable to extract title')
-            return
+            raise ExtractorError(u'Unable to extract title')
         file_title = mobj.group(1).decode('utf-8')
 
         return [{
@@ -2015,8 +1947,7 @@ class FacebookIE(InfoExtractor):
     def _real_extract(self, url):
         mobj = re.match(self._VALID_URL, url)
         if mobj is None:
-            self._downloader.report_error(u'invalid URL: %s' % url)
-            return
+            raise ExtractorError(u'Invalid URL: %s' % url)
         video_id = mobj.group('ID')
 
         url = 'https://www.facebook.com/video/video.php?v=%s' % video_id
@@ -2069,8 +2000,7 @@ class BlipTVIE(InfoExtractor):
     def _real_extract(self, url):
         mobj = re.match(self._VALID_URL, url)
         if mobj is None:
-            self._downloader.report_error(u'invalid URL: %s' % url)
-            return
+            raise ExtractorError(u'Invalid URL: %s' % url)
 
         urlp = compat_urllib_parse_urlparse(url)
         if urlp.path.startswith('/play/'):
@@ -2116,8 +2046,7 @@ class BlipTVIE(InfoExtractor):
                 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.report_error(u'unable to read video info webpage: %s' % compat_str(err))
-                return
+                raise ExtractorError(u'Unable to read video info webpage: %s' % compat_str(err))
 
             try:
                 json_data = json.loads(json_code)
@@ -2147,8 +2076,7 @@ class BlipTVIE(InfoExtractor):
                     'user_agent': 'iTunes/10.6.1',
                 }
             except (ValueError,KeyError) as err:
-                self._downloader.report_error(u'unable to parse video information: %s' % repr(err))
-                return
+                raise ExtractorError(u'Unable to parse video information: %s' % repr(err))
 
         return [info]
 
@@ -2162,8 +2090,7 @@ class MyVideoIE(InfoExtractor):
     def _real_extract(self,url):
         mobj = re.match(self._VALID_URL, url)
         if mobj is None:
-            self._download.report_error(u'invalid URL: %s' % url)
-            return
+            raise ExtractorError(u'Invalid URL: %s' % url)
 
         video_id = mobj.group(1)
 
@@ -2175,14 +2102,12 @@ class MyVideoIE(InfoExtractor):
         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')
-            return
+            raise ExtractorError(u'Unable to extract media URL')
         video_url = mobj.group(1) + ('/%s.flv' % video_id)
 
         mobj = re.search('<title>([^<]+)</title>', webpage)
         if mobj is None:
-            self._downloader.report_error(u'unable to extract title')
-            return
+            raise ExtractorError(u'Unable to extract title')
 
         video_title = mobj.group(1)
 
@@ -2245,8 +2170,7 @@ class ComedyCentralIE(InfoExtractor):
     def _real_extract(self, url):
         mobj = re.match(self._VALID_URL, url, re.VERBOSE)
         if mobj is None:
-            self._downloader.report_error(u'invalid URL: %s' % url)
-            return
+            raise ExtractorError(u'Invalid URL: %s' % url)
 
         if mobj.group('shortname'):
             if mobj.group('shortname') in ('tds', 'thedailyshow'):
@@ -2373,8 +2297,7 @@ class EscapistIE(InfoExtractor):
     def _real_extract(self, url):
         mobj = re.match(self._VALID_URL, url)
         if mobj is None:
-            self._downloader.report_error(u'invalid URL: %s' % url)
-            return
+            raise ExtractorError(u'Invalid URL: %s' % url)
         showName = mobj.group('showname')
         videoId = mobj.group('episode')
 
@@ -2400,8 +2323,7 @@ class EscapistIE(InfoExtractor):
         try:
             config = json.loads(configJSON)
         except (ValueError,) as err:
-            self._downloader.report_error(u'Invalid JSON in configuration file: ' + compat_str(err))
-            return
+            raise ExtractorError(u'Invalid JSON in configuration file: ' + compat_str(err))
 
         playlist = config['playlist']
         videoUrl = playlist[1]['url']
@@ -2434,8 +2356,7 @@ class CollegeHumorIE(InfoExtractor):
     def _real_extract(self, url):
         mobj = re.match(self._VALID_URL, url)
         if mobj is None:
-            self._downloader.report_error(u'invalid URL: %s' % url)
-            return
+            raise ExtractorError(u'Invalid URL: %s' % url)
         video_id = mobj.group('videoid')
 
         info = {
@@ -2449,8 +2370,7 @@ class CollegeHumorIE(InfoExtractor):
         try:
             metaXml = compat_urllib_request.urlopen(xmlUrl).read()
         except (compat_urllib_error.URLError, compat_http_client.HTTPException, socket.error) as err:
-            self._downloader.report_error(u'unable to download video info XML: %s' % compat_str(err))
-            return
+            raise ExtractorError(u'Unable to download video info XML: %s' % compat_str(err))
 
         mdoc = xml.etree.ElementTree.fromstring(metaXml)
         try:
@@ -2460,16 +2380,14 @@ class CollegeHumorIE(InfoExtractor):
             info['thumbnail'] = videoNode.findall('./thumbnail')[0].text
             manifest_url = videoNode.findall('./file')[0].text
         except IndexError:
-            self._downloader.report_error(u'Invalid metadata XML file')
-            return
+            raise ExtractorError(u'Invalid metadata XML file')
 
         manifest_url += '?hdcore=2.10.3'
         self.report_manifest(video_id)
         try:
             manifestXml = compat_urllib_request.urlopen(manifest_url).read()
         except (compat_urllib_error.URLError, compat_http_client.HTTPException, socket.error) as err:
-            self._downloader.report_error(u'unable to download video info XML: %s' % compat_str(err))
-            return
+            raise ExtractorError(u'Unable to download video info XML: %s' % compat_str(err))
 
         adoc = xml.etree.ElementTree.fromstring(manifestXml)
         try:
@@ -2477,8 +2395,7 @@ class CollegeHumorIE(InfoExtractor):
             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.report_error(u'Invalid manifest file')
-            return
+            raise ExtractorError(u'Invalid manifest file')
 
         url_pr = compat_urllib_parse_urlparse(manifest_url)
         url = url_pr.scheme + '://' + url_pr.netloc + '/z' + video_id[:-2] + '/' + node_id + 'Seg1-Frag1'
@@ -2497,8 +2414,7 @@ class XVideosIE(InfoExtractor):
     def _real_extract(self, url):
         mobj = re.match(self._VALID_URL, url)
         if mobj is None:
-            self._downloader.report_error(u'invalid URL: %s' % url)
-            return
+            raise ExtractorError(u'Invalid URL: %s' % url)
         video_id = mobj.group(1)
 
         webpage = self._download_webpage(url, video_id)
@@ -2509,24 +2425,21 @@ class XVideosIE(InfoExtractor):
         # Extract video URL
         mobj = re.search(r'flv_url=(.+?)&', webpage)
         if mobj is None:
-            self._downloader.report_error(u'unable to extract video url')
-            return
+            raise ExtractorError(u'Unable to extract video url')
         video_url = compat_urllib_parse.unquote(mobj.group(1))
 
 
         # Extract title
         mobj = re.search(r'<title>(.*?)\s+-\s+XVID', webpage)
         if mobj is None:
-            self._downloader.report_error(u'unable to extract video title')
-            return
+            raise ExtractorError(u'Unable to extract video title')
         video_title = mobj.group(1)
 
 
         # 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.report_error(u'unable to extract video thumbnail')
-            return
+            raise ExtractorError(u'Unable to extract video thumbnail')
         video_thumbnail = mobj.group(0)
 
         info = {
@@ -2562,8 +2475,7 @@ class SoundcloudIE(InfoExtractor):
     def _real_extract(self, url):
         mobj = re.match(self._VALID_URL, url)
         if mobj is None:
-            self._downloader.report_error(u'invalid URL: %s' % url)
-            return
+            raise ExtractorError(u'Invalid URL: %s' % url)
 
         # extract uploader (which is in the url)
         uploader = mobj.group(1)
@@ -2620,8 +2532,7 @@ class SoundcloudSetIE(InfoExtractor):
     def _real_extract(self, url):
         mobj = re.match(self._VALID_URL, url)
         if mobj is None:
-            self._downloader.report_error(u'invalid URL: %s' % url)
-            return
+            raise ExtractorError(u'Invalid URL: %s' % url)
 
         # extract uploader (which is in the url)
         uploader = mobj.group(1)
@@ -2673,8 +2584,7 @@ class InfoQIE(InfoExtractor):
     def _real_extract(self, url):
         mobj = re.match(self._VALID_URL, url)
         if mobj is None:
-            self._downloader.report_error(u'invalid URL: %s' % url)
-            return
+            raise ExtractorError(u'Invalid URL: %s' % url)
 
         webpage = self._download_webpage(url, video_id=url)
         self.report_extraction(url)
@@ -2682,16 +2592,14 @@ class InfoQIE(InfoExtractor):
         # Extract video URL
         mobj = re.search(r"jsclassref ?= ?'([^']*)'", webpage)
         if mobj is None:
-            self._downloader.report_error(u'unable to extract video url')
-            return
+            raise ExtractorError(u'Unable to extract video url')
         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
 
         # Extract title
         mobj = re.search(r'contentTitle = "(.*?)";', webpage)
         if mobj is None:
-            self._downloader.report_error(u'unable to extract video title')
-            return
+            raise ExtractorError(u'Unable to extract video title')
         video_title = mobj.group(1)
 
         # Extract description
@@ -2766,8 +2674,7 @@ class MixcloudIE(InfoExtractor):
     def _real_extract(self, url):
         mobj = re.match(self._VALID_URL, url)
         if mobj is None:
-            self._downloader.report_error(u'invalid URL: %s' % url)
-            return
+            raise ExtractorError(u'Invalid URL: %s' % url)
         # extract uploader & filename from url
         uploader = mobj.group(1).decode('utf-8')
         file_id = uploader + "-" + mobj.group(2).decode('utf-8')
@@ -2780,8 +2687,7 @@ class MixcloudIE(InfoExtractor):
             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.report_error(u'Unable to retrieve file: %s' % compat_str(err))
-            return
+            raise ExtractorError(u'Unable to retrieve file: %s' % compat_str(err))
 
         # parse JSON
         json_data = json.loads(jsonData)
@@ -2804,8 +2710,7 @@ class MixcloudIE(InfoExtractor):
                     break # got it!
         else:
             if req_format not in formats:
-                self._downloader.report_error(u'format is not available')
-                return
+                raise ExtractorError(u'Format is not available')
 
             url_list = self.get_urls(formats, req_format)
             file_url = self.check_urls(url_list)
@@ -2850,15 +2755,13 @@ class StanfordOpenClassroomIE(InfoExtractor):
             try:
                 metaXml = compat_urllib_request.urlopen(xmlUrl).read()
             except (compat_urllib_error.URLError, compat_http_client.HTTPException, socket.error) as err:
-                self._downloader.report_error(u'unable to download video info XML: %s' % compat_str(err))
-                return
+                raise ExtractorError(u'Unable to download video info XML: %s' % compat_str(err))
             mdoc = xml.etree.ElementTree.fromstring(metaXml)
             try:
                 info['title'] = mdoc.findall('./title')[0].text
                 info['url'] = baseUrl + mdoc.findall('./videoFile')[0].text
             except IndexError:
-                self._downloader.report_error(u'Invalid metadata XML file')
-                return
+                raise ExtractorError(u'Invalid metadata XML file')
             info['ext'] = info['url'].rpartition('.')[2]
             return [info]
         elif mobj.group('course'): # A course page
@@ -2909,8 +2812,7 @@ class StanfordOpenClassroomIE(InfoExtractor):
             try:
                 rootpage = compat_urllib_request.urlopen(rootURL).read()
             except (compat_urllib_error.URLError, compat_http_client.HTTPException, socket.error) as err:
-                self._downloader.report_error(u'unable to download course info page: ' + compat_str(err))
-                return
+                raise ExtractorError(u'Unable to download course info page: ' + compat_str(err))
 
             info['title'] = info['id']
 
@@ -2937,8 +2839,7 @@ class MTVIE(InfoExtractor):
     def _real_extract(self, url):
         mobj = re.match(self._VALID_URL, url)
         if mobj is None:
-            self._downloader.report_error(u'invalid URL: %s' % url)
-            return
+            raise ExtractorError(u'Invalid URL: %s' % url)
         if not mobj.group('proto'):
             url = 'http://' + url
         video_id = mobj.group('videoid')
@@ -2947,26 +2848,22 @@ class MTVIE(InfoExtractor):
 
         mobj = re.search(r'<meta name="mtv_vt" content="([^"]+)"/>', webpage)
         if mobj is None:
-            self._downloader.report_error(u'unable to extract song name')
-            return
+            raise ExtractorError(u'Unable to extract song name')
         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.report_error(u'unable to extract performer')
-            return
+            raise ExtractorError(u'Unable to extract performer')
         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.report_error(u'unable to mtvn_uri')
-            return
+            raise ExtractorError(u'Unable to mtvn_uri')
         mtvn_uri = mobj.group(1)
 
         mobj = re.search(r'MTVN.Player.defaultPlaylistId = ([0-9]+);', webpage)
         if mobj is None:
-            self._downloader.report_error(u'unable to extract content id')
-            return
+            raise ExtractorError(u'Unable to extract content id')
         content_id = mobj.group(1)
 
         videogen_url = 'http://www.mtv.com/player/includes/mediaGen.jhtml?uri=' + mtvn_uri + '&id=' + content_id + '&vid=' + video_id + '&ref=www.mtvn.com&viewUri=' + mtvn_uri
@@ -2975,8 +2872,7 @@ class MTVIE(InfoExtractor):
         try:
             metadataXml = compat_urllib_request.urlopen(request).read()
         except (compat_urllib_error.URLError, compat_http_client.HTTPException, socket.error) as err:
-            self._downloader.report_error(u'unable to download video metadata: %s' % compat_str(err))
-            return
+            raise ExtractorError(u'Unable to download video metadata: %s' % compat_str(err))
 
         mdoc = xml.etree.ElementTree.fromstring(metadataXml)
         renditions = mdoc.findall('.//rendition')
@@ -2989,8 +2885,7 @@ class MTVIE(InfoExtractor):
             format = ext + '-' + rendition.attrib['width'] + 'x' + rendition.attrib['height'] + '_' + rendition.attrib['bitrate']
             video_url = rendition.find('./src').text
         except KeyError:
-            self._downloader.report_error('Invalid rendition field.')
-            return
+            raise ExtractorError('Invalid rendition field.')
 
         info = {
             'id': video_id,
@@ -3039,8 +2934,7 @@ class YoukuIE(InfoExtractor):
     def _real_extract(self, url):
         mobj = re.match(self._VALID_URL, url)
         if mobj is None:
-            self._downloader.report_error(u'invalid URL: %s' % url)
-            return
+            raise ExtractorError(u'Invalid URL: %s' % url)
         video_id = mobj.group('ID')
 
         info_url = 'http://v.youku.com/player/getPlayList/VideoIDS/' + video_id
@@ -3074,8 +2968,7 @@ class YoukuIE(InfoExtractor):
             fileid = config['data'][0]['streamfileids'][format]
             keys = [s['k'] for s in config['data'][0]['segs'][format]]
         except (UnicodeDecodeError, ValueError, KeyError):
-            self._downloader.report_error(u'unable to extract info section')
-            return
+            raise ExtractorError(u'Unable to extract info section')
 
         files_info=[]
         sid = self._gen_sid()
@@ -3113,8 +3006,7 @@ class XNXXIE(InfoExtractor):
     def _real_extract(self, url):
         mobj = re.match(self._VALID_URL, url)
         if mobj is None:
-            self._downloader.report_error(u'invalid URL: %s' % url)
-            return
+            raise ExtractorError(u'Invalid URL: %s' % url)
         video_id = mobj.group(1)
 
         # Get webpage content
@@ -3122,20 +3014,17 @@ class XNXXIE(InfoExtractor):
 
         result = re.search(self.VIDEO_URL_RE, webpage)
         if result is None:
-            self._downloader.report_error(u'unable to extract video url')
-            return
+            raise ExtractorError(u'Unable to extract video url')
         video_url = compat_urllib_parse.unquote(result.group(1))
 
         result = re.search(self.VIDEO_TITLE_RE, webpage)
         if result is None:
-            self._downloader.report_error(u'unable to extract video title')
-            return
+            raise ExtractorError(u'Unable to extract video title')
         video_title = result.group(1)
 
         result = re.search(self.VIDEO_THUMB_RE, webpage)
         if result is None:
-            self._downloader.report_error(u'unable to extract video thumbnail')
-            return
+            raise ExtractorError(u'Unable to extract video thumbnail')
         video_thumbnail = result.group(1)
 
         return [{
@@ -3180,8 +3069,7 @@ class GooglePlusIE(InfoExtractor):
         # Extract id from URL
         mobj = re.match(self._VALID_URL, url)
         if mobj is None:
-            self._downloader.report_error(u'Invalid URL: %s' % url)
-            return
+            raise ExtractorError(u'Invalid URL: %s' % url)
 
         post_url = mobj.group(0)
         video_id = mobj.group(1)
@@ -3268,8 +3156,7 @@ class NBAIE(InfoExtractor):
     def _real_extract(self, url):
         mobj = re.match(self._VALID_URL, url)
         if mobj is None:
-            self._downloader.report_error(u'invalid URL: %s' % url)
-            return
+            raise ExtractorError(u'Invalid URL: %s' % url)
 
         video_id = mobj.group(1)
         if video_id.endswith('/index.html'):
@@ -3641,8 +3528,7 @@ class YouPornIE(InfoExtractor):
     def _real_extract(self, url):
         mobj = re.match(self._VALID_URL, url)
         if mobj is None:
-            self._downloader.report_error(u'invalid URL: %s' % url)
-            return
+            raise ExtractorError(u'Invalid URL: %s' % url)
 
         video_id = mobj.group('videoid')
 
@@ -3733,8 +3619,7 @@ class YouPornIE(InfoExtractor):
         else:
             format = self._specific( req_format, formats )
             if result is None:
-                self._downloader.report_error(u'requested format not available')
-                return
+                raise ExtractorError(u'Requested format not available')
             return [format]
 
 
@@ -3746,8 +3631,7 @@ class PornotubeIE(InfoExtractor):
     def _real_extract(self, url):
         mobj = re.match(self._VALID_URL, url)
         if mobj is None:
-            self._downloader.report_error(u'invalid URL: %s' % url)
-            return
+            raise ExtractorError(u'Invalid URL: %s' % url)
 
         video_id = mobj.group('videoid')
         video_title = mobj.group('title')
@@ -3759,16 +3643,14 @@ class PornotubeIE(InfoExtractor):
         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.report_error(u'unable to extract video url')
-            return
+            raise ExtractorError(u'Unable to extract video url')
         video_url = compat_urllib_parse.unquote(result.group('url'))
 
         #Get the uploaded date
         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.report_error(u'unable to extract video title')
-            return
+            raise ExtractorError(u'Unable to extract video title')
         upload_date = unified_strdate(result.group('date'))
 
         info = {'id': video_id,
@@ -3788,8 +3670,7 @@ class YouJizzIE(InfoExtractor):
     def _real_extract(self, url):
         mobj = re.match(self._VALID_URL, url)
         if mobj is None:
-            self._downloader.report_error(u'invalid URL: %s' % url)
-            return
+            raise ExtractorError(u'Invalid URL: %s' % url)
 
         video_id = mobj.group('videoid')
 
@@ -3995,14 +3876,12 @@ class MySpassIE(InfoExtractor):
         # extract values from metadata
         url_flv_el = metadata.find('url_flv')
         if url_flv_el is None:
-            self._downloader.report_error(u'unable to extract download url')
-            return
+            raise ExtractorError(u'Unable to extract download url')
         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.report_error(u'unable to extract title')
-            return
+            raise ExtractorError(u'Unable to extract title')
         title = title_el.text
         format_id_el = metadata.find('format_id')
         if format_id_el is None:
@@ -4071,8 +3950,7 @@ class LiveLeakIE(InfoExtractor):
     def _real_extract(self, url):
         mobj = re.match(self._VALID_URL, url)
         if mobj is None:
-            self._downloader.report_error(u'invalid URL: %s' % url)
-            return
+            raise ExtractorError(u'Invalid URL: %s' % url)
 
         video_id = mobj.group('video_id')
 
@@ -4080,8 +3958,7 @@ class LiveLeakIE(InfoExtractor):
 
         m = re.search(r'file: "(.*?)",', webpage)
         if not m:
-            self._downloader.report_error(u'unable to find video url')
-            return
+            raise ExtractorError(u'Unable to find video url')
         video_url = m.group(1)
 
         m = re.search(r'<meta property="og:title" content="(?P<title>.*?)"', webpage)
@@ -4133,8 +4010,7 @@ class ARDIE(InfoExtractor):
         streams = [m.groupdict() for m in re.finditer(self._MEDIA_STREAM, html)]
         if not streams:
             assert '"fsk"' in html
-            self._downloader.report_error(u'this video is only available after 8:00 pm')
-            return
+            raise ExtractorError(u'This video is only available after 8:00 pm')
 
         # choose default media type and highest quality for now
         stream = max([s for s in streams if int(s["media_type"]) == 0],
@@ -4196,8 +4072,8 @@ class BandcampIE(InfoExtractor):
         # We get the link to the free download page
         m_download = re.search(r'freeDownloadPage: "(.*?)"', webpage)
         if m_download is None:
-            self._downloader.report_error('No free songs founded')
-            return
+            raise ExtractorError(u'No free songs founded')
+
         download_link = m_download.group(1)
         id = re.search(r'var TralbumData = {(.*?)id: (?P<id>\d*?)$', 
                        webpage, re.MULTILINE|re.DOTALL).group('id')

From f8602d32429bf8a7dace35bcab91ba6be092cfde Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Jaime=20Marqui=CC=81nez=20Ferra=CC=81ndiz?=
 <jaime.marquinez.ferrandiz@gmail.com>
Date: Sun, 5 May 2013 11:48:47 +0200
Subject: [PATCH 178/221] ArteTvIE: Fix format of upload date

---
 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 0c544d747..8c3751d0a 100755
--- a/youtube_dl/InfoExtractors.py
+++ b/youtube_dl/InfoExtractors.py
@@ -1218,7 +1218,7 @@ class ArteTvIE(InfoExtractor):
             'id':           info.get('id'),
             'url':          compat_urllib_parse.unquote(info.get('url')),
             'uploader':     u'arte.tv',
-            'upload_date':  info.get('date'),
+            'upload_date':  unified_strdate(info.get('date')),
             'title':        info.get('title').decode('utf-8'),
             'ext':          u'mp4',
             'format':       u'NA',

From d96680f58d918c99baab952338f547c42266bdf3 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Jaime=20Marqui=CC=81nez=20Ferra=CC=81ndiz?=
 <jaime.marquinez.ferrandiz@gmail.com>
Date: Sun, 5 May 2013 13:07:00 +0200
Subject: [PATCH 179/221] PhotobucketIE: accept new format of urls and add a
 test

---
 test/tests.json              |  9 +++++++++
 youtube_dl/InfoExtractors.py | 31 ++++++++++++++++++++++---------
 2 files changed, 31 insertions(+), 9 deletions(-)

diff --git a/test/tests.json b/test/tests.json
index b4d511dd8..66e93a33a 100644
--- a/test/tests.json
+++ b/test/tests.json
@@ -411,5 +411,14 @@
     "info_dict":{
       "title":"Sucked on a toilet"
     }
+  },
+  {
+    "name": "Photobucket",
+    "url": "http://media.photobucket.com/user/rachaneronas/media/TiredofLinkBuildingTryBacklinkMyDomaincom_zpsc0c3b9fa.mp4.html?filters[term]=search&filters[primary]=videos&filters[secondary]=images&sort=1&o=0",
+    "file": "zpsc0c3b9fa.mp4",
+    "md5": "7dabfb92b0a31f6c16cebc0f8e60ff99",
+    "info_dict":{
+      "title":"Tired of Link Building? Try BacklinkMyDomain.com!"
+    }
   }
 ]
diff --git a/youtube_dl/InfoExtractors.py b/youtube_dl/InfoExtractors.py
index 8c3751d0a..a98d403b3 100755
--- a/youtube_dl/InfoExtractors.py
+++ b/youtube_dl/InfoExtractors.py
@@ -848,7 +848,10 @@ class DailymotionIE(InfoExtractor):
 class PhotobucketIE(InfoExtractor):
     """Information extractor for photobucket.com."""
 
-    _VALID_URL = r'(?:http://)?(?:[a-z0-9]+\.)?photobucket\.com/.*[\?\&]current=(.*\.flv)'
+    # TODO: the original _VALID_URL was:
+    # r'(?:http://)?(?:[a-z0-9]+\.)?photobucket\.com/.*[\?\&]current=(.*\.flv)'
+    # Check if it's necessary to keep the old extracion process
+    _VALID_URL = r'(?:http://)?(?:[a-z0-9]+\.)?photobucket\.com/.*(([\?\&]current=)|_)(?P<id>.*)\.(?P<ext>(flv)|(mp4))'
     IE_NAME = u'photobucket'
 
     def _real_extract(self, url):
@@ -857,20 +860,30 @@ class PhotobucketIE(InfoExtractor):
         if mobj is None:
             raise ExtractorError(u'Invalid URL: %s' % url)
 
-        video_id = mobj.group(1)
+        video_id = mobj.group('id')
 
-        video_extension = 'flv'
+        video_extension = mobj.group('ext')
 
         # Retrieve video webpage to extract further information
-        request = compat_urllib_request.Request(url)
-        try:
-            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:
-            raise ExtractorError(u'Unable to retrieve video webpage: %s' % compat_str(err))
+        webpage = self._download_webpage(url, video_id)
 
         # Extract URL, uploader, and title from webpage
         self.report_extraction(video_id)
+        # We try first by looking the javascript code:
+        mobj = re.search(r'Pb\.Data\.Shared\.put\(Pb\.Data\.Shared\.MEDIA, (?P<json>.*?)\);', webpage)
+        if mobj is not None:
+            info = json.loads(mobj.group('json'))
+            return [{
+                'id':       video_id,
+                'url':      info[u'downloadUrl'],
+                'uploader': info[u'username'],
+                'upload_date':  datetime.date.fromtimestamp(info[u'creationDate']).strftime('%Y%m%d'),
+                'title':    info[u'title'],
+                'ext':      video_extension,
+                'thumbnail': info[u'thumbUrl'],
+            }]
+
+        # We try looking in other parts of the webpage
         mobj = re.search(r'<link rel="video_src" href=".*\?file=([^"]+)" />', webpage)
         if mobj is None:
             raise ExtractorError(u'Unable to extract media URL')

From 486f0c947675eebb129414f8f46010206c9245b7 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Jaime=20Marqui=CC=81nez=20Ferra=CC=81ndiz?=
 <jaime.marquinez.ferrandiz@gmail.com>
Date: Sun, 5 May 2013 13:59:25 +0200
Subject: [PATCH 180/221] More callbacks changed to raise ExtractorError

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

diff --git a/youtube_dl/InfoExtractors.py b/youtube_dl/InfoExtractors.py
index a98d403b3..0f1252113 100755
--- a/youtube_dl/InfoExtractors.py
+++ b/youtube_dl/InfoExtractors.py
@@ -3125,7 +3125,7 @@ class GooglePlusIE(InfoExtractor):
         pattern = '"(https\://plus\.google\.com/photos/.*?)",,"image/jpeg","video"\]'
         mobj = re.search(pattern, webpage)
         if mobj is None:
-            self._downloader.report_error(u'unable to extract video page URL')
+            raise ExtractorError(u'Unable to extract video page URL')
 
         video_page = mobj.group(1)
         webpage = self._download_webpage(video_page, video_id, u'Downloading video page')
@@ -3137,7 +3137,7 @@ class GooglePlusIE(InfoExtractor):
         pattern = '\d+,\d+,(\d+),"(http\://redirector\.googlevideo\.com.*?)"'
         mobj = re.findall(pattern, webpage)
         if len(mobj) == 0:
-            self._downloader.report_error(u'unable to extract video links')
+            raise ExtractorError(u'Unable to extract video links')
 
         # Sort in resolution
         links = sorted(mobj)
@@ -3343,14 +3343,14 @@ class FunnyOrDieIE(InfoExtractor):
 
         m = re.search(r'<video[^>]*>\s*<source[^>]*>\s*<source src="(?P<url>[^"]+)"', webpage, re.DOTALL)
         if not m:
-            self._downloader.report_error(u'unable to find video information')
+            raise ExtractorError(u'Unable to find video information')
         video_url = unescapeHTML(m.group('url'))
 
         m = re.search(r"<h1 class='player_page_h1'.*?>(?P<title>.*?)</h1>", webpage, flags=re.DOTALL)
         if not m:
             m = re.search(r'<title>(?P<title>[^<]+?)</title>', webpage)
             if not m:
-                self._downloader.report_error(u'Cannot find video title')
+                raise ExtractorError(u'Cannot find video title')
         title = clean_html(m.group('title'))
 
         m = re.search(r'<meta property="og:description" content="(?P<desc>.*?)"', webpage)
@@ -3402,7 +3402,7 @@ class SteamIE(InfoExtractor):
             video_url = vid.group('videoURL')
             video_thumb = thumb.group('thumbnail')
             if not video_url:
-                self._downloader.report_error(u'Cannot find video url for %s' % video_id)
+                raise ExtractorError(u'Cannot find video url for %s' % video_id)
             info = {
                 'id':video_id,
                 'url':video_url,
@@ -3976,7 +3976,7 @@ class LiveLeakIE(InfoExtractor):
 
         m = re.search(r'<meta property="og:title" content="(?P<title>.*?)"', webpage)
         if not m:
-            self._downloader.report_error(u'Cannot find video title')
+            raise ExtractorError(u'Cannot find video title')
         title = unescapeHTML(m.group('title')).replace('LiveLeak.com -', '').strip()
 
         m = re.search(r'<meta property="og:description" content="(?P<desc>.*?)"', webpage)

From b338f1b15400d2aadde0588c13b691bd4444b1f0 Mon Sep 17 00:00:00 2001
From: Philipp Hagemeister <phihag@phihag.de>
Date: Sun, 5 May 2013 20:49:42 +0200
Subject: [PATCH 181/221] FileDownloader: Simplify and document

---
 youtube_dl/FileDownloader.py | 103 +++++++++++++++++------------------
 1 file changed, 51 insertions(+), 52 deletions(-)

diff --git a/youtube_dl/FileDownloader.py b/youtube_dl/FileDownloader.py
index 574863e7c..9b06633cc 100644
--- a/youtube_dl/FileDownloader.py
+++ b/youtube_dl/FileDownloader.py
@@ -435,47 +435,40 @@ class FileDownloader(object):
                 return u'[download] %s upload date is not in range %s' % (date_from_str(date).isoformat(), dateRange)
         return None
         
-    def extract_info(self, url, download = True, ie_name = None):
+    def extract_info(self, url, download=True, ie_key=None):
         '''
         Returns a list with a dictionary for each video we find.
         If 'download', also downloads the videos.
          '''
-        suitable_found = False
         
-        #We copy the original list
-        ies = list(self._ies)
-
-        if ie_name is not None:
-            #We put in the first place the given info extractor
-            first_ie = get_info_extractor(ie_name)()
-            first_ie.set_downloader(self)
-            ies.insert(0, first_ie)
+        if ie_key:
+            ie = get_info_extractor(ie_key)()
+            ie.set_downloader(self)
+            ies = [ie]
+        else:
+            ies = self._ies
 
         for ie in ies:
-            # Go to next InfoExtractor if not suitable
             if not ie.suitable(url):
                 continue
 
-            # Warn if the _WORKING attribute is False
             if not ie.working():
-                self.report_warning(u'the program functionality for this site has been marked as broken, '
-                               u'and will probably not work. If you want to go on, use the -i option.')
+                self.report_warning(u'The program functionality for this site has been marked as broken, '
+                                    u'and will probably not work.')
 
-            # Suitable InfoExtractor found
-            suitable_found = True
-
-            # Extract information from URL and process it
             try:
-                ie_results = ie.extract(url)
-                if ie_results is None: # Finished already (backwards compatibility; listformats and friends should be moved here)
+                ie_result = ie.extract(url)
+                if ie_result is None: # Finished already (backwards compatibility; listformats and friends should be moved here)
                     break
-                results = []
-                for ie_result in ie_results:
-                    if not 'extractor' in ie_result:
-                        #The extractor has already been set somewhere else
-                        ie_result['extractor'] = ie.IE_NAME
-                    results.append(self.process_ie_result(ie_result, download))
-                return results
+                if isinstance(ie_result, list):
+                    # Backwards compatibility: old IE result format
+                    ie_result = {
+                        '_type': 'compat_list',
+                        'entries': ie_result,
+                    }
+                if 'extractor' not in ie_result:
+                    ie_result['extractor'] = ie.IE_NAME
+                return self.process_ie_result(ie_result, download=download)
             except ExtractorError as de: # An error we somewhat expected
                 self.report_error(compat_str(de), de.format_traceback())
                 break
@@ -485,33 +478,31 @@ class FileDownloader(object):
                     break
                 else:
                     raise
-        if not suitable_found:
-                self.report_error(u'no suitable InfoExtractor: %s' % url)
+        else:
+            self.report_error(u'no suitable InfoExtractor: %s' % url)
         
-    def process_ie_result(self, ie_result, download = True):
+    def process_ie_result(self, ie_result, download=True):
         """
-        Take the result of the ie and return a list of videos.
-        For url elements it will search the suitable ie and get the videos
-        For playlist elements it will process each of the elements of the 'entries' key
-        
+        Take the result of the ie(may be modified) and resolve all unresolved
+        references (URLs, playlist items).
+
         It will also download the videos if 'download'.
+        Returns the resolved ie_result.
         """
-        result_type = ie_result.get('_type', 'video') #If not given we suppose it's a video, support the dafault old system
+
+        result_type = ie_result.get('_type', 'video') # If not given we suppose it's a video, support the default old system
         if result_type == 'video':
             if 'playlist' not in ie_result:
-                #It isn't part of a playlist
+                # It isn't part of a playlist
                 ie_result['playlist'] = None
                 ie_result['playlist_index'] = None
             if download:
-                #Do the download:
                 self.process_info(ie_result)
             return ie_result
         elif result_type == 'url':
-            #We get the video pointed by the url
-            result = self.extract_info(ie_result['url'], download, ie_name = ie_result['ie_key'])[0]
-            return result
+            return self.extract_info(ie_result['url'], download, ie_key=ie_result.get('ie_key'))
         elif result_type == 'playlist':
-            #We process each entry in the playlist
+            # We process each entry in the playlist
             playlist = ie_result.get('title', None) or ie_result.get('id', None)
             self.to_screen(u'[download] Downloading playlist: %s'  % playlist)
 
@@ -533,23 +524,31 @@ class FileDownloader(object):
 
             for i,entry in enumerate(entries,1):
                 self.to_screen(u'[download] Downloading video #%s of %s' %(i, n_entries))
-                entry_result = self.process_ie_result(entry, False)
-                entry_result['playlist'] = playlist
-                entry_result['playlist_index'] = i + playliststart
-                #We must do the download here to correctly set the 'playlist' key
-                if download:
-                    self.process_info(entry_result)
+                entry['playlist'] = playlist
+                entry['playlist_index'] = i + playliststart
+                entry_result = self.process_ie_result(entry, download=download)
                 playlist_results.append(entry_result)
-            result = ie_result.copy()
-            result['entries'] = playlist_results
-            return result
+            ie_result['entries'] = playlist_results
+            return ie_result
+        elif result_type == 'compat_list':
+            def _fixup(r):
+                r.setdefault('extractor', ie_result['extractor'])
+                return r
+            ie_result['entries'] = [
+                self.process_ie_result(_fixup(r), download=download)
+                for r in ie_result['entries']
+            ]
+            return ie_result
+        else:
+            raise Exception('Invalid result type: %s' % result_type)
 
     def process_info(self, info_dict):
-        """Process a single dictionary returned by an InfoExtractor."""
+        """Process a single resolved IE result."""
 
+        assert info_dict.get('_type', 'video') == 'video'
         #We increment the download the download count here to match the previous behaviour.
         self.increment_downloads()
-        
+
         info_dict['fulltitle'] = info_dict['title']
         if len(info_dict['title']) > 200:
             info_dict['title'] = info_dict['title'][:197] + u'...'

From 94ca71b7cce1516f0aaad43083fbb24ebbc91182 Mon Sep 17 00:00:00 2001
From: Philipp Hagemeister <phihag@phihag.de>
Date: Sun, 5 May 2013 20:49:57 +0200
Subject: [PATCH 182/221] Fix GoogleSearchIE (Fixes #822)

---
 youtube_dl/InfoExtractors.py | 87 ++++++++++++------------------------
 1 file changed, 29 insertions(+), 58 deletions(-)

diff --git a/youtube_dl/InfoExtractors.py b/youtube_dl/InfoExtractors.py
index 36343882b..54a37f266 100755
--- a/youtube_dl/InfoExtractors.py
+++ b/youtube_dl/InfoExtractors.py
@@ -1494,82 +1494,53 @@ class YoutubeSearchIE(InfoExtractor):
 
 class GoogleSearchIE(InfoExtractor):
     """Information Extractor for Google Video search queries."""
-    _VALID_URL = r'gvsearch(\d+|all)?:[\s\S]+'
-    _TEMPLATE_URL = 'http://video.google.com/videosearch?q=%s+site:video.google.com&start=%s&hl=en'
-    _VIDEO_INDICATOR = r'<a href="http://video\.google\.com/videoplay\?docid=([^"\&]+)'
+    _VALID_URL = r'gvsearch(?P<prefix>|\d+|all):(?P<query>[\s\S]+)'
     _MORE_PAGES_INDICATOR = r'class="pn" id="pnnext"'
     _max_google_results = 1000
     IE_NAME = u'video.google:search'
 
-    def report_download_page(self, query, pagenum):
-        """Report attempt to download playlist page with given number."""
-        query = query.decode(preferredencoding())
-        self.to_screen(u'query "%s": Downloading page %s' % (query, pagenum))
-
     def _real_extract(self, query):
         mobj = re.match(self._VALID_URL, query)
-        if mobj is None:
-            self._downloader.report_error(u'invalid search query "%s"' % query)
-            return
 
-        prefix, query = query.split(':')
-        prefix = prefix[8:]
-        query = query.encode('utf-8')
+        prefix = mobj.group('prefix')
+        query = mobj.group('query')
         if prefix == '':
-            self._download_n_results(query, 1)
-            return
+            return self._download_n_results(query, 1)
         elif prefix == 'all':
-            self._download_n_results(query, self._max_google_results)
-            return
+            return self._download_n_results(query, self._max_google_results)
         else:
-            try:
-                n = int(prefix)
-                if n <= 0:
-                    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))
-                    n = self._max_google_results
-                self._download_n_results(query, n)
-                return
-            except ValueError: # parsing prefix as integer fails
-                self._download_n_results(query, 1)
-                return
+            n = int(prefix)
+            if n <= 0:
+                raise ExtractorError(u'invalid download number %s for query "%s"' % (n, query))
+            elif n > self._max_google_results:
+                self._downloader.report_warning(u'gvsearch returns max %i results (you requested %i)' % (self._max_google_results, n))
+                n = self._max_google_results
+            return self._download_n_results(query, n)
 
     def _download_n_results(self, query, n):
         """Downloads a specified number of results for a query"""
 
-        video_ids = []
-        pagenum = 0
+        res = {
+            '_type': 'playlist',
+            'id': query,
+            'entries': []
+        }
 
-        while True:
-            self.report_download_page(query, pagenum)
-            result_url = self._TEMPLATE_URL % (compat_urllib_parse.quote_plus(query), pagenum*10)
-            request = compat_urllib_request.Request(result_url)
-            try:
-                page = compat_urllib_request.urlopen(request).read()
-            except (compat_urllib_error.URLError, compat_http_client.HTTPException, socket.error) as err:
-                self._downloader.report_error(u'unable to download webpage: %s' % compat_str(err))
-                return
+        for pagenum in itertools.count(1):
+            result_url = u'http://video.google.com/videosearch?q=%s&start=%s&hl=en' % (compat_urllib_parse.quote_plus(query), pagenum*10)
+            webpage = self._download_webpage(result_url, u'gvsearch:' + query,
+                                             note='Downloading result page ' + str(pagenum))
 
             # Extract video identifiers
-            for mobj in re.finditer(self._VIDEO_INDICATOR, page):
-                video_id = mobj.group(1)
-                if video_id not in video_ids:
-                    video_ids.append(video_id)
-                    if len(video_ids) == n:
-                        # Specified n videos reached
-                        for id in video_ids:
-                            self._downloader.download(['http://video.google.com/videoplay?docid=%s' % id])
-                        return
-
-            if re.search(self._MORE_PAGES_INDICATOR, page) is None:
-                for id in video_ids:
-                    self._downloader.download(['http://video.google.com/videoplay?docid=%s' % id])
-                return
-
-            pagenum = pagenum + 1
+            for mobj in re.finditer(r'<h3 class="r"><a href="([^"]+)"', webpage):
+                e = {
+                    '_type': 'url',
+                    'url': mobj.group(1)
+                }
+                res['entries'].append(e)
 
+            if (pagenum * 10 > n) or not re.search(self._MORE_PAGES_INDICATOR, webpage):
+                return res
 
 class YahooSearchIE(InfoExtractor):
     """Information Extractor for Yahoo! Video search queries."""

From 7f5bd09baf2118510c52115829180888ca7111ee Mon Sep 17 00:00:00 2001
From: julien <julien@julien-ThinkPad-X220.(none)>
Date: Sun, 5 May 2013 16:07:19 +0200
Subject: [PATCH 183/221] Add support to www.ina.fr

---
 test/tests.json              |  9 +++++++++
 youtube_dl/InfoExtractors.py | 37 ++++++++++++++++++++++++++++++++++++
 2 files changed, 46 insertions(+)

diff --git a/test/tests.json b/test/tests.json
index 66e93a33a..a342ce4b9 100644
--- a/test/tests.json
+++ b/test/tests.json
@@ -420,5 +420,14 @@
     "info_dict":{
       "title":"Tired of Link Building? Try BacklinkMyDomain.com!"
     }
+  },
+  {
+    "name": "Ina",
+    "url": "www.ina.fr/video/I12055569/francois-hollande-je-crois-que-c-est-clair-video.html",
+    "file": "I12055569.mp4",
+    "md5": "a667021bf2b41f8dc6049479d9bb38a3",
+    "info_dict":{
+      "title":"François Hollande \"Je crois que c'est clair\""
+    }
   }
 ]
diff --git a/youtube_dl/InfoExtractors.py b/youtube_dl/InfoExtractors.py
index f4e7065d1..0f506e618 100755
--- a/youtube_dl/InfoExtractors.py
+++ b/youtube_dl/InfoExtractors.py
@@ -4124,7 +4124,43 @@ class RedTubeIE(InfoExtractor):
             'ext':      video_extension,
             'title':    video_title,
         }]
+        
+class InaIE(InfoExtractor):
+    """Information Extractor for Ina.fr"""
+    _VALID_URL = r'(?:http://)?(?:www.)?ina\.fr/video/(?P<id>I[0-9]+)/.*'
+    IE_NAME = u'Ina'
+    def _real_extract(self,url):
+        mobj = re.match(self._VALID_URL, url)
+        if mobj is None:
+            raise ExtractorError(u'Invalid URL: %s' % url)
+        video_id = mobj.group('id')
+        self.to_screen(u'video id : %s' % video_id)
+        mrss_url='http://player.ina.fr/notices/%s.mrss'%video_id
+        self.to_screen(u'mrss url : %s' % mrss_url)
+        video_extension = 'mp4'        
+        webpage = self._download_webpage(mrss_url,video_id)
+        self.report_extraction(video_id)
+        reg1=r'<media:player url="(?P<mp4url>http://mp4.ina.fr/[^"]+\.mp4)'
+        mobj = re.search(reg1,webpage)
 
+        if mobj is None:
+            raise ExtractorError(u'Unable to extract media URL')
+
+        video_url = mobj.group(1)
+        reg2=r'<title><!\[CDATA\[(?P<titre>.*?)]]></title>'
+        mobj = re.search(reg2,webpage)
+        if mobj is None:
+            raise ExtractorError(u'Unable to extract title')
+        video_title = mobj.group(1)
+        
+        self.to_screen(u'Titre de la video : %s' % video_title)
+
+        return [{
+            'id':       video_id,
+            'url':      video_url,
+            'ext':      video_extension,
+            'title':    video_title,
+        }]
 
 def gen_extractors():
     """ Return a list of an instance of every supported extractor.
@@ -4182,6 +4218,7 @@ def gen_extractors():
         TumblrIE(),
         BandcampIE(),
         RedTubeIE(),
+        InaIE,
         GenericIE()
     ]
 

From dfb9323cf9f10c9a1fcb2ecc5532123441e9ffbb Mon Sep 17 00:00:00 2001
From: Philipp Hagemeister <phihag@phihag.de>
Date: Sun, 5 May 2013 20:57:19 +0200
Subject: [PATCH 184/221] Clean up InaIE (Closes #823)

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

diff --git a/youtube_dl/InfoExtractors.py b/youtube_dl/InfoExtractors.py
index 0f506e618..854592df8 100755
--- a/youtube_dl/InfoExtractors.py
+++ b/youtube_dl/InfoExtractors.py
@@ -4128,32 +4128,24 @@ class RedTubeIE(InfoExtractor):
 class InaIE(InfoExtractor):
     """Information Extractor for Ina.fr"""
     _VALID_URL = r'(?:http://)?(?:www.)?ina\.fr/video/(?P<id>I[0-9]+)/.*'
-    IE_NAME = u'Ina'
+
     def _real_extract(self,url):
         mobj = re.match(self._VALID_URL, url)
-        if mobj is None:
-            raise ExtractorError(u'Invalid URL: %s' % url)
-        video_id = mobj.group('id')
-        self.to_screen(u'video id : %s' % video_id)
-        mrss_url='http://player.ina.fr/notices/%s.mrss'%video_id
-        self.to_screen(u'mrss url : %s' % mrss_url)
-        video_extension = 'mp4'        
-        webpage = self._download_webpage(mrss_url,video_id)
-        self.report_extraction(video_id)
-        reg1=r'<media:player url="(?P<mp4url>http://mp4.ina.fr/[^"]+\.mp4)'
-        mobj = re.search(reg1,webpage)
 
+        video_id = mobj.group('id')
+        mrss_url='http://player.ina.fr/notices/%s.mrss' % video_id
+        video_extension = 'mp4'
+        webpage = self._download_webpage(mrss_url, video_id)
+
+        mobj = re.search(r'<media:player url="(?P<mp4url>http://mp4.ina.fr/[^"]+\.mp4)', webpage)
         if mobj is None:
             raise ExtractorError(u'Unable to extract media URL')
-
         video_url = mobj.group(1)
-        reg2=r'<title><!\[CDATA\[(?P<titre>.*?)]]></title>'
-        mobj = re.search(reg2,webpage)
+
+        mobj = re.search(r'<title><!\[CDATA\[(?P<titre>.*?)]]></title>', webpage)
         if mobj is None:
             raise ExtractorError(u'Unable to extract title')
         video_title = mobj.group(1)
-        
-        self.to_screen(u'Titre de la video : %s' % video_title)
 
         return [{
             'id':       video_id,
@@ -4218,7 +4210,7 @@ def gen_extractors():
         TumblrIE(),
         BandcampIE(),
         RedTubeIE(),
-        InaIE,
+        InaIE(),
         GenericIE()
     ]
 

From 67129e4a15d4dd53678aefe427bcc2e0358cdbf8 Mon Sep 17 00:00:00 2001
From: Philipp Hagemeister <phihag@phihag.de>
Date: Sun, 5 May 2013 21:01:46 +0200
Subject: [PATCH 185/221] release 2013.05.06

---
 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 f7227d0ad..b8dbed2cb 100644
--- a/youtube_dl/version.py
+++ b/youtube_dl/version.py
@@ -1,2 +1,2 @@
 
-__version__ = '2013.05.05'
+__version__ = '2013.05.06'

From 0f75d25991dcc152680463ac9f6260eed92457b8 Mon Sep 17 00:00:00 2001
From: Philipp Hagemeister <phihag@phihag.de>
Date: Sun, 5 May 2013 21:13:16 +0200
Subject: [PATCH 186/221] release 2013.05.07

---
 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 b8dbed2cb..e4220ccab 100644
--- a/youtube_dl/version.py
+++ b/youtube_dl/version.py
@@ -1,2 +1,2 @@
 
-__version__ = '2013.05.06'
+__version__ = '2013.05.07'

From 0ae456f08ab1742a22427685e851f681f5ad2a0f Mon Sep 17 00:00:00 2001
From: Philipp Hagemeister <phihag@phihag.de>
Date: Sun, 5 May 2013 21:35:39 +0200
Subject: [PATCH 187/221] Credit @julienfr112 for Ina IE (#823)

---
 youtube_dl/__init__.py | 1 +
 1 file changed, 1 insertion(+)

diff --git a/youtube_dl/__init__.py b/youtube_dl/__init__.py
index 05cb6e36a..bb8cc80a9 100644
--- a/youtube_dl/__init__.py
+++ b/youtube_dl/__init__.py
@@ -26,6 +26,7 @@ __authors__  = (
     'Osama Khalid',
     'Michael Walter',
     'M. Yasoob Ullah Khalid',
+    'Julien Fraichard',
     )
 
 __license__ = 'Public Domain'

From be74864aceeb6638cbe435e83a6a581d4bf3e1af Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Jaime=20Marqui=CC=81nez=20Ferra=CC=81ndiz?=
 <jaime.marquinez.ferrandiz@gmail.com>
Date: Sun, 5 May 2013 21:56:38 +0200
Subject: [PATCH 188/221] Credit @JohnyMoSwag for WorldstarhiphopIE (#730)

---
 youtube_dl/__init__.py | 1 +
 1 file changed, 1 insertion(+)

diff --git a/youtube_dl/__init__.py b/youtube_dl/__init__.py
index bb8cc80a9..1fc2fbcb4 100644
--- a/youtube_dl/__init__.py
+++ b/youtube_dl/__init__.py
@@ -27,6 +27,7 @@ __authors__  = (
     'Michael Walter',
     'M. Yasoob Ullah Khalid',
     'Julien Fraichard',
+    'Johny Mo Swag',
     )
 
 __license__ = 'Public Domain'

From 43b62accbb1b8701b24e4c9103de56e9e33288df Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Jaime=20Marqui=CC=81nez=20Ferra=CC=81ndiz?=
 <jaime.marquinez.ferrandiz@gmail.com>
Date: Sun, 5 May 2013 22:12:41 +0200
Subject: [PATCH 189/221] GoogleSearchIE: rename _download_n_results to
 _get_n_results

---
 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 854592df8..d66d64f00 100755
--- a/youtube_dl/InfoExtractors.py
+++ b/youtube_dl/InfoExtractors.py
@@ -1465,9 +1465,9 @@ class GoogleSearchIE(InfoExtractor):
         prefix = mobj.group('prefix')
         query = mobj.group('query')
         if prefix == '':
-            return self._download_n_results(query, 1)
+            return self._get_n_results(query, 1)
         elif prefix == 'all':
-            return self._download_n_results(query, self._max_google_results)
+            return self._get_n_results(query, self._max_google_results)
         else:
             n = int(prefix)
             if n <= 0:
@@ -1475,10 +1475,10 @@ class GoogleSearchIE(InfoExtractor):
             elif n > self._max_google_results:
                 self._downloader.report_warning(u'gvsearch returns max %i results (you requested %i)' % (self._max_google_results, n))
                 n = self._max_google_results
-            return self._download_n_results(query, n)
+            return self._get_n_results(query, n)
 
-    def _download_n_results(self, query, n):
-        """Downloads a specified number of results for a query"""
+    def _get_n_results(self, query, n):
+        """Get a specified number of results for a query"""
 
         res = {
             '_type': 'playlist',

From 1a2adf3f49c700acc75c6b284927e61881bd7ea6 Mon Sep 17 00:00:00 2001
From: jakeogh <github.com@v6y.net>
Date: Sun, 5 May 2013 22:30:07 -0700
Subject: [PATCH 190/221] added --get-id option to print video IDs

---
 README.md                    | 1 +
 youtube_dl/FileDownloader.py | 3 +++
 youtube_dl/__init__.py       | 7 +++++--
 3 files changed, 9 insertions(+), 2 deletions(-)

diff --git a/README.md b/README.md
index c95201c3f..a9eaed192 100644
--- a/README.md
+++ b/README.md
@@ -94,6 +94,7 @@ which means you can modify it, redistribute it or use it however you like.
     --skip-download            do not download the video
     -g, --get-url              simulate, quiet but print URL
     -e, --get-title            simulate, quiet but print title
+    --get-id                   simulate, quiet but print id
     --get-thumbnail            simulate, quiet but print thumbnail URL
     --get-description          simulate, quiet but print video description
     --get-filename             simulate, quiet but print output filename
diff --git a/youtube_dl/FileDownloader.py b/youtube_dl/FileDownloader.py
index 9b06633cc..eb68d9478 100644
--- a/youtube_dl/FileDownloader.py
+++ b/youtube_dl/FileDownloader.py
@@ -54,6 +54,7 @@ class FileDownloader(object):
     quiet:             Do not print messages to stdout.
     forceurl:          Force printing final URL.
     forcetitle:        Force printing title.
+    forceid:           Force printing ID.
     forcethumbnail:    Force printing thumbnail URL.
     forcedescription:  Force printing description.
     forcefilename:     Force printing final filename.
@@ -574,6 +575,8 @@ class FileDownloader(object):
         # Forced printings
         if self.params.get('forcetitle', False):
             compat_print(info_dict['title'])
+        if self.params.get('forceid', False):
+            compat_print(info_dict['id'])
         if self.params.get('forceurl', False):
             compat_print(info_dict['url'])
         if self.params.get('forcethumbnail', False) and 'thumbnail' in info_dict:
diff --git a/youtube_dl/__init__.py b/youtube_dl/__init__.py
index 1fc2fbcb4..80f3b9f33 100644
--- a/youtube_dl/__init__.py
+++ b/youtube_dl/__init__.py
@@ -216,6 +216,8 @@ def parseOpts(overrideArguments=None):
             action='store_true', dest='geturl', help='simulate, quiet but print URL', default=False)
     verbosity.add_option('-e', '--get-title',
             action='store_true', dest='gettitle', help='simulate, quiet but print title', default=False)
+    verbosity.add_option('--get-id',
+            action='store_true', dest='getid', help='simulate, quiet but print id', default=False)
     verbosity.add_option('--get-thumbnail',
             action='store_true', dest='getthumbnail',
             help='simulate, quiet but print thumbnail URL', default=False)
@@ -495,15 +497,16 @@ def _real_main(argv=None):
         'usenetrc': opts.usenetrc,
         'username': opts.username,
         'password': opts.password,
-        'quiet': (opts.quiet or opts.geturl or opts.gettitle or opts.getthumbnail or opts.getdescription or opts.getfilename or opts.getformat),
+        'quiet': (opts.quiet or opts.geturl or opts.gettitle or opts.getid or opts.getthumbnail or opts.getdescription or opts.getfilename or opts.getformat),
         'forceurl': opts.geturl,
         'forcetitle': opts.gettitle,
+        'forceid': opts.getid,
         'forcethumbnail': opts.getthumbnail,
         'forcedescription': opts.getdescription,
         'forcefilename': opts.getfilename,
         'forceformat': opts.getformat,
         'simulate': opts.simulate,
-        'skip_download': (opts.skip_download or opts.simulate or opts.geturl or opts.gettitle or opts.getthumbnail or opts.getdescription or opts.getfilename or opts.getformat),
+        'skip_download': (opts.skip_download or opts.simulate or opts.geturl or opts.gettitle or opts.getid or opts.getthumbnail or opts.getdescription or opts.getfilename or opts.getformat),
         'format': opts.format,
         'format_limit': opts.format_limit,
         'listformats': opts.listformats,

From 2a36c352a00d8b0c7a82426e409b97266a804c2e Mon Sep 17 00:00:00 2001
From: Filippo Valsorda <filippo.valsorda@gmail.com>
Date: Thu, 9 May 2013 00:39:10 +0200
Subject: [PATCH 191/221] Retry to disable YT ratelimit to unlock full
 bandwidth

This is the second attempt: a60b854d9099e5a286accf8065d1dc9e00a4bfe6
Sometimes the ratelimit=yes is already in the URL, and doubling it
leads to a 403. Now should work on all videos, at least works on all
I could test.

Closes #648
---
 youtube_dl/InfoExtractors.py | 11 +++++++----
 1 file changed, 7 insertions(+), 4 deletions(-)

diff --git a/youtube_dl/InfoExtractors.py b/youtube_dl/InfoExtractors.py
index d66d64f00..ec52cbcff 100755
--- a/youtube_dl/InfoExtractors.py
+++ b/youtube_dl/InfoExtractors.py
@@ -610,10 +610,13 @@ class YoutubeIE(InfoExtractor):
             self.report_rtmp_download()
             video_url_list = [(None, video_info['conn'][0])]
         elif 'url_encoded_fmt_stream_map' in video_info and len(video_info['url_encoded_fmt_stream_map']) >= 1:
-            url_data_strs = video_info['url_encoded_fmt_stream_map'][0].split(',')
-            url_data = [compat_parse_qs(uds) for uds in url_data_strs]
-            url_data = [ud for ud in url_data if 'itag' in ud and 'url' in ud]
-            url_map = dict((ud['itag'][0], ud['url'][0] + '&signature=' + ud['sig'][0]) for ud in url_data)
+            url_map = {}
+            for url_data_str in video_info['url_encoded_fmt_stream_map'][0].split(','):
+                url_data = compat_parse_qs(url_data_str)
+                if 'itag' in url_data and 'url' in url_data:
+                    url = url_data['url'][0] + '&signature=' + url_data['sig'][0]
+                    if not 'ratebypass' in url: url += '&ratebypass=yes'
+                    url_map[url_data['itag'][0]] = url
 
             format_limit = self._downloader.params.get('format_limit', None)
             available_formats = self._available_formats_prefer_free if self._downloader.params.get('prefer_free_formats', False) else self._available_formats

From 532a1e042964e698610908a0c3fde5188dce8f26 Mon Sep 17 00:00:00 2001
From: Philipp Hagemeister <phihag@phihag.de>
Date: Fri, 10 May 2013 01:45:21 +0200
Subject: [PATCH 192/221] release 2013.05.10

---
 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 e4220ccab..ae9688e17 100644
--- a/youtube_dl/version.py
+++ b/youtube_dl/version.py
@@ -1,2 +1,2 @@
 
-__version__ = '2013.05.07'
+__version__ = '2013.05.10'

From 92599661329c1e573359e9c80121537954a6967f Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Jaime=20Marqui=CC=81nez=20Ferra=CC=81ndiz?=
 <jaime.marquinez.ferrandiz@gmail.com>
Date: Fri, 10 May 2013 08:31:30 +0200
Subject: [PATCH 193/221] test_youtube_subtitles: FakeDownloader inherits form
 FileDownloader

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

diff --git a/test/test_youtube_subtitles.py b/test/test_youtube_subtitles.py
index 5b3f289af..1ab09d78b 100644
--- a/test/test_youtube_subtitles.py
+++ b/test/test_youtube_subtitles.py
@@ -24,7 +24,7 @@ proxy_handler = compat_urllib_request.ProxyHandler()
 opener = compat_urllib_request.build_opener(proxy_handler, cookie_processor, YoutubeDLHandler())
 compat_urllib_request.install_opener(opener)
 
-class FakeDownloader(object):
+class FakeDownloader(FileDownloader):
     def __init__(self):
         self.result = []
         self.params = parameters

From 057c9938a157bbf370097f60b37793ae94d2c411 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Jaime=20Marqui=CC=81nez=20Ferra=CC=81ndiz?=
 <jaime.marquinez.ferrandiz@gmail.com>
Date: Fri, 10 May 2013 08:37:49 +0200
Subject: [PATCH 194/221] Import FileDownloader in test_youtube_subtitles

Fix last commit
---
 test/test_youtube_subtitles.py | 1 +
 1 file changed, 1 insertion(+)

diff --git a/test/test_youtube_subtitles.py b/test/test_youtube_subtitles.py
index 1ab09d78b..a123e6d72 100644
--- a/test/test_youtube_subtitles.py
+++ b/test/test_youtube_subtitles.py
@@ -12,6 +12,7 @@ sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
 
 from youtube_dl.InfoExtractors import YoutubeIE
 from youtube_dl.utils import *
+from youtube_dl import FileDownloader
 
 PARAMETERS_FILE = os.path.join(os.path.dirname(os.path.abspath(__file__)), "parameters.json")
 with io.open(PARAMETERS_FILE, encoding='utf-8') as pf:

From c83411b9eefffbdc85c58c6ba7693c66896df7f7 Mon Sep 17 00:00:00 2001
From: Philipp Hagemeister <phihag@phihag.de>
Date: Fri, 10 May 2013 09:10:34 +0200
Subject: [PATCH 195/221] Skip bandcamp tests for now - free limit has been
 exceeded

---
 test/tests.json | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/test/tests.json b/test/tests.json
index a342ce4b9..5a14b0523 100644
--- a/test/tests.json
+++ b/test/tests.json
@@ -401,7 +401,8 @@
     "md5":"cdeb30cdae1921719a3cbcab696ef53c",
     "info_dict": {
       "title":"youtube-dl test song \"'/\\ä↭"
-    }
+    },
+    "skip": "There is a limit of 200 free downloads / month for the test song"
   },
   {
     "name": "RedTube",

From 5738240ee829684815bdb9e6a9028d3465140b48 Mon Sep 17 00:00:00 2001
From: chocolateboy <chocolate@cpan.org>
Date: Fri, 10 May 2013 22:47:37 +0100
Subject: [PATCH 196/221] only install to /etc if PREFIX is /usr or /usr/local

---
 Makefile | 12 +++++++++++-
 1 file changed, 11 insertions(+), 1 deletion(-)

diff --git a/Makefile b/Makefile
index 84ea70d2c..e00f5e650 100644
--- a/Makefile
+++ b/Makefile
@@ -9,9 +9,19 @@ cleanall: clean
 PREFIX=/usr/local
 BINDIR=$(PREFIX)/bin
 MANDIR=$(PREFIX)/man
-SYSCONFDIR=/etc
 PYTHON=/usr/bin/env python
 
+# set SYSCONFDIR to /etc if PREFIX=/usr or PREFIX=/usr/local
+ifeq ($(PREFIX),/usr)
+    SYSCONFDIR=/etc
+else
+    ifeq ($(PREFIX),/usr/local)
+        SYSCONFDIR=/etc
+    else
+        SYSCONFDIR=$(PREFIX)/etc
+    endif
+endif
+
 install: youtube-dl youtube-dl.1 youtube-dl.bash-completion
 	install -d $(DESTDIR)$(BINDIR)
 	install -m 755 youtube-dl $(DESTDIR)$(BINDIR)

From 59f4fd4dc65f0576fdf02bfb710cddc90262b1ba Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Jaime=20Marqui=CC=81nez=20Ferra=CC=81ndiz?=
 <jaime.marquinez.ferrandiz@gmail.com>
Date: Sun, 12 May 2013 14:05:14 +0200
Subject: [PATCH 197/221] YahooIE: remove old code and accept screen.yahoo.com
 videos (#300)

Videos require rtmpdump
---
 test/tests.json              |  10 +++
 youtube_dl/InfoExtractors.py | 146 +++++++++--------------------------
 2 files changed, 47 insertions(+), 109 deletions(-)

diff --git a/test/tests.json b/test/tests.json
index 5a14b0523..f0e5cd8bf 100644
--- a/test/tests.json
+++ b/test/tests.json
@@ -430,5 +430,15 @@
     "info_dict":{
       "title":"François Hollande \"Je crois que c'est clair\""
     }
+  },
+  {
+    "name": "Yahoo",
+    "url": "http://screen.yahoo.com/obama-celebrates-iraq-victory-27592561.html",
+    "file": "27592561.flv",
+    "md5": "c6179bed843512823fd284fa2e7f012d",
+    "info_dict": {
+        "title": "Obama Celebrates Iraq Victory"
+    },
+    "skip": "Requires rtmpdump"
   }
 ]
diff --git a/youtube_dl/InfoExtractors.py b/youtube_dl/InfoExtractors.py
index ec52cbcff..789f9872e 100755
--- a/youtube_dl/InfoExtractors.py
+++ b/youtube_dl/InfoExtractors.py
@@ -912,123 +912,51 @@ class PhotobucketIE(InfoExtractor):
 
 
 class YahooIE(InfoExtractor):
-    """Information extractor for video.yahoo.com."""
+    """Information extractor for screen.yahoo.com."""
+    _VALID_URL = r'http://screen\.yahoo\.com/.*?-(?P<id>\d*?)\.html'
 
-    _WORKING = False
-    # _VALID_URL matches all Yahoo! Video URLs
-    # _VPAGE_URL matches only the extractable '/watch/' URLs
-    _VALID_URL = r'(?:http://)?(?:[a-z]+\.)?video\.yahoo\.com/(?:watch|network)/([0-9]+)(?:/|\?v=)([0-9]+)(?:[#\?].*)?'
-    _VPAGE_URL = r'(?:http://)?video\.yahoo\.com/watch/([0-9]+)/([0-9]+)(?:[#\?].*)?'
-    IE_NAME = u'video.yahoo'
-
-    def _real_extract(self, url, new_video=True):
-        # Extract ID from URL
+    def _real_extract(self, url):
         mobj = re.match(self._VALID_URL, url)
         if mobj is None:
             raise ExtractorError(u'Invalid URL: %s' % url)
+        video_id = mobj.group('id')
 
-        video_id = mobj.group(2)
-        video_extension = 'flv'
-
-        # Rewrite valid but non-extractable URLs as
-        # extractable English language /watch/ URLs
-        if re.match(self._VPAGE_URL, url) is None:
-            request = compat_urllib_request.Request(url)
-            try:
-                webpage = compat_urllib_request.urlopen(request).read()
-            except (compat_urllib_error.URLError, compat_http_client.HTTPException, socket.error) as err:
-                raise ExtractorError(u'Unable to retrieve video webpage: %s' % compat_str(err))
-
-            mobj = re.search(r'\("id", "([0-9]+)"\);', webpage)
-            if mobj is None:
-                raise ExtractorError(u'Unable to extract id field')
-            yahoo_id = mobj.group(1)
-
-            mobj = re.search(r'\("vid", "([0-9]+)"\);', webpage)
-            if mobj is None:
-                raise ExtractorError(u'Unable to extract vid field')
-            yahoo_vid = mobj.group(1)
-
-            url = 'http://video.yahoo.com/watch/%s/%s' % (yahoo_vid, yahoo_id)
-            return self._real_extract(url, new_video=False)
-
-        # Retrieve video webpage to extract further information
-        request = compat_urllib_request.Request(url)
-        try:
-            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:
-            raise ExtractorError(u'Unable to retrieve video webpage: %s' % compat_str(err))
-
-        # Extract uploader and title from webpage
+        # TODO: Check which url parameters are required
+        info_url = 'http://cosmos.bcst.yahoo.com/rest/v2/pops;lmsoverride=1;outputformat=mrss;cb=974419660;id=%s;rd=news.yahoo.com;datacontext=mdb;lg=KCa2IihxG3qE60vQ7HtyUy' % video_id
+        webpage = self._download_webpage(info_url, video_id, "Downloading info webpage")
+        info_re = r'''<title><!\[CDATA\[(?P<title>.*?)\]\]></title>.*
+                    <description><!\[CDATA\[(?P<description>.*?)\]\]></description>.*
+                    <media:pubStart><!\[CDATA\[(?P<date>.*?)\ .*\]\]></media:pubStart>.*
+                    <media:content\ medium="image"\ url="(?P<thumb>.*?)"\ name="LARGETHUMB"
+                    '''
         self.report_extraction(video_id)
-        mobj = re.search(r'<meta name="title" content="(.*)" />', webpage)
-        if mobj is None:
-            raise ExtractorError(u'Unable to extract video title')
-        video_title = mobj.group(1).decode('utf-8')
+        m_info = re.search(info_re, webpage, re.VERBOSE|re.DOTALL)
+        if m_info is None:
+            raise ExtractorError(u'Unable to extract video info')
+        video_title = m_info.group('title')
+        video_description = m_info.group('description')
+        video_thumb = m_info.group('thumb')
+        video_date = m_info.group('date')
+        video_date = datetime.datetime.strptime(video_date, '%m/%d/%Y').strftime('%Y%m%d')
 
-        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:
-            raise ExtractorError(u'Unable to extract video uploader')
-        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:
-            raise ExtractorError(u'Unable to extract video thumbnail')
-        video_thumbnail = mobj.group(1).decode('utf-8')
-
-        # Extract video description
-        mobj = re.search(r'<meta name="description" content="(.*)" />', webpage)
-        if mobj is None:
-            raise ExtractorError(u'Unable to extract video description')
-        video_description = mobj.group(1).decode('utf-8')
-        if not video_description:
-            video_description = 'No description available.'
-
-        # Extract video height and width
-        mobj = re.search(r'<meta name="video_height" content="([0-9]+)" />', webpage)
-        if mobj is None:
-            raise ExtractorError(u'Unable to extract video height')
-        yv_video_height = mobj.group(1)
-
-        mobj = re.search(r'<meta name="video_width" content="([0-9]+)" />', webpage)
-        if mobj is None:
-            raise ExtractorError(u'Unable to extract video width')
-        yv_video_width = mobj.group(1)
-
-        # Retrieve video playlist to extract media URL
-        # I'm not completely sure what all these options are, but we
-        # seem to need most of them, otherwise the server sends a 401.
-        yv_lg = 'R0xx6idZnW2zlrKP8xxAIR'  # not sure what this represents
-        yv_bitrate = '700'  # according to Wikipedia this is hard-coded
-        request = compat_urllib_request.Request('http://cosmos.bcst.yahoo.com/up/yep/process/getPlaylistFOP.php?node_id=' + video_id +
-                '&tech=flash&mode=playlist&lg=' + yv_lg + '&bitrate=' + yv_bitrate + '&vidH=' + yv_video_height +
-                '&vidW=' + yv_video_width + '&swf=as3&rd=video.yahoo.com&tk=null&adsupported=v1,v2,&eventid=1301797')
-        try:
-            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:
-            raise ExtractorError(u'Unable to retrieve video webpage: %s' % compat_str(err))
-
-        # Extract media URL from playlist XML
-        mobj = re.search(r'<STREAM APP="(http://.*)" FULLPATH="/?(/.*\.flv\?[^"]*)"', webpage)
-        if mobj is None:
-            raise ExtractorError(u'Unable to extract media URL')
-        video_url = compat_urllib_parse.unquote(mobj.group(1) + mobj.group(2)).decode('utf-8')
-        video_url = unescapeHTML(video_url)
-
-        return [{
-            'id':       video_id.decode('utf-8'),
-            'url':      video_url,
-            'uploader': video_uploader,
-            'upload_date':  None,
-            'title':    video_title,
-            'ext':      video_extension.decode('utf-8'),
-            'thumbnail':    video_thumbnail.decode('utf-8'),
-            'description':  video_description,
-        }]
+        # TODO: Find a way to get mp4 videos
+        rest_url = 'http://cosmos.bcst.yahoo.com/rest/v2/pops;element=stream;outputformat=mrss;id=%s;lmsoverride=1;bw=375;dynamicstream=1;cb=83521105;tech=flv,mp4;rd=news.yahoo.com;datacontext=mdb;lg=KCa2IihxG3qE60vQ7HtyUy' % video_id
+        webpage = self._download_webpage(rest_url, video_id, 'Downloading video url webpage')
+        m_rest = re.search(r'<media:content url="(?P<url>.*?)" path="(?P<path>.*?)"', webpage)
+        if m_rest is None:
+            raise ExtractorError(u'Unable to extract video url')
 
+        info_dict = {
+                     'id': video_id,
+                     'url':m_rest.group('url'),
+                     'play_path': m_rest.group('path'),
+                     'title':video_title,
+                     'description': video_description,
+                     'thumbnail': video_thumb,
+                     'upload_date': video_date,
+                     'ext': 'flv',
+                     }
+        return info_dict
 
 class VimeoIE(InfoExtractor):
     """Information extractor for vimeo.com."""

From 2f58b12dad1b5e19f2daf338cdba958be0b0a87c Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Jaime=20Marqui=CC=81nez=20Ferra=CC=81ndiz?=
 <jaime.marquinez.ferrandiz@gmail.com>
Date: Sun, 12 May 2013 17:05:43 +0200
Subject: [PATCH 198/221] YahooIE: support more videos

---
 youtube_dl/InfoExtractors.py | 71 +++++++++++++++++++++++-------------
 1 file changed, 46 insertions(+), 25 deletions(-)

diff --git a/youtube_dl/InfoExtractors.py b/youtube_dl/InfoExtractors.py
index 789f9872e..139173016 100755
--- a/youtube_dl/InfoExtractors.py
+++ b/youtube_dl/InfoExtractors.py
@@ -920,36 +920,57 @@ class YahooIE(InfoExtractor):
         if mobj is None:
             raise ExtractorError(u'Invalid URL: %s' % url)
         video_id = mobj.group('id')
+        webpage = self._download_webpage(url, video_id)
+        m_id = re.search(r'YUI\.namespace\("Media"\)\.CONTENT_ID = "(?P<new_id>.+?)";', webpage)
 
-        # TODO: Check which url parameters are required
-        info_url = 'http://cosmos.bcst.yahoo.com/rest/v2/pops;lmsoverride=1;outputformat=mrss;cb=974419660;id=%s;rd=news.yahoo.com;datacontext=mdb;lg=KCa2IihxG3qE60vQ7HtyUy' % video_id
-        webpage = self._download_webpage(info_url, video_id, "Downloading info webpage")
-        info_re = r'''<title><!\[CDATA\[(?P<title>.*?)\]\]></title>.*
-                    <description><!\[CDATA\[(?P<description>.*?)\]\]></description>.*
-                    <media:pubStart><!\[CDATA\[(?P<date>.*?)\ .*\]\]></media:pubStart>.*
-                    <media:content\ medium="image"\ url="(?P<thumb>.*?)"\ name="LARGETHUMB"
-                    '''
-        self.report_extraction(video_id)
-        m_info = re.search(info_re, webpage, re.VERBOSE|re.DOTALL)
-        if m_info is None:
-            raise ExtractorError(u'Unable to extract video info')
-        video_title = m_info.group('title')
-        video_description = m_info.group('description')
-        video_thumb = m_info.group('thumb')
-        video_date = m_info.group('date')
-        video_date = datetime.datetime.strptime(video_date, '%m/%d/%Y').strftime('%Y%m%d')
+        if m_id is None: 
+            # TODO: Check which url parameters are required
+            info_url = 'http://cosmos.bcst.yahoo.com/rest/v2/pops;lmsoverride=1;outputformat=mrss;cb=974419660;id=%s;rd=news.yahoo.com;datacontext=mdb;lg=KCa2IihxG3qE60vQ7HtyUy' % video_id
+            webpage = self._download_webpage(info_url, video_id, u'Downloading info webpage')
+            info_re = r'''<title><!\[CDATA\[(?P<title>.*?)\]\]></title>.*
+                        <description><!\[CDATA\[(?P<description>.*?)\]\]></description>.*
+                        <media:pubStart><!\[CDATA\[(?P<date>.*?)\ .*\]\]></media:pubStart>.*
+                        <media:content\ medium="image"\ url="(?P<thumb>.*?)"\ name="LARGETHUMB"
+                        '''
+            self.report_extraction(video_id)
+            m_info = re.search(info_re, webpage, re.VERBOSE|re.DOTALL)
+            if m_info is None:
+                raise ExtractorError(u'Unable to extract video info')
+            video_title = m_info.group('title')
+            video_description = m_info.group('description')
+            video_thumb = m_info.group('thumb')
+            video_date = m_info.group('date')
+            video_date = datetime.datetime.strptime(video_date, '%m/%d/%Y').strftime('%Y%m%d')
+    
+            # TODO: Find a way to get mp4 videos
+            rest_url = 'http://cosmos.bcst.yahoo.com/rest/v2/pops;element=stream;outputformat=mrss;id=%s;lmsoverride=1;bw=375;dynamicstream=1;cb=83521105;tech=flv,mp4;rd=news.yahoo.com;datacontext=mdb;lg=KCa2IihxG3qE60vQ7HtyUy' % video_id
+            webpage = self._download_webpage(rest_url, video_id, u'Downloading video url webpage')
+            m_rest = re.search(r'<media:content url="(?P<url>.*?)" path="(?P<path>.*?)"', webpage)
+            video_url = m_rest.group('url')
+            video_path = m_rest.group('path')
+            if m_rest is None:
+                raise ExtractorError(u'Unable to extract video url')
 
-        # TODO: Find a way to get mp4 videos
-        rest_url = 'http://cosmos.bcst.yahoo.com/rest/v2/pops;element=stream;outputformat=mrss;id=%s;lmsoverride=1;bw=375;dynamicstream=1;cb=83521105;tech=flv,mp4;rd=news.yahoo.com;datacontext=mdb;lg=KCa2IihxG3qE60vQ7HtyUy' % video_id
-        webpage = self._download_webpage(rest_url, video_id, 'Downloading video url webpage')
-        m_rest = re.search(r'<media:content url="(?P<url>.*?)" path="(?P<path>.*?)"', webpage)
-        if m_rest is None:
-            raise ExtractorError(u'Unable to extract video url')
+        else: # We have to use a different method if another id is defined
+            long_id = m_id.group('new_id')
+            info_url = 'http://video.query.yahoo.com/v1/public/yql?q=SELECT%20*%20FROM%20yahoo.media.video.streams%20WHERE%20id%3D%22' + long_id + '%22%20AND%20format%3D%22mp4%2Cflv%22%20AND%20protocol%3D%22rtmp%2Chttp%22%20AND%20plrs%3D%2286Gj0vCaSzV_Iuf6hNylf2%22%20AND%20acctid%3D%22389%22%20AND%20plidl%3D%22%22%20AND%20pspid%3D%22792700001%22%20AND%20offnetwork%3D%22false%22%20AND%20site%3D%22ivy%22%20AND%20lang%3D%22en-US%22%20AND%20region%3D%22US%22%20AND%20override%3D%22none%22%3B&env=prod&format=json&callback=YUI.Env.JSONP.yui_3_8_1_1_1368368376830_335'
+            webpage = self._download_webpage(info_url, video_id, u'Downloading info json')
+            json_str = re.search(r'YUI.Env.JSONP.yui.*?\((.*?)\);', webpage).group(1)
+            info = json.loads(json_str)
+            res = info[u'query'][u'results'][u'mediaObj'][0]
+            stream = res[u'streams'][0]
+            video_path = stream[u'path']
+            video_url = stream[u'host']
+            meta = res[u'meta']
+            video_title = meta[u'title']
+            video_description = meta[u'description']
+            video_thumb = meta[u'thumbnail']
+            video_date = None # I can't find it
 
         info_dict = {
                      'id': video_id,
-                     'url':m_rest.group('url'),
-                     'play_path': m_rest.group('path'),
+                     'url': video_url,
+                     'play_path': video_path,
                      'title':video_title,
                      'description': video_description,
                      'thumbnail': video_thumb,

From 5a853e14231d1e69aa027fcb746ef3aa6ddeb864 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Jaime=20Marqui=CC=81nez=20Ferra=CC=81ndiz?=
 <jaime.marquinez.ferrandiz@gmail.com>
Date: Sun, 12 May 2013 17:49:35 +0200
Subject: [PATCH 199/221] Fix YahooSearchIE: (closes #300)

---
 youtube_dl/InfoExtractors.py | 78 ++++++++++++++----------------------
 1 file changed, 29 insertions(+), 49 deletions(-)

diff --git a/youtube_dl/InfoExtractors.py b/youtube_dl/InfoExtractors.py
index 139173016..5c7af5229 100755
--- a/youtube_dl/InfoExtractors.py
+++ b/youtube_dl/InfoExtractors.py
@@ -1456,18 +1456,10 @@ class GoogleSearchIE(InfoExtractor):
 class YahooSearchIE(InfoExtractor):
     """Information Extractor for Yahoo! Video search queries."""
 
-    _WORKING = False
     _VALID_URL = r'yvsearch(\d+|all)?:[\s\S]+'
-    _TEMPLATE_URL = 'http://video.yahoo.com/search/?p=%s&o=%s'
-    _VIDEO_INDICATOR = r'href="http://video\.yahoo\.com/watch/([0-9]+/[0-9]+)"'
-    _MORE_PAGES_INDICATOR = r'\s*Next'
-    _max_yahoo_results = 1000
-    IE_NAME = u'video.yahoo:search'
 
-    def report_download_page(self, query, pagenum):
-        """Report attempt to download playlist page with given number."""
-        query = query.decode(preferredencoding())
-        self.to_screen(u'query "%s": Downloading page %s' % (query, pagenum))
+    _max_yahoo_results = 1000
+    IE_NAME = u'screen.yahoo:search'
 
     def _real_extract(self, query):
         mobj = re.match(self._VALID_URL, query)
@@ -1478,11 +1470,9 @@ class YahooSearchIE(InfoExtractor):
         prefix = prefix[8:]
         query = query.encode('utf-8')
         if prefix == '':
-            self._download_n_results(query, 1)
-            return
+            return self._get_n_results(query, 1)
         elif prefix == 'all':
-            self._download_n_results(query, self._max_yahoo_results)
-            return
+            return self._get_n_results(query, self._max_yahoo_results)
         else:
             try:
                 n = int(prefix)
@@ -1491,46 +1481,36 @@ class YahooSearchIE(InfoExtractor):
                 elif n > self._max_yahoo_results:
                     self._downloader.report_warning(u'yvsearch returns max %i results (you requested %i)' % (self._max_yahoo_results, n))
                     n = self._max_yahoo_results
-                self._download_n_results(query, n)
-                return
+                return self._get_n_results(query, n)
             except ValueError: # parsing prefix as integer fails
-                self._download_n_results(query, 1)
-                return
+                return self._get_n_results(query, 1)
 
-    def _download_n_results(self, query, n):
-        """Downloads a specified number of results for a query"""
+    def _get_n_results(self, query, n):
+        """Get a specified number of results for a query"""
 
-        video_ids = []
-        already_seen = set()
-        pagenum = 1
+        res = {
+            '_type': 'playlist',
+            'id': query,
+            'entries': []
+        }
+        for pagenum in itertools.count(0): 
+            result_url = u'http://video.search.yahoo.com/search/?p=%s&fr=screen&o=js&gs=0&b=%d' % (compat_urllib_parse.quote_plus(query), pagenum * 30)
+            webpage = self._download_webpage(result_url, query,
+                                             note='Downloading results page '+str(pagenum+1))
+            info = json.loads(webpage)
+            m = info[u'm']
+            results = info[u'results']
 
-        while True:
-            self.report_download_page(query, pagenum)
-            result_url = self._TEMPLATE_URL % (compat_urllib_parse.quote_plus(query), pagenum)
-            request = compat_urllib_request.Request(result_url)
-            try:
-                page = compat_urllib_request.urlopen(request).read()
-            except (compat_urllib_error.URLError, compat_http_client.HTTPException, socket.error) as err:
-                raise ExtractorError(u'Unable to download webpage: %s' % compat_str(err))
+            for (i, r) in enumerate(results):
+                if (pagenum * 30) +i >= n:
+                    break
+                mobj = re.search(r'(?P<url>screen\.yahoo\.com/.*?-\d*?\.html)"', r)
+                e = self.url_result('http://' + mobj.group('url'), 'Yahoo')
+                res['entries'].append(e)
+            if (pagenum * 30 +i >= n) or (m[u'last'] >= (m[u'total'] -1 )):
+                break
 
-            # Extract video identifiers
-            for mobj in re.finditer(self._VIDEO_INDICATOR, page):
-                video_id = mobj.group(1)
-                if video_id not in already_seen:
-                    video_ids.append(video_id)
-                    already_seen.add(video_id)
-                    if len(video_ids) == n:
-                        # Specified n videos reached
-                        for id in video_ids:
-                            self._downloader.download(['http://video.yahoo.com/watch/%s' % id])
-                        return
-
-            if re.search(self._MORE_PAGES_INDICATOR, page) is None:
-                for id in video_ids:
-                    self._downloader.download(['http://video.yahoo.com/watch/%s' % id])
-                return
-
-            pagenum = pagenum + 1
+        return res
 
 
 class YoutubePlaylistIE(InfoExtractor):

From 3c5e7729e1ec3663f6cf2894b6e0474d76f2b206 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Jaime=20Marqui=CC=81nez=20Ferra=CC=81ndiz?=
 <jaime.marquinez.ferrandiz@gmail.com>
Date: Sun, 12 May 2013 18:44:56 +0200
Subject: [PATCH 200/221] GoogleSearchIE: change query urls to
 http://www.google.com/search

The old one was given HTTP 404 errors
---
 youtube_dl/InfoExtractors.py | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

diff --git a/youtube_dl/InfoExtractors.py b/youtube_dl/InfoExtractors.py
index 5c7af5229..e4b6c01ab 100755
--- a/youtube_dl/InfoExtractors.py
+++ b/youtube_dl/InfoExtractors.py
@@ -1407,7 +1407,7 @@ class YoutubeSearchIE(InfoExtractor):
 class GoogleSearchIE(InfoExtractor):
     """Information Extractor for Google Video search queries."""
     _VALID_URL = r'gvsearch(?P<prefix>|\d+|all):(?P<query>[\s\S]+)'
-    _MORE_PAGES_INDICATOR = r'class="pn" id="pnnext"'
+    _MORE_PAGES_INDICATOR = r'id="pnnext" class="pn"'
     _max_google_results = 1000
     IE_NAME = u'video.google:search'
 
@@ -1439,7 +1439,8 @@ class GoogleSearchIE(InfoExtractor):
         }
 
         for pagenum in itertools.count(1):
-            result_url = u'http://video.google.com/videosearch?q=%s&start=%s&hl=en' % (compat_urllib_parse.quote_plus(query), pagenum*10)
+            result_url = u'http://www.google.com/search?tbm=vid&q=%s&start=%s&hl=en' % (compat_urllib_parse.quote_plus(query), pagenum*10)
+            print(result_url)
             webpage = self._download_webpage(result_url, u'gvsearch:' + query,
                                              note='Downloading result page ' + str(pagenum))
 

From fb2f83360cc48b2b2fbc27c268437688094032b6 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Jaime=20Marqui=CC=81nez=20Ferra=CC=81ndiz?=
 <jaime.marquinez.ferrandiz@gmail.com>
Date: Sun, 12 May 2013 19:08:32 +0200
Subject: [PATCH 201/221] FFmpegPostProcessor: decode stderr first and then get
 the last line (closes #837)

---
 youtube_dl/PostProcessor.py | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/youtube_dl/PostProcessor.py b/youtube_dl/PostProcessor.py
index 0c6885dda..8868b37af 100644
--- a/youtube_dl/PostProcessor.py
+++ b/youtube_dl/PostProcessor.py
@@ -85,8 +85,9 @@ class FFmpegPostProcessor(PostProcessor):
         p = subprocess.Popen(cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
         stdout,stderr = p.communicate()
         if p.returncode != 0:
+            stderr = stderr.decode('utf-8', 'replace')
             msg = stderr.strip().split('\n')[-1]
-            raise FFmpegPostProcessorError(msg.decode('utf-8', 'replace'))
+            raise FFmpegPostProcessorError(msg)
 
     def _ffmpeg_filename_argument(self, fn):
         # ffmpeg broke --, see https://ffmpeg.org/trac/ffmpeg/ticket/2127 for details

From 98d4a4e6bc15e533c941f0e024b48faf4cae4a40 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Jaime=20Marqui=CC=81nez=20Ferra=CC=81ndiz?=
 <jaime.marquinez.ferrandiz@gmail.com>
Date: Sun, 12 May 2013 20:53:37 +0200
Subject: [PATCH 202/221] YoutubeSearchIE: return a playlist (related #838)

---
 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 e4b6c01ab..6a42ed090 100755
--- a/youtube_dl/InfoExtractors.py
+++ b/youtube_dl/InfoExtractors.py
@@ -1401,7 +1401,7 @@ class YoutubeSearchIE(InfoExtractor):
         if len(video_ids) > n:
             video_ids = video_ids[:n]
         videos = [self.url_result('http://www.youtube.com/watch?v=%s' % id, 'Youtube') for id in video_ids]
-        return videos
+        return self.playlist_result(videos, query)
 
 
 class GoogleSearchIE(InfoExtractor):

From 929f85d851748acb385c17342201f6469f193a17 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Jaime=20Marqui=CC=81nez=20Ferra=CC=81ndiz?=
 <jaime.marquinez.ferrandiz@gmail.com>
Date: Sun, 12 May 2013 20:56:54 +0200
Subject: [PATCH 203/221] Remove a print call used for debugging

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

diff --git a/youtube_dl/InfoExtractors.py b/youtube_dl/InfoExtractors.py
index 6a42ed090..4bcd8b9cd 100755
--- a/youtube_dl/InfoExtractors.py
+++ b/youtube_dl/InfoExtractors.py
@@ -1440,7 +1440,6 @@ class GoogleSearchIE(InfoExtractor):
 
         for pagenum in itertools.count(1):
             result_url = u'http://www.google.com/search?tbm=vid&q=%s&start=%s&hl=en' % (compat_urllib_parse.quote_plus(query), pagenum*10)
-            print(result_url)
             webpage = self._download_webpage(result_url, u'gvsearch:' + query,
                                              note='Downloading result page ' + str(pagenum))
 

From 1bd96c3a60e40d2490be834f95b9acca6c74eb07 Mon Sep 17 00:00:00 2001
From: Philipp Hagemeister <phihag@phihag.de>
Date: Mon, 13 May 2013 09:06:18 +0200
Subject: [PATCH 204/221] Deprecate --only-sub

---
 youtube_dl/FileDownloader.py | 8 ++------
 youtube_dl/__init__.py       | 5 ++---
 2 files changed, 4 insertions(+), 9 deletions(-)

diff --git a/youtube_dl/FileDownloader.py b/youtube_dl/FileDownloader.py
index eb68d9478..8a3bdf21b 100644
--- a/youtube_dl/FileDownloader.py
+++ b/youtube_dl/FileDownloader.py
@@ -83,7 +83,6 @@ class FileDownloader(object):
     writeinfojson:     Write the video description to a .info.json file
     writethumbnail:    Write the thumbnail image to a file
     writesubtitles:    Write the video subtitles to a file
-    onlysubtitles:     Downloads only the subtitles of the video
     allsubtitles:      Downloads all the subtitles of the video
     listsubtitles:     Lists all available subtitles for the video
     subtitlesformat:   Subtitle format [sbv/srt] (default=srt)
@@ -93,6 +92,7 @@ class FileDownloader(object):
     min_filesize:      Skip files smaller than this size
     max_filesize:      Skip files larger than this size
     daterange:         A DateRange object, download only if the upload_date is in the range.
+    skip_download:     Skip the actual download of the video file
     """
 
     params = None
@@ -597,7 +597,7 @@ class FileDownloader(object):
 
         try:
             dn = os.path.dirname(encodeFilename(filename))
-            if dn != '' and not os.path.exists(dn): # dn is already encoded
+            if dn != '' and not os.path.exists(dn):
                 os.makedirs(dn)
         except (OSError, IOError) as err:
             self.report_error(u'unable to create directory ' + compat_str(err))
@@ -630,8 +630,6 @@ class FileDownloader(object):
                 except (OSError, IOError):
                     self.report_error(u'Cannot write subtitles file ' + descfn)
                     return
-            if self.params.get('onlysubtitles', False):
-                return 
 
         if self.params.get('allsubtitles', False) and 'subtitles' in info_dict and info_dict['subtitles']:
             subtitles = info_dict['subtitles']
@@ -649,8 +647,6 @@ class FileDownloader(object):
                     except (OSError, IOError):
                         self.report_error(u'Cannot write subtitles file ' + descfn)
                         return
-            if self.params.get('onlysubtitles', False):
-                return 
 
         if self.params.get('writeinfojson', False):
             infofn = filename + u'.info.json'
diff --git a/youtube_dl/__init__.py b/youtube_dl/__init__.py
index 80f3b9f33..308c48fe6 100644
--- a/youtube_dl/__init__.py
+++ b/youtube_dl/__init__.py
@@ -191,8 +191,8 @@ def parseOpts(overrideArguments=None):
             action='store_true', dest='writesubtitles',
             help='write subtitle file (currently youtube only)', default=False)
     video_format.add_option('--only-sub',
-            action='store_true', dest='onlysubtitles',
-            help='downloads only the subtitles (no video)', default=False)
+            action='store_true', dest='skip_download',
+            help='[deprecated] alias of --skip-download', default=False)
     video_format.add_option('--all-subs',
             action='store_true', dest='allsubtitles',
             help='downloads all the available subtitles of the video (currently youtube only)', default=False)
@@ -532,7 +532,6 @@ def _real_main(argv=None):
         'writeinfojson': opts.writeinfojson,
         'writethumbnail': opts.writethumbnail,
         'writesubtitles': opts.writesubtitles,
-        'onlysubtitles': opts.onlysubtitles,
         'allsubtitles': opts.allsubtitles,
         'listsubtitles': opts.listsubtitles,
         'subtitlesformat': opts.subtitlesformat,

From f45c185fa9f7bab1714cbde1227c421e170c027a Mon Sep 17 00:00:00 2001
From: Philipp Hagemeister <phihag@phihag.de>
Date: Mon, 13 May 2013 09:20:08 +0200
Subject: [PATCH 205/221] Do not re-encode / to # if / is a platform separator,
 and correctly handle permission errors (Fixes #831)

---
 youtube_dl/utils.py | 19 ++++++++++++++-----
 1 file changed, 14 insertions(+), 5 deletions(-)

diff --git a/youtube_dl/utils.py b/youtube_dl/utils.py
index f2342b10a..616948e10 100644
--- a/youtube_dl/utils.py
+++ b/youtube_dl/utils.py
@@ -1,6 +1,7 @@
 #!/usr/bin/env python
 # -*- coding: utf-8 -*-
 
+import errno
 import gzip
 import io
 import json
@@ -334,12 +335,20 @@ def sanitize_open(filename, open_mode):
         stream = open(encodeFilename(filename), open_mode)
         return (stream, filename)
     except (IOError, OSError) as err:
-        # In case of error, try to remove win32 forbidden chars
-        filename = re.sub(u'[/<>:"\\|\\\\?\\*]', u'#', filename)
+        if err.errno in (errno.EACCES,):
+            raise
 
-        # An exception here should be caught in the caller
-        stream = open(encodeFilename(filename), open_mode)
-        return (stream, filename)
+        # In case of error, try to remove win32 forbidden chars
+        alt_filename = os.path.join(
+                        re.sub(u'[/<>:"\\|\\\\?\\*]', u'#', path_part)
+                        for path_part in os.path.split(filename)
+                       )
+        if alt_filename == filename:
+            raise
+        else:
+            # An exception here should be caught in the caller
+            stream = open(encodeFilename(filename), open_mode)
+            return (stream, alt_filename)
 
 
 def timeconvert(timestr):

From 02030ff7fe47a0f1e6a75a50a2d76b3154545dc2 Mon Sep 17 00:00:00 2001
From: Philipp Hagemeister <phihag@phihag.de>
Date: Mon, 13 May 2013 09:38:27 +0200
Subject: [PATCH 206/221] release 2013.05.13

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

diff --git a/README.md b/README.md
index a9eaed192..2f3c81a7c 100644
--- a/README.md
+++ b/README.md
@@ -116,7 +116,7 @@ which means you can modify it, redistribute it or use it however you like.
     -F, --list-formats         list all available formats (currently youtube
                                only)
     --write-sub                write subtitle file (currently youtube only)
-    --only-sub                 downloads only the subtitles (no video)
+    --only-sub                 [deprecated] alias of --skip-download
     --all-subs                 downloads all the available subtitles of the
                                video (currently youtube only)
     --list-subs                lists all available subtitles for the video
diff --git a/youtube_dl/version.py b/youtube_dl/version.py
index ae9688e17..6619cfecc 100644
--- a/youtube_dl/version.py
+++ b/youtube_dl/version.py
@@ -1,2 +1,2 @@
 
-__version__ = '2013.05.10'
+__version__ = '2013.05.13'

From 5c51028d38e636ad92a11aaab92af9521d878667 Mon Sep 17 00:00:00 2001
From: Philipp Hagemeister <phihag@phihag.de>
Date: Mon, 13 May 2013 13:50:05 +0200
Subject: [PATCH 207/221] release 2013.05.14

---
 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 6619cfecc..dbc928394 100644
--- a/youtube_dl/version.py
+++ b/youtube_dl/version.py
@@ -1,2 +1,2 @@
 
-__version__ = '2013.05.13'
+__version__ = '2013.05.14'

From e30e9318da0b66c29985defc9022dcd92f314e81 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Jaime=20Marqui=CC=81nez=20Ferra=CC=81ndiz?=
 <jaime.marquinez.ferrandiz@gmail.com>
Date: Sat, 11 May 2013 23:04:56 +0200
Subject: [PATCH 208/221] Add base class SearchInfoExtractor for search queries
 IEs

---
 youtube_dl/InfoExtractors.py | 124 ++++++++++++++---------------------
 1 file changed, 48 insertions(+), 76 deletions(-)

diff --git a/youtube_dl/InfoExtractors.py b/youtube_dl/InfoExtractors.py
index 4bcd8b9cd..3e737b8d1 100755
--- a/youtube_dl/InfoExtractors.py
+++ b/youtube_dl/InfoExtractors.py
@@ -188,6 +188,45 @@ class InfoExtractor(object):
             video_info['title'] = playlist_title
         return video_info
 
+class SearchInfoExtractor(InfoExtractor):
+    """
+    Base class for search queries extractors
+    They accept urls in the format _SEARCH_KEY(|all|[0-9]):{query}
+    """
+    _max_results = 0 # The maximum number of results the extractor can get
+
+    @classmethod
+    def _VALID_URL(cls):
+        return r'%s(?P<prefix>|\d+|all):(?P<query>[\s\S]+)' % cls._SEARCH_KEY
+
+    @classmethod
+    def suitable(cls, url):
+        return re.match(cls._VALID_URL() , url) is not None
+
+    def _real_extract(self, query):
+        mobj = re.match(self._VALID_URL(), query)
+        if mobj is None:
+            raise ExtractorError(u'Invalid search query "%s"' % query)
+
+        prefix = mobj.group('prefix')
+        query = mobj.group('query')
+        if prefix == '':
+            return self._get_n_results(query, 1)
+        elif prefix == 'all':
+            return self._get_n_results(query, self._max_results)
+        else:
+            n = int(prefix)
+            if n <= 0:
+                raise ExtractorError(u'invalid download number %s for query "%s"' % (n, query))
+            elif n > self._max_results:
+                self._downloader.report_warning(u'%s returns max %i results (you requested %i)' % (self._SEARCH_KEY, self._max_results, n))
+                n = self._max_results
+            return self._get_n_results(query, n)
+
+    def _get_n_results(self, query, n):
+        """Get a specified number of results for a query"""
+        raise NotImplementedError("This method must be implemented by sublclasses")
+
 
 class YoutubeIE(InfoExtractor):
     """Information extractor for youtube.com."""
@@ -1336,42 +1375,18 @@ class GenericIE(InfoExtractor):
         }]
 
 
-class YoutubeSearchIE(InfoExtractor):
+class YoutubeSearchIE(SearchInfoExtractor):
     """Information Extractor for YouTube search queries."""
-    _VALID_URL = r'ytsearch(\d+|all)?:[\s\S]+'
     _API_URL = 'https://gdata.youtube.com/feeds/api/videos?q=%s&start-index=%i&max-results=50&v=2&alt=jsonc'
-    _max_youtube_results = 1000
+    _max_results = 1000
     IE_NAME = u'youtube:search'
+    _SEARCH_KEY = 'ytsearch'
 
     def report_download_page(self, query, pagenum):
         """Report attempt to download search page with given number."""
         query = query.decode(preferredencoding())
         self._downloader.to_screen(u'[youtube] query "%s": Downloading page %s' % (query, pagenum))
 
-    def _real_extract(self, query):
-        mobj = re.match(self._VALID_URL, query)
-        if mobj is None:
-            raise ExtractorError(u'Invalid search query "%s"' % query)
-
-        prefix, query = query.split(':')
-        prefix = prefix[8:]
-        query = query.encode('utf-8')
-        if prefix == '':
-            return self._get_n_results(query, 1)
-        elif prefix == 'all':
-            self._get_n_results(query, self._max_youtube_results)
-        else:
-            try:
-                n = int(prefix)
-                if n <= 0:
-                    raise ExtractorError(u'Invalid download number %s for query "%s"' % (n, query))
-                elif n > self._max_youtube_results:
-                    self._downloader.report_warning(u'ytsearch returns max %i results (you requested %i)' % (self._max_youtube_results, n))
-                    n = self._max_youtube_results
-                return self._get_n_results(query, n)
-            except ValueError: # parsing prefix as integer fails
-                return self._get_n_results(query, 1)
-
     def _get_n_results(self, query, n):
         """Get a specified number of results for a query"""
 
@@ -1404,30 +1419,12 @@ class YoutubeSearchIE(InfoExtractor):
         return self.playlist_result(videos, query)
 
 
-class GoogleSearchIE(InfoExtractor):
+class GoogleSearchIE(SearchInfoExtractor):
     """Information Extractor for Google Video search queries."""
-    _VALID_URL = r'gvsearch(?P<prefix>|\d+|all):(?P<query>[\s\S]+)'
     _MORE_PAGES_INDICATOR = r'id="pnnext" class="pn"'
-    _max_google_results = 1000
+    _max_results = 1000
     IE_NAME = u'video.google:search'
-
-    def _real_extract(self, query):
-        mobj = re.match(self._VALID_URL, query)
-
-        prefix = mobj.group('prefix')
-        query = mobj.group('query')
-        if prefix == '':
-            return self._get_n_results(query, 1)
-        elif prefix == 'all':
-            return self._get_n_results(query, self._max_google_results)
-        else:
-            n = int(prefix)
-            if n <= 0:
-                raise ExtractorError(u'invalid download number %s for query "%s"' % (n, query))
-            elif n > self._max_google_results:
-                self._downloader.report_warning(u'gvsearch returns max %i results (you requested %i)' % (self._max_google_results, n))
-                n = self._max_google_results
-            return self._get_n_results(query, n)
+    _SEARCH_KEY = 'gvsearch'
 
     def _get_n_results(self, query, n):
         """Get a specified number of results for a query"""
@@ -1453,37 +1450,12 @@ class GoogleSearchIE(InfoExtractor):
             if (pagenum * 10 > n) or not re.search(self._MORE_PAGES_INDICATOR, webpage):
                 return res
 
-class YahooSearchIE(InfoExtractor):
+class YahooSearchIE(SearchInfoExtractor):
     """Information Extractor for Yahoo! Video search queries."""
 
-    _VALID_URL = r'yvsearch(\d+|all)?:[\s\S]+'
-
-    _max_yahoo_results = 1000
+    _max_results = 1000
     IE_NAME = u'screen.yahoo:search'
-
-    def _real_extract(self, query):
-        mobj = re.match(self._VALID_URL, query)
-        if mobj is None:
-            raise ExtractorError(u'Invalid search query "%s"' % query)
-
-        prefix, query = query.split(':')
-        prefix = prefix[8:]
-        query = query.encode('utf-8')
-        if prefix == '':
-            return self._get_n_results(query, 1)
-        elif prefix == 'all':
-            return self._get_n_results(query, self._max_yahoo_results)
-        else:
-            try:
-                n = int(prefix)
-                if n <= 0:
-                    raise ExtractorError(u'Invalid download number %s for query "%s"' % (n, query))
-                elif n > self._max_yahoo_results:
-                    self._downloader.report_warning(u'yvsearch returns max %i results (you requested %i)' % (self._max_yahoo_results, n))
-                    n = self._max_yahoo_results
-                return self._get_n_results(query, n)
-            except ValueError: # parsing prefix as integer fails
-                return self._get_n_results(query, 1)
+    _SEARCH_KEY = 'yvsearch'
 
     def _get_n_results(self, query, n):
         """Get a specified number of results for a query"""

From 99a5ae3f8ed30ee7b6fb723232895d7836afbc2d Mon Sep 17 00:00:00 2001
From: Philipp Hagemeister <phihag@phihag.de>
Date: Mon, 13 May 2013 19:53:52 +0200
Subject: [PATCH 209/221] Simplify generic search IE (Closes #839)

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

diff --git a/youtube_dl/InfoExtractors.py b/youtube_dl/InfoExtractors.py
index 3e737b8d1..ce959a6df 100755
--- a/youtube_dl/InfoExtractors.py
+++ b/youtube_dl/InfoExtractors.py
@@ -190,21 +190,21 @@ class InfoExtractor(object):
 
 class SearchInfoExtractor(InfoExtractor):
     """
-    Base class for search queries extractors
+    Base class for paged search queries extractors.
     They accept urls in the format _SEARCH_KEY(|all|[0-9]):{query}
+    Instances should define _SEARCH_KEY and _MAX_RESULTS.
     """
-    _max_results = 0 # The maximum number of results the extractor can get
 
     @classmethod
-    def _VALID_URL(cls):
-        return r'%s(?P<prefix>|\d+|all):(?P<query>[\s\S]+)' % cls._SEARCH_KEY
+    def _make_valid_url(cls):
+        return r'%s(?P<prefix>|[1-9][0-9]*|all):(?P<query>[\s\S]+)' % cls._SEARCH_KEY
 
     @classmethod
     def suitable(cls, url):
-        return re.match(cls._VALID_URL() , url) is not None
+        return re.match(cls._make_valid_url(), url) is not None
 
     def _real_extract(self, query):
-        mobj = re.match(self._VALID_URL(), query)
+        mobj = re.match(self._make_valid_url(), query)
         if mobj is None:
             raise ExtractorError(u'Invalid search query "%s"' % query)
 
@@ -213,14 +213,14 @@ class SearchInfoExtractor(InfoExtractor):
         if prefix == '':
             return self._get_n_results(query, 1)
         elif prefix == 'all':
-            return self._get_n_results(query, self._max_results)
+            return self._get_n_results(query, self._MAX_RESULTS)
         else:
             n = int(prefix)
             if n <= 0:
                 raise ExtractorError(u'invalid download number %s for query "%s"' % (n, query))
-            elif n > self._max_results:
-                self._downloader.report_warning(u'%s returns max %i results (you requested %i)' % (self._SEARCH_KEY, self._max_results, n))
-                n = self._max_results
+            elif n > self._MAX_RESULTS:
+                self._downloader.report_warning(u'%s returns max %i results (you requested %i)' % (self._SEARCH_KEY, self._MAX_RESULTS, n))
+                n = self._MAX_RESULTS
             return self._get_n_results(query, n)
 
     def _get_n_results(self, query, n):
@@ -1378,7 +1378,7 @@ class GenericIE(InfoExtractor):
 class YoutubeSearchIE(SearchInfoExtractor):
     """Information Extractor for YouTube search queries."""
     _API_URL = 'https://gdata.youtube.com/feeds/api/videos?q=%s&start-index=%i&max-results=50&v=2&alt=jsonc'
-    _max_results = 1000
+    _MAX_RESULTS = 1000
     IE_NAME = u'youtube:search'
     _SEARCH_KEY = 'ytsearch'
 
@@ -1422,7 +1422,7 @@ class YoutubeSearchIE(SearchInfoExtractor):
 class GoogleSearchIE(SearchInfoExtractor):
     """Information Extractor for Google Video search queries."""
     _MORE_PAGES_INDICATOR = r'id="pnnext" class="pn"'
-    _max_results = 1000
+    _MAX_RESULTS = 1000
     IE_NAME = u'video.google:search'
     _SEARCH_KEY = 'gvsearch'
 
@@ -1453,7 +1453,7 @@ class GoogleSearchIE(SearchInfoExtractor):
 class YahooSearchIE(SearchInfoExtractor):
     """Information Extractor for Yahoo! Video search queries."""
 
-    _max_results = 1000
+    _MAX_RESULTS = 1000
     IE_NAME = u'screen.yahoo:search'
     _SEARCH_KEY = 'yvsearch'
 

From 419c64b107896628a159f558abdb298117249b9a Mon Sep 17 00:00:00 2001
From: Philipp Hagemeister <phihag@phihag.de>
Date: Mon, 13 May 2013 19:54:07 +0200
Subject: [PATCH 210/221] Throw a better error if the protocol is invalid

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

diff --git a/youtube_dl/InfoExtractors.py b/youtube_dl/InfoExtractors.py
index ce959a6df..6d6203a1c 100755
--- a/youtube_dl/InfoExtractors.py
+++ b/youtube_dl/InfoExtractors.py
@@ -1304,6 +1304,8 @@ class GenericIE(InfoExtractor):
             opener.add_handler(handler())
 
         response = opener.open(HeadRequest(url))
+        if response is None:
+            raise ExtractorError(u'Invalid URL protocol')
         new_url = response.geturl()
 
         if url == new_url:

From 7bdb17d4d52121624286207489154908fd5a773f Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Jaime=20Marqui=CC=81nez=20Ferra=CC=81ndiz?=
 <jaime.marquinez.ferrandiz@gmail.com>
Date: Tue, 14 May 2013 14:40:40 +0200
Subject: [PATCH 211/221] Add extra_info argument to extract_info and
 process_ie_result

It allows to update the info_dicts with other values

(closes #840)
---
 youtube_dl/FileDownloader.py | 26 ++++++++++++++++++++------
 1 file changed, 20 insertions(+), 6 deletions(-)

diff --git a/youtube_dl/FileDownloader.py b/youtube_dl/FileDownloader.py
index 8a3bdf21b..52017a6c3 100644
--- a/youtube_dl/FileDownloader.py
+++ b/youtube_dl/FileDownloader.py
@@ -436,10 +436,11 @@ class FileDownloader(object):
                 return u'[download] %s upload date is not in range %s' % (date_from_str(date).isoformat(), dateRange)
         return None
         
-    def extract_info(self, url, download=True, ie_key=None):
+    def extract_info(self, url, download=True, ie_key=None, extra_info={}):
         '''
         Returns a list with a dictionary for each video we find.
         If 'download', also downloads the videos.
+        extra_info is a dict containing the extra values to add to each result
          '''
         
         if ie_key:
@@ -463,10 +464,14 @@ class FileDownloader(object):
                     break
                 if isinstance(ie_result, list):
                     # Backwards compatibility: old IE result format
+                    for result in ie_result:
+                        result.update(extra_info)
                     ie_result = {
                         '_type': 'compat_list',
                         'entries': ie_result,
                     }
+                else:
+                    ie_result.update(extra_info)
                 if 'extractor' not in ie_result:
                     ie_result['extractor'] = ie.IE_NAME
                 return self.process_ie_result(ie_result, download=download)
@@ -482,7 +487,7 @@ class FileDownloader(object):
         else:
             self.report_error(u'no suitable InfoExtractor: %s' % url)
         
-    def process_ie_result(self, ie_result, download=True):
+    def process_ie_result(self, ie_result, download=True, extra_info={}):
         """
         Take the result of the ie(may be modified) and resolve all unresolved
         references (URLs, playlist items).
@@ -501,7 +506,12 @@ class FileDownloader(object):
                 self.process_info(ie_result)
             return ie_result
         elif result_type == 'url':
-            return self.extract_info(ie_result['url'], download, ie_key=ie_result.get('ie_key'))
+            # We have to add extra_info to the results because it may be
+            # contained in a playlist
+            return self.extract_info(ie_result['url'],
+                                     download,
+                                     ie_key=ie_result.get('ie_key'),
+                                     extra_info=extra_info)
         elif result_type == 'playlist':
             # We process each entry in the playlist
             playlist = ie_result.get('title', None) or ie_result.get('id', None)
@@ -525,9 +535,13 @@ class FileDownloader(object):
 
             for i,entry in enumerate(entries,1):
                 self.to_screen(u'[download] Downloading video #%s of %s' %(i, n_entries))
-                entry['playlist'] = playlist
-                entry['playlist_index'] = i + playliststart
-                entry_result = self.process_ie_result(entry, download=download)
+                extra = {
+                         'playlist': playlist, 
+                         'playlist_index': i + playliststart,
+                         }
+                entry_result = self.process_ie_result(entry,
+                                                      download=download,
+                                                      extra_info=extra)
                 playlist_results.append(entry_result)
             ie_result['entries'] = playlist_results
             return ie_result

From de5d66d43132db1bf950a97e053cc659e12a145d Mon Sep 17 00:00:00 2001
From: mc2avr <mc2avr@googlemail.com>
Date: Wed, 15 May 2013 23:38:44 +0200
Subject: [PATCH 212/221] MyVideoIE: add rtmp support

---
 youtube_dl/FileDownloader.py |   7 +-
 youtube_dl/InfoExtractors.py | 154 +++++++++++++++++++++++++++++++----
 2 files changed, 145 insertions(+), 16 deletions(-)

diff --git a/youtube_dl/FileDownloader.py b/youtube_dl/FileDownloader.py
index 52017a6c3..75fe0eea9 100644
--- a/youtube_dl/FileDownloader.py
+++ b/youtube_dl/FileDownloader.py
@@ -748,7 +748,7 @@ class FileDownloader(object):
             except (IOError, OSError):
                 self.report_warning(u'Unable to remove downloaded video file')
 
-    def _download_with_rtmpdump(self, filename, url, player_url, page_url, play_path):
+    def _download_with_rtmpdump(self, filename, url, player_url, page_url, play_path, tc_url):
         self.report_destination(filename)
         tmpfilename = self.temp_name(filename)
 
@@ -769,6 +769,8 @@ class FileDownloader(object):
             basic_args += ['--pageUrl', page_url]
         if play_path is not None:
             basic_args += ['-y', play_path]
+        if tc_url is not None:
+            basic_args += ['--tcUrl', url]
         args = basic_args + [[], ['-e', '-k', '1']][self.params.get('continuedl', False)]
         if self.params.get('verbose', False):
             try:
@@ -824,7 +826,8 @@ class FileDownloader(object):
             return self._download_with_rtmpdump(filename, url,
                                                 info_dict.get('player_url', None),
                                                 info_dict.get('page_url', None),
-                                                info_dict.get('play_path', None))
+                                                info_dict.get('play_path', None),
+                                                info_dict.get('tc_url', None))
 
         tmpfilename = self.temp_name(filename)
         stream = None
diff --git a/youtube_dl/InfoExtractors.py b/youtube_dl/InfoExtractors.py
index 6d6203a1c..cd7923c52 100755
--- a/youtube_dl/InfoExtractors.py
+++ b/youtube_dl/InfoExtractors.py
@@ -16,6 +16,9 @@ import xml.etree.ElementTree
 import random
 import math
 import operator
+import hashlib
+import binascii
+import urllib
 
 from .utils import *
 
@@ -1979,37 +1982,160 @@ class MyVideoIE(InfoExtractor):
     _VALID_URL = r'(?:http://)?(?:www\.)?myvideo\.de/watch/([0-9]+)/([^?/]+).*'
     IE_NAME = u'myvideo'
 
+#     Original Code from: https://github.com/dersphere/plugin.video.myvideo_de.git
+#     Copyright (C) 2013 Tristan Fischer (sphere@dersphere.de) - GPLv3
+    def __rc4crypt(self,data, key):
+        x = 0
+        box = list(range(256))
+        for i in list(range(256)):
+            x = (x + box[i] + ord(key[i % len(key)])) % 256
+            box[i], box[x] = box[x], box[i]
+        x = 0
+        y = 0
+        out = []
+        for char in data:
+            x = (x + 1) % 256
+            y = (y + box[x]) % 256
+            box[x], box[y] = box[y], box[x]
+#            out.append(chr(ord(char) ^ box[(box[x] + box[y]) % 256]))
+            out.append(chr(char ^ box[(box[x] + box[y]) % 256]))
+        return ''.join(out)
+
+    def __md5(self,s):
+        return hashlib.md5(s).hexdigest()
+
     def _real_extract(self,url):
         mobj = re.match(self._VALID_URL, url)
         if mobj is None:
-            raise ExtractorError(u'Invalid URL: %s' % url)
+            raise ExtractorError(u'invalid URL: %s' % url)
 
         video_id = mobj.group(1)
 
+        GK = (
+          b'WXpnME1EZGhNRGhpTTJNM01XVmhOREU0WldNNVpHTTJOakpt'
+          b'TW1FMU5tVTBNR05pWkRaa05XRXhNVFJoWVRVd1ptSXhaVEV3'
+          b'TnpsbA0KTVRkbU1tSTRNdz09'
+        )
+
         # Get video webpage
         webpage_url = 'http://www.myvideo.de/watch/%s' % video_id
         webpage = self._download_webpage(webpage_url, video_id)
 
+        mobj = re.search('source src=\'(.+?)[.]([^.]+)\'', webpage)
+        if mobj is not None:
+            self.report_extraction(video_id)
+            video_url = mobj.group(1) + '.flv'
+
+            mobj = re.search('<title>([^<]+)</title>', webpage)
+            if mobj is None:
+                raise ExtractorError(u'Unable to extract title')
+            video_title = mobj.group(1)
+
+            mobj = re.search('[.](.+?)$', video_url)
+            if mobj is None:
+                raise ExtractorError(u'Unable to extract extention')
+            video_ext = mobj.group(1)
+
+            return [{
+                'id':       video_id,
+                'url':      video_url,
+                'uploader': None,
+                'upload_date':  None,
+                'title':    video_title,
+                'ext':      u'flv',
+            }]
+
+        # try encxml
+        params = {}
+        encxml = ''
+        sec = re.search('var flashvars={(.+?)}', webpage).group(1)
+        for (a, b) in re.findall('(.+?):\'(.+?)\',?', sec):
+            if not a == '_encxml':
+                params[a] = b
+            else:
+                encxml = compat_urllib_parse.unquote(b)
+        if not params.get('domain'):
+            params['domain'] = 'www.myvideo.de'
+        xmldata_url = '%s?%s' % (encxml, compat_urllib_parse.urlencode(params))
+        if 'flash_playertype=MTV' in xmldata_url:
+            self._downloader.report_warning(u'avoiding MTV player')
+            xmldata_url = (
+                'http://www.myvideo.de/dynamic/get_player_video_xml.php'
+                '?flash_playertype=D&ID=%s&_countlimit=4&autorun=yes'
+            ) % video_id
+
+        # get enc data
+        enc_data = self._download_webpage(xmldata_url, video_id).split('=')[1]
+        enc_data_b = binascii.unhexlify(enc_data)
+        sk = self.__md5( 
+            base64.b64decode(base64.b64decode(GK)) + 
+            self.__md5( 
+                str(video_id).encode('utf-8') 
+            ).encode('utf-8') 
+        )
+        dec_data = self.__rc4crypt(enc_data_b, sk)
+
+        # extracting infos
         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\'',
-                 webpage)
-        if mobj is None:
-            raise ExtractorError(u'Unable to extract media URL')
-        video_url = mobj.group(1) + ('/%s.flv' % video_id)
 
-        mobj = re.search('<title>([^<]+)</title>', webpage)
+        mobj = re.search('connectionurl=\'(.*?)\'', dec_data)
         if mobj is None:
-            raise ExtractorError(u'Unable to extract title')
+            raise ExtractorError(u'unable to extract rtmpurl')
+        video_rtmpurl = compat_urllib_parse.unquote(mobj.group(1))
+        if 'myvideo2flash' in video_rtmpurl:
+            self._downloader.report_warning(u'forcing RTMPT ...')
+            video_rtmpurl = video_rtmpurl.replace('rtmpe://', 'rtmpt://')
 
+        # extract non rtmp videos
+        if (video_rtmpurl is None) or (video_rtmpurl == ''):
+            mobj = re.search('path=\'(http.*?)\' source=\'(.*?)\'', dec_data)
+            if mobj is None:
+                raise ExtractorError(u'unable to extract url')
+            video_rtmpurl = compat_urllib_parse.unquote(mobj.group(1)) + compat_urllib_parse.unquote(mobj.group(2))
+
+        mobj = re.search('source=\'(.*?)\'', dec_data)
+        if mobj is None:
+            raise ExtractorError(u'unable to extract swfobj')
+        video_file     = compat_urllib_parse.unquote(mobj.group(1))
+
+#        mobj = re.search('path=\'(.*?)\'', dec_data)
+#        if mobj is None:
+#            raise ExtractorError(u'unable to extract filepath')
+#        video_filepath = mobj.group(1)
+
+        if not video_file.endswith('f4m'):
+            ppath, prefix = video_file.split('.')
+            video_playpath = '%s:%s' % (prefix, ppath)
+            video_hls_playlist = ''
+        else:
+            video_playpath = ''
+            video_hls_playlist = (
+                video_filepath + video_file
+            ).replace('.f4m', '.m3u8')
+
+        mobj = re.search('swfobject.embedSWF\(\'(.+?)\'', webpage)
+        if mobj is None:
+            raise ExtractorError(u'unable to extract swfobj')
+        video_swfobj = compat_urllib_parse.unquote(mobj.group(1))
+
+        mobj = re.search("<h1(?: class='globalHd')?>(.*?)</h1>", webpage)
+        if mobj is None:
+            raise ExtractorError(u'unable to extract title')
         video_title = mobj.group(1)
 
         return [{
-            'id':       video_id,
-            'url':      video_url,
-            'uploader': None,
-            'upload_date':  None,
-            'title':    video_title,
-            'ext':      u'flv',
+            'id':                 video_id,
+            'url':                video_rtmpurl,
+            'tc_url':             video_rtmpurl,
+            'uploader':           None,
+            'upload_date':        None,
+            'title':              video_title,
+            'ext':                u'flv',
+            'play_path':          video_playpath,
+            'video_file':         video_file,
+#            'file_path':          video_filepath,
+            'video_hls_playlist': video_hls_playlist,
+            'player_url':         video_swfobj,
         }]
 
 class ComedyCentralIE(InfoExtractor):

From 340fa21198b214d97e73c114fcb27a9d2b04012f Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Jaime=20Marqui=CC=81nez=20Ferra=CC=81ndiz?=
 <jaime.marquinez.ferrandiz@gmail.com>
Date: Sat, 18 May 2013 11:54:18 +0200
Subject: [PATCH 213/221] UstreamIE: get thumbnail and uploader name

---
 test/tests.json              |  3 ++-
 youtube_dl/InfoExtractors.py | 20 ++++++++++++++------
 2 files changed, 16 insertions(+), 7 deletions(-)

diff --git a/test/tests.json b/test/tests.json
index f0e5cd8bf..0a9052f9d 100644
--- a/test/tests.json
+++ b/test/tests.json
@@ -152,7 +152,8 @@
     "file": "20274954.flv",
     "md5": "088f151799e8f572f84eb62f17d73e5c",
     "info_dict": {
-        "title": "Young Americans for Liberty February 7, 2012 2:28 AM"
+        "title": "Young Americans for Liberty February 7, 2012 2:28 AM",
+        "uploader": "Young Americans for Liberty"
     }
   },
   {
diff --git a/youtube_dl/InfoExtractors.py b/youtube_dl/InfoExtractors.py
index 6d6203a1c..112d97a86 100755
--- a/youtube_dl/InfoExtractors.py
+++ b/youtube_dl/InfoExtractors.py
@@ -3301,18 +3301,26 @@ class UstreamIE(InfoExtractor):
         video_id = m.group('videoID')
         video_url = u'http://tcdn.ustream.tv/video/%s' % video_id
         webpage = self._download_webpage(url, video_id)
-        m = re.search(r'data-title="(?P<title>.+)"',webpage)
-        title = m.group('title')
-        m = re.search(r'<a class="state" data-content-type="channel" data-content-id="(?P<uploader>\d+)"',webpage)
-        uploader = m.group('uploader')
+        self.report_extraction(video_id)
+        try:
+            m = re.search(r'data-title="(?P<title>.+)"',webpage)
+            title = m.group('title')
+            m = re.search(r'data-content-type="channel".*?>(?P<uploader>.*?)</a>',
+                          webpage, re.DOTALL)
+            uploader = unescapeHTML(m.group('uploader').strip())
+            m = re.search(r'<link rel="image_src" href="(?P<thumb>.*?)"', webpage)
+            thumb = m.group('thumb')
+        except AttributeError:
+            raise ExtractorError(u'Unable to extract info')
         info = {
                 'id':video_id,
                 'url':video_url,
                 'ext': 'flv',
                 'title': title,
-                'uploader': uploader
+                'uploader': uploader,
+                'thumbnail': thumb,
                   }
-        return [info]
+        return info
 
 class WorldStarHipHopIE(InfoExtractor):
     _VALID_URL = r'https?://(?:www|m)\.worldstar(?:candy|hiphop)\.com/videos/video\.php\?v=(?P<id>.*)'

From d4f76f1674c5fd6d5714a7500bc119b4b230f2b2 Mon Sep 17 00:00:00 2001
From: Filippo Valsorda <filippo.valsorda@gmail.com>
Date: Sat, 18 May 2013 19:17:19 +0200
Subject: [PATCH 214/221] Add support for Howcast.com - closes #835

---
 test/tests.json              | 10 +++++++++
 youtube_dl/InfoExtractors.py | 39 +++++++++++++++++++++++++++++++++++-
 2 files changed, 48 insertions(+), 1 deletion(-)

diff --git a/test/tests.json b/test/tests.json
index 0a9052f9d..740f7756c 100644
--- a/test/tests.json
+++ b/test/tests.json
@@ -441,5 +441,15 @@
         "title": "Obama Celebrates Iraq Victory"
     },
     "skip": "Requires rtmpdump"
+  },
+  {
+    "name": "Howcast",
+    "url": "http://www.howcast.com/videos/390161-How-to-Tie-a-Square-Knot-Properly",
+    "file": "390161.mp4",
+    "md5": "1d7ba54e2c9d7dc6935ef39e00529138",
+    "info_dict":{
+      "title":"How to Tie a Square Knot Properly",
+      "description":"The square knot, also known as the reef knot, is one of the oldest, most basic knots to tie, and can be used in many different ways. Here's the proper way to tie a square knot."
+    }
   }
 ]
diff --git a/youtube_dl/InfoExtractors.py b/youtube_dl/InfoExtractors.py
index 112d97a86..938d2d805 100755
--- a/youtube_dl/InfoExtractors.py
+++ b/youtube_dl/InfoExtractors.py
@@ -4041,7 +4041,7 @@ class RedTubeIE(InfoExtractor):
         
 class InaIE(InfoExtractor):
     """Information Extractor for Ina.fr"""
-    _VALID_URL = r'(?:http://)?(?:www.)?ina\.fr/video/(?P<id>I[0-9]+)/.*'
+    _VALID_URL = r'(?:http://)?(?:www\.)?ina\.fr/video/(?P<id>I[0-9]+)/.*'
 
     def _real_extract(self,url):
         mobj = re.match(self._VALID_URL, url)
@@ -4068,6 +4068,42 @@ class InaIE(InfoExtractor):
             'title':    video_title,
         }]
 
+class HowcastIE(InfoExtractor):
+    """Information Extractor for Ina.fr"""
+    _VALID_URL = r'(?:https?://)?(?:www\.)?howcast\.com/videos/(?P<id>[\d]+)'
+
+    def _real_extract(self, url):
+        mobj = re.match(self._VALID_URL, url)
+
+        video_id = mobj.group('id')
+        webpage_url = 'http://www.howcast.com/videos/' + video_id
+        webpage = self._download_webpage(webpage_url, video_id)
+
+        mobj = re.search(r'\'file\': "(http://mobile-media\.howcast\.com/\d+\.mp4)"', webpage)
+        if mobj is None:
+            raise ExtractorError(u'Unable to extract video URL')
+        video_url = mobj.group(1)
+
+        mobj = re.search(r'<meta content=(?:"([^"]+)"|\'([^\']+)\') property=\'og:title\'', webpage)
+        if mobj is None:
+            raise ExtractorError(u'Unable to extract title')
+        video_title = mobj.group(1) or mobj.group(2)
+
+        mobj = re.search(r'<meta content=(?:"([^"]+)"|\'([^\']+)\') name=\'description\'', webpage)
+        if mobj is None:
+            self._downloader.report_warning(u'unable to extract description')
+            video_description = None
+        else:
+            video_description = mobj.group(1) or mobj.group(2)
+
+        return [{
+            'id':       video_id,
+            'url':      video_url,
+            'ext':      'mp4',
+            'title':    video_title,
+            'description': video_description,
+        }]
+
 def gen_extractors():
     """ Return a list of an instance of every supported extractor.
     The order does matter; the first extractor matched is the one handling the URL.
@@ -4125,6 +4161,7 @@ def gen_extractors():
         BandcampIE(),
         RedTubeIE(),
         InaIE(),
+        HowcastIE(),
         GenericIE()
     ]
 

From 5b0d3cc0cd10c737df20d87aa5842d18549c3c4c Mon Sep 17 00:00:00 2001
From: Anna Bernardi <anna.bernardi.9@gmail.com>
Date: Mon, 20 May 2013 00:25:26 +0200
Subject: [PATCH 215/221] Add support for Vine - closes #845

---
 test/tests.json              |  9 +++++++++
 youtube_dl/InfoExtractors.py | 34 ++++++++++++++++++++++++++++++++--
 2 files changed, 41 insertions(+), 2 deletions(-)

diff --git a/test/tests.json b/test/tests.json
index 740f7756c..195051556 100644
--- a/test/tests.json
+++ b/test/tests.json
@@ -451,5 +451,14 @@
       "title":"How to Tie a Square Knot Properly",
       "description":"The square knot, also known as the reef knot, is one of the oldest, most basic knots to tie, and can be used in many different ways. Here's the proper way to tie a square knot."
     }
+  },
+  {
+    "name": "Vine",
+    "url": "https://vine.co/v/b9KOOWX7HUx",
+    "file": "b9KOOWX7HUx.mp4",
+    "md5": "2f36fed6235b16da96ce9b4dc890940d",
+    "info_dict":{
+      "title":"Chicken."
+    }
   }
 ]
diff --git a/youtube_dl/InfoExtractors.py b/youtube_dl/InfoExtractors.py
index 938d2d805..551969a2e 100755
--- a/youtube_dl/InfoExtractors.py
+++ b/youtube_dl/InfoExtractors.py
@@ -4069,8 +4069,8 @@ class InaIE(InfoExtractor):
         }]
 
 class HowcastIE(InfoExtractor):
-    """Information Extractor for Ina.fr"""
-    _VALID_URL = r'(?:https?://)?(?:www\.)?howcast\.com/videos/(?P<id>[\d]+)'
+    """Information Extractor for Howcast.com"""
+    _VALID_URL = r'(?:https?://)?(?:www\.)?howcast\.com/videos/(?P<id>\d+)'
 
     def _real_extract(self, url):
         mobj = re.match(self._VALID_URL, url)
@@ -4104,6 +4104,35 @@ class HowcastIE(InfoExtractor):
             'description': video_description,
         }]
 
+class VineIE(InfoExtractor):
+    """Information Extractor for Vine.co"""
+    _VALID_URL = r'(?:https?://)?(?:www\.)?vine\.co/v/(?P<id>\w+)'
+
+    def _real_extract(self, url):
+
+        mobj = re.match(self._VALID_URL, url)
+
+        video_id = mobj.group('id')
+        webpage_url = 'https://vine.co/v/' + video_id
+        webpage = self._download_webpage(webpage_url, video_id)
+
+        mobj = re.search(r'<meta property="twitter:player:stream" content="([^"]+)"', webpage)
+        if mobj is None:
+            raise ExtractorError(u'Unable to extract video URL')
+        video_url = mobj.group(1)
+
+        mobj = re.search(r'<meta property="og:title" content="([^"]+)"', webpage)
+        if mobj is None:
+            raise ExtractorError(u'Unable to extract title')
+        video_title = mobj.group(1)
+
+        return [{
+            'id':       video_id,
+            'url':      video_url,
+            'ext':      'mp4',
+            'title':    video_title,
+        }]
+
 def gen_extractors():
     """ Return a list of an instance of every supported extractor.
     The order does matter; the first extractor matched is the one handling the URL.
@@ -4162,6 +4191,7 @@ def gen_extractors():
         RedTubeIE(),
         InaIE(),
         HowcastIE(),
+        VineIE(),
         GenericIE()
     ]
 

From 17bd1b2f4174f9ceb600faf2bd284b676b770c9f Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Jaime=20Marqui=CC=81nez=20Ferra=CC=81ndiz?=
 <jaime.marquinez.ferrandiz@gmail.com>
Date: Mon, 20 May 2013 08:31:03 +0200
Subject: [PATCH 216/221] VineIE: extract more information and minor style
 changes

---
 test/tests.json              |  3 ++-
 youtube_dl/InfoExtractors.py | 26 ++++++++++++++++++++------
 2 files changed, 22 insertions(+), 7 deletions(-)

diff --git a/test/tests.json b/test/tests.json
index 195051556..1ff9ad7ee 100644
--- a/test/tests.json
+++ b/test/tests.json
@@ -458,7 +458,8 @@
     "file": "b9KOOWX7HUx.mp4",
     "md5": "2f36fed6235b16da96ce9b4dc890940d",
     "info_dict":{
-      "title":"Chicken."
+      "title": "Chicken.",
+      "uploader": "Jack Dorsey"
     }
   }
 ]
diff --git a/youtube_dl/InfoExtractors.py b/youtube_dl/InfoExtractors.py
index 551969a2e..64726e698 100755
--- a/youtube_dl/InfoExtractors.py
+++ b/youtube_dl/InfoExtractors.py
@@ -4116,21 +4116,35 @@ class VineIE(InfoExtractor):
         webpage_url = 'https://vine.co/v/' + video_id
         webpage = self._download_webpage(webpage_url, video_id)
 
-        mobj = re.search(r'<meta property="twitter:player:stream" content="([^"]+)"', webpage)
+        self.report_extraction(video_id)
+
+        mobj = re.search(r'<meta property="twitter:player:stream" content="(.+?)"', webpage)
         if mobj is None:
             raise ExtractorError(u'Unable to extract video URL')
         video_url = mobj.group(1)
 
-        mobj = re.search(r'<meta property="og:title" content="([^"]+)"', webpage)
+        mobj = re.search(r'<meta property="og:title" content="(.+?)"', webpage)
         if mobj is None:
             raise ExtractorError(u'Unable to extract title')
         video_title = mobj.group(1)
 
+        mobj = re.search(r'<meta property="og:image" content="(.+?)(\?.*?)?"', webpage)
+        if mobj is None:
+            raise ExtractorError(u'Unable to extract thumbnail')
+        thumbnail = mobj.group(1)
+
+        mobj = re.search(r'<div class="user">.*?<h2>(.+?)</h2>', webpage, re.DOTALL)
+        if mobj is None:
+            raise ExtractorError(u'Unable to extract uploader')
+        uploader = mobj.group(1)
+
         return [{
-            'id':       video_id,
-            'url':      video_url,
-            'ext':      'mp4',
-            'title':    video_title,
+            'id':        video_id,
+            'url':       video_url,
+            'ext':       'mp4',
+            'title':     video_title,
+            'thumbnail': thumbnail,
+            'uploader':  uploader,
         }]
 
 def gen_extractors():

From b1d568f0bc131e2bead64b0c6909fb35378b941a Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Jaime=20Marqui=CC=81nez=20Ferra=CC=81ndiz?=
 <jaime.marquinez.ferrandiz@gmail.com>
Date: Mon, 20 May 2013 08:39:41 +0200
Subject: [PATCH 217/221] HowcastIE: extract thumbnail

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

diff --git a/youtube_dl/InfoExtractors.py b/youtube_dl/InfoExtractors.py
index 64726e698..759658a47 100755
--- a/youtube_dl/InfoExtractors.py
+++ b/youtube_dl/InfoExtractors.py
@@ -4079,6 +4079,8 @@ class HowcastIE(InfoExtractor):
         webpage_url = 'http://www.howcast.com/videos/' + video_id
         webpage = self._download_webpage(webpage_url, video_id)
 
+        self.report_extraction(video_id)
+
         mobj = re.search(r'\'file\': "(http://mobile-media\.howcast\.com/\d+\.mp4)"', webpage)
         if mobj is None:
             raise ExtractorError(u'Unable to extract video URL')
@@ -4096,12 +4098,18 @@ class HowcastIE(InfoExtractor):
         else:
             video_description = mobj.group(1) or mobj.group(2)
 
+        mobj = re.search(r'<meta content=\'(.+?)\' property=\'og:image\'', webpage)
+        if mobj is None:
+            raise ExtractorError(u'Unable to extract thumbnail')
+        thumbnail = mobj.group(1)
+
         return [{
             'id':       video_id,
             'url':      video_url,
             'ext':      'mp4',
             'title':    video_title,
             'description': video_description,
+            'thumbnail': thumbnail,
         }]
 
 class VineIE(InfoExtractor):

From f008688520ad0fadcf80601ce193d352cc0d4bd3 Mon Sep 17 00:00:00 2001
From: Filippo Valsorda <filippo.valsorda@gmail.com>
Date: Mon, 20 May 2013 11:54:21 +0200
Subject: [PATCH 218/221] make rtmpdump inherit the verbose option for
 debugging

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

diff --git a/youtube_dl/FileDownloader.py b/youtube_dl/FileDownloader.py
index 75fe0eea9..49f3a8712 100644
--- a/youtube_dl/FileDownloader.py
+++ b/youtube_dl/FileDownloader.py
@@ -763,6 +763,7 @@ class FileDownloader(object):
         # the connection was interrumpted and resuming appears to be
         # possible. This is part of rtmpdump's normal usage, AFAIK.
         basic_args = ['rtmpdump', '-q', '-r', url, '-o', tmpfilename]
+        if self.params.get('verbose', False): basic_args[1] = '-v'
         if player_url is not None:
             basic_args += ['-W', player_url]
         if page_url is not None:

From b31756c18e708605f1ba0257f8a28234c229bf70 Mon Sep 17 00:00:00 2001
From: Filippo Valsorda <filippo.valsorda@gmail.com>
Date: Mon, 20 May 2013 11:57:10 +0200
Subject: [PATCH 219/221] Python 2 compat fixes for MyVideo.de rtmpdump
 downloads

---
 youtube_dl/InfoExtractors.py | 38 +++++++++++++++++-------------------
 youtube_dl/utils.py          |  4 ++++
 2 files changed, 22 insertions(+), 20 deletions(-)

diff --git a/youtube_dl/InfoExtractors.py b/youtube_dl/InfoExtractors.py
index 2dd1c49f6..c38592e79 100755
--- a/youtube_dl/InfoExtractors.py
+++ b/youtube_dl/InfoExtractors.py
@@ -1982,27 +1982,27 @@ class MyVideoIE(InfoExtractor):
     _VALID_URL = r'(?:http://)?(?:www\.)?myvideo\.de/watch/([0-9]+)/([^?/]+).*'
     IE_NAME = u'myvideo'
 
-#     Original Code from: https://github.com/dersphere/plugin.video.myvideo_de.git
-#     Copyright (C) 2013 Tristan Fischer (sphere@dersphere.de) - GPLv3
+    # Original Code from: https://github.com/dersphere/plugin.video.myvideo_de.git
+    # Released into the Public Domain by Tristan Fischer on 2013-05-19
+    # https://github.com/rg3/youtube-dl/pull/842
     def __rc4crypt(self,data, key):
         x = 0
         box = list(range(256))
         for i in list(range(256)):
-            x = (x + box[i] + ord(key[i % len(key)])) % 256
+            x = (x + box[i] + compat_ord(key[i % len(key)])) % 256
             box[i], box[x] = box[x], box[i]
         x = 0
         y = 0
-        out = []
+        out = ''
         for char in data:
             x = (x + 1) % 256
             y = (y + box[x]) % 256
             box[x], box[y] = box[y], box[x]
-#            out.append(chr(ord(char) ^ box[(box[x] + box[y]) % 256]))
-            out.append(chr(char ^ box[(box[x] + box[y]) % 256]))
-        return ''.join(out)
+            out += chr(compat_ord(char) ^ box[(box[x] + box[y]) % 256])
+        return out
 
     def __md5(self,s):
-        return hashlib.md5(s).hexdigest()
+        return hashlib.md5(s).hexdigest().encode()
 
     def _real_extract(self,url):
         mobj = re.match(self._VALID_URL, url)
@@ -2046,9 +2046,13 @@ class MyVideoIE(InfoExtractor):
             }]
 
         # try encxml
+        mobj = re.search('var flashvars={(.+?)}', webpage)
+        if mobj is None:
+            raise ExtractorError(u'Unable to extract video')
+
         params = {}
         encxml = ''
-        sec = re.search('var flashvars={(.+?)}', webpage).group(1)
+        sec = mobj.group(1)
         for (a, b) in re.findall('(.+?):\'(.+?)\',?', sec):
             if not a == '_encxml':
                 params[a] = b
@@ -2067,11 +2071,11 @@ class MyVideoIE(InfoExtractor):
         # get enc data
         enc_data = self._download_webpage(xmldata_url, video_id).split('=')[1]
         enc_data_b = binascii.unhexlify(enc_data)
-        sk = self.__md5( 
-            base64.b64decode(base64.b64decode(GK)) + 
-            self.__md5( 
-                str(video_id).encode('utf-8') 
-            ).encode('utf-8') 
+        sk = self.__md5(
+            base64.b64decode(base64.b64decode(GK)) +
+            self.__md5(
+                str(video_id).encode('utf-8')
+            )
         )
         dec_data = self.__rc4crypt(enc_data_b, sk)
 
@@ -2098,11 +2102,6 @@ class MyVideoIE(InfoExtractor):
             raise ExtractorError(u'unable to extract swfobj')
         video_file     = compat_urllib_parse.unquote(mobj.group(1))
 
-#        mobj = re.search('path=\'(.*?)\'', dec_data)
-#        if mobj is None:
-#            raise ExtractorError(u'unable to extract filepath')
-#        video_filepath = mobj.group(1)
-
         if not video_file.endswith('f4m'):
             ppath, prefix = video_file.split('.')
             video_playpath = '%s:%s' % (prefix, ppath)
@@ -2133,7 +2132,6 @@ class MyVideoIE(InfoExtractor):
             'ext':                u'flv',
             'play_path':          video_playpath,
             'video_file':         video_file,
-#            'file_path':          video_filepath,
             'video_hls_playlist': video_hls_playlist,
             'player_url':         video_swfobj,
         }]
diff --git a/youtube_dl/utils.py b/youtube_dl/utils.py
index 616948e10..63d9d0ae5 100644
--- a/youtube_dl/utils.py
+++ b/youtube_dl/utils.py
@@ -150,6 +150,10 @@ try:
 except NameError:
     compat_chr = chr
 
+def compat_ord(c):
+    if type(c) is int: return c
+    else: return ord(c)
+
 std_headers = {
     'User-Agent': 'Mozilla/5.0 (X11; Linux x86_64; rv:10.0) Gecko/20100101 Firefox/10.0',
     'Accept-Charset': 'ISO-8859-1,utf-8;q=0.7,*;q=0.7',

From afef36c950fd158d7bcfb6a1990d666241949b63 Mon Sep 17 00:00:00 2001
From: Anna Bernardi <anna.bernardi.9@gmail.com>
Date: Mon, 20 May 2013 23:18:40 +0200
Subject: [PATCH 220/221] add support for Flickr videos - closes #261

---
 test/tests.json              | 11 +++++++
 youtube_dl/InfoExtractors.py | 64 ++++++++++++++++++++++++++++++++++++
 2 files changed, 75 insertions(+)

diff --git a/test/tests.json b/test/tests.json
index 1ff9ad7ee..eed062813 100644
--- a/test/tests.json
+++ b/test/tests.json
@@ -461,5 +461,16 @@
       "title": "Chicken.",
       "uploader": "Jack Dorsey"
     }
+  },
+  {
+    "name": "Flickr",
+    "url": "http://www.flickr.com/photos/forestwander-nature-pictures/5645318632/in/photostream/",
+    "file": "5645318632.mp4",
+    "md5": "6fdc01adbc89d72fc9c4f15b4a4ba87b",
+    "info_dict":{
+      "title": "Dark Hollow Waterfalls",
+      "uploader_id": "forestwander-nature-pictures",
+      "description": "Waterfalls in the Springtime at Dark Hollow Waterfalls. These are located just off of Skyline Drive in Virginia. They are only about 6/10 of a mile hike but it is a pretty steep hill and a good climb back up."
+    }
   }
 ]
diff --git a/youtube_dl/InfoExtractors.py b/youtube_dl/InfoExtractors.py
index c38592e79..fe47e5254 100755
--- a/youtube_dl/InfoExtractors.py
+++ b/youtube_dl/InfoExtractors.py
@@ -4279,6 +4279,69 @@ class VineIE(InfoExtractor):
             'uploader':  uploader,
         }]
 
+class FlickrIE(InfoExtractor):
+    """Information Extractor for Flickr videos"""
+    _VALID_URL = r'(?:https?://)?(?:www\.)?flickr\.com/photos/(?P<uploader_id>[\w\-]+)/(?P<id>\d+).*'
+
+    def _real_extract(self, url):
+        mobj = re.match(self._VALID_URL, url)
+
+        video_id = mobj.group('id')
+        video_uploader_id = mobj.group('uploader_id')
+        webpage_url = 'http://www.flickr.com/photos/' + video_uploader_id + '/' + video_id
+        webpage = self._download_webpage(webpage_url, video_id)
+
+        self.report_extraction(video_id)
+        
+        mobj = re.search(r"photo_secret: '(\w+)'", webpage)
+        if mobj is None:
+            raise ExtractorError(u'Unable to extract video secret')
+        secret = mobj.group(1)
+
+        first_url = 'https://secure.flickr.com/apps/video/video_mtl_xml.gne?v=x&photo_id=' + video_id + '&secret=' + secret + '&bitrate=700&target=_self'
+        first_xml = self._download_webpage(first_url, video_id)
+
+        mobj = re.search(r'<Item id="id">(\d+-\d+)</Item>', first_xml)
+        if mobj is None:
+            raise ExtractorError(u'Unable to extract node_id')
+        node_id = mobj.group(1)
+
+        second_url = 'https://secure.flickr.com/video_playlist.gne?node_id=' + node_id + '&tech=flash&mode=playlist&bitrate=700&secret=' + secret + '&rd=video.yahoo.com&noad=1'
+        second_xml = self._download_webpage(second_url, video_id)
+
+        mobj = re.search(r'<STREAM APP="(.+?)" FULLPATH="(.+?)"', second_xml)
+        if mobj is None:
+            raise ExtractorError(u'Unable to extract video url')
+        video_url = mobj.group(1) + unescapeHTML(mobj.group(2))
+
+        mobj = re.search(r'<meta property="og:title" content=(?:"([^"]+)"|\'([^\']+)\')', webpage)
+        if mobj is None:
+            raise ExtractorError(u'Unable to extract title')
+        video_title = mobj.group(1) or mobj.group(2)
+
+        mobj = re.search(r'<meta property="og:description" content=(?:"([^"]+)"|\'([^\']+)\')', webpage)
+        if mobj is None:
+            self._downloader.report_warning(u'unable to extract description')
+            video_description = None
+        else:
+            video_description = mobj.group(1) or mobj.group(2)
+
+        mobj = re.search(r'<meta property="og:image" content=(?:"([^"]+)"|\'([^\']+)\')', webpage)
+        if mobj is None:
+            raise ExtractorError(u'Unable to extract thumbnail')
+        thumbnail = mobj.group(1) or mobj.group(2)
+
+        return [{
+            'id':       video_id,
+            'url':      video_url,
+            'ext':      'mp4',
+            'title':    video_title,
+            'description': video_description,
+            'thumbnail': thumbnail,
+            'uploader_id': video_uploader_id,
+        }]
+
+
 def gen_extractors():
     """ Return a list of an instance of every supported extractor.
     The order does matter; the first extractor matched is the one handling the URL.
@@ -4338,6 +4401,7 @@ def gen_extractors():
         InaIE(),
         HowcastIE(),
         VineIE(),
+        FlickrIE(),
         GenericIE()
     ]
 

From 45014296be276399f6d4b761e6ffec3a6c6b292b Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Jaime=20Marqui=CC=81nez=20Ferra=CC=81ndiz?=
 <jaime.marquinez.ferrandiz@gmail.com>
Date: Tue, 21 May 2013 14:37:32 +0200
Subject: [PATCH 221/221] Add TeamcocoIE (closes #212)

---
 test/tests.json              | 10 ++++++++
 youtube_dl/InfoExtractors.py | 46 ++++++++++++++++++++++++++++++++++++
 2 files changed, 56 insertions(+)

diff --git a/test/tests.json b/test/tests.json
index eed062813..f57ebf1c9 100644
--- a/test/tests.json
+++ b/test/tests.json
@@ -472,5 +472,15 @@
       "uploader_id": "forestwander-nature-pictures",
       "description": "Waterfalls in the Springtime at Dark Hollow Waterfalls. These are located just off of Skyline Drive in Virginia. They are only about 6/10 of a mile hike but it is a pretty steep hill and a good climb back up."
     }
+  },
+  {
+    "name": "Teamcoco",
+    "url": "http://teamcoco.com/video/louis-ck-interview-george-w-bush",
+    "file": "19705.mp4",
+    "md5": "27b6f7527da5acf534b15f21b032656e",
+    "info_dict":{
+      "title": "Louis C.K. Interview Pt. 1 11/3/11",
+      "description": "Louis C.K. got starstruck by George W. Bush, so what? Part one."
+    }
   }
 ]
diff --git a/youtube_dl/InfoExtractors.py b/youtube_dl/InfoExtractors.py
index fe47e5254..6b644e15f 100755
--- a/youtube_dl/InfoExtractors.py
+++ b/youtube_dl/InfoExtractors.py
@@ -4341,6 +4341,51 @@ class FlickrIE(InfoExtractor):
             'uploader_id': video_uploader_id,
         }]
 
+class TeamcocoIE(InfoExtractor):
+    _VALID_URL = r'http://teamcoco\.com/video/(?P<url_title>.*)'
+
+    def _real_extract(self, url):
+        mobj = re.match(self._VALID_URL, url)
+        if mobj is None:
+            raise ExtractorError(u'Invalid URL: %s' % url)
+        url_title = mobj.group('url_title')
+        webpage = self._download_webpage(url, url_title)
+
+        mobj = re.search(r'<article class="video" data-id="(\d+?)"', webpage)
+        video_id = mobj.group(1)
+
+        self.report_extraction(video_id)
+
+        mobj = re.search(r'<meta property="og:title" content="(.+?)"', webpage)
+        if mobj is None:
+            raise ExtractorError(u'Unable to extract title')
+        video_title = mobj.group(1)
+
+        mobj = re.search(r'<meta property="og:image" content="(.+?)"', webpage)
+        if mobj is None:
+            raise ExtractorError(u'Unable to extract thumbnail')
+        thumbnail = mobj.group(1)
+
+        mobj = re.search(r'<meta property="og:description" content="(.*?)"', webpage)
+        if mobj is None:
+            raise ExtractorError(u'Unable to extract description')
+        description = mobj.group(1)
+
+        data_url = 'http://teamcoco.com/cvp/2.0/%s.xml' % video_id
+        data = self._download_webpage(data_url, video_id, 'Downloading data webpage')
+        mobj = re.search(r'<file type="high".*?>(.*?)</file>', data)
+        if mobj is None:
+            raise ExtractorError(u'Unable to extract video url')
+        video_url = mobj.group(1)
+
+        return [{
+            'id':          video_id,
+            'url':         video_url,
+            'ext':         'mp4',
+            'title':       video_title,
+            'thumbnail':   thumbnail,
+            'description': description,
+        }]
 
 def gen_extractors():
     """ Return a list of an instance of every supported extractor.
@@ -4402,6 +4447,7 @@ def gen_extractors():
         HowcastIE(),
         VineIE(),
         FlickrIE(),
+        TeamcocoIE(),
         GenericIE()
     ]