bestvideo+bestaudio), output to given
container format. One of mkv, mp4, ogg,
webm, flv. Ignored if no merge is required
- --allow-unplayable-formats Allow unplayable formats to be listed and
- downloaded. All video post-processing will
- also be turned off
- --no-allow-unplayable-formats Do not allow unplayable formats to be
- listed or downloaded (default)
## Subtitle Options:
--write-subs Write subtitle file
--test Download only part of video for testing extractors
--youtube-print-sig-code For testing youtube signatures
+ --allow-unplayable-formats List unplayable formats also
+ --no-allow-unplayable-formats Default
#### Old aliases
self.report_warning(
'Python version %d.%d is not supported! Please update to Python 3.6 or above' % sys.version_info[:2])
+ if self.params.get('allow_unplayable_formats'):
+ self.report_warning(
+ 'You have asked for unplayable formats to be listed/downloaded. '
+ 'This is a developer option intended for debugging. '
+ 'If you experience any issues while using this option, DO NOT open a bug report')
+
def check_deprecated(param, option, suggestion):
if self.params.get(param) is not None:
self.report_warning('%s is deprecated. Use %s instead' % (option, suggestion))
except UnicodeEncodeError:
self.to_screen('Deleting existing file')
+ def raise_no_formats(self, has_drm=False, forced=False):
+ msg = 'This video is DRM protected' if has_drm else 'No video formats found!'
+ expected = self.params.get('ignore_no_formats_error')
+ if forced or not expected:
+ raise ExtractorError(msg, expected=has_drm or expected)
+ else:
+ self.report_warning(msg)
+
def parse_outtmpl(self):
outtmpl_dict = self.params.get('outtmpl', {})
if not isinstance(outtmpl_dict, dict):
else:
formats = info_dict['formats']
+ if not self.params.get('allow_unplayable_formats'):
+ formats = [f for f in formats if not f.get('has_drm')]
+ info_dict['__has_drm'] = len(info_dict.get('formats') or ['']) > len(formats)
+
if not formats:
- if not self.params.get('ignore_no_formats_error'):
- raise ExtractorError('No video formats found!')
- else:
- self.report_warning('No video formats found!')
+ self.raise_no_formats(info_dict.get('__has_drm'))
def is_wellformed(f):
url = f.get('url')
# TODO Central sorting goes here
- if formats and formats[0] is not info_dict:
+ if not formats or formats[0] is not info_dict:
# only set the 'formats' fields if the original info_dict list them
# otherwise we end up with a circular reference, the first (and unique)
# element in the 'formats' field in info_dict is info_dict itself,
self.list_thumbnails(info_dict)
if self.params.get('listformats'):
if not info_dict.get('formats') and not info_dict.get('url'):
- raise ExtractorError('No video formats found', expected=True)
- self.list_formats(info_dict)
+ self.to_screen('%s has no formats' % info_dict['id'])
+ else:
+ self.list_formats(info_dict)
if self.params.get('listsubtitles'):
if 'automatic_captions' in info_dict:
self.list_subtitles(
self.to_stdout(json.dumps(self.sanitize_info(info_dict)))
def dl(self, name, info, subtitle=False, test=False):
+ if not info.get('url'):
+ self.raise_no_formats(info.get('__has_drm'), forced=True)
if test:
verbose = self.params.get('verbose')
error.get('message') or error.get('error_subcode') or error['error_code'], expected=True)
elif (not self.get_param('allow_unplayable_formats')
and sources and num_drm_sources == len(sources)):
- raise ExtractorError('This video is DRM protected.', expected=True)
+ self.report_drm(video_id)
self._sort_formats(formats)
is_live = item.get('type') == 'LIVE'
formats = []
for format_id, stream_url in item.get('streamUrls', {}).items():
- if (not self.get_param('allow_unplayable_formats')
- and 'drmOnly=true' in stream_url):
- continue
if 'playerType=flash' in stream_url:
stream_formats = self._extract_m3u8_formats(
stream_url, playlist_id, 'mp4', 'm3u8_native',
stream_formats = self._extract_mpd_formats(
stream_url, playlist_id,
mpd_id='dash-%s' % format_id, fatal=False)
+ if 'drmOnly=true' in stream_url:
+ for f in stream_formats:
+ f['has_drm'] = True
# See https://github.com/ytdl-org/youtube-dl/issues/12119#issuecomment-280037031
if format_id == 'audioDescription':
for f in stream_formats:
width : height ratio as float.
* no_resume The server does not support resuming the
(HTTP or RTMP) download. Boolean.
+ * has_drm The format has DRM and cannot be downloaded. Boolean
* downloader_options A dictionary of downloader options as
described in FileDownloader
RTMP formats can also have the additional fields: page_url,
return self._downloader.params.get(name, default, *args, **kwargs)
return default
+ def report_drm(self, video_id, partial=False):
+ self.raise_no_formats('This video is DRM protected', expected=True, video_id=video_id)
+
def report_extraction(self, id_or_name):
"""Report information extraction."""
self.to_screen('%s: Extracting information' % id_or_name)
def _sort_formats(self, formats, field_preference=[]):
if not formats:
- if self.get_param('ignore_no_formats_error'):
- return
- raise ExtractorError('No video formats found')
+ return
format_sort = self.FormatSort() # params and to_screen are taken from the downloader
format_sort.evaluate_params(self._downloader.params, field_preference)
if self.get_param('verbose', False):
if '#EXT-X-FAXS-CM:' in m3u8_doc: # Adobe Flash Access
return formats, subtitles
- if (not self.get_param('allow_unplayable_formats')
- and re.search(r'#EXT-X-SESSION-KEY:.*?URI="skd://', m3u8_doc)): # Apple FairPlay
- return formats, subtitles
+ has_drm = re.search(r'#EXT-X-SESSION-KEY:.*?URI="skd://', m3u8_doc)
def format_url(url):
return url if re.match(r'^https?://', url) else compat_urlparse.urljoin(m3u8_url, url)
'protocol': entry_protocol,
'preference': preference,
'quality': quality,
+ 'has_drm': has_drm,
} for idx in _extract_m3u8_playlist_indices(m3u8_doc=m3u8_doc)]
return formats, subtitles
extract_Initialization(segment_template)
return ms_info
- skip_unplayable = not self.get_param('allow_unplayable_formats')
-
mpd_duration = parse_duration(mpd_doc.get('mediaPresentationDuration'))
formats = []
subtitles = {}
'timescale': 1,
})
for adaptation_set in period.findall(_add_ns('AdaptationSet')):
- if skip_unplayable and is_drm_protected(adaptation_set):
- continue
adaption_set_ms_info = extract_multisegment_info(adaptation_set, period_ms_info)
for representation in adaptation_set.findall(_add_ns('Representation')):
- if skip_unplayable and is_drm_protected(representation):
- continue
representation_attrib = adaptation_set.attrib.copy()
representation_attrib.update(representation.attrib)
# According to [1, 5.3.7.2, Table 9, page 41], @mimeType is mandatory
'acodec': 'none',
'vcodec': 'none',
}
+ if is_drm_protected(adaptation_set) or is_drm_protected(representation):
+ f['has_drm'] = True
representation_ms_info = extract_multisegment_info(representation, adaption_set_ms_info)
def prepare_template(template_name, identifiers):
"""
if ism_doc.get('IsLive') == 'TRUE':
return [], {}
- if (not self.get_param('allow_unplayable_formats')
- and ism_doc.find('Protection') is not None):
- return [], {}
duration = int(ism_doc.attrib['Duration'])
timescale = int_or_none(ism_doc.get('TimeScale')) or 10000000
'acodec': 'none' if stream_type == 'video' else fourcc,
'protocol': 'ism',
'fragments': fragments,
+ 'has_drm': ism_doc.find('Protection') is not None,
'_download_params': {
'stream_type': stream_type,
'duration': duration,
formats.extend(self._parse_smil_formats(
smil, smil_url, video_id, namespace))
if not formats and video.get('drm'):
- self.raise_no_formats('This video is DRM protected.', expected=True)
+ self.report_drm(video_id)
self._sort_formats(formats)
subtitles = {}
'width': mfs_info['width'],
'height': mfs_info['height'],
})
- if not formats and has_drm and not ignore_no_formats:
- raise ExtractorError('The video is DRM protected', expected=True)
+ if not formats and has_drm:
+ self.report_drm(video_id)
self._sort_formats(formats)
description = media.get('Description')
'http://api.globovideos.com/videos/%s/playlist' % video_id,
video_id)['videos'][0]
if not self.get_param('allow_unplayable_formats') and video.get('encrypted') is True:
- raise ExtractorError('This video is DRM protected.', expected=True)
+ self.report_drm(video_id)
title = video['title']
title = video_data['title']
if not self.get_param('allow_unplayable_formats') and video_data.get('drmProtected'):
- raise ExtractorError('This video is DRM protected.', expected=True)
+ self.report_drm(video_id)
+
headers = {'Referer': 'https://www.hotstar.com/in'}
formats = []
subs = {}
from .common import InfoExtractor
from ..utils import (
- ExtractorError,
float_or_none,
int_or_none,
parse_iso8601,
if (not self.get_param('allow_unplayable_formats')
and try_get(content_package, lambda x: x['Constraints']['Security']['Type'])):
- raise ExtractorError('This video is DRM protected.', expected=True)
+ self.report_drm(content_id)
manifest_base_url = content_package_url + 'manifest.'
formats = []
video_data = common_data['video']
- if not self.get_param('allow_unplayable_formats') and video_data.get('drm'):
- raise ExtractorError('This video is DRM protected.', expected=True)
-
brightcove_id = video_data.get('brightcoveId') or 'ref:' + video_data['referenceId']
video_id = compat_str(video_data.get('id') or brightcove_id)
+
+ if not self.get_param('allow_unplayable_formats') and video_data.get('drm'):
+ self.report_drm(video_id)
+
title = common_data['name']
thumbnails = [{
if not formats:
if not self.get_param('allow_unplayable_formats') and drm:
- self.raise_no_formats('This video is DRM protected.', expected=True)
- return
+ self.report_drm(video_id)
self._sort_formats(formats)
})[0]
if not self.get_param('allow_unplayable_formats') and video.get('is_protected') is True:
- raise ExtractorError('This video is DRM protected.', expected=True)
+ self.report_drm(clip_id)
formats = []
if self._ACCESS_ID:
(lambda x: x['rights_management']['rights']['drm'],
lambda x: x['program_info']['rights_management']['rights']['drm']),
dict):
- raise ExtractorError('This video is DRM protected.', expected=True)
+ self.report_drm(video_id)
title = media['name']
video = media['video']
if not formats:
if (not self.get_param('allow_unplayable_formats')
and xpath_text(video_xml, './Clip/DRM', default=None)):
- self.raise_no_formats('This video is DRM protected.', expected=True)
+ self.report_drm(video_id)
ns_st_cds = pv('ns_st_cds')
if ns_st_cds != 'free':
raise ExtractorError('This video is %s.' % ns_st_cds, expected=True)
'playout/new/url/' + video_id, video_id)['playout']
if not self.get_param('allow_unplayable_formats') and playout.get('drm'):
- raise ExtractorError('This video is DRM protected.', expected=True)
+ self.report_drm(video_id)
formats = self._extract_m3u8_formats(re.sub(
# https://docs.aws.amazon.com/mediapackage/latest/ug/manifest-filtering.html
content = self._call_api(
'1.5', 'IN/CONTENT/VIDEOURL/VOD/' + video_id, video_id)
if not self.get_param('allow_unplayable_formats') and content.get('isEncrypted'):
- raise ExtractorError('This video is DRM protected.', expected=True)
+ self.report_drm(video_id)
dash_url = content['videoURL']
headers = {
'x-playback-session-id': '%s-%d' % (uuid.uuid4().hex, time.time() * 1000)
for meta in (info.get('Metas') or []):
if (not self.get_param('allow_unplayable_formats')
and meta.get('Key') == 'Encryption' and meta.get('Value') == '1'):
- self.raise_no_formats(
- 'This video is DRM protected.', expected=True)
+ self.report_drm(video_id)
# Most likely because geo-blocked if no formats and no DRM
self._sort_formats(formats)
'filesize': int_or_none(item.get('fileSize')),
})
if not formats and data.get('drmProtected'):
- self.raise_no_formats('This video is DRM protected.', expected=True)
+ self.report_drm(video_id)
self._sort_formats(formats)
thumbnails = [{
formats = []
if stream_meta.get('is_drm'):
if not self.get_param('allow_unplayable_formats'):
- self.raise_no_formats(
- 'This video is DRM protected.', expected=True)
+ self.report_drm(video_id)
if stream_meta.get('is_premium'):
sources = self._download_json(
'https://www.vidio.com/interactions_stream.json?video_id=%s&type=livestreamings' % video_id,
from .common import InfoExtractor
from ..utils import (
- ExtractorError,
merge_dicts,
urljoin,
)
r'encryption%3D(c(?:enc|bc(?:s-aapl)?))',
m3u8_url, 'encryption', default=None)
if encryption in ('cenc', 'cbcs-aapl'):
- raise ExtractorError('This video is DRM protected.', expected=True)
+ self.report_drm(video_id)
formats = self._extract_m3u8_formats(
m3u8_url, video_id, 'mp4', entry_protocol='m3u8_native',
extract_formats({delivery.get('format'): delivery.get('url')})
if not formats:
if delivery.get('drm'):
- self.raise_no_formats('This video is DRM protected.', expected=True)
+ self.report_drm(video_id)
manifest_urls = self._download_json(
'http://www.wat.tv/get/webhtml/' + video_id, video_id, fatal=False)
if manifest_urls:
if not formats:
if not self.get_param('allow_unplayable_formats') and traverse_obj(streaming_data, (..., 'licenseInfos')):
- self.raise_no_formats(
- 'This video is DRM protected.', expected=True)
+ self.report_drm(video_id)
pemr = get_first(
playability_statuses,
('errorScreen', 'playerErrorMessageRenderer'), expected_type=dict) or {}
video_format.add_option(
'--allow-unplayable-formats',
action='store_true', dest='allow_unplayable_formats', default=False,
- help=(
- 'Allow unplayable formats to be listed and downloaded. '
- 'All video post-processing will also be turned off'))
+ help=optparse.SUPPRESS_HELP)
video_format.add_option(
'--no-allow-unplayable-formats',
action='store_false', dest='allow_unplayable_formats',
- help='Do not allow unplayable formats to be listed or downloaded (default)')
+ help=optparse.SUPPRESS_HELP)
subtitles = optparse.OptionGroup(parser, 'Subtitle Options')
subtitles.add_option(
projects / yt-dlp.git / commitdiff
