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): """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 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 rtpConnect(self): """Send messages over UDP.""" while True: # wait until current rtp has sent data self.playEvent.wait(0.05) # Stop sending if request is PAUSE or TEARDOWN if self.playEvent.isSet(): break # RtpPacket arguments version = 2 padding = 0 extension = 0 cc = 0 seqnum = self.file.frameNbr() marker = 0 pt = 26 ssrc = 34 payload = self.file.nextFrame() # if not finished playing if payload: # create RtpPacket instance rtpPacket = RtpPacket() # encode Rtppacket rtpPacket.encode(version, padding, extension, cc, seqnum, marker, pt, ssrc, payload) # getPacket packet = rtpPacket.getPacket() # get the RTP/UDP address of client self.rtpAddress = self.clientInfo['rtspSocket'][1][0] try: self.rtpScoket.sendto(packet,(self.rtpAddress, self.rtpPort)) except: self.rtpError += 1 print "ServerWorker RTP/UDP Sending Error: %d" % self.rtpError # if finished playing, inform client else: self.state = self.INIT self.finishPlaying(seqnum-1) break """Terminate thread. Problem with invalid thread id""" self._async_raise(self.rtpThread.ident, SystemExit)
def makePacket(self, payload, frameSeq):
version = 2
padding = 0
extension = 0
CC = 0
marker = 0
PT = 26
seqNum = frameSeq
SSRC = 0
# Create and encode the RTP packet
# ...
rtpPacket = RtpPacket()
rtpPacket.encode(version, padding, extension, CC, seqNum, marker, PT, SSRC, payload)
# Return the RTP packet
# ...
return rtpPacket.getPacket()
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
#RFD
print 'using frame num for seq num: ' + str(frameNbr)
ssrc = 0
rtpPacket = RtpPacket()
rtpPacket.encode(version, padding, extension, cc, marker, pt, seqnum,
ssrc, payload)
return rtpPacket.getPacket()
def SendRTPPacket(self, TheData, WhetherFirst, TheDataSequence):
'''
描述：将一个数据打包成RTP包，然后发送出去
参数：数据，是否第一个，seq
返回：无
'''
ThePacket = RtpPacket()
if WhetherFirst:
TheMarker = 0
else:
TheMarker = 1
ThePacket.encode(Constants.RTP_CURRENT_VERSION, Constants.RTP_PADDLING_FALSE, Constants.RTP_EXTENSION_FALSE, \
Constants.RTP_CC, TheDataSequence, TheMarker, Constants.RTP_TYPE_JPEG, Constants.RTP_SSRC ,\
TheData)
TheSendData = ThePacket.getPacket()
try:
self.DataSocket.sendto(TheSendData,(self.ClientIP, self.ClientDataPort))
except:
donothing = True
return
def sendRtp(self):
while True:
if self.sendRtpThread.isSet(): break
time.sleep(0.05)# pause for 50 milliseconds
try:
vidata=self.videoStream.nextFrame()
if vidata:
rtpp=RtpPacket()
rtpp.encode(2,0,0,0,self.videoStream.frameNbr(),0,26,6,vidata)
self.rtpSocket.sendto(rtpp.getPacket(),(self.clientAddr,self.rtpPort))
else:
printLogToConsole("end of stream")
self.sendRtpThread.set()
self.rtpSocket.sendto(RTSPVERSION+' '+RESPONSE_OK_END+MESSAGESEP+"TotalFrame: "+str(self.videoStream.frameNbr())+MESSAGESEP+"Session: "+str(self.csession),(self.clientAddr,self.rtpPort))
try:
self.videoStream.file.close()
except: printLogToConsole("close file error")
break
except:
print "\n"
traceback.print_exc(file=sys.stdout)
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:
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):
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)
#------------------------------
#-------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 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 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:
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 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:
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 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:
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 makeRtp(self, payload, frameNbr):
"""RTP-packetize the video data."""
#-------------
# TO COMPLETE
#-------------
# Set the fields
# ...
V = 2
P = 0
X = 0
CC = 0
M = 0
PT = 26
seqNum = frameNbr
SSRC = 0
# Create and encode the RTP packet
# ...
rtpPacket = RtpPacket()
rtpPacket.encode(V, P, X, CC, seqNum, M, PT, SSRC, payload)
# Return the RTP packet
# ...
return rtpPacket.getPacket()
def makeRtp(self, payload, frameNbr):
"""RTP-packetize the video data."""
#-------------
# TO COMPLETE
#-------------
# Set the fields
# ...
V = 2
P = 0
X = 0
CC = 0
M = 0
PT = 26
seqNum = frameNbr
SSRC = 0
# Create and encode the RTP packet
# ...
rtpPacket = RtpPacket()
rtpPacket.encode(V, P, X, CC, seqNum, M, PT, SSRC, payload)
# Return the RTP packet
# ...
return rtpPacket.getPacket()
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):
print('Client: def listenRtp')
"""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))
try:
print(self.frameNbr +1,'--',rtpPacket.seqNum())
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
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 receive_rtp_packet(self):
if self.start == 0:
self.start = time.time()
while True:
try:
data, clientAddr = self.rtp_socket.recvfrom(
Client.RTP_BUFFER_SIZE)
if data:
header, payload = RtpPacket.decode(data)
now = time.time()
frame_nbr = header[2] * 256 + header[3]
self.receive_frame.append(frame_nbr)
if frame_nbr < max(self.receive_frame):
self.loss += 1
if self.is_pausing:
self.is_pausing = False
self.pause_time += now - self.begin_pause
self.timeline = (now - self.start) - self.pause_time
self.total_size += len(payload)
text = '\tSTATISTICS'
text += '\nLoss rate = {:.2f}%'.format(
self.loss / len(self.receive_frame) * 100)
text += '\nVideo data rate = {:.2f} (bps)'.format(
self.total_size / self.timeline)
text += f'\nNumber of frames = {len(self.receive_frame)}'
self.statitics.config(text=text, justify='left')
image = Image.open(io.BytesIO(payload))
imagetk = ImageTk.PhotoImage(image=image)
self.label_video.configure(image=imagetk)
self.label_video.image = imagetk
except:
if self.last_requesttype == RequestType.PAUSE:
print('[LOG]', 'Video is paused')
self.begin_pause = time.time()
self.is_pausing = True
elif self.state == State.PLAYING:
showinfo('info', 'The video is ended')
# Clear frame being displayed
self.label_video.image = None
self.statitics.config(text="")
self.state = State.READY
self.receive_frame = []
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 onNewCol(self, col, generator):
u"""
Called by self=FecGenerator when a new column FEC packet is generated and available for output.
Send the encapsulated column FEC packet.
:param col: Generated column FEC packet
:type col: FecPacket
:param generator: The generator that fired this method / event
:type generator: FecGenerator
"""
col_rtp = RtpPacket.create(col.sequence, 0, RtpPacket.MP2T_PT, col.bytes)
log.info('Send COL FEC packet seq=%s snbase=%s LxD=%sx%s trec=%s socket=%s' %
(col.sequence, col.snbase, col.L, col.D, col.timestamp_recovery, self.col_socket))
sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM, socket.IPPROTO_UDP)
sock.setsockopt(socket.IPPROTO_IP, socket.IP_MULTICAST_TTL, 2)
sock.sendto(col_rtp.bytes, (self.col_socket['ip'], self.col_socket['port']))
def onNewRow(self, row, generator):
u"""
Called by self=FecGenerator when a new row FEC packet is generated and available for output.
Send the encapsulated row FEC packet.
:param row: Generated row FEC packet
:type row: FecPacket
:param generator: The generator that fired this method / event
:type generator: FecGenerator
"""
row_rtp = RtpPacket.create(row.sequence, 0, RtpPacket.MP2T_PT, row.bytes)
log.info('Send ROW FEC packet seq=%s snbase=%s LxD=%sx%s trec=%s socket=%s' %
(row.sequence, row.snbase, row.L, row.D, row.timestamp_recovery, self.col_socket))
sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM, socket.IPPROTO_UDP)
sock.setsockopt(socket.IPPROTO_IP, socket.IP_MULTICAST_TTL, 2)
sock.sendto(row_rtp.bytes, (self.row_socket['ip'], self.row_socket['port']))
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('listening')
m = 0
payload = None
while m == 0:
data = self.rtpSocket.recv(20480)
if data:
rtpPacket = RtpPacket()
rtpPacket.decode(data)
m = rtpPacket.getM()
currFrameNbr = rtpPacket.seqNum()
if not payload:
payload = rtpPacket.getPayload()
else:
payload = payload + rtpPacket.getPayload()
#print(m)
if m == 1:
#print('break')
break
#print("Current Seq Num: " + str(currFrameNbr))
#print(len(payload))
#input()
self.frameNbr = -1
if currFrameNbr > self.frameNbr: # Discard the late packet
self.frameNbr = currFrameNbr
self.updateMovie(self.writeFrame(payload))
payload = None
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 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 run(self):
log.info('SMPTE 2022-1 FEC Generator by David Fischer')
log.info('started Listening %s' % self.media_socket)
sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, True)
sock.bind((self.media_socket['ip'], self.media_socket['port']))
# Tell the operating system to add the socket to the multicast group on all interfaces
group = socket.inet_aton(self.media_socket['ip'])
mreq = struct.pack('4sL', group, socket.INADDR_ANY)
sock.setsockopt(socket.IPPROTO_IP, socket.IP_ADD_MEMBERSHIP, mreq)
# Receive loop
while True:
datagram, address = sock.recvfrom(1024)
media = RtpPacket(bytearray(datagram), len(datagram))
log.debug(
'Incoming media packet seq=%s ts=%s psize=%s ssrc=%s address=%s'
% (media.sequence, media.timestamp, media.payload_size,
media.ssrc, address))
self._generator.putMedia(media)
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):
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
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):
"""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 onNewRow(self, row, generator):
u"""
Called by self=FecGenerator when a new row FEC packet is generated and available for output.
Send the encapsulated row FEC packet.
:param row: Generated row FEC packet
:type row: FecPacket
:param generator: The generator that fired this method / event
:type generator: FecGenerator
"""
row_rtp = RtpPacket.create(row.sequence, 0, RtpPacket.MP2T_PT,
row.bytes)
log.info(
'Send ROW FEC packet seq=%s snbase=%s LxD=%sx%s trec=%s socket=%s'
% (row.sequence, row.snbase, row.L, row.D, row.timestamp_recovery,
self.col_socket))
sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM,
socket.IPPROTO_UDP)
sock.setsockopt(socket.IPPROTO_IP, socket.IP_MULTICAST_TTL, 2)
sock.sendto(row_rtp.bytes,
(self.row_socket['ip'], self.row_socket['port']))
def onNewCol(self, col, generator):
u"""
Called by self=FecGenerator when a new column FEC packet is generated and available for output.
Send the encapsulated column FEC packet.
:param col: Generated column FEC packet
:type col: FecPacket
:param generator: The generator that fired this method / event
:type generator: FecGenerator
"""
col_rtp = RtpPacket.create(col.sequence, 0, RtpPacket.MP2T_PT,
col.bytes)
log.info(
'Send COL FEC packet seq=%s snbase=%s LxD=%sx%s trec=%s socket=%s'
% (col.sequence, col.snbase, col.L, col.D, col.timestamp_recovery,
self.col_socket))
sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM,
socket.IPPROTO_UDP)
sock.setsockopt(socket.IPPROTO_IP, socket.IP_MULTICAST_TTL, 2)
sock.sendto(col_rtp.bytes,
(self.col_socket['ip'], self.col_socket['port']))
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):
while 1:
try:
cachename = CACHE_FILE_NAME + str(
self.sessionId) + CACHE_FILE_EXT
file = open(cachename, "wb+")
while 1:
data = self.rtpSocket.recv(RECV_SIZE)
if data:
rtpPacket = RtpPacket()
rtpPacket.decode(data)
self.page_main.scrollLine.setValue(rtpPacket.getPot())
currFrameNbr = rtpPacket.seqNum()
file.write(rtpPacket.getPayload())
print("FrameNo:", currFrameNbr)
# if new frame
if currFrameNbr > self.frameNbr and rtpPacket.getIfEnd(
):
self.frameNbr = currFrameNbr
self.updateMovie(cachename)
file.close()
break
except:
# pause or teardown
if self.playEvent.isSet():
break
print('Error: Frame receiving failed!')
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
def recoverMediaPacket(self, media_sequence, cross, fec):
u"""
Recover a missing media packet helped by a FEC packet, this method is also called to
register an incoming media packet if it is registered as missing.
"""
recovered_by_fec = not fec is None
# Read and remove "cross" it from the buffer
col_sequence = cross['col_sequence']
row_sequence = cross['row_sequence']
del self.crosses[media_sequence]
# Recover the missing media packet and remove any useless linked fec packet
if recovered_by_fec:
if len(fec.missing) != 1:
raise NotImplementedError(FecReceiver.ER_MISSING_COUNT % len(fec.missing))
if fec.direction == FecPacket.COL and fec.sequence != col_sequence:
raise NotImplementedError(FecReceiver.ER_COL_MISMATCH % (fec.sequence, col_sequence))
if fec.direction == FecPacket.ROW and fec.sequence != row_sequence:
raise NotImplementedError(FecReceiver.ER_ROW_MISMATCH % (fec.sequence, row_sequence))
# Media packet recovery
# > Copy fec packet fields into the media packet
media = RtpPacket.create(media_sequence, fec.timestamp_recovery,
fec.payload_type_recovery, fec.payload_recovery)
payload_size = fec.length_recovery
# > recovered payload ^= all media packets linked to the fec packet
aborted = False
media_max = (fec.snbase + fec.na * fec.offset) & RtpPacket.S_MASK
media_test = fec.snbase
while media_test != media_max:
if media_test == media_sequence:
media_test = (media_test + fec.offset) & RtpPacket.S_MASK
continue
friend = self.medias[media_test]
# Unable to recover the media packet if any of the friend media packets is missing
if not friend:
self.media_aborted_recovery += 1
aborted = True
break
media.payload_type ^= friend.payload_type
media.timestamp ^= friend.timestamp
payload_size ^= friend.payload_size
# FIXME FIXME FIXME FIXME FIXME OPTIMIZATION FIXME FIXME FIXME FIXME
for no in range(min(len(media.payload), len(friend.payload))):
media.payload[no] ^= friend.payload[no]
media_test = (media_test + fec.offset) & RtpPacket.S_MASK
# If the media packet is successfully recovered
if not aborted:
media.payload = media.payload[0:payload_size]
self.media_recovered += 1
if media.sequence in self.medias:
self.media_overwritten += 1
self.medias[media.sequence] = media
if len(self.medias) > self.max_media:
self.max_media = len(self.medias)
if fec.direction == FecPacket.COL:
del self.cols[fec.sequence]
else:
del self.rows[fec.sequence]
# Check if a cascade effect happens ...
fec_col = self.cols.get(col_sequence) if col_sequence else None
fec_row = self.rows.get(row_sequence) if row_sequence else None
if fec_col:
fec_col.setRecovered(media_sequence)
if fec_row:
fec_row.setRecovered(media_sequence)
if fec_col:
if len(fec_col.missing) == 1:
# Cascade !
cascade_media_sequence = fec_col.missing[0]
if cascade_media_sequence:
cascade_cross = self.crosses.get(cascade_media_sequence)
if cascade_cross:
self.recoverMediaPacket(cascade_media_sequence, cascade_cross, fec_col)
else:
raise NotImplementedError(
'recoverMediaPacket(%s, %s, %s):\n%s\nmedia sequence : %s\n%s\n' %
(media_sequence, cross, fec, FecReceiver.ER_NULL_COL_CASCADE,
cascade_media_sequence, fec_col))
else:
raise NotImplementedError(FecReceiver.ER_GET_COL_CASCADE % fec_col)
if fec_row:
if len(fec_row.missing) == 1:
# Cascade !
cascade_media_sequence = fec_row.missing[0]
if cascade_media_sequence:
cascade_cross = self.crosses.get(cascade_media_sequence)
if cascade_cross:
self.recoverMediaPacket(cascade_media_sequence, cascade_cross, fec_row)
else:
raise NotImplementedError(
'%s\nrecoverMediaPacket(%s, %s, %s):\nmedia sequence : %s\n%s\n' %
(FecReceiver.ER_NULL_ROW_CASCADE, media_sequence, cross, fec,
cascade_media_sequence, fec_row))
else:
raise NotImplementedError(FecReceiver.ER_GET_ROW_CASCADE % fec_row)
