plugin.video.torrenter/BTClientPlayer.py

475 lines
20 KiB
Python

# -*- coding: utf-8 -*-
'''
Torrenter v2 plugin for XBMC/Kodi
Copyright (C) 2012-2015 Vadim Skorba v1 - DiMartino v2
http://forum.kodi.tv/showthread.php?tid=214366
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>.
'''
import os
from contextlib import contextmanager, closing, nested
from resources.btclient.argparse import Namespace
import xbmc
import xbmcgui
import Downloader
import xbmcgui
import xbmcvfs
import Localization
from platform_pulsar import get_platform
from resources.btclient.btclient import *
from functions import showMessage, DownloadDB, get_ids_video, log, debug, clearStorage
from Player import OverlayText
ROOT = sys.modules["__main__"].__root__
RESOURCES_PATH = os.path.join(ROOT, 'resources')
TORRENT2HTTP_TIMEOUT = 20
TORRENT2HTTP_POLL = 1000
PLAYING_EVENT_INTERVAL = 60
MIN_COMPLETED_PIECES = 0.5
WINDOW_FULLSCREEN_VIDEO = 12005
XBFONT_LEFT = 0x00000000
XBFONT_RIGHT = 0x00000001
XBFONT_CENTER_X = 0x00000002
XBFONT_CENTER_Y = 0x00000004
XBFONT_TRUNCATED = 0x00000008
XBFONT_JUSTIFY = 0x00000010
STATE_STRS = [
'Queued',
'Checking',
'Downloading metadata',
'Downloading',
'Finished',
'Seeding',
'Allocating',
'Allocating file & Checking resume'
]
VIEWPORT_WIDTH = 1920.0
VIEWPORT_HEIGHT = 1088.0
OVERLAY_WIDTH = int(VIEWPORT_WIDTH * 0.7) # 70% size
OVERLAY_HEIGHT = 150
class BTClientPlayer(xbmc.Player):
__plugin__ = sys.modules["__main__"].__plugin__
__settings__ = sys.modules["__main__"].__settings__
ROOT = sys.modules["__main__"].__root__ # .decode('utf-8').encode(sys.getfilesystemencoding())
USERAGENT = "Mozilla/5.0 (Windows NT 6.1; rv:5.0) Gecko/20100101 Firefox/5.0"
torrentFilesDirectory = 'torrents'
debug = __settings__.getSetting('debug') == 'true'
subs_dl = __settings__.getSetting('subs_dl') == 'true'
seeding = __settings__.getSetting('keep_seeding') == 'true' and __settings__.getSetting('keep_files') == '1'
seeding_status = False
seeding_run = False
ids_video = None
episodeId = None
basename = ''
def __del__(self):
print '!!!!!!!!!!!!!!!!!! DIED !!! '+self.__class__.__name__
def __init__(self, userStorageDirectory, torrentUrl, params={}):
print '!!!!!!!!!!!!!!!!!! BORN '+self.__class__.__name__
self.userStorageDirectory = userStorageDirectory
self.torrentUrl = torrentUrl
xbmc.Player.__init__(self)
log("[BTClientPlayer] Initalized")
self.params = params
self.get = self.params.get
self.contentId = int(self.get("url"))
self.platform = get_platform()
self.init()
self.torrent = Downloader.Torrent(self.userStorageDirectory, self.torrentUrl, self.torrentFilesDirectory).player
self.lt=self.torrent.lt
try:
if self.get("url2"):
self.ids_video = urllib.unquote_plus(self.get("url2")).split(',')
else:
self.ids_video = self.get_ids()
except:
pass
args=Namespace(bt_download_limit=self.download_limit,#KB
bt_upload_limit=self.upload_limit,
choose_subtitles=False,
clear_older=0,
debug_log=os.path.join(self.userStorageDirectory, 'log.txt'),
delete_on_finish=False,
directory=self.userStorageDirectory,
listen_port_max=6891,#
listen_port_min=6881,
no_resume=False,
player='kodi',
port=5001,
print_pieces=False,
quiet=False,
stdin=False,
stream=True,
subtitles=None,
trace=True,
content_id=self.contentId,
url=self.torrentUrl)
args=main(args) #config
self.free_port = args.port
log('BTClientPlayer: args '+str(args))
self.btclient=self.stream(args, BTClient)
def stream(self, args, client_class):
self.c = client_class(args.directory, args=args, lt=self.lt)
try:
while True:
try:
s = socket.socket()
res = s.connect_ex(('127.0.0.1', self.free_port))
if res:
break
finally:
s.close()
self.free_port += 1
self.server = StreamServer(('127.0.0.1', self.free_port), BTFileHandler, allow_range=True,
status_fn=self.c.get_normalized_status)
log('Started http server on port %d' % self.free_port)
self.server.run()
log('Starting btclient - libtorrent version %s' % self.lt.version)
self.c.start_url(args.url)
self.setup_torrent()
if self.buffer():
f = self.c._file
self.server.set_file(f)
self.setup_play()
while True:
if self.setup_play():
log('************************************* GOING LOOP')
#self.torrent.continueSession(self.contentId)
self.loop()
else:
break
log('************************************* GO NEXT?')
if self.next_dl and self.next_dling and isinstance(self.next_contentId, int) and self.iterator == 100:
self.contentId = self.next_contentId
continue
log('************************************* NO! break')
break
if '1' != self.__settings__.getSetting("keep_files") and 'Saved Files' not in self.userStorageDirectory:
xbmc.sleep(1000)
clearStorage(self.userStorageDirectory)
else:
if self.seeding_status:
showMessage(self.localize('Information'),
self.localize('Torrent is seeding. To stop it use Download Status.'), forced=True)
else:
if self.seeding: self.db_delete()
showMessage(self.localize('Information'),
self.localize('Torrent downloading is stopped.'), forced=True)
log('Play ended')
if self.server:
self.server.stop()
except Exception:
traceback.print_exc()
finally:
self.on_exit()
def init(self):
self.next_dl = True if self.__settings__.getSetting('next_dl') == 'true' and self.ids_video else False
log('[BTClientPlayer]: init next_dl - ' + str(self.next_dl))
self.next_contentId = False
self.display_name = ''
self.downloadedSize = 0
self.dialog = xbmcgui.Dialog()
self.on_playback_started = []
self.on_playback_resumed = []
self.on_playback_paused = []
self.on_playback_stopped = []
self.fullSize = 0
if self.__settings__.getSetting("upload_limit") == "":
self.upload_limit = 0.0
else:
self.upload_limit = float(self.__settings__.getSetting("upload_limit")) / 8 * 1024
if self.__settings__.getSetting("download_limit") == "":
self.download_limit = 0.0
else:
self.download_limit = float(self.__settings__.getSetting("download_limit")) / 8 * 1024
def setup_torrent(self):
pass
#if self.__settings__.getSetting('encryption') == 'true':
# self.c.encrypt()
#if self.subs_dl:
# subs = self.torrent.getSubsIds(os.path.basename(self.torrent.getFilePath(self.contentId)))
# if len(subs) > 0:
# for ind, title in subs:
# self.torrent.continueSession(ind)
def buffer(self):
iterator = 0
progressBar = xbmcgui.DialogProgress()
progressBar.create('%s [%s]' % (self.__class__.__name__,str(self.lt.version)),
self.localize('Seeds searching.'))
while not self.c.is_file_ready:#iterator < 100:
iterator = 0
ready_list=[]
status = self.c.get_normalized_status()
conditions=[status['state'] in ['downloading', 'finished', 'seeding'], status['desired_rate'] > 0 or status['progress'] > 0.01,
status['progress'] > 0.005, self.c.is_file_ready,# or status['progress'] > 0.02
(status['download_rate'] > status['desired_rate'] or
status['download_rate'] * int(status['progress'] * 100) > status['desired_rate'])]
for cond in conditions:
if cond:
ready_list.append(True)
iterator+=100/len(conditions)
else:
ready_list.append(False)
speedsText = '%s: %s Mbit/s %s %s: %s Mbit/s' % (self.localize('Download speed'),str(status['download_rate'] * 8 / 1000000),
'[COLOR=green]>[/COLOR]' if ready_list[4] else '[COLOR=red]<[/COLOR]',
self.localize('Bitrate'), str(int(status['desired_rate'] * 8 / (1024 * 1024))) if status['desired_rate'] else 0,)
if status['state'] in ['queued','checking','checking fastresume'] or (status['progress'] == 0 and status['num_pieces'] > 0):
progressBar.update(iterator, self.localize('Checking preloaded files...'), speedsText, ' ')
elif status['state'] in ['downloading', 'finished', 'seeding']:
dialogText = self.localize('Preloaded: ') + '%s MB %s %s MB (%s MB)' % \
(str(status['downloaded'] / 1024 / 1024), '[COLOR=green]>[/COLOR]' if ready_list[2] else '[COLOR=red]<[/COLOR]', str(status['total_size'] / 1024 / 1024 /200), str(status['total_size'] / 1024 / 1024))
peersText = '%s: %s [%s: %s; %s: %s]' % (self.localize('File ready: '), '[COLOR=green]YES[/COLOR]' if ready_list[3] else '[COLOR=red]NO[/COLOR]',
self.localize('Seeds'), str(status['seeds_connected']), self.localize('Peers'), str(status['peers_connected']),)
progressBar.update(iterator, peersText, speedsText, dialogText,
)
else:
progressBar.update(iterator, self.localize('UNKNOWN STATUS'), ' ', ' ')
if progressBar.iscanceled():
self.on_exit()
break
xbmc.sleep(1000)
progressBar.update(0)
progressBar.close()
return True
def setup_subs(self, label, path):
iterator = 0
subs = self.torrent.getSubsIds(label)
log('[setup_subs] subs: '+str(subs))
if len(subs) > 0:
showMessage(self.localize('Information'),
self.localize('Downloading and copy subtitles. Please wait.'), forced=True)
for ind, title in subs:
self.torrent.continueSession(ind)
while iterator < 100:
xbmc.sleep(1000)
#self.torrent.debug()
status = self.torrent.torrentHandle.status()
iterator = int(status.progress * 100)
# xbmc.sleep(2000)
for ind, title in subs:
folder = title.split(os.sep)[0]
temp = os.path.basename(title)
addition = os.path.dirname(title).lstrip(folder + os.sep).replace(os.sep, '.').replace(' ', '_').strip()
ext = temp.split('.')[-1]
temp = temp[:len(temp) - len(ext) - 1] + '.' + addition + '.' + ext
newFileName = os.path.join(os.path.dirname(path), temp)
log('[setup_subs]: '+str((os.path.join(os.path.dirname(os.path.dirname(path)),title),newFileName)))
if not xbmcvfs.exists(newFileName):
xbmcvfs.copy(os.path.join(os.path.dirname(os.path.dirname(path)), title), newFileName)
def setup_play(self):
#self.next_dling = False
#self.iterator = 0
path = os.path.join(self.userStorageDirectory, self.c._file.path)
label = os.path.basename(self.c._file.path)
self.basename = label
#self.seeding_run = False
listitem = xbmcgui.ListItem(label)
info={}
#if self.subs_dl:
# self.setup_subs(label, path)
try:
seasonId = self.get("seasonId")
self.episodeId = self.get("episodeId") if not self.episodeId else int(self.episodeId) + 1
title = urllib.unquote_plus(self.get("title")) if self.get("title") else None
if self.get("label") and self.episodeId == self.get("episodeId"):
label = urllib.unquote_plus(self.get("label"))
elif seasonId and self.episodeId and title:
label = '%s S%02dE%02d.%s (%s)' % (
title, int(seasonId), int(self.episodeId), self.basename.split('.')[-1], self.basename)
if seasonId and self.episodeId and label and title:
info={'title': label,
'episode': int(self.episodeId),
'season': int(seasonId),
'tvshowtitle': title}
except:
log('[BTClientPlayer] Operation INFO failed!')
thumbnail = self.get("thumbnail")
listitem.setInfo(type='Video', infoLabels=info)
if thumbnail:
listitem.setThumbnailImage(urllib.unquote_plus(thumbnail))
self.display_name = label
base = 'http://127.0.0.1:' + str(self.free_port) + '/'
url = urlparse.urljoin(base, urllib.quote(self.c._file.path))
# мегакостыль!
rpc = ({'jsonrpc': '2.0', 'method': 'Files.GetDirectory', 'params': {
'media': 'video', 'directory': path}, 'id': 0})
data = json.dumps(rpc)
request = xbmc.executeJSONRPC(data)
response = json.loads(request)
while not response:
xbmc.sleep(100)
if response:
xbmc.sleep(3000)
#if 1==1:
playlist = xbmc.PlayList(xbmc.PLAYLIST_VIDEO)
playlist.clear()
playlist.add(url, listitem)
xbmc.Player().play(playlist)
log("Serving file on %s" % url)
return True
def onPlayBackStarted(self):
for f in self.on_playback_started:
f()
log('[onPlayBackStarted]: '+(str(("video", "play", self.display_name))))
def onPlayBackResumed(self):
for f in self.on_playback_resumed:
f()
self.onPlayBackStarted()
def onPlayBackPaused(self):
for f in self.on_playback_paused:
f()
log('[onPlayBackPaused]: '+(str(("video", "pause", self.display_name))))
def onPlayBackStopped(self):
for f in self.on_playback_stopped:
f()
log('[onPlayBackStopped]: '+(str(("video", "stop", self.display_name))))
def onPlayBackSeek(self, x ,y):
log('[onPlayBackSeek]: '+(str(("video", "seek", self.display_name))))
#xbmc.Player().pause()
#if self.buffer():
# xbmc.Player().play()
def onPlayBackSeekChapter(self, x):
log('[onPlayBackSeek]: '+(str(("video", "seek", self.display_name))))
#xbmc.Player().pause()
#if self.buffer():
# xbmc.Player().play()
@contextmanager
def attach(self, callback, *events):
for event in events:
event.append(callback)
yield
for event in events:
event.remove(callback)
def loop(self):
#debug_counter=0
with closing(
OverlayText(w=OVERLAY_WIDTH, h=OVERLAY_HEIGHT, alignment=XBFONT_CENTER_X | XBFONT_CENTER_Y)) as overlay:
with nested(self.attach(overlay.show, self.on_playback_paused),
self.attach(overlay.hide, self.on_playback_resumed, self.on_playback_stopped)):
while True:
if xbmc.abortRequested or not self.isPlaying():
break
#if self.iterator == 100 and debug_counter < 100:
# debug_counter += 1
#else:
# self.torrent.debug()
# debug_counter=0
status = self.c.status
overlay.text = "\n".join(self._get_status_lines(status))
self.iterator = int(status.progress * 100)
xbmc.sleep(1000)
if self.iterator == 100 and self.next_dl:
next_contentId_index = self.ids_video.index(str(self.contentId)) + 1
if len(self.ids_video) > next_contentId_index:
self.next_contentId = int(self.ids_video[next_contentId_index])
else:
self.next_contentId = False
log('[loop] next_contentId: '+str(self.next_contentId))
if not self.seeding_run and self.iterator == 100 and self.seeding:
self.seeding_run = True
self.seed(self.contentId)
self.seeding_status = True
# xbmc.sleep(7000)
if self.iterator == 100 and self.next_dl and not self.next_dling and isinstance(self.next_contentId,
int) and self.next_contentId != False:
showMessage(self.localize('Torrent Downloading'),
self.localize('Starting download next episode!'), forced=True)
self.torrent.stopSession()
# xbmc.sleep(1000)
path = self.torrent.getFilePath(self.next_contentId)
self.basename = self.display_name = os.path.basename(path)
self.torrent.continueSession(self.next_contentId)
self.next_dling = True
def _get_status_lines(self, s):
return [
self.display_name.decode('utf-8'),
"%.2f%% %s" % (s.progress * 100, self.localize(STATE_STRS[s.state]).decode('utf-8')),
"D:%.2f%s U:%.2f%s S:%d P:%d" % (s.download_rate / 1024, self.localize('kb/s').decode('utf-8'),
s.upload_rate / 1024, self.localize('kb/s').decode('utf-8'),
s.num_seeds, s.num_peers)
]
def db_delete(self):
if self.basename:
db = DownloadDB()
get = db.get(self.basename)
if get:
db.delete(get[0])
def seed(self, contentId):
self.db_delete()
exec_str = 'XBMC.RunPlugin(%s)' % \
('%s?action=%s&url=%s&storage=%s&ind=%s') % \
(sys.argv[0], 'downloadLibtorrent', urllib.quote_plus(self.torrentUrl),
urllib.quote_plus(self.userStorageDirectory), str(contentId))
xbmc.executebuiltin(exec_str)
def get_ids(self):
contentList = []
for filedict in self.torrent.getContentList():
contentList.append((filedict.get('title'), str(filedict.get('ind'))))
contentList = sorted(contentList, key=lambda x: x[0])
return get_ids_video(contentList)
def localize(self, string):
try:
return Localization.localize(string)
except:
return string
def on_exit(self):
self.c.close()
sys.exit(0)