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