def __init__(self, id):
IR2A.__init__(self, id)
self.average_type = "exponential_average"
#"exponential_average" #tipo de média dos filtros
#"sliding_window_average"
#"harmonic_mean"
self.throughputs = []
self.request_time = 0
self.qi = []
self.smooth = [] #average estimated and smooth band
self.estimateband = [] #estimativa de banda
self.k = 0.14
self.w = 50000 #ganho constante de aproximadamente o valor minimo de segmentação do vídeo
self.m = 10 #tamanho da minha janela
self.beta = 0.15 #ganho do feedback de controle do buffer
self.alfa = 0.1
self.e = 0.10 #ganho da zona neutra de quantização
self.buffer = [] #lista para o buffer
self.buffer_min = 40
self.Tf = 1 #período de espera do próximo segmento
self.t = 0
self.deltaup = 0
self.deltadown = 0
self.quality = [0]
def __init__(self, id):
IR2A.__init__(self, id)
self.parsed_mpd = ''
self.qi = []
self.nameLog = 'r2a.log'
self.maxBufferSize = 0
self.lastRequestTime = 0
self.lastDecreaseNetworkReliability = 0
self.bpsHistory = []
self.QiHistory = []
self.initWindowSize = 10
self.windowSize = self.initWindowSize
self.windowSizeQi = 5
self.maxDownload = 0
self.avgDownload = 0
self.minDownload = 0
self.networkReliability = 100
self.timeReturnNetworkReliability = 5
self.timeVariationMultiplier = 1
self.maximumRisePercentageQi = 5
self.networkReliabilityLimit = 5
def __init__(self, id):
IR2A.__init__(self, id)
self.parsed_mpd = ''
self.qi = []
self.throughputs = [] # Array containing the throughputs available across the execution
self.request_time = None # Last request timestamp
def __init__(self, id, probe_inc=50000, probe_conv=1.9): # {{{2
"""Init for R2APANDA class. {{{
@param probe_inc Probing additive increase bitrate (ω)
@param probe_conv Probing convergence rate (κ)
}}}"""
IR2A.__init__(self, id)
self.probe_inc = probe_inc # (ω)
self.probe_conv = probe_conv # (κ)
self.request_time = None # Last request timestamp
self.interreq_time = [] # Actual time between requests (Τ)
self.target_interreq_time = [0]
self.target_bandshare = [] # Target average data rate (x̂)
self.smooth_bandshare = [] # Smoothed version of x̂ (ŷ)
self.throughputs = [] # TCP throughput measured (x̃)
self.buffer_duration = [0]
self.buffer_convergence = 0.5
self.buffer_min = self.whiteboard.get_max_buffer_size() * 0.25
self.buffer_min *= R2APANDA.seg_duration
self.parsed_mpd = None
self.qi = [] # List of available bitrates (quality) from manifest
self.q = [] # List of chosen bitrates (r)
def _init_(self, id):
IR2A._init_(self, id)
self.qi = []
self.throughput = []
self.time_request = 0
self.parsed_mpd = 0
self.vm = 0.0
def __init__(self, id): #inicializa as variaveis
IR2A.__init__(self, id)
self.request_time = 0
self.qi = []
self.tempos = []
self.bestperf = 0
self.besttime = 10000000000000
self.lastpause = -1
def __init__(self, id):
IR2A.__init__(self, id)
self.qi = []
self.throughput = 0
self.request_time = 0
self.vM = 0
self.timer = Timer.get_instance()
self.pause_started_at = None
def __init__(self, id):
IR2A.__init__(self, id)
self.parsed_mpd = ''
self.qi = []
self.time_of_request = []
self.bit_len = []
self.connection_speed = []
self.quality_id = []
def __init__(self, id):
IR2A.__init__(self, id)
self.throughputs = []
self.request_time = 0
self.qi = []
self.bandwidthShare = []
self.downloadTime = []
self.targetInterRequestTime = [1]
def __init__(self, id):
IR2A.__init__(self, id)
self.lastRequest = 0
self.lastBufferSz = 0
self.tabom = 0
self.parsed_mpd = ''
self.qi = []
self.whiteboard = whiteboard.Whiteboard.get_instance()
self.ini = time.time()
def __init__(self, id):
IR2A.__init__(self, id)
self.parsed_mpd = ''
self.qi = []
self.segment_throughput = []
self.estimated_throughput = []
self.request_time = 0
self.p = 0
def __init__(self, id):
IR2A.__init__(self, id)
self.parsed_mpd = ''
self.qi = []
self.d = 2 # seconds
self.throughputs = [] # np array
self.target_buff_t = 15 # seconds
self.start_idx_br = -10
self.curr_idx = 0
def __init__(self, id):
IR2A.__init__(self, id)
self.request_time = 0
self.qi = []
self.bandwidths = []
self.parsed_mpd = ''
self.current_qi = 0
self.current_buffer = 0
self.last_buffer = 0
def __init__(self, id):
IR2A.__init__(self, id)
self.timeToDownload = 0
self.segmentSize = 0
self.riList = []
self.qi = []
self.maxBufferSize = self.whiteboard.get_max_buffer_size()
self.d = 30 # tal
def __init__(self, id):
IR2A.__init__(self, id)
self.parsed_mpd = ''
self.qi = []
(self.bufferTime, self.diffBufferTime, self.output) = fuzzyfy()
self.rules = createRules(self.bufferTime, self.diffBufferTime,
self.output)
self.quality_ctrl = ctrl.ControlSystem(self.rules)
self.throughputs = []
self.request_time = 0.0
def __init__(self, id):
IR2A.__init__(self, id)
self.whiteboard = Whiteboard.get_instance()
self.parsed_mpd = ''
self.qi = []
# qi[1] = 91917bps
self.throughputs = [91917]
self.selected_qi = [91917]
self.request_time = 0.0
def __init__(self, id):
IR2A.__init__(self, id)
self.parsed_mpd = ''
self.qi = []
self.time_of_request = []
self.bit_len = []
self.throughput_arr = []
self.config_parameters = {}
self.medium_buffer = 40
self.qualities_len = 20
self.duration = 0
def __init__(self, id):
IR2A.__init__(self, id)
# Real throughput of the segments
self.tpSegment_list = []
# Estimated throughput of the segments
self.tpEstimated_list = []
self.request_time = 0
self.qi_list = []
self.segment_idx = 0
self.ideal_buffer = 20
def __init__(self, id):
IR2A.__init__(self, id)
self.throughputs = [] # corresponde a uma lista com os valores reais do throughput
self.calc_throughputs = [] # corresponde a uma lista com os valores alvo para o throughput usando o PANDA
self.smooth_throughputs = [] # corresponde a uma lista com os throughputs alvos filtrados
self.request_time = 0
self.inter_request_time = [] # tempo entre cada requisição de um novo segmento
self.qi = []
self.seg_duration = 1 # duração de um segmento
self.selected_qi = [] # lista com a qualidade selecionada para cada segmento
self.buffer_min = 20 # tamanho mínimo para o buffer, deve ser inferior ao máximo definido no json
def __init__(self, id):
IR2A.__init__(self, id)
self.parsed_mpd = ''
self.qi = []
self.whiteboard = Whiteboard.get_instance()
self.T = 8 #Valor do artigo T = 35
self.d = 2 # d = 60
self.ultimo = 0.0
self.penultimo = 0.0
self.firsTimeOcurrence = True
self.timeParameter = 0.0
def __init__(self, id):
IR2A.__init__(self, id)
self.parsed_mpd = ''
self.qi = []
self.whiteboard = whiteboard.Whiteboard.get_instance()
self.index = 0
self.t_estimated = 0
self.t_estimated_1 = 0
self.delta = 0
self.throughput = 1
self.ini = time.time()
def __init__(self, id):
IR2A.__init__(self, id)
self.quality_score_array = []
self.rebuf_avoid_level = 5
self.request_time = 0
self.qi_array = []
self.video_total_playtime = 0
self.video_current_playtime = 0
self.segment_time = 0
self.max_buffer_size = player.max_buffer_size
self.bandwith_anterior = 0
self.qi_anterior = 0
def __init__(self, id):
IR2A.__init__(self, id)
self.parsed_mpd = ''
self.qi = []
self.qi_index = 0
self.now_buffer_size = 0
self.before_buffer_size = 0
self.first_package = True
self.buffer_time = 0
self.ri = []
self.request_time = 0
self.previous_quality_index = 0
def __init__(self, id):
IR2A.__init__(self, id)
self.parsed_mpd = ''
self.throughputs = []
self.request_time = 0
self.qi = []
# starts with the worst quality
self.index_selected_qi = 0
# range of throughputs analyzed
self.M = 5
def __init__(self, id):
IR2A.__init__(self, id)
self.parsed_mpd = ''
self.qi_list = []
self.request_time = 0
self.real_throughput_list = []
self.estimated_throughput_list = []
self.constraint_list = []
self.mu = 0.2
self.k = 21
self.p0 = 0.25
self.whiteboard = Whiteboard.get_instance()
def __init__(self, id):
IR2A.__init__(self, id)
self.throughputs = []
self.request_time = 0
self.qi = [] # lista de qualidades
self.buffer = [] # lista de buffer
self.flag = False # auxilia na seleção da primeira qualidade
self.selected_qi = 46980 # qualidade em QI padrao
self.media = 0 # media para testes, print
self.lista_qi_selects = []
self.limite_bff_baixo = 0 # para testes, para saber se o buffer chegou perto de zero
def __init__(self, id):
IR2A.__init__(self, id)
self.parsed_mpd = ''
self.qi = []
self.momento_resposta = 0
self.momento_requisicao = 0
self.taxas_transferencia = [
1
] # o primeiro segmento terá sempre a menor qualidade possivel e por isso não é contabilizado
self.limite_taxa_bits = []
self.delta = 0.1
self.mu = 0.05
def __init__(self, id):
IR2A.__init__(self, id)
self.parsed_mpd = ''
self.qi = []
# Usamos o tempo para cálculo de vazão, usando o método descrito no documento de especificação.
self.timer = Timer.get_instance()
self.request_time = self.timer.get_started_time()
# Mantém-se uma lista das qualidades escolhidas durante a execução do programa.
# Ela é utilizada no algoritmo de decisão.
self.chosen_qi = [0]
# Também é mantida uma lista de valores de vazão medidos em cada ponto de escolha, para uso no algoritmo.
self.throughput = [0]
def __init__(self, id):
IR2A.__init__(self, id)
self.parsed_mpd = ''
self.qi = []
self.avgDataRate = []
self.targetAvgDataRate = []
self.measuredDataRate = []
self.segmentDownloadDuration = [0.01, 0.01]
self.bufferDuration = [0.0, 0.0]
self.segmentTime = 0.0017
self.bufferMinDuration = 26
self.clientBufferConvergenceRate = 0.2
def __init__(self, id):
IR2A.__init__(self, id)
self.parsed_mpd = ''
self.qi = []
self.lastRequestTime = 0
self.bpsList = []
self.downloadTaxas = (0, 0, 0)
self.qtdPactosAnalisados = 10
self.bufferSizesLimits = [40, 30, 25, 20]
self.confiabilidade = 1
self.setLestDecrementoConfiabilidade = 0
