logo

youtube-dl

[mirror] Download/Watch videos from video hostersgit clone https://hacktivis.me/git/mirror/youtube-dl.git

adn.py (11515B)

    

  1. # coding: utf-8
  2. from __future__ import unicode_literals
  4. import base64
  5. import binascii
  6. import json
  7. import os
  8. import random
  10. from .common import InfoExtractor
  11. from ..aes import aes_cbc_decrypt
  12. from ..compat import (
  13.     compat_HTTPError,
  14.     compat_b64decode,
  15.     compat_ord,
  16. )
  17. from ..utils import (
  18.     bytes_to_intlist,
  19.     bytes_to_long,
  20.     ExtractorError,
  21.     float_or_none,
  22.     int_or_none,
  23.     intlist_to_bytes,
  24.     long_to_bytes,
  25.     pkcs1pad,
  26.     strip_or_none,
  27.     try_get,
  28.     unified_strdate,
  29.     urlencode_postdata,
  30. )
  33. class ADNIE(InfoExtractor):
  34.     IE_DESC = 'Animation Digital Network'
  35.     _VALID_URL = r'https?://(?:www\.)?(?:animation|anime)digitalnetwork\.fr/video/[^/]+/(?P<id>\d+)'
  36.     _TESTS = [{
  37.         'url': 'https://animationdigitalnetwork.fr/video/fruits-basket/9841-episode-1-a-ce-soir',
  38.         'md5': '1c9ef066ceb302c86f80c2b371615261',
  39.         'info_dict': {
  40.             'id': '9841',
  41.             'ext': 'mp4',
  42.             'title': 'Fruits Basket - Episode 1',
  43.             'description': 'md5:14be2f72c3c96809b0ca424b0097d336',
  44.             'series': 'Fruits Basket',
  45.             'duration': 1437,
  46.             'release_date': '20190405',
  47.             'comment_count': int,
  48.             'average_rating': float,
  49.             'season_number': 1,
  50.             'episode': 'À ce soir !',
  51.             'episode_number': 1,
  52.         },
  53.         'skip': 'Only available in region (FR, ...)',
  54.     }, {
  55.         'url': 'http://animedigitalnetwork.fr/video/blue-exorcist-kyoto-saga/7778-episode-1-debut-des-hostilites',
  56.         'only_matching': True,
  57.     }]
  59.     _NETRC_MACHINE = 'animationdigitalnetwork'
  60.     _BASE = 'animationdigitalnetwork.fr'
  61.     _API_BASE_URL = 'https://gw.api.' + _BASE + '/'
  62.     _PLAYER_BASE_URL = _API_BASE_URL + 'player/'
  63.     _HEADERS = {}
  64.     _LOGIN_ERR_MESSAGE = 'Unable to log in'
  65.     _RSA_KEY = (0x9B42B08905199A5CCE2026274399CA560ECB209EE9878A708B1C0812E1BB8CB5D1FB7441861147C1A1F2F3A0476DD63A9CAC20D3E983613346850AA6CB38F16DC7D720FD7D86FC6E5B3D5BBC72E14CD0BF9E869F2CEA2CCAD648F1DCE38F1FF916CEFB2D339B64AA0264372344BC775E265E8A852F88144AB0BD9AA06C1A4ABB, 65537)
  66.     _POS_ALIGN_MAP = {
  67.         'start': 1,
  68.         'end': 3,
  69.     }
  70.     _LINE_ALIGN_MAP = {
  71.         'middle': 8,
  72.         'end': 4,
  73.     }
  75.     @staticmethod
  76.     def _ass_subtitles_timecode(seconds):
  77.         return '%01d:%02d:%02d.%02d' % (seconds / 3600, (seconds % 3600) / 60, seconds % 60, (seconds % 1) * 100)
  79.     def _get_subtitles(self, sub_url, video_id):
  80.         if not sub_url:
  81.             return None
  83.         enc_subtitles = self._download_webpage(
  84.             sub_url, video_id, 'Downloading subtitles location', fatal=False) or '{}'
  85.         subtitle_location = (self._parse_json(enc_subtitles, video_id, fatal=False) or {}).get('location')
  86.         if subtitle_location:
  87.             enc_subtitles = self._download_webpage(
  88.                 subtitle_location, video_id, 'Downloading subtitles data',
  89.                 fatal=False, headers={'Origin': 'https://' + self._BASE})
  90.         if not enc_subtitles:
  91.             return None
  93.         # http://animationdigitalnetwork.fr/components/com_vodvideo/videojs/adn-vjs.min.js
  94.         dec_subtitles = intlist_to_bytes(aes_cbc_decrypt(
  95.             bytes_to_intlist(compat_b64decode(enc_subtitles[24:])),
  96.             bytes_to_intlist(binascii.unhexlify(self._K + '7fac1178830cfe0c')),
  97.             bytes_to_intlist(compat_b64decode(enc_subtitles[:24]))
  98.         ))
  99.         subtitles_json = self._parse_json(
  100.             dec_subtitles[:-compat_ord(dec_subtitles[-1])].decode(),
  101.             None, fatal=False)
  102.         if not subtitles_json:
  103.             return None
  105.         subtitles = {}
  106.         for sub_lang, sub in subtitles_json.items():
  107.             ssa = '''[Script Info]
  108. ScriptType:V4.00
  109. [V4 Styles]
  110. Format: Name,Fontname,Fontsize,PrimaryColour,SecondaryColour,TertiaryColour,BackColour,Bold,Italic,BorderStyle,Outline,Shadow,Alignment,MarginL,MarginR,MarginV,AlphaLevel,Encoding
  111. Style: Default,Arial,18,16777215,16777215,16777215,0,-1,0,1,1,0,2,20,20,20,0,0
  112. [Events]
  113. Format: Marked,Start,End,Style,Name,MarginL,MarginR,MarginV,Effect,Text'''
  114.             for current in sub:
  115.                 start, end, text, line_align, position_align = (
  116.                     float_or_none(current.get('startTime')),
  117.                     float_or_none(current.get('endTime')),
  118.                     current.get('text'), current.get('lineAlign'),
  119.                     current.get('positionAlign'))
  120.                 if start is None or end is None or text is None:
  121.                     continue
  122.                 alignment = self._POS_ALIGN_MAP.get(position_align, 2) + self._LINE_ALIGN_MAP.get(line_align, 0)
  123.                 ssa += os.linesep + 'Dialogue: Marked=0,%s,%s,Default,,0,0,0,,%s%s' % (
  124.                     self._ass_subtitles_timecode(start),
  125.                     self._ass_subtitles_timecode(end),
  126.                     '{\\a%d}' % alignment if alignment != 2 else '',
  127.                     text.replace('\n', '\\N').replace('<i>', '{\\i1}').replace('</i>', '{\\i0}'))
  129.             if sub_lang == 'vostf':
  130.                 sub_lang = 'fr'
  131.             subtitles.setdefault(sub_lang, []).extend([{
  132.                 'ext': 'json',
  133.                 'data': json.dumps(sub),
  134.             }, {
  135.                 'ext': 'ssa',
  136.                 'data': ssa,
  137.             }])
  138.         return subtitles
  140.     def _real_initialize(self):
  141.         username, password = self._get_login_info()
  142.         if not username:
  143.             return
  144.         try:
  145.             url = self._API_BASE_URL + 'authentication/login'
  146.             access_token = (self._download_json(
  147.                 url, None, 'Logging in', self._LOGIN_ERR_MESSAGE, fatal=False,
  148.                 data=urlencode_postdata({
  149.                     'password': password,
  150.                     'rememberMe': False,
  151.                     'source': 'Web',
  152.                     'username': username,
  153.                 })) or {}).get('accessToken')
  154.             if access_token:
  155.                 self._HEADERS = {'authorization': 'Bearer ' + access_token}
  156.         except ExtractorError as e:
  157.             message = None
  158.             if isinstance(e.cause, compat_HTTPError) and e.cause.code == 401:
  159.                 resp = self._parse_json(
  160.                     self._webpage_read_content(e.cause, url, username),
  161.                     username, fatal=False) or {}
  162.                 message = resp.get('message') or resp.get('code')
  163.             self.report_warning(message or self._LOGIN_ERR_MESSAGE)
  165.     def _real_extract(self, url):
  166.         video_id = self._match_id(url)
  167.         video_base_url = self._PLAYER_BASE_URL + 'video/%s/' % video_id
  168.         player = self._download_json(
  169.             video_base_url + 'configuration', video_id,
  170.             'Downloading player config JSON metadata',
  171.             headers=self._HEADERS)['player']
  172.         options = player['options']
  174.         user = options['user']
  175.         if not user.get('hasAccess'):
  176.             self.raise_login_required()
  178.         token = self._download_json(
  179.             user.get('refreshTokenUrl') or (self._PLAYER_BASE_URL + 'refresh/token'),
  180.             video_id, 'Downloading access token', headers={
  181.                 'x-player-refresh-token': user['refreshToken']
  182.             }, data=b'')['token']
  184.         links_url = try_get(options, lambda x: x['video']['url']) or (video_base_url + 'link')
  185.         self._K = ''.join([random.choice('0123456789abcdef') for _ in range(16)])
  186.         message = bytes_to_intlist(json.dumps({
  187.             'k': self._K,
  188.             't': token,
  189.         }))
  191.         # Sometimes authentication fails for no good reason, retry with
  192.         # a different random padding
  193.         links_data = None
  194.         for _ in range(3):
  195.             padded_message = intlist_to_bytes(pkcs1pad(message, 128))
  196.             n, e = self._RSA_KEY
  197.             encrypted_message = long_to_bytes(pow(bytes_to_long(padded_message), e, n))
  198.             authorization = base64.b64encode(encrypted_message).decode()
  200.             try:
  201.                 links_data = self._download_json(
  202.                     links_url, video_id, 'Downloading links JSON metadata', headers={
  203.                         'X-Player-Token': authorization
  204.                     }, query={
  205.                         'freeWithAds': 'true',
  206.                         'adaptive': 'false',
  207.                         'withMetadata': 'true',
  208.                         'source': 'Web'
  209.                     })
  210.                 break
  211.             except ExtractorError as e:
  212.                 if not isinstance(e.cause, compat_HTTPError):
  213.                     raise e
  215.                 if e.cause.code == 401:
  216.                     # This usually goes away with a different random pkcs1pad, so retry
  217.                     continue
  219.                 error = self._parse_json(
  220.                     self._webpage_read_content(e.cause, links_url, video_id),
  221.                     video_id, fatal=False) or {}
  222.                 message = error.get('message')
  223.                 if e.cause.code == 403 and error.get('code') == 'player-bad-geolocation-country':
  224.                     self.raise_geo_restricted(msg=message)
  225.                 raise ExtractorError(message)
  226.         else:
  227.             raise ExtractorError('Giving up retrying')
  229.         links = links_data.get('links') or {}
  230.         metas = links_data.get('metadata') or {}
  231.         sub_url = (links.get('subtitles') or {}).get('all')
  232.         video_info = links_data.get('video') or {}
  233.         title = metas['title']
  235.         formats = []
  236.         for format_id, qualities in (links.get('streaming') or {}).items():
  237.             if not isinstance(qualities, dict):
  238.                 continue
  239.             for quality, load_balancer_url in qualities.items():
  240.                 load_balancer_data = self._download_json(
  241.                     load_balancer_url, video_id,
  242.                     'Downloading %s %s JSON metadata' % (format_id, quality),
  243.                     fatal=False) or {}
  244.                 m3u8_url = load_balancer_data.get('location')
  245.                 if not m3u8_url:
  246.                     continue
  247.                 m3u8_formats = self._extract_m3u8_formats(
  248.                     m3u8_url, video_id, 'mp4', 'm3u8_native',
  249.                     m3u8_id=format_id, fatal=False)
  250.                 if format_id == 'vf':
  251.                     for f in m3u8_formats:
  252.                         f['language'] = 'fr'
  253.                 formats.extend(m3u8_formats)
  254.         self._sort_formats(formats)
  256.         video = (self._download_json(
  257.             self._API_BASE_URL + 'video/%s' % video_id, video_id,
  258.             'Downloading additional video metadata', fatal=False) or {}).get('video') or {}
  259.         show = video.get('show') or {}
  261.         return {
  262.             'id': video_id,
  263.             'title': title,
  264.             'description': strip_or_none(metas.get('summary') or video.get('summary')),
  265.             'thumbnail': video_info.get('image') or player.get('image'),
  266.             'formats': formats,
  267.             'subtitles': self.extract_subtitles(sub_url, video_id),
  268.             'episode': metas.get('subtitle') or video.get('name'),
  269.             'episode_number': int_or_none(video.get('shortNumber')),
  270.             'series': show.get('title'),
  271.             'season_number': int_or_none(video.get('season')),
  272.             'duration': int_or_none(video_info.get('duration') or video.get('duration')),
  273.             'release_date': unified_strdate(video.get('releaseDate')),
  274.             'average_rating': float_or_none(video.get('rating') or metas.get('rating')),
  275.             'comment_count': int_or_none(video.get('commentsCount')),
  276.         }