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."""
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.
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 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 makeRtp(self, payload, frameNbr):
"""RTP-packetize the video data."""
version = 2
padding = 0
extension = 0
cc = 0
marker = 0
pt = 26 # MJPEG type
seqnum = frameNbr
ssrc = 0
extid = 0
extlen = 1 # the length of the extension in 32-bit units,
frameCnt = self.frameCnt + 1
rtpPacket = RtpPacket()
rtpPacket.encode(version,
padding,
extension,
cc,
seqnum,
marker,
pt,
ssrc,
payload,
extid,
extlen,
frameCnt=frameCnt)
return rtpPacket.getPacket()
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 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 sendRtp(self):
while True:
if self.event_trigger.isSet():
break
# It then sends the frame to the client over UDP every 50 milliseconds
self.event_trigger.wait(0.05)
# get the video source
video = self.clientInfo['videoStream'].nextFrame()
if video:
videoNum = self.clientInfo['videoStream'].frameNbr()
try:
rtpParket = RtpPacket()
# follow the format of RTP packet and establish the packet
rtpParket.encode(2, 0, 0, 0, videoNum, 0, 26, 0, video)
# send the data over UDP
self.rtpSocket.sendto(
rtpParket.getPacket(),
(self.clientAddr, self.clientrtpPort))
except:
if self.rtpSocket == None:
self.rtpSocket.shutdown(socket.SHUT_RDWR)
self.rtpSocket.close()
traceback.print_exc(file=sys.stdout)
else:
print "Finish the playing"
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 createRtpPacket(self, path):
file = open(path, "rb")
data = file.read()
file.close()
rtp_packet = RtpPacket()
rtp_packet.encode(0, 0, 0, 0, 0, 0, self.frame_number, 0, data)
return rtp_packet
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:
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:
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 setPacket(self, frame, currentFrame, counter, ifEnd, frameNo,
totalFrame):
# set packet
rtpPacket = RtpPacket()
rtpPacket.encode(2, 0, 0, 0, currentFrame, 0, 26, 0, frame, counter,
ifEnd, frameNo, totalFrame)
return rtpPacket.getPacket()
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 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 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."""
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 makePacket(self, payload, frameSeq):
version = 2
padding = 0
extension = 0
CC = 0
marker = 0
PT = 26
seqNum = frameSeq
SSRC = 0
rtpPacket = RtpPacket()
rtpPacket.encode(version, padding, extension, CC, seqNum, marker, PT,
SSRC, payload)
return rtpPacket.getPacket()
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 makeRtp(self, payload, frameNbr):
"""RTP-packetize the video data."""
version = 2
padding = 0
extension = 0
cc = 0
marker = 0
pt = 26 # MJPEG type
seqnum = frameNbr
ssrc = 0
rtpPacket = RtpPacket()
rtpPacket.encode(version, padding, extension, cc, seqnum, marker, pt, ssrc, payload)
return rtpPacket.getPacket()
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.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 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 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
