def play_from_library(item): """ Los .strm al reproducirlos desde kodi, este espera que sea un archivo "reproducible" asi que no puede contener más items, como mucho se puede colocar un dialogo de seleccion. Esto lo solucionamos "engañando a kodi" y haciendole creer que se ha reproducido algo, asi despues mediante "Container.Update()" cargamos el strm como si un item desde dentro de pelisalacarta se tratara, quitando todas las limitaciones y permitiendo reproducir mediante la funcion general sin tener que crear nuevos métodos para la biblioteca. @type item: item @param item: elemento con información """ logger.info("streamondemand.platformcode.launcher play_from_library") # logger.debug("item: \n" + item.tostring('\n')) import xbmcgui import xbmcplugin import xbmc # Intentamos reproducir una imagen (esto no hace nada y ademas no da error) xbmcplugin.setResolvedUrl(int(sys.argv[1]), True, xbmcgui.ListItem(path=os.path.join(config.get_runtime_path(), "icon.png"))) # Por si acaso la imagen hiciera (en futuras versiones) le damos a stop para detener la reproduccion xbmc.Player().stop() # modificamos el action (actualmente la biblioteca necesita "findvideos" ya que es donde se buscan las fuentes item.action = "findvideos" # y volvemos a lanzar kodi if xbmc.getCondVisibility('Window.IsMedia'): xbmc.executebuiltin("Container.Update(" + sys.argv[0] + "?" + item.tourl() + ")") else: from channels import biblioteca from platformcode import xbmc_library p_dialog = platformtools.dialog_progress_bg('streamondemand', 'Caricamento in corso...') p_dialog.update(0, '') itemlist = biblioteca.findvideos(item) p_dialog.update(50, '') if len(itemlist) > 0: # El usuario elige el mirror opciones = [] for item in itemlist: opciones.append(item.title) seleccion = platformtools.dialog_select(config.get_localized_string(30163), opciones) if seleccion == -1: return item = biblioteca.play(itemlist[seleccion])[0] p_dialog.update(100, '') platformtools.play_video(item) p_dialog.close() xbmc_library.mark_auto_as_watched(itemlist[seleccion])
def play_from_library(item): """ Los .strm al reproducirlos desde kodi, este espera que sea un archivo "reproducible" asi que no puede contener más items, como mucho se puede colocar un dialogo de seleccion. Esto lo solucionamos "engañando a kodi" y haciendole creer que se ha reproducido algo, asi despues mediante "Container.Update()" cargamos el strm como si un item desde dentro de pelisalacarta se tratara, quitando todas las limitaciones y permitiendo reproducir mediante la funcion general sin tener que crear nuevos métodos para la biblioteca. @type item: item @param item: elemento con información """ logger.info("pelisalacarta.platformcode.launcher play_from_library") # logger.debug("item: \n" + item.tostring('\n')) import xbmcgui import xbmcplugin import xbmc # Intentamos reproducir una imagen (esto no hace nada y ademas no da error) xbmcplugin.setResolvedUrl(int(sys.argv[1]), True, xbmcgui.ListItem(path=os.path.join(config.get_runtime_path(), "icon.png"))) # Por si acaso la imagen hiciera (en futuras versiones) le damos a stop para detener la reproduccion xbmc.Player().stop() # modificamos el action (actualmente la biblioteca necesita "findvideos" ya que es donde se buscan las fuentes item.action = "findvideos" # y volvemos a lanzar kodi if xbmc.getCondVisibility('Window.IsMedia'): xbmc.executebuiltin("Container.Update(" + sys.argv[0] + "?" + item.tourl() + ")") else: from channels import biblioteca from platformcode import xbmc_library p_dialog = platformtools.dialog_progress_bg('pelisalacarta', 'Cargando...') p_dialog.update(0, '') itemlist = biblioteca.findvideos(item) p_dialog.update(50, '') if len(itemlist) > 0: # El usuario elige el mirror opciones = [] for item in itemlist: opciones.append(item.title) seleccion = platformtools.dialog_select(config.get_localized_string(30163), opciones) if seleccion == -1: return item = biblioteca.play(itemlist[seleccion])[0] p_dialog.update(100, '') platformtools.play_video(item) p_dialog.close() xbmc_library.mark_auto_as_watched(itemlist[seleccion])
def play_video(item, strm=False): logger.info("pelisalacarta.platformcode.platformtools play_video") #logger.debug(item.tostring('\n')) if item.channel == 'descargas': logger.info("Reproducir video local: %s [%s]" % (item.title, item.url)) xlistitem = xbmcgui.ListItem(path=item.url, thumbnailImage=item.thumbnail) set_infolabels(xlistitem, item, True) xbmc.Player().play(item.url, xlistitem) return default_action = config.get_setting("default_action") logger.info("default_action=" + default_action) # Abre el diálogo de selección para ver las opciones disponibles opciones, video_urls, seleccion, salir = get_dialogo_opciones( item, default_action, strm) if salir: return # se obtienen la opción predeterminada de la configuración del addon seleccion = get_seleccion(default_action, opciones, seleccion, video_urls) if seleccion < 0: # Cuadro cancelado return logger.info("seleccion=%d" % seleccion) logger.info("seleccion=%s" % opciones[seleccion]) # se ejecuta la opcion disponible, jdwonloader, descarga, favoritos, añadir a la biblioteca... SI NO ES PLAY salir = set_opcion(item, seleccion, opciones, video_urls) if salir: return # obtenemos el video seleccionado mediaurl, view, mpd = get_video_seleccionado(item, seleccion, video_urls) if mediaurl == "": return # se obtiene la información del video. xlistitem = xbmcgui.ListItem(path=mediaurl, thumbnailImage=item.thumbnail) set_infolabels(xlistitem, item, True) # si se trata de un vídeo en formato mpd, se configura el listitem para reproducirlo # con el addon inpustreamaddon implementado en Kodi 17 if mpd: xlistitem.setProperty('inputstreamaddon', 'inputstream.adaptive') xlistitem.setProperty('inputstream.adaptive.manifest_type', 'mpd') # se lanza el reproductor set_player(item, xlistitem, mediaurl, view, strm) # si es un archivo de la biblioteca enviar a marcar como visto if strm or item.strm_path: from platformcode import xbmc_library xbmc_library.mark_auto_as_watched(item)
def play_video(item, strm=False): logger.info("pelisalacarta.platformcode.platformtools play_video") # logger.debug(item.tostring('\n')) if item.channel == 'descargas': logger.info("Reproducir video local: %s [%s]" % (item.title, item.url)) xlistitem = xbmcgui.ListItem(path=item.url, thumbnailImage=item.thumbnail) set_infolabels(xlistitem, item, True) xbmc.Player().play(item.url, xlistitem) return default_action = config.get_setting("default_action") logger.info("default_action=" + default_action) # Abre el diálogo de selección para ver las opciones disponibles opciones, video_urls, seleccion, salir = get_dialogo_opciones(item, default_action, strm) if salir: return # se obtienen la opción predeterminada de la configuración del addon seleccion = get_seleccion(default_action, opciones, seleccion, video_urls) if seleccion < 0: # Cuadro cancelado return logger.info("seleccion=%d" % seleccion) logger.info("seleccion=%s" % opciones[seleccion]) # se ejecuta la opcion disponible, jdwonloader, descarga, favoritos, añadir a la biblioteca... SI NO ES PLAY salir = set_opcion(item, seleccion, opciones, video_urls) if salir: return # obtenemos el video seleccionado mediaurl, view, mpd = get_video_seleccionado(item, seleccion, video_urls) if mediaurl == "": return # se obtiene la información del video. xlistitem = xbmcgui.ListItem(path=mediaurl, thumbnailImage=item.thumbnail) set_infolabels(xlistitem, item, True) # si se trata de un vídeo en formato mpd, se configura el listitem para reproducirlo # con el addon inpustreamaddon implementado en Kodi 17 if mpd: xlistitem.setProperty('inputstreamaddon', 'inputstream.adaptive') xlistitem.setProperty('inputstream.adaptive.manifest_type', 'mpd') # se lanza el reproductor set_player(item, xlistitem, mediaurl, view, strm) # si es un archivo de la biblioteca enviar a marcar como visto if strm or item.strm_path: from platformcode import xbmc_library xbmc_library.mark_auto_as_watched(item)
def set_player(item, xlistitem, mediaurl, view, strm): logger.info() logger.debug("item:\n" + item.tostring('\n')) # Movido del conector "torrent" aqui if item.server == "torrent": play_torrent(item, xlistitem, mediaurl) return # Si es un fichero strm no hace falta el play elif strm: xbmcplugin.setResolvedUrl(int(sys.argv[1]), True, xlistitem) if item.subtitle != "": xbmc.sleep(2000) xbmc.Player().setSubtitles(item.subtitle) else: logger.info("player_mode=%s" % config.get_setting("player_mode")) logger.info("mediaurl=" + mediaurl) if config.get_setting( "player_mode") == 3 or "megacrypter.com" in mediaurl: import download_and_play download_and_play.download_and_play( mediaurl, "download_and_play.tmp", config.get_setting("downloadpath")) return elif config.get_setting("player_mode") == 0 or \ (config.get_setting("player_mode") == 3 and mediaurl.startswith("rtmp")): # Añadimos el listitem a una lista de reproducción (playlist) playlist = xbmc.PlayList(xbmc.PLAYLIST_VIDEO) playlist.clear() playlist.add(mediaurl, xlistitem) # Reproduce playersettings = config.get_setting('player_type') logger.info("playersettings=%s" % playersettings) if config.get_system_platform() == "xbox": player_type = xbmc.PLAYER_CORE_AUTO if playersettings == 0: player_type = xbmc.PLAYER_CORE_AUTO logger.debug("PLAYER_CORE_AUTO") elif playersettings == 1: player_type = xbmc.PLAYER_CORE_MPLAYER logger.debug("PLAYER_CORE_MPLAYER") elif playersettings == 2: player_type = xbmc.PLAYER_CORE_DVDPLAYER logger.debug("PLAYER_CORE_DVDPLAYER") xbmc_player = xbmc.Player(player_type) else: xbmc_player = xbmc.Player() xbmc_player.play(playlist, xlistitem) elif config.get_setting("player_mode") == 1: logger.info("mediaurl :" + mediaurl) logger.info("Tras setResolvedUrl") xbmcplugin.setResolvedUrl(int(sys.argv[1]), True, xbmcgui.ListItem(path=mediaurl)) elif config.get_setting("player_mode") == 2: xbmc.executebuiltin("PlayMedia(" + mediaurl + ")") # TODO MIRAR DE QUITAR VIEW if item.subtitle != "" and view: logger.info("Subtítulos externos: " + item.subtitle) xbmc.sleep(2000) xbmc.Player().setSubtitles(item.subtitle) # si es un archivo de la biblioteca enviar a marcar como visto if strm or item.strm_path: from platformcode import xbmc_library xbmc_library.mark_auto_as_watched(item)
def play_torrent(item, xlistitem, mediaurl): logger.info() # Opciones disponibles para Reproducir torrents torrent_options = list() torrent_options.append(["Client interno (necessario libtorrent)"]) torrent_options.append(["Client interno MCT (necessario libtorrent)"]) # Plugins externos se pueden añadir otros if xbmc.getCondVisibility('System.HasAddon("plugin.video.xbmctorrent")'): torrent_options.append([ "Plugin externo: xbmctorrent", "plugin://plugin.video.xbmctorrent/play/%s" ]) if xbmc.getCondVisibility('System.HasAddon("plugin.video.pulsar")'): torrent_options.append([ "Plugin externo: pulsar", "plugin://plugin.video.pulsar/play?uri=%s" ]) if xbmc.getCondVisibility('System.HasAddon("plugin.video.quasar")'): torrent_options.append([ "Plugin externo: quasar", "plugin://plugin.video.quasar/play?uri=%s" ]) if xbmc.getCondVisibility('System.HasAddon("plugin.video.stream")'): torrent_options.append( ["Plugin externo: stream", "plugin://plugin.video.stream/play/%s"]) if xbmc.getCondVisibility('System.HasAddon("plugin.video.torrenter")'): torrent_options.append([ "Plugin externo: torrenter", "plugin://plugin.video.torrenter/?action=playSTRM&url=%s" ]) if xbmc.getCondVisibility('System.HasAddon("plugin.video.torrentin")'): torrent_options.append([ "Plugin externo: torrentin", "plugin://plugin.video.torrentin/?uri=%s&image=" ]) if len(torrent_options) > 1: seleccion = dialog_select("Apri torrent con...", [opcion[0] for opcion in torrent_options]) else: seleccion = 0 # Plugins externos if seleccion > 1: mediaurl = urllib.quote_plus(item.url) xbmc.executebuiltin("PlayMedia(" + torrent_options[seleccion][1] % mediaurl + ")") if seleccion == 1: from platformcode import mct mct.play(mediaurl, xlistitem, subtitle=item.subtitle, item=item) # Reproductor propio (libtorrent) if seleccion == 0: import time played = False debug = (config.get_setting("debug") == True) # Importamos el cliente from btserver import Client client_tmp_path = config.get_setting("downloadpath") if not client_tmp_path: client_tmp_path = config.get_data_path() # Iniciamos el cliente: c = Client(url=mediaurl, is_playing_fnc=xbmc.Player().isPlaying, wait_time=None, timeout=10, temp_path=os.path.join(client_tmp_path, "streamondemand-torrent"), print_status=debug) # Mostramos el progreso progreso = dialog_progress("Streamondemand - Torrent", "Avvio...") # Mientras el progreso no sea cancelado ni el cliente cerrado while not c.closed: try: # Obtenemos el estado del torrent s = c.status if debug: # Montamos las tres lineas con la info del torrent txt = '%.2f%% de %.1fMB %s | %.1f kB/s' % \ (s.progress_file, s.file_size, s.str_state, s._download_rate) txt2 = 'S: %d(%d) P: %d(%d) | DHT:%s (%d) | Trakers: %d' % \ (s.num_seeds, s.num_complete, s.num_peers, s.num_incomplete, s.dht_state, s.dht_nodes, s.trackers) txt3 = 'Origen Peers TRK: %d DHT: %d PEX: %d LSD %d ' % \ (s.trk_peers, s.dht_peers, s.pex_peers, s.lsd_peers) else: txt = '%.2f%% de %.1fMB %s | %.1f kB/s' % \ (s.progress_file, s.file_size, s.str_state, s._download_rate) txt2 = 'S: %d(%d) P: %d(%d)' % ( s.num_seeds, s.num_complete, s.num_peers, s.num_incomplete) try: txt3 = 'Arresto automatico in: %ss' % (int(s.timeout)) except: txt3 = '' progreso.update(s.buffer, txt, txt2, txt3) time.sleep(0.5) if progreso.iscanceled(): progreso.close() if s.buffer == 100: if dialog_yesno("Streamondemand - Torrent", "Vuoi avviare la riproduzione?"): played = False progreso = dialog_progress( "Streamondemand - Torrent", "") progreso.update(s.buffer, txt, txt2, txt3) else: progreso = dialog_progress( "Streamondemand - Torrent", "") break else: if dialog_yesno("Streamondemand - Torrent", "Vuoi annullare?"): progreso = dialog_progress( "Streamondemand - Torrent", "") break else: progreso = dialog_progress( "Streamondemand - Torrent", "") progreso.update(s.buffer, txt, txt2, txt3) # Si el buffer se ha llenado y la reproduccion no ha sido iniciada, se inicia if s.buffer == 100 and not played: # Cerramos el progreso progreso.close() # Obtenemos el playlist del torrent videourl = c.get_play_list() # Iniciamos el reproductor playlist = xbmc.PlayList(xbmc.PLAYLIST_VIDEO) playlist.clear() playlist.add(videourl, xlistitem) xbmc_player = xbmc.Player() xbmc_player.play(playlist) # Marcamos como reproducido para que no se vuelva a iniciar played = True # si es un archivo de la biblioteca enviar a marcar como visto if item.strm_path: from platformcode import xbmc_library xbmc_library.mark_auto_as_watched(item) # Y esperamos a que el reproductor se cierre while xbmc.Player().isPlaying(): time.sleep(1) # Cuando este cerrado, Volvemos a mostrar el dialogo progreso = dialog_progress("Streamondemand - Torrent", "") progreso.update(s.buffer, txt, txt2, txt3) except: import traceback logger.error(traceback.format_exc()) break progreso.update(100, "Completamento e cancellazione dei dati", " ", " ") # Detenemos el cliente if not c.closed: c.stop() # Y cerramos el progreso progreso.close()
def play(url, xlistitem={}, is_view=None, subtitle="", item=None): allocate = True try: import platform xbmc.log( "XXX KODI XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX" ) xbmc.log("OS platform: %s %s" % (platform.system(), platform.release())) xbmc.log("xbmc/kodi version: %s" % xbmc.getInfoLabel("System.BuildVersion")) xbmc_version = int(xbmc.getInfoLabel("System.BuildVersion")[:2]) xbmc.log("xbmc/kodi version number: %s" % xbmc_version) xbmc.log( "XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX KODI XXXX" ) _platform = get_platform() if str(_platform['system']) in [ "android_armv7", "linux_armv6", "linux_armv7" ]: allocate = False # -- log ------------------------------------------------ xbmc.log( "XXX platform XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX" ) xbmc.log("_platform['system']: %s" % _platform['system']) xbmc.log("allocate: %s" % allocate) xbmc.log( "XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX platform XXXX" ) # -- ---------------------------------------------------- except: pass DOWNLOAD_PATH = config.get_setting("downloadpath") # -- adfly: ------------------------------------ if url.startswith("http://adf.ly/"): try: data = scrapertools.downloadpage(url) url = decode_adfly(data) except: ddd = xbmcgui.Dialog() ddd.ok("streamondemand-MCT: Senza supporto adf.ly", "Lo script non supporta gli URL adf.ly shortener.", "", "url: " + url) return # -- Necesario para algunas webs ---------------------------- if not url.endswith(".torrent") and not url.startswith("magnet"): t_file = scrapertools.get_header_from_response( url, header_to_get="location") if len(t_file) > 0: url = t_file t_file = scrapertools.get_header_from_response( url, header_to_get="location") if len(t_file) > 0: url = t_file # -- Crear dos carpetas en descargas para los archivos ------ save_path_videos = os.path.join(DOWNLOAD_PATH, "torrent-videos") save_path_torrents = os.path.join(DOWNLOAD_PATH, "torrent-torrents") if not os.path.exists(save_path_torrents): os.mkdir(save_path_torrents) # -- Usar - archivo torrent desde web, magnet o HD --------- if not os.path.isfile(url) and not url.startswith("magnet"): # -- http - crear archivo torrent ----------------------- data = url_get(url) # -- El nombre del torrent será el que contiene en los -- # -- datos. - re_name = urllib.unquote( scrapertools.get_match(data, ':name\d+:(.*?)\d+:')) torrent_file = filetools.join(save_path_torrents, filetools.encode(re_name + '.torrent')) f = open(torrent_file, 'wb') f.write(data) f.close() elif os.path.isfile(url): # -- file - para usar torrens desde el HD --------------- torrent_file = url else: # -- magnet --------------------------------------------- torrent_file = url # ----------------------------------------------------------- # -- MCT - MiniClienteTorrent ------------------------------- ses = lt.session() # -- log ---------------------------------------------------- xbmc.log("### Init session ########") xbmc.log(lt.version) xbmc.log("#########################") # -- -------------------------------------------------------- ses.add_dht_router("router.bittorrent.com", 6881) ses.add_dht_router("router.utorrent.com", 6881) ses.add_dht_router("dht.transmissionbt.com", 6881) trackers = [ "udp://tracker.openbittorrent.com:80/announce", "http://tracker.torrentbay.to:6969/announce", "http://tracker.pow7.com/announce", "udp://tracker.ccc.de:80/announce", "udp://open.demonii.com:1337", "http://9.rarbg.com:2710/announce", "http://bt.careland.com.cn:6969/announce", "http://explodie.org:6969/announce", "http://mgtracker.org:2710/announce", "http://tracker.best-torrents.net:6969/announce", "http://tracker.tfile.me/announce", "http://tracker1.wasabii.com.tw:6969/announce", "udp://9.rarbg.com:2710/announce", "udp://9.rarbg.me:2710/announce", "udp://coppersurfer.tk:6969/announce", "http://www.spanishtracker.com:2710/announce", "http://www.todotorrents.com:2710/announce", ] video_file = "" # -- magnet2torrent ----------------------------------------- if torrent_file.startswith("magnet"): try: import zlib btih = hex( zlib.crc32( scrapertools.get_match( torrent_file, 'magnet:\?xt=urn:(?:[A-z0-9:]+|)([A-z0-9]{32})')) & 0xffffffff) files = [ f for f in os.listdir(save_path_torrents) if os.path.isfile(os.path.join(save_path_torrents, f)) ] for file in files: if btih in os.path.basename(file): torrent_file = os.path.join(save_path_torrents, file) except: pass if torrent_file.startswith("magnet"): try: tempdir = tempfile.mkdtemp() except IOError: tempdir = os.path.join(save_path_torrents, "temp") if not os.path.exists(tempdir): os.mkdir(tempdir) params = { 'save_path': tempdir, 'trackers': trackers, 'storage_mode': lt.storage_mode_t.storage_mode_allocate, 'paused': False, 'auto_managed': True, 'duplicate_is_error': True } h = lt.add_magnet_uri(ses, torrent_file, params) dp = xbmcgui.DialogProgress() dp.create('streamondemand-MCT') while not h.has_metadata(): message, porcent, msg_file, s, download = getProgress( h, "Creating torrent from magnet") dp.update(porcent, message, msg_file) if s.state == 1: download = 1 if dp.iscanceled(): dp.close() remove_files(download, torrent_file, video_file, ses, h) return h.force_dht_announce() xbmc.sleep(1000) dp.close() info = h.get_torrent_info() data = lt.bencode(lt.create_torrent(info).generate()) torrent_file = os.path.join( save_path_torrents, unicode(info.name() + "-" + btih, "'utf-8'", errors="replace") + ".torrent") f = open(torrent_file, 'wb') f.write(data) f.close() ses.remove_torrent(h) shutil.rmtree(tempdir) # ----------------------------------------------------------- # -- Archivos torrent --------------------------------------- e = lt.bdecode(open(torrent_file, 'rb').read()) info = lt.torrent_info(e) # -- El más gordo o uno de los más gordo se entiende que es - # -- el vídeo o es el vídeo que se usará como referencia - # -- para el tipo de archivo - xbmc.log("##### Archivos ## %s ##" % len(info.files())) _index_file, _video_file, _size_file = get_video_file(info) # -- Prioritarizar/Seleccionar archivo----------------------- _index, video_file, video_size, len_files = get_video_files_sizes(info) if len_files == 0: dp = xbmcgui.Dialog().ok("Impossibile riprodurre", "Il file torrent non contiene il video") if _index == -1: _index = _index_file video_file = _video_file video_size = _size_file _video_file_ext = os.path.splitext(_video_file)[1] xbmc.log("##### _video_file_ext ## %s ##" % _video_file_ext) if (_video_file_ext == ".avi" or _video_file_ext == ".mp4") and allocate: xbmc.log("##### storage_mode_t.storage_mode_allocate (" + _video_file_ext + ") #####") h = ses.add_torrent({ 'ti': info, 'save_path': save_path_videos, 'trackers': trackers, 'storage_mode': lt.storage_mode_t.storage_mode_allocate }) else: xbmc.log("##### storage_mode_t.storage_mode_sparse (" + _video_file_ext + ") #####") h = ses.add_torrent({ 'ti': info, 'save_path': save_path_videos, 'trackers': trackers, 'storage_mode': lt.storage_mode_t.storage_mode_sparse }) allocate = True # ----------------------------------------------------------- # -- Descarga secuencial - trozo 1, trozo 2, ... ------------ h.set_sequential_download(True) h.force_reannounce() h.force_dht_announce() # -- Inicio de variables para 'pause' automático cuando el - # -- el vídeo se acerca a una pieza sin completar - is_greater_num_pieces = False is_greater_num_pieces_plus = False is_greater_num_pieces_pause = False porcent4first_pieces = int(video_size * 0.000000005) if porcent4first_pieces < 10: porcent4first_pieces = 10 if porcent4first_pieces > 100: porcent4first_pieces = 100 porcent4last_pieces = int(porcent4first_pieces / 2) num_pieces_to_resume = int(video_size * 0.0000000025) if num_pieces_to_resume < 5: num_pieces_to_resume = 5 if num_pieces_to_resume > 25: num_pieces_to_resume = 25 xbmc.log("##### porcent4first_pieces ## %s ##" % porcent4first_pieces) xbmc.log("##### porcent4last_pieces ## %s ##" % porcent4last_pieces) xbmc.log("##### num_pieces_to_resume ## %s ##" % num_pieces_to_resume) # -- Prioritarizar o seleccionar las piezas del archivo que - # -- se desea reproducir con 'file_priorities' - piece_set = set_priority_pieces(h, _index, video_file, video_size, porcent4first_pieces, porcent4last_pieces, allocate) # -- Crear diálogo de progreso para el primer bucle --------- dp = xbmcgui.DialogProgress() dp.create('streamondemand-MCT') _pieces_info = {} # -- Doble bucle anidado ------------------------------------ # -- Descarga - Primer bucle - while not h.is_seed(): s = h.status() xbmc.sleep(100) # -- Recuperar los datos del progreso ------------------- message, porcent, msg_file, s, download = getProgress(h, video_file, _pf=_pieces_info) # -- Si hace 'checking' existe descarga ----------------- # -- 'download' Se usará para saber si hay datos - # -- descargados para el diálogo de 'remove_files' - if s.state == 1: download = 1 # -- Player - play -------------------------------------- # -- Comprobar si se han completado las piezas para el - # -- inicio del vídeo - first_pieces = True _c = 0 for i in range(piece_set[0], piece_set[porcent4first_pieces]): first_pieces &= h.have_piece(i) if h.have_piece(i): _c += 1 _pieces_info = { 'current': 0, 'continuous': "%s/%s" % (_c, porcent4first_pieces), 'continuous2': "", 'have': h.status().num_pieces, 'len': len(piece_set) } last_pieces = True if not allocate: _c = len(piece_set) - 1 _cc = 0 for i in range( len(piece_set) - porcent4last_pieces, len(piece_set)): last_pieces &= h.have_piece(i) if h.have_piece(i): _c -= 1 _cc += 1 _pieces_info['continuous2'] = "[%s/%s] " % (_cc, porcent4last_pieces) if is_view != "Ok" and first_pieces and last_pieces: _pieces_info['continuous2'] = "" xbmc.log("##### porcent [%.2f%%]" % (s.progress * 100)) is_view = "Ok" dp.close() # -- Player - Ver el vídeo -------------------------- playlist = xbmc.PlayList(xbmc.PLAYLIST_VIDEO) playlist.clear() ren_video_file = os.path.join(save_path_videos, video_file) try: playlist.add(ren_video_file, xlistitem) except: playlist.add(ren_video_file) if xbmc_version < 17: player = play_video(xbmc.PLAYER_CORE_AUTO) else: player = play_video() player.play(playlist) # -- Contador de cancelaciones para la ventana de - # -- 'pause' automático - is_greater_num_pieces_canceled = 0 continuous_pieces = 0 porcent_time = 0.00 current_piece = 0 set_next_continuous_pieces = porcent4first_pieces # -- Impedir que kodi haga 'resume' a un archivo ---- # -- que se reprodujo con anterioridad y que se - # -- eliminó para impedir que intente la reprucción - # -- en una pieza que aún no se ha completado y se - # -- active 'pause' automático - not_resume = True # -- Bandera subTítulos _sub = False # -- Segundo bucle - Player - Control de eventos ---- while player.isPlaying(): xbmc.sleep(100) # -- Añadir subTítulos if subtitle != "" and not _sub: _sub = True player.setSubtitles(subtitle) # -- Impedir que kodi haga 'resume' al inicio --- # -- de la descarga de un archivo conocido - if not_resume: player.seekTime(0) not_resume = False # -- Control 'pause' automático - continuous_pieces = count_completed_continuous_pieces( h, piece_set) if xbmc.Player().isPlaying(): # -- Porcentage del progreso del vídeo ------ player_getTime = player.getTime() player_getTotalTime = player.getTotalTime() porcent_time = player_getTime / player_getTotalTime * 100 # -- Pieza que se está reproduciendo -------- current_piece = int(porcent_time / 100 * len(piece_set)) # -- Banderas de control -------------------- is_greater_num_pieces = ( current_piece > continuous_pieces - num_pieces_to_resume) is_greater_num_pieces_plus = ( current_piece + porcent4first_pieces > continuous_pieces) is_greater_num_pieces_finished = ( current_piece + porcent4first_pieces >= len(piece_set)) # -- Activa 'pause' automático -------------- if is_greater_num_pieces and not player.paused and not is_greater_num_pieces_finished: is_greater_num_pieces_pause = True player.pause() if continuous_pieces >= set_next_continuous_pieces: set_next_continuous_pieces = continuous_pieces + num_pieces_to_resume next_continuous_pieces = str( continuous_pieces - current_piece) + "/" + str(set_next_continuous_pieces - current_piece) _pieces_info = { 'current': current_piece, 'continuous': next_continuous_pieces, 'continuous2': _pieces_info['continuous2'], 'have': h.status().num_pieces, 'len': len(piece_set) } # si es un archivo de la biblioteca enviar a marcar como visto if item.strm_path: from platformcode import xbmc_library xbmc_library.mark_auto_as_watched(item) # -- Cerrar el diálogo de progreso -------------- if player.resumed: dp.close() # -- Mostrar el diálogo de progreso ------------- if player.paused: # -- Crear diálogo si no existe ------------- if not player.statusDialogoProgress: dp = xbmcgui.DialogProgress() dp.create('streamondemand-MCT') player.setDialogoProgress() # -- Diálogos de estado en el visionado ----- if not h.is_seed(): # -- Recuperar los datos del progreso --- message, porcent, msg_file, s, download = getProgress( h, video_file, _pf=_pieces_info) dp.update(porcent, message, msg_file) else: dp.update(100, "Download completo: " + video_file) # -- Se canceló el progreso en el visionado - # -- Continuar - if dp.iscanceled(): dp.close() player.pause() # -- Se canceló el progreso en el visionado - # -- en la ventana de 'pause' automático. - # -- Parar si el contador llega a 3 - if dp.iscanceled() and is_greater_num_pieces_pause: is_greater_num_pieces_canceled += 1 if is_greater_num_pieces_canceled == 3: player.stop() # -- Desactiva 'pause' automático y --------- # -- reinicia el contador de cancelaciones - if not dp.iscanceled( ) and not is_greater_num_pieces_plus and is_greater_num_pieces_pause: dp.close() player.pause() is_greater_num_pieces_pause = False is_greater_num_pieces_canceled = 0 # -- El usuario cancelo el visionado -------- # -- Terminar - if player.ended: # -- Diálogo eliminar archivos ---------- remove_files(download, torrent_file, video_file, ses, h) return # -- Kodi - Se cerró el visionado ----------------------- # -- Continuar | Terminar - if is_view == "Ok" and not xbmc.Player().isPlaying(): if info.num_files() == 1: # -- Diálogo continuar o terminar --------------- d = xbmcgui.Dialog() ok = d.yesno('streamondemand-MCT', 'Kodi ha chiuso il video.', 'Continuare con la sessione?') else: ok = False # -- SI --------------------------------------------- if ok: # -- Continuar: --------------------------------- is_view = None else: # -- Terminar: ---------------------------------- # -- Comprobar si el vídeo pertenece a una ------ # -- lista de archivos - _index, video_file, video_size, len_files = get_video_files_sizes( info) if _index == -1 or len_files == 1: # -- Diálogo eliminar archivos -------------- remove_files(download, torrent_file, video_file, ses, h) return else: # -- Lista de archivos. Diálogo de opciones - piece_set = set_priority_pieces(h, _index, video_file, video_size, porcent4first_pieces, porcent4last_pieces, allocate) is_view = None dp = xbmcgui.DialogProgress() dp.create('streamondemand-MCT') # -- Mostar progeso antes del visionado ----------------- if is_view != "Ok": dp.update(porcent, message, msg_file) # -- Se canceló el progreso antes del visionado --------- # -- Terminar - if dp.iscanceled(): dp.close() # -- Comprobar si el vídeo pertenece a una lista de - # -- archivos - _index, video_file, video_size, len_files = get_video_files_sizes( info) if _index == -1 or len_files == 1: # -- Diálogo eliminar archivos ------------------ remove_files(download, torrent_file, video_file, ses, h) return else: # -- Lista de archivos. Diálogo de opciones ----- piece_set = set_priority_pieces(h, _index, video_file, video_size, porcent4first_pieces, porcent4last_pieces, allocate) is_view = None dp = xbmcgui.DialogProgress() dp.create('streamondemand-MCT') # -- Kodi - Error? - No debería llegar aquí ----------------- if is_view == "Ok" and not xbmc.Player().isPlaying(): dp.close() # -- Diálogo eliminar archivos -------------------------- remove_files(download, torrent_file, video_file, ses, h) return