# -*- coding: utf-8 -*- ''' Torrenter v2 plugin for XBMC/Kodi Copyright (C) 2012-2015 Vadim Skorba v1 - DiMartino v2 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 . ''' import thread import os import urllib2 import hashlib import re from StringIO import StringIO import gzip import xbmc import xbmcgui import xbmcvfs import Localization from functions import file_encode, isSubtitle, DownloadDB, log, debug, is_writable, unquote import os import urllib import json import sys from contextlib import contextmanager, closing, nested from functions import calculate, showMessage, clearStorage, DownloadDB, get_ids_video, log, debug from torrent2http import State, Engine, MediaType 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 ENCRYPTION_SETTINGS = { "Forced": 0, "Enabled": 1, "Disabled": 2, } class Encryption: FORCED = 0 ENABLED = 1 DISABLED = 2 class AnteoLoader: magnetLink = None engine = None torrentFile = None def __init__(self, storageDirectory='', torrentFile='', torrentFilesDirectory='torrents'): self.storageDirectory = storageDirectory self.torrentFilesPath = os.path.join(self.storageDirectory, torrentFilesDirectory) + os.sep if not is_writable(self.storageDirectory): xbmcgui.Dialog().ok(self.localize('Torrenter v2'), self.localize('Your storage path is not writable or not local! Please change it in settings!'), self.localize(self.storageDirectory)) sys.exit(1) #pre settings if os.path.exists(torrentFile): self.torrentFile = "file:///"+torrentFile.replace('\\','//').replace('////','//') elif re.match("^magnet\:.+$", torrentFile): self.magnetLink = torrentFile else: self.torrentFile = torrentFile def __exit__(self): log('on __exit__') if self.engine: self.engine.close() log('__exit__ worked!') def localize(self, string): try: return Localization.localize(string) except: return string def getContentList(self): self.engine = Engine(uri=self.torrentFile) files = [] filelist = [] with closing(self.engine): self.engine.start() #media_types=[MediaType.VIDEO, MediaType.AUDIO, MediaType.SUBTITLES, MediaType.UNKNOWN] while not files and not xbmc.abortRequested: files = self.engine.list() self.engine.check_torrent_error() xbmc.sleep(200) for fs in files: stringdata = {"title": fs.name, "size": fs.size, "ind": fs.index, 'offset': fs.offset} filelist.append(stringdata) return filelist def saveTorrent(self, torrentUrl): if not xbmcvfs.exists(torrentUrl) or re.match("^http.+$", torrentUrl): if re.match("^magnet\:.+$", torrentUrl): self.magnetLink = torrentUrl self.magnetToTorrent(torrentUrl) self.magnetLink = None return self.torrentFile else: if not xbmcvfs.exists(self.torrentFilesPath): xbmcvfs.mkdirs(self.torrentFilesPath) torrentFile = self.torrentFilesPath + self.md5(torrentUrl) + '.torrent' try: if not re.match("^http\:.+$", torrentUrl): content = xbmcvfs.File(torrentUrl, "rb").read() else: request = urllib2.Request(torrentUrl) request.add_header('Referer', torrentUrl) request.add_header('Accept-encoding', 'gzip') result = urllib2.urlopen(request) if result.info().get('Content-Encoding') == 'gzip': buf = StringIO(result.read()) f = gzip.GzipFile(fileobj=buf) content = f.read() else: content = result.read() localFile = xbmcvfs.File(torrentFile, "w+b") localFile.write(content) localFile.close() except Exception, e: print 'Unable to save torrent file from "' + torrentUrl + '" to "' + torrentFile + '" in Torrent::saveTorrent' + '. Exception: ' + str( e) return else: torrentFile = torrentUrl if xbmcvfs.exists(torrentFile) and not os.path.exists(torrentFile): if not xbmcvfs.exists(self.torrentFilesPath): xbmcvfs.mkdirs(self.torrentFilesPath) torrentFile = self.torrentFilesPath + self.md5(torrentUrl) + '.torrent' xbmcvfs.copy(torrentUrl, torrentFile) if xbmcvfs.exists(torrentFile): self.torrentFile = "file:///"+torrentFile.replace('\\','//').replace('////','//') return self.torrentFile def md5(self, string): hasher = hashlib.md5() try: hasher.update(string) except: hasher.update(string.encode('utf-8', 'ignore')) return hasher.hexdigest() def magnetToTorrent(self, magnet): self.torrentFile = magnet class AnteoPlayer(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 __init__(self, userStorageDirectory, torrentUrl, params={}): self.userStorageDirectory = userStorageDirectory self.torrentUrl = torrentUrl xbmc.Player.__init__(self) log("[AnteoPlayer] Initalized") self.params = params self.get = self.params.get self.contentId = int(self.get("url")) #self.torrent = AnteoLoader(self.userStorageDirectory, self.torrentUrl, self.torrentFilesDirectory) self.init() self.setup_engine() with closing(self.engine): self.engine.start(self.contentId) self.setup_nextep() while True: if self.buffer(): log('[AnteoPlayer]: ************************************* GOING LOOP') if self.setup_play(): self.loop() else: log('[AnteoPlayer]: ************************************* break') break log('[AnteoPlayer]: ************************************* GO NEXT?') if self.next_dl and isinstance(self.next_contentId, int) and self.iterator == 100: self.contentId = self.next_contentId continue log('[AnteoPlayer]: ************************************* NO! break') break xbmc.Player().stop() 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) def __exit__(self): log('on __exit__') if self.engine: self.engine.close() log('__exit__ worked!') def init(self): 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 = [] if xbmcvfs.exists(self.torrentUrl): self.torrentUrl = "file:///"+str(self.torrentUrl).replace('\\','//').replace('////','//') def setup_engine(self): #uri=None, binaries_path=None, platform=None, download_path=".", #bind_host='127.0.0.1', bind_port=5001, connections_limit=None, download_kbps=None, upload_kbps=None, #enable_dht=True, enable_lsd=True, enable_natpmp=True, enable_upnp=True, enable_scrape=False, #log_stats=False, encryption=Encryption.ENABLED, keep_complete=False, keep_incomplete=False, #keep_files=False, log_files_progress=False, log_overall_progress=False, log_pieces_progress=False, #listen_port=6881, use_random_port=False, max_idle_timeout=None, no_sparse=False, resume_file=None, #user_agent=None, startup_timeout=5, state_file=None, enable_utp=True, enable_tcp=True, #debug_alerts=False, logger=None, torrent_connect_boost=50, connection_speed=50, #peer_connect_timeout=15, request_timeout=20, min_reconnect_time=60, max_failcount=3, #dht_routers=None, trackers=None) encryption = Encryption.ENABLED if self.__settings__.getSetting('encryption') == 'true' else Encryption.DISABLED upload_limit = int(self.__settings__.getSetting("upload_limit"))*1024 if self.__settings__.getSetting( "upload_limit") != "" else 0 download_limit = int(self.__settings__.getSetting("download_limit"))*1024 if self.__settings__.getSetting( "download_limit") != "" else 0 if self.__settings__.getSetting("connections_limit") not in ["",0,"0"]: connections_limit = int(self.__settings__.getSetting("connections_limit")) else: connections_limit = None if '1' != self.__settings__.getSetting("keep_files") and 'Saved Files' not in self.userStorageDirectory: keep_complete = False keep_incomplete = False else: keep_complete = True keep_incomplete = True dht_routers = ["router.bittorrent.com:6881","router.utorrent.com:6881"] self.engine = Engine(uri=self.torrentUrl, download_path=self.userStorageDirectory, connections_limit=connections_limit, download_kbps=download_limit, upload_kbps=upload_limit, encryption=encryption, keep_complete=keep_complete, keep_incomplete=keep_incomplete, dht_routers=dht_routers) def buffer(self): self.pre_buffer_bytes = 30*1024*1024 #30 MB ready = False progressBar = xbmcgui.DialogProgress() progressBar.create(self.localize('Please Wait'), self.localize('Seeds searching.')) #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) while not xbmc.abortRequested and not ready: xbmc.sleep(500) status = self.engine.status() self.print_debug(status) self.engine.check_torrent_error(status) file_status = self.engine.file_status(self.contentId) if not file_status: continue fullSize = file_status.size / 1024 / 1024 downloadedSize = status.total_download / 1024 / 1024 getDownloadRate = status.download_rate / 1024 * 8 getUploadRate = status.upload_rate / 1024 * 8 getSeeds, getPeers = status.num_seeds, status.num_peers iterator = int(round(float(file_status.download) / self.pre_buffer_bytes, 2) * 100) if iterator > 99: iterator = 99 if status.state == State.QUEUED_FOR_CHECKING: progressBar.update(iterator, self.localize('Checking preloaded files...'), ' ', ' ') elif status.state == State.DOWNLOADING: dialogText = self.localize('Preloaded: ') + "%d MB / %d MB" % \ (int(downloadedSize), int(fullSize)) peersText = ' [%s: %s; %s: %s]' % ( self.localize('Seeds'), getSeeds, self.localize('Peers'), getPeers) speedsText = '%s: %d Mbit/s; %s: %d Mbit/s' % ( self.localize('Downloading'), int(getDownloadRate), self.localize('Uploading'), int(getUploadRate)) #if self.debug: # peersText=peersText + ' ' + self.torrent.get_debug_info('dht_state') # dialogText=dialogText.replace(self.localize('Preloaded: '),'') + ' ' + self.torrent.get_debug_info('trackers_sum') progressBar.update(iterator, self.localize('Seeds searching.') + peersText, dialogText, speedsText) if file_status.download >= self.pre_buffer_bytes: ready = True break elif status.state in [State.FINISHED, State.SEEDING]: ready = True break else: progressBar.update(iterator, self.localize('UNKNOWN STATUS'), ' ', ' ') if progressBar.iscanceled(): ready = False break progressBar.update(0) progressBar.close() return ready def setup_nextep(self): try: if self.get("url2"): debug("url2") self.ids_video = urllib.unquote_plus(self.get("url2")).split(',') else: debug("not url2") self.ids_video = self.get_ids() except: pass if self.__settings__.getSetting('next_dl') == 'true' and self.ids_video: self.next_dl = True else: self.next_dl = False log('[AnteoPlayer]: nextdl - %s, ids_video - %s' % (str(self.next_dl), str(self.ids_video))) def setup_play(self): file_status = self.engine.file_status(self.contentId) self.iterator = 0 url = file_status.url label = os.path.basename(file_status.name) self.basename = label self.seeding_run = False subtitles = None listitem = xbmcgui.ListItem(label, path=url) if 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('[AnteoPlayer][setup_play]: next_contentId: '+str(self.next_contentId)) if self.subs_dl: sub_files = self.engine.list(media_types=[MediaType.SUBTITLES]) if sub_files: log("[AnteoPlayer][setup_play]: Detected subtitles: %s" % str(sub_files[0])) subtitles = sub_files[0] 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: listitem = xbmcgui.ListItem(label, path=url) listitem.setInfo(type='video', infoLabels={'title': label, 'episode': int(self.episodeId), 'season': int(seasonId), 'tvshowtitle': title}) except: log('[AnteoPlayer]: Operation INFO failed!') thumbnail = self.get("thumbnail") if thumbnail: listitem.setThumbnailImage(urllib.unquote_plus(thumbnail)) self.display_name = label player = xbmc.Player() player.play(url, listitem) xbmc.sleep(1000) if subtitles: player.setSubtitles(subtitles.url) xbmc.sleep(2000) # very important, do not edit this, podavan return True def loop(self): debug_counter=0 xbmc.sleep(1000) 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 not xbmc.abortRequested and self.isPlaying(): #self.print_fulldebug() status = self.engine.status() file_status = self.engine.file_status(self.contentId) if self.iterator == 100 and debug_counter < 100: debug_counter += 1 else: self.print_debug(status) debug_counter=0 overlay.text = "\n".join(self._get_status_lines(status, file_status)) self.iterator = int(file_status.progress * 100) xbmc.sleep(1000) #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) 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)))) @contextmanager def attach(self, callback, *events): for event in events: event.append(callback) yield for event in events: event.remove(callback) def _get_status_lines(self, s, f): return [ self.display_name, "%.2f%% %s" % (f.progress * 100, self.localize(STATE_STRS[s.state]).decode('utf-8')), "D:%.2f%s U:%.2f%s S:%d P:%d" % (s.download_rate * 8, self.localize('kb/s').decode('utf-8'), s.upload_rate * 8, self.localize('kb/s').decode('utf-8'), s.num_seeds, s.num_peers) ] def localize(self, string): try: return Localization.localize(string) except: return string def print_debug(self, status=None): #FileStatus = namedtuple('FileStatus', "name, save_path, url, size, offset, download, progress, index, media_type") #SessionStatus = namedtuple('SessionStatus', "name, state, state_str, error, progress, download_rate, upload_rate, " # "total_download, total_upload, num_peers, num_seeds, total_seeds, " # "total_peers") #log('[buffer] file_status:'+str(file_status)) #log('[buffer] status:'+str(status)) if not status: status = self.engine.status() self.engine.check_torrent_error(status) log('[AnteoPlayer]: %.2f%% complete (down: %.1f kb/s up: %.1f kb/s peers: %d) %s' % \ (status.progress * 100, status.download_rate * 8, status.upload_rate * 8, status.num_peers, status.state_str)) def print_fulldebug(self): status = self.engine.status() file_status = self.engine.file_status(self.contentId) log('[buffer] file_status:'+str(file_status)) log('[buffer] status:'+str(status)) def get_ids(self): contentList = [] for fs in self.engine.list(): contentList.append((fs.name, str(fs.index))) contentList = sorted(contentList, key=lambda x: x[0]) return get_ids_video(contentList) class OverlayText(object): def __init__(self, w, h, *args, **kwargs): self.window = xbmcgui.Window(WINDOW_FULLSCREEN_VIDEO) viewport_w, viewport_h = self._get_skin_resolution() # Adjust size based on viewport, we are using 1080p coordinates w = int(w * viewport_w / VIEWPORT_WIDTH) h = int(h * viewport_h / VIEWPORT_HEIGHT) x = (viewport_w - w) / 2 y = (viewport_h - h) / 2 self._shown = False self._text = "" self._label = xbmcgui.ControlLabel(x, y, w, h, self._text, *args, **kwargs) self._background = xbmcgui.ControlImage(x, y, w, h, os.path.join(RESOURCES_PATH, "images", "black.png")) self._background.setColorDiffuse("0xD0000000") def show(self): if not self._shown: self.window.addControls([self._background, self._label]) self._shown = True self._background.setColorDiffuse("0xD0000000") def hide(self): if self._shown: self._shown = False self.window.removeControls([self._background, self._label]) self._background.setColorDiffuse("0xFF000000") def close(self): self.hide() @property def text(self): return self._text @text.setter def text(self, text): self._text = text if self._shown: self._label.setLabel(self._text) # This is so hackish it hurts. def _get_skin_resolution(self): import xml.etree.ElementTree as ET skin_path = xbmc.translatePath("special://skin/") tree = ET.parse(os.path.join(skin_path, "addon.xml")) res = tree.findall("./extension/res")[0] return int(res.attrib["width"]), int(res.attrib["height"])