mirror of
https://github.com/jellyfin/jellyfin-kodi.git
synced 2024-12-25 10:16:11 +00:00
603 lines
19 KiB
Python
603 lines
19 KiB
Python
# -*- coding: utf-8 -*-
|
|
|
|
#################################################################################################
|
|
|
|
import collections
|
|
import logging
|
|
import requests
|
|
import os
|
|
import urllib
|
|
|
|
import xbmc
|
|
import xbmcgui
|
|
import xbmcvfs
|
|
|
|
import clientinfo
|
|
import downloadutils
|
|
import read_embyserver as embyserver
|
|
from utils import window, settings, language as lang, urllib_path, create_id
|
|
|
|
#################################################################################################
|
|
|
|
log = logging.getLogger("EMBY."+__name__)
|
|
|
|
#################################################################################################
|
|
|
|
|
|
class PlayUtils():
|
|
|
|
play_session_id = None
|
|
method = "DirectPlay"
|
|
force_transcode = False
|
|
|
|
|
|
def __init__(self, item, listitem, **kwargs):
|
|
|
|
self.info = kwargs
|
|
|
|
self.item = item
|
|
self.listitem = listitem
|
|
|
|
self.clientInfo = clientinfo.ClientInfo()
|
|
self.emby = embyserver.Read_EmbyServer()
|
|
|
|
self.server = window('emby_server%s' % window('emby_currUser'))
|
|
self.play_session_id = str(create_id()).replace("-", "")
|
|
|
|
def get_play_url(self, force_transcode=False):
|
|
|
|
''' New style to retrieve the best playback method based on sending
|
|
the profile to the server. Based on capabilities the correct path is returned,
|
|
including livestreams that need to be opened by the server
|
|
'''
|
|
|
|
self.force_transcode = force_transcode
|
|
info = self.get_playback_info()
|
|
url = False if info == False else None
|
|
|
|
if info:
|
|
url = info['Path'].encode('utf-8')
|
|
window('emby_%s.play.json' % url, {
|
|
|
|
'playmethod': self.method,
|
|
'playsession_id': self.play_session_id,
|
|
'mediasource_id': info.get('Id') or self.item['Id']
|
|
})
|
|
|
|
if self.method == "DirectPlay":
|
|
# Log filename, used by other addons eg subtitles which require the file name
|
|
window('embyfilename', value=url)
|
|
|
|
log.info("playback info: %s", info)
|
|
log.info("play method: %s play url: %s", self.method, url)
|
|
|
|
return url
|
|
|
|
def _is_media_selection(self):
|
|
|
|
if self.item['MediaType'] != 'Video':
|
|
log.debug("MediaType not video detected.")
|
|
return False
|
|
|
|
elif self.item['Type'] == 'TvChannel':
|
|
log.debug("TvChannel detected.")
|
|
return False
|
|
|
|
elif len(self.item['MediaSources']) == 1 and self.item['MediaSources'][0]['Type'] == 'Placeholder':
|
|
log.debug("Placeholder detected.")
|
|
return False
|
|
|
|
elif 'SourceType' in self.item and self.item['SourceType'] != 'Library':
|
|
log.debug("SourceType not library detected.")
|
|
return False
|
|
|
|
return True
|
|
|
|
def get_playback_info(self):
|
|
|
|
# Get the playback info for the current item
|
|
|
|
info = self.emby.get_playback_info(self.item['Id'], self.get_device_profile())
|
|
media_sources = info['MediaSources']
|
|
|
|
# Select the mediasource
|
|
if not media_sources:
|
|
log.error('No media sources found: %s', info)
|
|
return
|
|
|
|
selected_source = media_sources[0]
|
|
|
|
if 'MediaSourceId' in self.info:
|
|
for source in media_sources:
|
|
if source['Id'] == self.info['MediaSourceId']:
|
|
selected_source = source
|
|
break
|
|
|
|
elif not self._is_media_selection():
|
|
log.info("Special media type detected. Skip source selection.")
|
|
|
|
elif len(media_sources) > 1:
|
|
# Offer choices
|
|
sources = []
|
|
for source in media_sources:
|
|
sources.append(source.get('Name', "na"))
|
|
|
|
resp = xbmcgui.Dialog().select("Select the source", sources)
|
|
if resp > -1:
|
|
selected_source = media_sources[resp]
|
|
else:
|
|
log.info("No media source selected.")
|
|
return False
|
|
|
|
return self.get_optimal_source(selected_source)
|
|
|
|
def get_optimal_source(self, source):
|
|
|
|
''' Because we posted our deviceprofile to the server, only streams will be
|
|
returned that can actually be played by this client so no need to check bitrates etc.
|
|
'''
|
|
|
|
if (not self.force_transcode and (self.is_h265(source) or self.is_strm(source) or
|
|
(source['SupportsDirectPlay'] and settings('playFromStream') == "false" and self.is_file_exists(source)))):
|
|
# Do nothing, path is updated with our verification if applies.
|
|
pass
|
|
else:
|
|
source['Path'] = self.get_http_path(source, self.force_transcode or source['SupportsDirectStream'] == False)
|
|
|
|
log.debug('get source: %s', source)
|
|
return source
|
|
|
|
def is_file_exists(self, source):
|
|
|
|
path = self.get_direct_path(source)
|
|
|
|
if xbmcvfs.exists(path) or ":" not in path:
|
|
log.info("Path exists or assumed linux or web.")
|
|
|
|
self.method = "DirectPlay"
|
|
source['Path'] = path
|
|
|
|
return True
|
|
|
|
log.info("Failed to find file.")
|
|
return False
|
|
|
|
def is_strm(self, source):
|
|
|
|
if source['Container'] == "strm":
|
|
log.info('Strm detected.')
|
|
|
|
self.method = "DirectPlay"
|
|
source['Path'] = self.get_direct_path(source)
|
|
|
|
return True
|
|
|
|
return False
|
|
|
|
def is_h265(self, source):
|
|
|
|
if source['MediaStreams']:
|
|
force_transcode = False
|
|
|
|
for stream in source['MediaStreams']:
|
|
if self._is_h265(stream) or self._is_high10(stream):
|
|
force_transcode = True
|
|
break
|
|
|
|
if force_transcode:
|
|
source['Path'] = self.get_http_path(source, True)
|
|
return True
|
|
|
|
return False
|
|
|
|
@classmethod
|
|
def _is_h265(cls, stream):
|
|
|
|
if stream['Type'] == "Video" and stream['Codec'] in ("hevc", "h265"):
|
|
if settings('transcode_h265') == "true":
|
|
log.info("Force transcode h265/hevc detected.")
|
|
return True
|
|
|
|
return False
|
|
|
|
@classmethod
|
|
def _is_high10(cls, stream):
|
|
|
|
if stream.get('Profile') == "High 10":
|
|
if settings('transcodeHi10P') == "true":
|
|
log.info("Force transcode hi10p detected.")
|
|
return True
|
|
|
|
return False
|
|
|
|
def get_direct_path(self, source):
|
|
|
|
path = source['Path']
|
|
|
|
if 'VideoType' in source:
|
|
if source['VideoType'] == "Dvd":
|
|
path = "%s/VIDEO_TS/VIDEO_TS.IFO" % path
|
|
elif source['VideoType'] == "BluRay":
|
|
path = "%s/BDMV/index.bdmv" % path
|
|
|
|
# Assign network protocol
|
|
if path.startswith('\\\\'):
|
|
path = path.replace('\\\\', "smb://")
|
|
path = path.replace('\\', "/")
|
|
|
|
if "://" in path:
|
|
# Protocol needs to be lowercase, otherwise weird things happen.
|
|
protocol = path.split('://')[0]
|
|
path = path.replace(protocol, protocol.lower())
|
|
|
|
return path
|
|
|
|
def get_http_path(self, source, transcode=False):
|
|
|
|
if transcode and settings('ignoreTranscode') and source['MediaStreams']:
|
|
# Specified by user should not be transcoded.
|
|
ignore_codecs = settings('ignoreTranscode').split(',')
|
|
|
|
for stream in source['MediaStreams']:
|
|
if stream['Type'] == "Video" and stream['Codec'] in ignore_codecs:
|
|
log.info("Ignoring transcode for: %s", stream['Codec'])
|
|
transcode = False
|
|
break
|
|
|
|
url = self.get_transcode_url(source) if transcode else self.get_direct_url(source)
|
|
url += "&MediaSourceId=%s" % source['Id']
|
|
url += "&PlaySessionId=%s" % self.play_session_id
|
|
url += "&api_key=%s" % downloadutils.DownloadUtils().get_token()
|
|
|
|
return url
|
|
|
|
def get_direct_url(self, source):
|
|
|
|
self.method = "DirectStream"
|
|
|
|
if self.item['Type'] == "Audio":
|
|
url = "%s/emby/Audio/%s/stream.%s?static=true" % (self.server, self.item['Id'], self.item['MediaSources'][0]['Container'])
|
|
else:
|
|
url = "%s/emby/Videos/%s/stream?static=true" % (self.server, self.item['Id'])
|
|
|
|
# Append external subtitles
|
|
if settings('enableExternalSubs') == "true":
|
|
self.set_external_subs(source, url)
|
|
|
|
return url
|
|
|
|
def get_transcode_url(self, source):
|
|
|
|
self.method = "Transcode"
|
|
|
|
item_id = self.item['Id']
|
|
url = urllib_path("%s/emby/Videos/%s/master.m3u8" % (self.server, item_id), {
|
|
|
|
'VideoCodec': "h264",
|
|
'AudioCodec': "ac3",
|
|
'MaxAudioChannels': 6,
|
|
'deviceId': self.clientInfo.get_device_id(),
|
|
'VideoBitrate': self.get_bitrate() * 1000
|
|
})
|
|
|
|
# Limit to 8 bit if user selected transcode Hi10P
|
|
if settings('transcodeHi10P') == "true":
|
|
url += "&MaxVideoBitDepth=8"
|
|
|
|
# Adjust the video resolution
|
|
url += "&maxWidth=%s&maxHeight=%s" % (self.get_resolution())
|
|
# Select audio and subtitles
|
|
url += self.get_audio_subs(source)
|
|
|
|
return url
|
|
|
|
def set_external_subs(self, source, play_url):
|
|
|
|
subs = []
|
|
mapping = {}
|
|
|
|
item_id = self.item['Id']
|
|
streams = source['MediaStreams']
|
|
|
|
if not source['MediaStreams']:
|
|
log.info("No media streams found.")
|
|
return
|
|
|
|
temp = xbmc.translatePath("special://profile/addon_data/plugin.video.emby/temp/").decode('utf-8')
|
|
|
|
''' Since Emby returns all possible tracks together, sort them.
|
|
IsTextSubtitleStream if true, is available to download from server.
|
|
'''
|
|
|
|
kodi_index = 0
|
|
for stream in streams:
|
|
|
|
if stream['Type'] == "Subtitle" and stream['IsExternal'] and stream['IsTextSubtitleStream']:
|
|
index = stream['Index']
|
|
|
|
url = self.server + stream['DeliveryUrl']
|
|
|
|
if 'Language' in stream:
|
|
filename = "Stream.%s.%s" % (stream['Language'].encode('utf-8'), stream['Codec'])
|
|
try:
|
|
subs.append(self._download_external_subs(url, temp, filename))
|
|
except Exception as error:
|
|
log.warn(error)
|
|
subs.append(url)
|
|
else:
|
|
subs.append(url)
|
|
|
|
# Map external subtitles for player.py
|
|
mapping[kodi_index] = index
|
|
kodi_index += 1
|
|
|
|
window('emby_%s.indexMapping.json' % play_url, value=mapping)
|
|
self.listitem.setSubtitles(subs)
|
|
|
|
return
|
|
|
|
@classmethod
|
|
def _download_external_subs(cls, src, dst, filename):
|
|
|
|
if not xbmcvfs.exists(dst):
|
|
xbmcvfs.mkdir(dst)
|
|
|
|
path = os.path.join(dst, filename)
|
|
|
|
try:
|
|
response = requests.get(src, stream=True)
|
|
response.raise_for_status()
|
|
except Exception as e:
|
|
raise
|
|
else:
|
|
response.encoding = 'utf-8'
|
|
with open(path, 'wb') as f:
|
|
f.write(response.content)
|
|
del response
|
|
|
|
return path
|
|
|
|
def get_audio_subs(self, source):
|
|
|
|
''' For transcoding only
|
|
Present the list of audio/subs to select from, before playback starts.
|
|
Returns part of the url to append.
|
|
'''
|
|
|
|
prefs = ""
|
|
streams = source['MediaStreams']
|
|
|
|
audio_streams = collections.OrderedDict()
|
|
subs_streams = collections.OrderedDict()
|
|
|
|
if streams:
|
|
|
|
''' Since Emby returns all possible tracks together, sort them.
|
|
IsTextSubtitleStream if true, is available to download from server.
|
|
'''
|
|
|
|
for stream in streams:
|
|
index = stream['Index']
|
|
stream_type = stream['Type']
|
|
|
|
if stream_type == "Audio":
|
|
codec = stream['Codec']
|
|
channel = stream.get('ChannelLayout', "")
|
|
|
|
if 'Language' in stream:
|
|
track = "%s - %s - %s %s" % (index, stream['Language'], codec, channel)
|
|
else:
|
|
track = "%s - %s %s" % (index, codec, channel)
|
|
|
|
audio_streams[track] = index
|
|
|
|
elif stream_type == "Subtitle":
|
|
|
|
if 'Language' in stream:
|
|
track = "%s - %s" % (index, stream['Language'])
|
|
else:
|
|
track = "%s - %s" % (index, stream['Codec'])
|
|
|
|
if stream['IsDefault']:
|
|
track = "%s - Default" % track
|
|
if stream['IsForced']:
|
|
track = "%s - Forced" % track
|
|
|
|
subs_streams[track] = index
|
|
|
|
dialog = xbmcgui.Dialog()
|
|
skip_dialog = int(settings('skipDialogTranscode') or 0)
|
|
audio_selected = None
|
|
|
|
if self.info.get('AudioStreamIndex'):
|
|
audio_selected = self.info['AudioStreamIndex']
|
|
|
|
elif skip_dialog in (0, 1):
|
|
if len(audio_streams) > 1:
|
|
selection = list(audio_streams.keys())
|
|
resp = dialog.select(lang(33013), selection)
|
|
audio_selected = audio_streams[selection[resp]] if resp else source['DefaultAudioStreamIndex']
|
|
else: # Only one choice
|
|
audio_selected = audio_streams[next(iter(audio_streams))]
|
|
else:
|
|
audio_selected = source['DefaultAudioStreamIndex']
|
|
|
|
prefs += "&AudioStreamIndex=%s" % audio_selected
|
|
prefs += "&AudioBitrate=384000" if streams[audio_selected].get('Channels', 0) > 2 else "&AudioBitrate=192000"
|
|
|
|
if self.info.get('SubtitleStreamIndex'):
|
|
index = self.info['SubtitleStreamIndex']
|
|
|
|
if index:
|
|
server_settings = self.emby.get_server_transcoding_settings()
|
|
if server_settings['EnableSubtitleExtraction'] and streams[index]['SupportsExternalStream']:
|
|
self._get_subtitles(source, index)
|
|
else:
|
|
prefs += "&SubtitleStreamIndex=%s" % index
|
|
|
|
elif skip_dialog in (0, 2) and len(subs_streams):
|
|
selection = list(['No subtitles']) + list(subs_streams.keys())
|
|
resp = dialog.select(lang(33014), selection)
|
|
if resp:
|
|
index = subs_streams[selection[resp]] if resp > -1 else sources.get('DefaultSubtitleStreamIndex')
|
|
if index is not None:
|
|
server_settings = self.emby.get_server_transcoding_settings()
|
|
if server_settings['EnableSubtitleExtraction'] and streams[index]['SupportsExternalStream']:
|
|
self._get_subtitles(source, index)
|
|
else:
|
|
prefs += "&SubtitleStreamIndex=%s" % index
|
|
|
|
return prefs
|
|
|
|
def _get_subtitles(self, source, index):
|
|
|
|
url = [("%s/Videos/%s/%s/Subtitles/%s/Stream.srt"
|
|
% (self.server, self.item['Id'], source['Id'], index))]
|
|
|
|
log.info("Set up subtitles: %s %s", index, url)
|
|
self.listitem.setSubtitles(url)
|
|
|
|
def get_bitrate(self):
|
|
|
|
''' Get the addon video quality
|
|
Max bit rate supported by server: 2147483 (max signed 32bit integer)
|
|
'''
|
|
|
|
bitrate = {
|
|
|
|
'0': 664,
|
|
'1': 996,
|
|
'2': 1320,
|
|
'3': 2000,
|
|
'4': 3200,
|
|
'5': 4700,
|
|
'6': 6200,
|
|
'7': 7700,
|
|
'8': 9200,
|
|
'9': 10700,
|
|
'10': 12200,
|
|
'11': 13700,
|
|
'12': 15200,
|
|
'13': 16700,
|
|
'14': 18200,
|
|
'15': 20000,
|
|
'16': 25000,
|
|
'17': 30000,
|
|
'18': 35000,
|
|
'16': 40000,
|
|
'17': 100000,
|
|
'18': 1000000
|
|
}
|
|
return bitrate.get(settings('videoBitrate'), 2147483)
|
|
|
|
def get_device_profile(self):
|
|
return {
|
|
|
|
"Name": "Kodi",
|
|
"MaxStreamingBitrate": self.get_bitrate() * 1000,
|
|
"MusicStreamingTranscodingBitrate": 1280000,
|
|
"TimelineOffsetSeconds": 5,
|
|
|
|
"Identification": {
|
|
"ModelName": "Kodi",
|
|
"Headers": [
|
|
{
|
|
"Name": "User-Agent",
|
|
"Value": "Kodi",
|
|
"Match": 2
|
|
}
|
|
]
|
|
},
|
|
|
|
"TranscodingProfiles": [
|
|
{
|
|
"Container": "mp3",
|
|
"AudioCodec": "mp3",
|
|
"Type": 0
|
|
},
|
|
{
|
|
"Container": "ts",
|
|
"AudioCodec": "aac",
|
|
"VideoCodec": "h264",
|
|
"Type": 1
|
|
},
|
|
{
|
|
"Container": "jpeg",
|
|
"Type": 2
|
|
}
|
|
],
|
|
|
|
"DirectPlayProfiles": [
|
|
{
|
|
"Container": "",
|
|
"Type": 0
|
|
},
|
|
{
|
|
"Container": "",
|
|
"Type": 1
|
|
},
|
|
{
|
|
"Container": "",
|
|
"Type": 2
|
|
}
|
|
],
|
|
|
|
"ResponseProfiles": [],
|
|
"ContainerProfiles": [],
|
|
"CodecProfiles": [],
|
|
|
|
"SubtitleProfiles": [
|
|
{
|
|
"Format": "srt",
|
|
"Method": 2
|
|
},
|
|
{
|
|
"Format": "sub",
|
|
"Method": 2
|
|
},
|
|
{
|
|
"Format": "srt",
|
|
"Method": 1
|
|
},
|
|
{
|
|
"Format": "ass",
|
|
"Method": 1,
|
|
"DidlMode": ""
|
|
},
|
|
{
|
|
"Format": "ssa",
|
|
"Method": 1,
|
|
"DidlMode": ""
|
|
},
|
|
{
|
|
"Format": "smi",
|
|
"Method": 1,
|
|
"DidlMode": ""
|
|
},
|
|
{
|
|
"Format": "dvdsub",
|
|
"Method": 1,
|
|
"DidlMode": ""
|
|
},
|
|
{
|
|
"Format": "pgs",
|
|
"Method": 1,
|
|
"DidlMode": ""
|
|
},
|
|
{
|
|
"Format": "pgssub",
|
|
"Method": 1,
|
|
"DidlMode": ""
|
|
},
|
|
{
|
|
"Format": "sub",
|
|
"Method": 1,
|
|
"DidlMode": ""
|
|
}
|
|
]
|
|
}
|
|
|
|
def get_resolution(self):
|
|
|
|
window = xbmcgui.Window()
|
|
return window.getWidth(), window.getHeight()
|