def __init__(self): if VideoPlaybackCrawler.__single is not None: raise RuntimeError, "VideoPlaybackCrawler is singleton" crawler = Crawler.get_instance() if crawler.am_crawler(): self._file = open("videoplaybackcrawler.txt", "a") self._file.write("".join(("# ", "*" * 80, "\n# ", strftime("%Y/%m/%d %H:%M:%S"), " Crawler started\n"))) self._file.flush() self._event_db = None else: self._file = None self._event_db = VideoPlaybackDBHandler.get_instance()
def get_reporter_instance(): """ A helper class that gets the right event reporter based on some configuration options. """ session = Session.get_instance() if session.get_overlay(): # hack: we should not import this since it is not part of # the core nor should we import here, but otherwise we # will get import errors # # note: the name VideoPlaybackDBHandler is a legacy name from # when this reporter was solely used to report video-playback # statistics. from Tribler.Core.CacheDB.SqliteVideoPlaybackStatsCacheDB import VideoPlaybackDBHandler return VideoPlaybackDBHandler.get_instance() else: return EventStatusReporter.get_instance()
def __init__(self,bt1download,videostatus,videoinfo,videoanalyserpath,vodeventfunc): # dirty hack to get the Tribler Session from Tribler.Core.Session import Session session = Session.get_instance() if session.get_overlay(): # see comment in else section on importing... from Tribler.Core.CacheDB.SqliteVideoPlaybackStatsCacheDB import VideoPlaybackDBHandler self._playback_stats = VideoPlaybackDBHandler.get_instance() else: # hack: we should not import this since it is not part of # the core nor should we import here, but otherwise we # will get import errors from Tribler.Player.Reporter import VideoPlaybackReporter self._playback_stats = VideoPlaybackReporter.get_instance() # add an event to indicate that the user wants playback to # start def set_nat(nat): self._playback_stats.add_event(self._playback_key, "nat:%s" % nat) self._playback_key = base64.b64encode(os.urandom(20)) self._playback_stats.add_event(self._playback_key, "play-init") self._playback_stats.add_event(self._playback_key, "piece-size:%d" % videostatus.piecelen) self._playback_stats.add_event(self._playback_key, "num-pieces:%d" % videostatus.movie_numpieces) self._playback_stats.add_event(self._playback_key, "bitrate:%d" % videostatus.bitrate) self._playback_stats.add_event(self._playback_key, "nat:%s" % session.get_nat_type(callback=set_nat)) self._complete = False self.videoinfo = videoinfo self.bt1download = bt1download self.piecepicker = bt1download.picker self.rawserver = bt1download.rawserver self.storagewrapper = bt1download.storagewrapper self.fileselector = bt1download.fileselector self.vodeventfunc = vodeventfunc self.videostatus = vs = videostatus # Add quotes around path, as that's what os.popen() wants on win32 if sys.platform == "win32" and videoanalyserpath is not None and videoanalyserpath.find(' ') != -1: self.video_analyser_path='"'+videoanalyserpath+'"' else: self.video_analyser_path=videoanalyserpath # counter for the sustainable() call. Every X calls the # buffer-percentage is updated. self.sustainable_counter = sys.maxint # boudewijn: because we now update the downloadrate for each # received chunk instead of each piece we do not need to # average the measurement over a 'long' period of time. Also, # we only update the downloadrate for pieces that are in the # high priority range giving us a better estimation on how # likely the pieces will be available on time. self.overall_rate = Measure(10) self.high_range_rate = Measure(2) # buffer: a link to the piecepicker buffer self.has = self.piecepicker.has # number of pieces in buffer self.pieces_in_buffer = 0 self.data_ready = Condition() # Arno: Call FFMPEG only if the torrent did not provide the # bitrate and video dimensions. This is becasue FFMPEG # sometimes hangs e.g. Ivaylo's Xvid Finland AVI, for unknown # reasons # Arno: 2007-01-06: Since we use VideoLan player, videodimensions not important assert vs.bitrate_set self.doing_ffmpeg_analysis = False self.doing_bitrate_est = False self.videodim = None #self.movieselector.videodim self.player_opened_with_width_height = False self.ffmpeg_est_bitrate = None prebufsecs = self.PREBUF_SEC_VOD # assumes first piece is whole (first_piecelen == piecelen) piecesneeded = vs.time_to_pieces( prebufsecs ) bytesneeded = piecesneeded * vs.piecelen self.max_prebuf_packets = min(vs.movie_numpieces, piecesneeded) if self.doing_ffmpeg_analysis and DEBUG: print >>sys.stderr,"vod: trans: Want",self.max_prebuf_packets,"pieces for FFMPEG analysis, piecesize",vs.piecelen if DEBUG: print >>sys.stderr,"vod: trans: Want",self.max_prebuf_packets,"pieces for prebuffering" self.nreceived = 0 if DEBUG: print >>sys.stderr,"vod: trans: Setting MIME type to",self.videoinfo['mimetype'] self.set_mimetype(self.videoinfo['mimetype']) # some statistics self.stat_playedpieces = 0 # number of pieces played successfully self.stat_latepieces = 0 # number of pieces that arrived too late self.stat_droppedpieces = 0 # number of pieces dropped self.stat_stalltime = 0.0 # total amount of time the video was stalled self.stat_prebuffertime = 0.0 # amount of prebuffer time used self.stat_pieces = PieceStats() # information about each piece # start periodic tasks self.curpiece = "" self.curpiece_pos = 0 # The outbuf keeps only the pieces from the base layer.. We play if we # have at least a piece from the base layer! self.outbuf = [] #self.last_pop = None # time of last pop self.reset_bitrate_prediction() self.lasttime=0 # For DownloadState self.prebufprogress = 0.0 self.prebufstart = time.time() self.playable = False self.usernotified = False self.outbuflen = None # LIVESOURCEAUTH self.authenticator = None self.refill_rawserv_tasker() self.tick_second() # link to others (last thing to do) self.piecepicker.set_transporter( self ) #self.start() if FAKEPLAYBACK: import threading class FakeReader(threading.Thread): def __init__(self,movie): threading.Thread.__init__(self) self.movie = movie def run(self): self.movie.start() while not self.movie.done(): self.movie.read() t = FakeReader(self) t.start()