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()
