Mirroring
/
yt-dlp
mirror of https://github.com/yt-dlp/yt-dlp
1
0
Fork 0
Code Issues Releases Wiki Activity

[common] add a generic support for mpd manifests

Browse Source
pull/8/head
remitamine 9 years ago
parent 0436157b95
commit 1bac34556f
1 changed files with 133 additions and 67 deletions
Show Stats Download Patch File Download Diff File

200
youtube_dl/extractor/common.py
Unescape Escape View File

@ -10,6 +10,7 @@ import re
import socket import socket
import sys import sys
import time import time
import math
from ..compat import ( from ..compat import (
compat_cookiejar, compat_cookiejar,
@ -44,6 +45,7 @@ from ..utils import (
xpath_text, xpath_text,
xpath_with_ns, xpath_with_ns,
determine_protocol, determine_protocol,
parse_duration,
) )
@ -1330,81 +1332,145 @@ class InfoExtractor(object):
}) })
return entries return entries
def _download_dash_manifest(self, dash_manifest_url, video_id, fatal=True): def _extract_mpd_formats(self, mpd_url, video_id, mpd_id=None, note=None, errnote=None, fatal=True, formats_dict={}):
return self._download_xml( res = self._download_webpage_handle(
dash_manifest_url, video_id, mpd_url, video_id,
note='Downloading DASH manifest', note=note or 'Downloading MPD manifest',
errnote='Could not download DASH manifest', errnote=errnote or 'Failed to download MPD manifest',
fatal=fatal) fatal=fatal)
if res is False:
def _extract_dash_manifest_formats(self, dash_manifest_url, video_id, fatal=True, namespace=None, formats_dict={}):
dash_doc = self._download_dash_manifest(dash_manifest_url, video_id, fatal)
if dash_doc is False:
return [] return []
mpd, urlh = res
mpd_base_url = re.match(r'https?://.+/', urlh.geturl()).group()
return self._parse_mpd(
compat_etree_fromstring(mpd.encode('utf-8')), mpd_id, mpd_base_url, formats_dict=formats_dict)
return self._parse_dash_manifest( def _parse_mpd(self, mpd_doc, mpd_id=None, mpd_base_url='', formats_dict={}):
dash_doc, namespace=namespace, formats_dict=formats_dict) if mpd_doc.get('type') == 'dynamic':
return []
def _parse_dash_manifest(self, dash_doc, namespace=None, formats_dict={}): def extract_multisegment_info(element, ms_parent_info):
def _add_ns(path): ms_info = ms_parent_info.copy()
return self._xpath_ns(path, namespace) segment_list = element.find(self._xpath_ns('SegmentList', namespace))
if segment_list is not None:
segment_urls_e = segment_list.findall(self._xpath_ns('SegmentURL', namespace))
if segment_urls_e:
ms_info['segment_urls'] = [segment.attrib['media'] for segment in segment_urls_e]
initialization = segment_list.find(self._xpath_ns('Initialization', namespace))
if initialization is not None:
ms_info['initialization_url'] = initialization.attrib['sourceURL']
else:
segment_template = element.find(self._xpath_ns('SegmentTemplate', namespace))
if segment_template is not None:
start_number = segment_template.get('startNumber')
if start_number:
ms_info['start_number'] = int(start_number)
segment_timeline = segment_template.find(self._xpath_ns('SegmentTimeline', namespace))
if segment_timeline is not None:
s_e = segment_timeline.findall(self._xpath_ns('S', namespace))
if s_e:
ms_info['total_number'] = 0
for s in s_e:
ms_info['total_number'] += 1 + int(s.get('r', '0'))
else:
timescale = segment_template.get('timescale')
if timescale:
ms_info['timescale'] = int(timescale)
segment_duration = segment_template.get('duration')
if segment_duration:
ms_info['segment_duration'] = int(segment_duration)
media_template = segment_template.get('media')
if media_template:
ms_info['media_template'] = media_template
initialization = segment_template.get('initialization')
if initialization:
ms_info['initialization_url'] = initialization
else:
initialization = segment_template.find(self._xpath_ns('Initialization', namespace))
if initialization is not None:
ms_info['initialization_url'] = initialization.attrib['sourceURL']
return ms_info
namespace = self._search_regex(r'(?i)^{([^}]+)?}MPD$', mpd_doc.tag, 'namespace')
mpd_duration = parse_duration(mpd_doc.get('mediaPresentationDuration'))
formats = [] formats = []
for a in dash_doc.findall('.//' + _add_ns('AdaptationSet')): for period in mpd_doc.findall(self._xpath_ns('Period', namespace)):
mime_type = a.attrib.get('mimeType') period_duration = parse_duration(period.get('duration')) or mpd_duration
for r in a.findall(_add_ns('Representation')): period_ms_info = extract_multisegment_info(period, {
mime_type = r.attrib.get('mimeType') or mime_type 'start_number': 1,
url_el = r.find(_add_ns('BaseURL')) 'timescale': 1,
if mime_type == 'text/vtt': })
# TODO implement WebVTT downloading for adaptation_set in period.findall(self._xpath_ns('AdaptationSet', namespace)):
pass adaption_set_ms_info = extract_multisegment_info(adaptation_set, period_ms_info)
elif mime_type.startswith('audio/') or mime_type.startswith('video/'): for representation in adaptation_set.findall(self._xpath_ns('Representation', namespace)):
segment_list = r.find(_add_ns('SegmentList')) representation_attrib = adaptation_set.attrib.copy()
format_id = r.attrib['id'] representation_attrib.update(representation.attrib)
video_url = url_el.text if url_el is not None else None mime_type = representation_attrib.get('mimeType')
filesize = int_or_none(url_el.attrib.get('{http://youtube.com/yt/2012/10/10}contentLength') if url_el is not None else None) content_type = mime_type.split('/')[0] if mime_type else representation_attrib.get('contentType')
f = { if content_type == 'text':
'format_id': format_id, # TODO implement WebVTT downloading
'url': video_url, pass
'width': int_or_none(r.attrib.get('width')), elif content_type == 'video' or content_type == 'audio':
'height': int_or_none(r.attrib.get('height')), base_url = ''
'tbr': int_or_none(r.attrib.get('bandwidth'), 1000), for element in (representation, adaptation_set, period, mpd_doc):
'asr': int_or_none(r.attrib.get('audioSamplingRate')), base_url_e = element.find(self._xpath_ns('BaseURL', namespace))
'filesize': filesize, if base_url_e is not None:
'fps': int_or_none(r.attrib.get('frameRate')), base_url = base_url_e.text + base_url
} if re.match(r'^https?://', base_url):
if segment_list is not None: break
initialization_url = segment_list.find(_add_ns('Initialization')).attrib['sourceURL'] if not re.match(r'^https?://', base_url):
f.update({ base_url = mpd_base_url + base_url
'initialization_url': initialization_url, representation_id = representation_attrib.get('id')
'segment_urls': [segment.attrib.get('media') for segment in segment_list.findall(_add_ns('SegmentURL'))], f = {
'protocol': 'http_dash_segments', 'format_id': mpd_id or representation_id,
}) 'url': base_url,
if not f.get('url'): 'width': int_or_none(representation_attrib.get('width')),
f['url'] = initialization_url 'height': int_or_none(representation_attrib.get('height')),
try: 'tbr': int_or_none(representation_attrib.get('bandwidth'), 1000),
existing_format = next( 'asr': int_or_none(representation_attrib.get('audioSamplingRate')),
fo for fo in formats 'fps': int_or_none(representation_attrib.get('frameRate')),
if fo['format_id'] == format_id) 'vcodec': 'none' if content_type == 'audio' else representation_attrib.get('codecs'),
except StopIteration: 'acodec': 'none' if content_type == 'video' else representation_attrib.get('codecs'),
full_info = formats_dict.get(format_id, {}).copy() 'language': representation_attrib.get('lang'),
full_info.update(f) 'format_note': 'DASH %s' % content_type,
codecs = r.attrib.get('codecs') }
if codecs: representation_ms_info = extract_multisegment_info(representation, adaption_set_ms_info)
if mime_type.startswith('video/'): if 'segment_urls' not in representation_ms_info and 'media_template' in representation_ms_info:
vcodec, acodec = codecs, 'none' if 'total_number' not in representation_ms_info and 'segment_duration':
else: # mime_type.startswith('audio/') segment_duration = representation_ms_info['segment_duration'] / representation_ms_info['timescale']
vcodec, acodec = 'none', codecs representation_ms_info['total_number'] = int(math.ceil(period_duration / segment_duration))
media_template = representation_ms_info['media_template']
full_info.update({ media_template = media_template.replace('$RepresentationID$', representation_id)
'vcodec': vcodec, media_template = re.sub(r'\$(Bandwidth)(?:%(0\d+d))?\$', r'%(\1)\2', media_template)
'acodec': acodec, media_template = media_template % {'Bandwidth': representation_attrib.get('bandwidth')}
media_template = re.sub(r'\$(Number)(?:%(0\d+d))?\$', r'%(\1)\2', media_template)
media_template.replace('$$', '$')
representation_ms_info['segment_urls'] = [media_template % {'Number': segment_number} for segment_number in range(representation_ms_info['start_number'], representation_ms_info['total_number'] + representation_ms_info['start_number'])]
if 'segment_urls' in representation_ms_info:
f.update({
'segment_urls': representation_ms_info['segment_urls'],
'protocol': 'http_dash_segments',
}) })
formats.append(full_info) if 'initialization_url' in representation_ms_info:
initialization_url = representation_ms_info['initialization_url'].replace('$RepresentationID$', representation_id)
f.update({
'initialization_url': initialization_url,
})
if not f.get('url'):
f['url'] = initialization_url
try:
existing_format = next(
fo for fo in formats
if fo['format_id'] == representation_id)
except StopIteration:
full_info = formats_dict.get(representation_id, {}).copy()
full_info.update(f)
formats.append(full_info)
else:
existing_format.update(f)
else: else:
existing_format.update(f) self.report_warning('Unknown MIME type %s in DASH manifest' % mime_type)
else:
self.report_warning('Unknown MIME type %s in DASH manifest' % mime_type)
return formats return formats
def _live_title(self, name): def _live_title(self, name):

Write Preview
Loading…
Cancel
Save