def listenRtp(self):
"""Listen for RTP packets."""
print("....................Try listening ...............")
while True:
try:
data = self.rtpSocket.recv(20480)
if data:
#print("Frame receieved : ")
rtpPacket = RtpPacket()
rtpPacket.decode(data)
currFrameNbr = rtpPacket.seqNum()
print("---> Current Seq Number : " + str(currFrameNbr))
if currFrameNbr > self.frameNbr: # Discard the late packet
#print("Video on")
self.frameNbr = currFrameNbr
self.updateMovie(
self.writeFrame(rtpPacket.getPayload()))
except:
# Stop listening upon requesting PAUSE or TEARDOWN
#if self.playEvent.isSet():
#break
# Upon receiving ACK for TEARDOWN request,
# close the RTP socket
if self.teardownAcked == 1:
self.rtpSocket.shutdown(socket.SHUT_RDWR)
self.rtpSocket.close()
break
def listenRtp(self):
"""Listen for RTP packets."""
# TODO [listen Rtp]
while True:
try:
data = self.rtpSocket.recv(self.BUFFER_SIZE)
if data:
rtpPacket = RtpPacket()
rtpPacket.decode(data)
currFrameNbr = rtpPacket.seqNum()
if currFrameNbr > self.frameNbr: # Discard the late packet
self.frameNbr = currFrameNbr
self.updateMovie(
self.writeFrame(rtpPacket.getPayload()))
except:
# Stop listening upon requesting PAUSE or TEARDOWN
if self.playEvent.isSet():
break
# Upon receiving ACK for TEARDOWN request,
# close the RTP socket
if self.teardownAcked == 1:
self.rtpSocket.shutdown(socket.SHUT_RDWR)
self.rtpSocket.close()
break
def listenRtp(self):
"""Listen for RTP packets."""
while True:
try:
data = self.rtpSocket.recv(20480)
if data:
rtpPacket = RtpPacket()
rtpPacket.decode(data)
currFrameNbr = rtpPacket.seqNum()
if currFrameNbr > self.frameNbr: # Discard the late packet
self.frameNbr = currFrameNbr
self.updateMovie(
self.writeFrame(rtpPacket.getPayload()))
# TODO: Update timer
if int(self.frameNbr) % int(
self.fps
) == 0 or self.frameNbr == self.noFrames:
self.updateCountDownTimer()
# self.step()
except:
# Stop listening upon requesting PAUSE or TEARDOWN or STOP
if self.playEvent.isSet():
break
# Upon receiving ACK for TEARDOWN request,
# close the RTP socket
if self.teardownAcked == 1:
self.rtpSocket.shutdown(socket.SHUT_RDWR)
self.rtpSocket.close()
break
def listenRtp(self):
# Listen for RTP packets.
while True:
try:
while True:
enc_frame = self.rtpSocket.recv(20480)
if enc_frame:
rtpPacket = RtpPacket()
rtpPacket.decode(enc_frame)
break
while True:
nonce = self.rtpSocket.recv(1024)
if nonce:
frame = self.aesgcm.decrypt(nonce,
rtpPacket.getPayload(),
None)
currFrameNbr = rtpPacket.seqNum()
print("Current Seq Num: " + str(currFrameNbr))
break
if currFrameNbr > self.frameNbr: # must be new packet
self.frameNbr = currFrameNbr
self.updateMovie(self.writeFrame(frame))
except:
# Stop listening upon requesting PAUSE or TEARDOWN
if self.playEvent.isSet():
break
# Upon receiving ACK for TEARDOWN request,
# close the RTP socket
if self.exitAcked == 1:
self.rtpSocket.shutdown(socket.SHUT_RDWR)
self.rtpSocket.close()
break
def listenRtp(self):
while True:
try:
data = self.rtpSocket.recv(20480)
if data:
rtpPacket = RtpPacket()
rtpPacket.decode(data)
currFrameNbr = rtpPacket.seqNum()
print("Current Seq Num: " + str(currFrameNbr))
if currFrameNbr > self.frameNbr: # Discard the late packet
self.frameNbr = currFrameNbr
self.updateMovie(
self.writeFrame(rtpPacket.getPayload()))
except:
# Stop listening upon requesting PAUSE or TEARDOWN
print("Didn't receive data!")
if self.playEvent.isSet():
break
# Upon receiving ACK for TEARDOWN request,
# close the RTP socket
if self.teardownAcked == 1:
self.rtpSocket.shutdown(socket.SHUT_RDWR)
self.rtpSocket.close()
break
def listenRtp(self): """Listen for the RTP/UDP socket """ while True: try: # read data over RTP/UDP socket receivedRtpData= self.rtpSocket.recv(20480) if receivedRtpData: # create RtpPacket instance rtpPacket = RtpPacket() # encode Rtppacket rtpPacket.decode(receivedRtpData) # RtpPacket FrameNbr self.rtpPacketFrame = rtpPacket.seqNum() if self.rtpPacketFrame > self.frame: self.frame = self.rtpPacketFrame #print "RtpPacket FrameNbr: " + str(self.rtpPacketFrame) print "Movie Frame: " + str(self.frame) self.updateScreen(self.frame, rtpPacket.getPayload()) except: # Stop listening upon requesting PAUSE or TEARDOWN if self.pauseEvent.isSet(): break # Upon receiving ACK for TEARDOWN request, # close the UDP socket if self.teardownAcked == 1: """Without try...except... will raise "error: [Errno 9] Bad file descriptor". Don't know why, seems like rtspSocket name is wrong.""" try: self.rtpSocket.shutdown(socket.SHUT_RDWR) except: pass self.rtpSocket.close() break
def listenRtp(self):
"""Listen for RTP packets."""
while True:
try:
data = self.rtpSocket.recv(40960)
if data:
rtpPacket = RtpPacket()
rtpPacket.decode(data)
currFrameNumber = rtpPacket.seqNum()
if currFrameNumber > self.frameNumber:
self.frameNumber = currFrameNumber
self.updateVideo(
self.writeFrame(rtpPacket.getPayload()))
currentTime = self.frameNumber // self.fps
self.setCurrentTime(currentTime)
self.receivedBytes += len(rtpPacket.getPacket())
self.setVideoRate(time.time() - self.startTime,
self.receivedBytes)
totalFrames = rtpPacket.getFrameCnt()
self.totalReceivedFrames += 1
self.setLossRate(totalFrames, self.totalReceivedFrames)
except:
if self.playEvent.isSet():
self.resetVideoRate()
break
def listenRtp(self):
"""Listen for RTP packets."""
while True:
try:
data = self.rtpSocket.recv(20480)
#------------------------------
#-------CODE-OF-MINE-----------
#------------------------------
curtime = time.time()
self.toltalPlayTime += curtime - self.startTime
self.startTime = curtime
#-----------END----------------
if data:
rtpPacket = RtpPacket()
rtpPacket.decode(data)
currFrameNbr = rtpPacket.seqNum()
print("Current Seq Num: " + str(currFrameNbr))
if currFrameNbr > self.frameNbr: # Discard the late packet
self.frameNbr = currFrameNbr
self.updateMovie(
self.writeFrame(rtpPacket.getPayload()))
#------------------------------
#-------CODE-OF-MINE-----------
#------------------------------
# calculate statistics
if currFrameNbr > self.highSeqNum:
self.highSeqNum = currFrameNbr
self.expRtpNum += 1
if self.expRtpNum < currFrameNbr:
self.sumLost += 1
#self.expRtpNum += 1
self.dataRate = 0 if (
self.toltalPlayTime
== 0) else self.totalBytes / self.toltalPlayTime
self.fractionLost = float(self.sumLost / self.highSeqNum)
self.totalBytes += len(data) - 12
update = "Total Bytes Received: " + str(
self.totalBytes) + "\nPacket Lost Rate: " + str(
self.fractionLost) + "\nData Rate: " + str(
self.dataRate) + " bytes/s"
self.label1 = Label(text=update)
self.label1.grid(row=2, column=1)
#--------------END--------------
except:
# Stop listening upon requesting PAUSE or TEARDOWN
if self.playEvent.isSet():
break
# Upon receiving ACK for TEARDOWN request,
# close the RTP socket
if self.teardownAcked == 1:
self.rtpSocket.shutdown(socket.SHUT_RDWR)
self.rtpSocket.close()
break
def parseReplyRtp(self): while True: if self.playthread.isSet(): break try: rtpPacket=self.rtpSocket.recv(RTPBUFFERSIZE) if rtpPacket: if not rtpPacket.startswith(RTSPVERSION): self.fileWritelock.acquire()# acquire lock for writing image file to the disk try: rtpp=RtpPacket() rtpp.decode(rtpPacket) if self.frameNumber<rtpp.seqNum():# ignore late packets with lower sequence number self.frameNumber=rtpp.seqNum() movieFile="cache-"+self.sessionId+".jpg" with open(movieFile,"wb") as tmp:# write binary tmp.write(rtpp.getPayload())# write actual data self.loadedFrame.append(rtpp) time.sleep(0.05)# pause for 50 milliseconds for synchronized with server sending interval photo=ImageTk.PhotoImage(Image.open(movieFile)) self.label.configure(image=photo,height=288) self.label.image=photo finally: self.fileWritelock.release()# release the lock else: print rtpPacket self.endOfStream=True temp=rtpPacket.strip().split(MESSAGESEP) self.calculateTimeDiff() self.totalFrame=temp[1].split()[1] except: print "\n" traceback.print_exc(file=sys.stdout)
def listenRtp(self):
"""Listen for RTP packets."""
while True:
try:
data = self.rtpSocket.recv(20480)
if data:
self.totPackets += 1.0
rtpPacket = RtpPacket()
rtpPacket.decode(data)
currFrameNbr = rtpPacket.seqNum()
print "Current Seq Num: " + str(currFrameNbr)
if currFrameNbr > self.frameNbr: # Discard the late packet
self.numPackets += 1.0
self.numBytes = self.numBytes + sys.getsizeof(
rtpPacket.getPayload())
self.frameNbr = currFrameNbr
self.updateMovie(
self.writeFrame(rtpPacket.getPayload()))
except:
# Stop listening upon requesting PAUSE or TEARDOWN
if self.playEvent.isSet():
break
# Upon receiving ACK for TEARDOWN request,
# close the RTP socket
if self.teardownAcked == 1:
self.rtpSocket.shutdown(socket.SHUT_RDWR)
self.rtpSocket.close()
break
def getRtp(self):
while True:
try:
# receive the video data from the server
vedio = self.rtpSocket.recv(65535)
if vedio:
time.sleep(0.035)
rtpCon = RtpPacket()
rtpCon.decode(vedio)
currFrameNbr = rtpCon.seqNum()
if currFrameNbr > self.NowNbr:
self.NowNbr = currFrameNbr
self.updateMovie(self.writeFrame(rtpCon.getPayload()))
else:
self.updateMovie(self.writeFrame(rtpCon.getPayload()))
except:
if self.playEvent.isSet() and self.teardownACK ==1:
self.teardownACK = 0
#close the rtp socket, if the movie is already over, print the text!
try:
self.rtpSocket.shutdown(socket.SHUT_RDWR)
self.rtpSocket.close()
except:
print "fiish playing"
break
if self.playEvent.isSet():
break
def listenRtp(self):
"""Listen for RTP packets."""
while True:
try:
print("listening")
data = self.rtpSocket.recv(20480)
if data:
rtpPacket = RtpPacket()
rtpPacket.decode(data)
currFrameNbr = rtpPacket.seqNum()
print "Current Seq Num: " + str(currFrameNbr)
if currFrameNbr > self.frameNbr: # Discard the late packet
self.frameNbr = currFrameNbr
self.updateMovie(self.writeFrame(rtpPacket.getPayload()))
except:
# Stop listening upon requesting PAUSE or TEARDOWN
if self.playEvent.isSet():
break
# Upon receiving ACK for TEARDOWN request,
# close the RTP socket
if self.teardownAcked == 1:
self.rtpSocket.shutdown(socket.SHUT_RDWR)
self.rtpSocket.close()
break
def listenRtp(self):
while True:
try:
data, addr = self.rtpSocket.recvfrom(20480)
if data:
rtpPacket = RtpPacket()
rtpPacket.decode(data)
print "Current Seq Num: " + str(rtpPacket.seqNum())
#Check for dropped packets and update counter
try:
if self.frameNbr + 1 != rtpPacket.seqNum():
self.counter += 1
print '*' * 3 + "PACKET DROPPED" + '*' * 3
currFrameNbr = rtpPacket.seqNum()
except:
traceback.print_exc(file=sys.stdout)
if currFrameNbr > self.frameNbr: # Discard the late packet
self.frameNbr = currFrameNbr
self.updateMovie(
self.writeFrame(rtpPacket.getPayload()))
except:
# Stop listening upon requesting PAUSE or TEARDOWN
if self.playEvent.isSet():
break
# Upon receiving ACK for TEARDOWN request,
# close the RTP socket
if self.teardownAcked == 1:
self.rtpSocket.shutdown(socket.SHUT_RDWR)
self.rtpSocket.close()
break
def getRtp(self):
while True:
try:
# receive the video data from the server
vedio = self.rtpSocket.recv(65535)
if vedio:
time.sleep(0.035)
rtpCon = RtpPacket()
rtpCon.decode(vedio)
currFrameNbr = rtpCon.seqNum()
if currFrameNbr > self.NowNbr:
self.NowNbr = currFrameNbr
self.updateMovie(self.writeFrame(rtpCon.getPayload()))
else:
self.updateMovie(self.writeFrame(rtpCon.getPayload()))
except:
if self.playEvent.isSet() and self.teardownACK == 1:
self.teardownACK = 0
#close the rtp socket, if the movie is already over, print the text!
try:
self.rtpSocket.shutdown(socket.SHUT_RDWR)
self.rtpSocket.close()
except:
print "fiish playing"
break
if self.playEvent.isSet():
break
def listenRtp(self):
"""Listen for RTP packets."""
while True:
try:
data = self.rtpSocket.recv(20480)
if data:
rtpPacket = RtpPacket()
rtpPacket.decode(data)
self.numberFrameRec += 1
currFrameNbr = rtpPacket.seqNum()
print("Current Seq Num: " + str(currFrameNbr))
if currFrameNbr > self.frameNbr: # Discard the late packet
if currFrameNbr - self.frameNbr > 1:
self.numberFrameLos += currFrameNbr - self.frameNbr - 1
self.frameNbr = currFrameNbr
self.dataSize += len(rtpPacket.getPayload())
self.updateMovie(
self.writeFrame(rtpPacket.getPayload()))
except:
# Stop listening upon requesting PAUSE or TEARDOWN
if self.playEvent.isSet():
self.videoTime += time() - self.startTime
break
# Upon receiving ACK for TEARDOWN request,
# close the RTP socket
if self.teardownAcked == 1:
self.rtpSocket.shutdown(socket.SHUT_RDWR)
self.rtpSocket.close()
break
def listenRtp(self):
"""Listen for RTP packets."""
while True:
try:
print("LISTENING...")
data = self.rtpSocket.recv(20480)
if data:
rtpPacket = RtpPacket()
rtpPacket.decode(data)
currFrameNbr = rtpPacket.seqNum()
print("CURRENT SEQUENCE NUM: " + str(currFrameNbr))
if currFrameNbr > self.frameNbr: # Discard the late packet
self.frameNbr = currFrameNbr
self.updateMovie(
self.writeFrame(rtpPacket.getPayload()))
except:
# Stop listening upon requesting PAUSE or TEARDOWN
if self.playEvent.isSet():
break
# Upon receiving ACK for TEARDOWN request,
# close the RTP socket
if self.teardownAcked == 1:
self.rtpSocket.shutdown(socket.SHUT_RDWR)
self.rtpSocket.close()
break
def listenRtp(self):
"""Listen for RTP packets."""
while True:
try:
data = self.rtpSocket.recv(20480)
if data:
rtpPacket = RtpPacket()
rtpPacket.decode(data)
currFrameNbr = rtpPacket.seqNum()
print("Current Seq Num: " + str(currFrameNbr))
if currFrameNbr > self.frameNbr: # Discard the late packet
if currFrameNbr - self.frameNbr > 1:
self.stat[
"lossPackage"] += currFrameNbr - self.frameNbr - 1
self.frameNbr = currFrameNbr
self.updateMovie(
self.writeFrame(rtpPacket.getPayload()))
if self.stat["recv"] == 0 or (self.stat.get("pause")
and self.stat["pause"]):
self.stat["beginTransmit"] = rtpPacket.timestamp()
self.stat["pause"] = False
self.stat["recv"] += len(bytes(rtpPacket.getPayload()))
continue
self.stat["recv"] += len(bytes(rtpPacket.getPayload()))
# curTime = int(time()*(10**7)) % 0x100000000
curTime = rtpPacket.timestamp()
self.stat["transmitTime"] += (
curTime - self.stat["beginTransmit"]) / (10**7)
self.stat["beginTransmit"] = curTime
self.Statistic["text"] = (
"Statistic :\n" +
"\tAvgDataRate: {value}\n".format(value=str(
round(
self.stat["recv"] /
self.stat["transmitTime"], 3))) +
"\tlossRate(%): {value}".format(value=str(
round(
self.stat["lossPackage"] / self.frameNbr *
100, 3))))
except:
# Stop listening upon requesting PAUSE or TEARDOWN
if self.playEvent.isSet():
break
# Upon receiving ACK for TEARDOWN request,
# close the RTP socket
if self.teardownAcked == 1:
self.rtpSocket.shutdown(socket.SHUT_RDWR)
self.rtpSocket.close()
break
def DataLinkReceive(self):
'''
描述：处理服务器的控制连接回复
参数：回复内容
返回：无
'''
WhetherStartedPlay = False
while True:
try:
TheData, TheAddress = self.DataSocket.recvfrom(
Constants.DATA_PACKET_SIZE)
#控制接收文件
if TheData:
ThePacket = RtpPacket()
ThePacket.decode(TheData)
CurrentSequenceNum = ThePacket.seqNum()
CurrentMarker = ThePacket.Marker()
#丢弃其余数据包
if self.DataSequence == CurrentSequenceNum - 1:
#print("received packet ", CurrentSequenceNum)
#回复ACK
ACKMessage = "ACK " + str(CurrentSequenceNum)
self.DataSocket.sendto(ACKMessage.encode(), TheAddress)
#判断是否新图片
if CurrentMarker == 0:
self.PictureFrame = self.PictureFrame + 1
#print(self.PictureFrame)
#写入
self.DataSequence = CurrentSequenceNum
self.WritePictureFrame(ThePacket.getPayload())
#控制播放图片
if self.PictureFrame - self.PicturePlay >= (
self.PicturePerSecond * self.BufferTime):
if WhetherStartedPlay == False:
WhetherStartedPlay = True
threading.Thread(target=self.UpdateMovie).start()
except:
# Stop listening upon requesting PAUSE or TEARDOWN
if self.PlayEvent.isSet():
break
#处理teardown事件
if self.Valid == False:
try:
self.DataSocket.shutdown(socket.SHUT_RDWR)
self.DataSocket.close()
except:
donothing = True
break
def listenRtp(self):
"""Listen for RTP packets."""
# TODO
startTime = time.time()
endTime = time.time()
while True:
try:
startTime = time.time()
data, addr = self.rtpSocket.recvfrom(20480)
# data = self.rtpSocket.recv(20480)
if data:
rtpPacket = RtpPacket()
rtpPacket.decode(data)
print("||Received Rtp Packet #" + str(rtpPacket.seqNum()) +
"|| ")
try:
if self.frameNbr + 1 != rtpPacket.seqNum():
self.counter += 1
print("self.frameNbr:", self.frameNbr)
print("rtpPacket.seqNum():", rtpPacket.seqNum())
print('!' * 60 + "\nPACKET LOSS\n" + '!' * 60)
currFrameNbr = rtpPacket.seqNum()
except:
print("seqNum() error")
print('-' * 60)
traceback.print_exc(file=sys.stdout)
print('-' * 60)
if currFrameNbr != self.frameNbr: # Discard the late packet
self.frameNbr = currFrameNbr
self.updateMovie(
self.writeFrame(rtpPacket.getPayload()))
endTime = time.time()
self.loss_rate["text"] = "Loss rate: {: .02f}%".format(
100 * float(self.counter / self.frameNbr))
self.fps["text"] = "FPS: {}".format(
int(1 / (endTime - startTime)))
self.progressbar[
'value'] = self.frameNbr * 100 / self.totalFrame
except:
# Stop listening upon requesting PAUSE or TEARDOWN
print("Didn't receive data!")
if self.playEvent.isSet():
print("Continue to click")
break
if self.setupEvent.isSet():
break
# Upon receiving ACK for TEARDOWN request,
# close the RTP socket
if self.teardownAcked == 1:
self.rtpSocket.shutdown(socket.SHUT_RDWR)
self.rtpSocket.close()
break
def listenRtp(self):
"""Listen for RTP packets."""
while True:
try:
data = self.rtpSocket.recv(20480)
# Time
curTime = time.time()
self.statTotalPlayTime += curTime - self.statStartTime
self.statStartTime = curTime
# -----------------------------
if data:
rtpPacket = RtpPacket()
rtpPacket.decode(data)
currFrameNbr = rtpPacket.seqNum()
print("Received frame", currFrameNbr)
# Calculate statistics
# Data rate
self.statDataRate = 0 if self.statTotalPlayTime == 0 else (self.statTotalByte / self.statTotalPlayTime)
# Lost rate
if currFrameNbr != self.frameNbr + 1:
self.statLostPack += 1
if currFrameNbr > self.statHighestSq:
self.statHighestSq = currFrameNbr
if self.statHighestSq != 0:
self.statLostRate = self.statLostPack / self.statHighestSq
# Total data
self.statTotalByte += len(data)
# ----------------------------------------------------
if currFrameNbr > self.frameNbr: # Discard the old packet
self.frameNbr = currFrameNbr
self.updateMovie(self.writeFrame(rtpPacket.getPayload()))
except:
# Stop listening upon requesting PAUSE or TEARDOWN
if self.playEvent.isSet():
break
# Upon receiving ACK for TEARDOWN request,
# close the RTP socket
if self.teardownAcked == 1:
try:
self.rtpSocket.shutdown(socket.SHUT_RDWR)
self.rtpSocket.close()
except:
pass
break
def listenRtp(self):
"""Listen for RTP packets."""
while True:
try:
print("A espera de pacotes RTP...")
data = self.rtpSocket.recv(20480)
# take current time and keep total Play Time
curTime = int(round(time.time() * 1000))
self.totalPlayTime += curTime - self.startTime
self.startTime = curTime
if data:
rtpPacket = RtpPacket()
rtpPacket.decode(data)
#Update Total of Bytes received
self.totalOfBytes += rtpPacket.getPayloadSize(len(data))
self.labelTotalBytesRcv.configure(
text="Total de Bytes Recebidos: " +
str(self.totalOfBytes))
currFrameNbr = rtpPacket.seqNum()
print "Sequência Atual (Frame): " + str(currFrameNbr)
self.sequenceExpectedRTPMessage += 1
if currFrameNbr > self.frameNbr: # Discard the late packet
self.frameNbr = currFrameNbr
self.updateMovie(
self.writeFrame(rtpPacket.getPayload()))
# if we lost any packet
if self.sequenceExpectedRTPMessage != currFrameNbr:
self.totalPacketsLost += 1
self.labelLostPackets.configure(
text="Pacotes Perdidos: " +
str(self.totalPacketsLost))
#Update rate: Bytes per Second
self.dataRate = 0 if self.totalPlayTime == 0 else (
self.totalOfBytes / (self.totalPlayTime / 1000.0))
self.labelRateTransf.configure(
text="Taxa de transferência: " + str(self.dataRate) +
" B/s")
except:
# Stop listening upon requesting PAUSE or TEARDOWN
if self.playEvent.isSet():
break
# Upon receiving ACK for TEARDOWN request,
# close the RTP socket
if self.teardownAcked == 1:
self.rtpSocket.shutdown(socket.SHUT_RDWR)
self.rtpSocket.close()
break
def jumbNext(self):
if self.state != self.INIT:
self.sendRtspRequest(self.NEXT)
data = self.rtpSocket.recv(20480)
if data:
rtpPacket = RtpPacket()
rtpPacket.decode(data)
currFrameNbr = rtpPacket.seqNum()
print("Current Seq Num: " + str(currFrameNbr))
self.frameNbr = currFrameNbr
self.updateMovie(self.writeFrame(rtpPacket.getPayload()))
def listenRtp(self):
"Listen for RTP packages"
while True:
try:
data = self.rtpSocket.recv(20480)
if data:
rtpPacket = RtpPacket()
rtpPacket.decode(data)
currFrameNbr = rtpPacket.seqNum() #Server response seq num
print("===================================")
print("Client Frame Num: " + str(self.frameNbr))
print("Server Response Frame Num: " + str(currFrameNbr))
if currFrameNbr > self.frameNbr: # Discard the late packet
# Calculate and update Statistics, late packet counted as lost
self.pckLost += currFrameNbr - self.frameNbr - 1
self.rcv += 1
self.lossRate = self.pckLost / (self.pckLost +
self.rcv)
self.totalRcvBytes += sys.getsizeof(
rtpPacket.getPayload())
print("Total rcv {}".format(self.totalRcvBytes))
print("Payload: {}".format(
sys.getsizeof(rtpPacket.getPayload())))
self.totalTime = int(
time()) - self.startTime + self.accumTime
print("Time {}".format(self.totalTime))
self.dataRate = (
self.totalRcvBytes /
self.totalTime) if self.totalTime != 0 else 0
self.updateText()
self.frameNbr = currFrameNbr
self.updateMovie(
self.writeFrame(rtpPacket.getPayload()))
except:
# If paused, stop listening
if self.playEvent.isSet():
break
# Close RTP socket
if self.isTearDowned:
self.rtpSocket.shutdown(socket.SHUT_RDWR)
self.rtpSocket.close()
break
def listenRtp(self):
while True:
try:
# slightly less than the maximum
data = self.rtpSocket.recv(50000)
if data:
rtpPacket = RtpPacket()
rtpPacket.decode(data)
self.frameNbr = rtpPacket.seqNum()
# for video, combine the small packets together
if rtpPacket.payloadType() == 26:
if self.video_frame_no == rtpPacket.seqNum():
self.packet_data += rtpPacket.getPayload()
else:
self.video_frame_no = rtpPacket.seqNum()
self.collectVideoFrame(self.packet_data,
self.video_frame_no - 1)
self.packet_data = rtpPacket.getPayload()
# audio
elif rtpPacket.payloadType() == 10:
self.collectAudioFrame(rtpPacket.getPayload(),
self.frameNbr)
# text
elif rtpPacket.payloadType() == 37:
self.collectSubtitle(rtpPacket.getPayload(),
self.frameNbr)
else:
# remaining data that belongs to video
if self.packet_data:
self.collectVideoFrame(self.packet_data,
self.video_frame_no)
break
except Exception as e:
print("rtp", str(e))
# Stop listening upon requesting PAUSE or TEARDOWN
if self.playEvent.isSet():
break
# Upon receiving ACK for TEARDOWN request,
# close the RTP socket
if self.teardownAcked == 1:
self.rtpSocket.shutdown(socket.SHUT_RDWR)
self.rtpSocket.close()
self.rtsp_seq = 0
self.teardownAcked = 0
break
def listenRtp(self):
"""Listen for RTP packets."""
while True:
try:
data = self.rtpSocket.recv(20480)
print("[*]Received RTP packet")
curTime = time.time()
self.totalPlayTime += curTime - self.startTime
self.startTime = curTime
if data:
rtpPacket = RtpPacket()
rtpPacket.decode(data)
# Tính tổng số byte nhận được bằng cách cộng dồn size của payload
self.totalBytes += len(rtpPacket.getPayload())
currFrameNbr = rtpPacket.seqNum()
print("Current Seq Num: " + str(currFrameNbr))
# xác định mất gói và số gói bị mất (Packet loss rate is defined as the fraction of the total transmitted packets that did not arrive at the receiver.)
if self.frameNbr + 1 != currFrameNbr:
self.lostNum += currFrameNbr - self.frameNbr - 1
print("[*]Packet loss!")
# tính packet loss rate
self.statLost = 0 if self.lostNum == 0 else self.lostNum/currFrameNbr
# Tính data rate
self.dataRate = round(self.totalBytes/self.totalPlayTime, 2)
# Update lại các thông số
self.updateStat()
if currFrameNbr > self.frameNbr: # Discard the late packet
self.frameNbr = currFrameNbr
self.updateMovie(self.writeFrame(rtpPacket.getPayload()))
except:
# Stop listening upon requesting PAUSE or TEARDOWN
if self.playEvent.isSet():
break
# Upon receiving ACK for TEARDOWN request,
# close the RTP socket
if self.teardownAcked == 1:
self.rtpSocket.shutdown(socket.SHUT_RDWR)
self.rtpSocket.close()
break
def listenRtp(self):
"""Listen for RTP packets."""
self.TIMESTART = time.time()
while True:
try:
data = self.rtpSocket.recv(20480)
if data:
rtpPacket = RtpPacket()
rtpPacket.decode(data)
self.TOTALSIZE += len(data)
currFrameNbr = rtpPacket.seqNum()
self.COUNT += 1
if self.COUNT != currFrameNbr:
self.TOTALLOSSPACKET += 1
self.COUNT = currFrameNbr
print("Current Seq Num: " + str(currFrameNbr))
if currFrameNbr > self.frameNbr: # Discard the late packet
self.frameNbr = currFrameNbr
self.updateMovie(
self.writeFrame(rtpPacket.getPayload()))
if self.COUNT == 500:
self.TIMEEND = time.time()
except:
# Stop listening upon requesting PAUSE or TEARDOWN
if self.playEvent.isSet():
if self.TIMEEND == 0:
self.TIMEEND = time.time()
print("Rate loss packet: " + str(
round((self.TOTALLOSSPACKET /
(self.COUNT - self.PASTSTOP)) * 100, 2)) + "%")
print("Video data rate: " + str(
round((self.TOTALSIZE /
(self.TIMEEND - self.TIMESTART)), 2)) +
str("byte/s"))
self.PASTSTOP = self.COUNT
self.TOTALLOSSPACKET = 0
self.TIMEEND = 0
self.TOTALSIZE = 0
break
# Upon receiving ACK for TEARDOWN request,
# close the RTP socket
if self.teardownAcked == 1:
self.rtpSocket.shutdown(socket.SHUT_RDWR)
self.rtpSocket.close()
break
def listenRtp(self):
"""Listen for RTP packets."""
self.startingTime = datetime.now()
oldframeNbr = 0
self.setClientStat()
ploss = 0
while True:
try:
data = self.rtpSocket.recv(20480)
if data:
rtpPacket = RtpPacket()
rtpPacket.decode(data)
currFrameNbr = rtpPacket.seqNum()
print("Current Seq Num: " + str(currFrameNbr))
self.totalByte += len(rtpPacket.getPayload())
if currFrameNbr > self.frameNbr: # Discard the late packet
if (currFrameNbr - self.frameNbr > 1):
ploss = ploss + currFrameNbr - self.frameNbr - 1
self.frameNbr = currFrameNbr
self.updateMovie(
self.writeFrame(rtpPacket.getPayload()))
self.totalPlayTime = datetime.now() - self.startingTime
self.lossRate = ploss / self.frameNbr * 100
print("LossRate : " + str(self.lossRate) +
" Loss Packet : " + str(ploss))
print("Total data : " + str(self.totalByte))
print("Playtime : " + str(self.totalPlayTime))
self.dataRate = self.totalByte / abs(
self.totalPlayTime.seconds) / 1024
print("Data rate " + "{:.2f}".format(self.dataRate) +
" kb/s")
if (self.frameNbr - oldframeNbr > 20):
oldframeNbr = self.frameNbr
self.setClientStat()
except:
# Stop listening upon requesting PAUSE or TEARDOWN
if self.playEvent.isSet():
break
# Upon receiving ACK for TEARDOWN request,
# close the RTP socket
if self.teardownAcked == 1:
self.rtpSocket.shutdown(socket.SHUT_RDWR)
self.rtpSocket.close()
# reconnect to server
break
def receiveRtp(self):
maxFrameTime = 0.05 * self.maxFrameNum
while self.rtpListener_PlayingFlag:
try:
data = self.rtpSocket.recv(1024*1024) #1MB buffer
if data:
packet = RtpPacket()
packet.decode(data)
if(self.currentFrame + 1 != packet.seqnum):
self.lossFrame += 1
self.currentFrame = packet.seqnum
self.totalFrame += 1
current = time.time()
duration = current - self.lastTime
self.lastTime = current
speed = len(packet.frame) / duration
fps = 1/duration
currentFrameTime = 0.05 * self.currentFrame
remainingTime = maxFrameTime - currentFrameTime
#Extend 1
stats = "RTP Packet: " + str(self.currentFrame) + "\n\n"
stats += "RTP Lost Packet: " + str(self.lossFrame) + "\n\n"
stats += "Loss Rate: " + '{:.2f}'.format(self.lossFrame / self.totalFrame * 100) + "%\n\n"
stats += "Data Rate: " + '{:.2f}'.format(speed) + " Bytes/s\n\n"
stats += "Frame Duration: " + '{:.0f}'.format(duration*1000) + " ms\n\n"
stats += "Frame per Second: " + '{:.2f}'.format(fps) + "\n\n"
stats += "-----------------------\n\n"
#Extend 4
stats += "Remaining Time: " + '{:.0f}'.format(remainingTime) + " s\n\n"
stats += "Total Time: " + '{:.0f}'.format(maxFrameTime) + " s\n\n"
self.statsLabel.configure(text = stats, font = "Raleway")
file_jpgdata = BytesIO(packet.frame) #PIL Image.open accept jpeg format from a file stream
self.photo = ImageTk.PhotoImage(Image.open(file_jpgdata))
self.imagePanel.configure(image = self.photo)
self.imagePanel.image = self.photo
#self.videoScrollBar.set(self.currentFrame - 1) #This will trigger the callback
self.controlScrollVar.set(self.currentFrame - 1) #This won't trigger the callback
except:
pass
def listenRtp(self):
"""Listen for RTP packets."""
while True:
try:
data = self.rtpSocket.recv(20480)
if data:
rtpPacket = RtpPacket()
rtpPacket.decode(data)
print("Current Seq Num: " + str(rtpPacket.seqNum()))
try:
if self.frameNbr + 1 != rtpPacket.seqNum():
self.counter += 1
print('!' * 60 + '\nPacket Loss\n' + '!' * 60)
currFrameNbr = rtpPacket.seqNum()
except:
print("seqNum() ERROR")
traceback.print_exc(file=sys.stdout)
if currFrameNbr > self.frameNbr: # Discard the late packet
self.frameNbr = currFrameNbr
payload = rtpPacket.getPayload()
self.totalSize += payload.__sizeof__()
self.currentTimeStamp = rtpPacket.timestamp()
if self.firstPacket == 0:
self.initTimestamp = rtpPacket.timestamp()
self.firstPacket = 1
self.updateMovie(
self.writeFrame(rtpPacket.getPayload()))
self.updateStat()
except:
# Stop listening upon requesting PAUSE or TEARDOWN
if self.state == self.PLAYING:
print('Didn\'t receive data')
if self.playEvent.isSet():
break
# Upon receiving ACK for TEARDOWN request,
# close the RTP socket
if self.teardownAcked == 1:
self.rtpSocket.shutdown(socket.SHUT_RDWR)
self.rtpSocket.close()
break
def listenRtp(self):
"""Listen for RTP packets."""
while True:
try:
data = self.rtpSocket.recv(20480)
if data:
self.frameReceive += 1
rtpPacket = RtpPacket()
rtpPacket.decode(data)
currFrameNbr = rtpPacket.seqNum()
print("Current Seq Num: " + str(currFrameNbr))
if currFrameNbr >= self.frameNbr: # Discard the late packet
if currFrameNbr - self.frameNbr > 1:
self.frameLoss += currFrameNbr - self.frameNbr
print('-' * 60)
print(' ' * 20 +
f'FRAME LOSS: {currFrameNbr-self.frameNbr}' +
' ' * 20)
print('-' * 60)
self.frameNbr = currFrameNbr
self.updateMovie(
self.writeFrame(rtpPacket.getPayload()))
except:
# Stop listening upon requesting PAUSE or TEARDOWN
if self.playEvent.isSet():
break
# Upon receiving ACK for TEARDOWN request,
# close the RTP socket
if self.teardownAcked or self.stopAcked:
self.rtpSocket.close()
print('-' * 60)
print(' ' * 20 + f'LOSS: {self.frameLoss}' + ' ' * 20)
print(' ' * 20 + f'RECEIVE: {self.frameReceive}' +
' ' * 20)
print(' ' * 20 +
f'LOSS RATE: {self.frameLoss/self.frameNbr:.6f}' +
' ' * 20)
print('-' * 60)
break
if self.extend:
if self.frameNbr >= self.progressbar['maximum']:
self.stopMovieExtends()
def listenRtp(self):
"""Listen for RTP packets."""
while True:
try:
data = self.rtpSocket.recv(20480)
if data:
rtpPacket = RtpPacket()
rtpPacket.decode(data)
currFrameNbr = rtpPacket.seqNum()
arrivalTimeOfPacket = time.perf_counter()
print("Current Seq Num: " + str(currFrameNbr))
self.bytes += len(rtpPacket.getPacket())
if currFrameNbr > self.frameNbr: # Discard the late packet
self.frameNbr = currFrameNbr
self.updateMovie(
self.writeFrame(rtpPacket.getPayload()))
#statUpdate
self.packets += 1
self.packetsLost += currFrameNbr - self.lastSequence - 1
#calculate total jitter
if self.lastSequence == currFrameNbr - 1 and currFrameNbr > 1:
interPacketSpacing = arrivalTimeOfPacket - self.arrivalTimeofPreviousPacket
jitterIncrement = abs(interPacketSpacing -
self.lastPacketSpacing)
self.totalJitter = self.totalJitter + jitterIncrement
self.lastPacketSpacing = interPacketSpacing
self.arrivalTimeofPreviousPacket = arrivalTimeOfPacket
self.lastSequence = currFrameNbr
except:
# Stop listening upon requesting PAUSE or TEARDOWN
if self.playEvent.isSet():
self.displayStats()
break
# Upon receiving ACK for TEARDOWN request,
# close the RTP socket
if self.teardownAcked == 1:
self.displayStats()
self.rtpSocket.shutdown(socket.SHUT_RDWR)
self.rtpSocket.close()
break
def listenRtp(self):
"""Listen for RTP packets."""
isMiddle = False
data = bytearray()
while True:
try:
#print("listening")
while True:
packetChunk = self.rtpSocket.recv(20480)
if packetChunk.find("EOF".encode("utf-8")) >= 0:
if packetChunk.find("EOF".encode("utf-8")) == 0:
isMiddle = False
else:
isMiddle = True
break
else:
data += packetChunk
if data:
rtpPacket = RtpPacket()
rtpPacket.decode(data)
currFrameNbr = rtpPacket.seqNum()
print("Current Seq Num: ", str(currFrameNbr))
if currFrameNbr > self.frameNbr: # Discard the late packet
self.frameNbr = currFrameNbr
self.updateMovie(
self.writeFrame(rtpPacket.getPayload()))
if isMiddle:
data = packetChunk[packetChunk.find("EOF".encode("utf-8")
):]
else:
data = bytearray()
except:
# Stop listening upon requesting PAUSE or TEARDOWN
if self.playEvent.isSet():
break
# Upon receiving ACK for TEARDOWN request,
# close the RTP socket
if self.teardownAcked == 1:
self.rtpSocket.shutdown(socket.SHUT_RDWR)
self.rtpSocket.close()
break
def listenRtp(self):
"""Listen for RTP packets."""
while True:
if self.playEvent.isSet():
break
try:
data = self.rtpSocket.recv(62040)
if data:
rtpPacket = RtpPacket()
rtpPacket.decode(data)
currFrameNbr = rtpPacket.seqNum()
self.bufferFrameNbr = currFrameNbr
self.frameQueue[
self.bufferFrameNbr] = rtpPacket.getPayload()
except Exception as e:
print("listen error:", e)
def listenRtp(self):
"""Listen for RTP packets."""
while True:
try:
print("LISTENING...")
data = self.rtpSocket.recv(20480)
if data:
rtpPacket = RtpPacket()
rtpPacket.decode(data)
currFrameNbr = rtpPacket.seqNum()
print("CURRENT SEQUENCE NUM: " + str(currFrameNbr))
if currFrameNbr > self.frameNbr:
self.frameNbr = currFrameNbr
self.updateMovie(
self.writeFrame(rtpPacket.getPayload()))
currTime = int(round(time.time() * 1000))
self.statTotalPlayTime += currTime - self.statStartTime
self.statStartTime = currTime
self.statExpectedRptNbr += 1
if currFrameNbr > self.statHighestSeq:
self.statHighestSeq = currFrameNbr
if self.statExpectedRptNbr != currFrameNbr:
self.statCumLost += 1
if self.statTotalPlayTime == 0:
self.statDataRate = 0
else:
self.statDataRate = self.statTotalBytes / (
self.statTotalPlayTime / 1000.0)
self.statFractionLost = float(self.statCumLost /
self.statHighestSeq)
self.statTotalBytes += rtpPacket.getPayLoadSize()
self.updateStatLabel()
except:
# Stop listening upon requesting PAUSE or TEARDOWN
if self.playEvent.isSet():
break
# Upon receiving ACK for TEARDOWN request,
# close the RTP socket
if self.teardownAcked == 1:
self.rtpSocket.shutdown(socket.SHUT_RDWR)
self.rtpSocket.close()
break
def listenRtp(self): while True: try: data,addr = self.rtpSocket.recvfrom(20480) if data: rtpPacket = RtpPacket() rtpPacket.decode(data) print "||Received Rtp Packet #" + str(rtpPacket.seqNum()) + "|| " try: if self.frameNbr + 1 != rtpPacket.seqNum(): self.counter += 1 print '!'*60 + "\nPACKET LOSS\n" + '!'*60 currFrameNbr = rtpPacket.seqNum() #version = rtpPacket.version() except: print "seqNum() error" print '-'*60 traceback.print_exc(file=sys.stdout) print '-'*60 if currFrameNbr > self.frameNbr: # Discard the late packet self.frameNbr = currFrameNbr self.updateMovie(self.writeFrame(rtpPacket.getPayload())) except: # Stop listening upon requesting PAUSE or TEARDOWN print "Didn`t receive data!" if self.playEvent.isSet(): break # Upon receiving ACK for TEARDOWN request, # close the RTP socket if self.teardownAcked == 1: self.rtpSocket.shutdown(socket.SHUT_RDWR) self.rtpSocket.close() break
