def test_fromBytes_default(self):
self.thisRTP.sequenceNumber = 0
self.thisRTP.ssrc = 0
default = b'\x80\x60\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
newRTP = RTP().fromBytes(default)
self.assertEqual(newRTP, self.thisRTP)
def test_pushGet(self, startKey, len):
self.assertFalse(self.buffer.available())
for x in range(len):
seqNum = (startKey + x) % (MAX_SEQ_NUM + 1)
packet = RTP(sequenceNumber=seqNum)
ret = self.buffer.pushGet(seqNum, packet)
self.assertEqual([packet], ret)
self.assertFalse(self.buffer.available())
def test_fromBytearray_payload(self, value):
self.thisRTP.sequenceNumber = 0
self.thisRTP.ssrc = 0
payload = bytearray(
b'\x80\x60\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00')
payload += value
newRTP = RTP().fromBytearray(payload)
self.thisRTP.payload = bytearray(value)
self.assertEqual(newRTP, self.thisRTP)
def test_fromBytearray_marker(self, value):
self.thisRTP.sequenceNumber = 0
self.thisRTP.ssrc = 0
payload = bytearray(
b'\x80\x60\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00')
payload[1] |= value << 7
newRTP = RTP().fromBytearray(payload)
self.thisRTP.marker = value
self.assertEqual(newRTP, self.thisRTP)
def test_fromBytearray_ssrc(self, value):
self.thisRTP.sequenceNumber = 0
self.thisRTP.ssrc = 0
payload = bytearray(
b'\x80\x60\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00')
payload[8:12] = value.to_bytes(4, byteorder='big')
newRTP = RTP().fromBytearray(payload)
self.thisRTP.ssrc = value
self.assertEqual(newRTP, self.thisRTP)
def _processData(self, data: bytes) -> None:
newPacket = RTP().fromBytes(data)
packets = self._packetBuff.pushGet(
newPacket.sequenceNumber, newPacket)
for packet in packets:
self._processPacket(packet)
if packet.marker:
self._processFragments()
def test_pop(self, startKey, len):
fragments = []
for x in range(len):
seqNum = (startKey + x) % (MAX_SEQ_NUM + 1)
packet = RTP(sequenceNumber=seqNum)
fragments.append((seqNum, packet))
self.buffer.push(seqNum, packet)
for _, packet in fragments[-5:]:
poppedPacket = self.buffer.pop()
self.assertEqual(packet, poppedPacket)
def test_get(self, startKey, len):
fragments = []
for x in range(len):
seqNum = (startKey + x) % (MAX_SEQ_NUM + 1)
packet = RTP(sequenceNumber=seqNum)
fragments.append(packet)
self.buffer.push(seqNum, packet)
gotPackets = self.buffer.get()
self.assertEqual(gotPackets, fragments[-5:])
self.assertFalse(self.buffer.available())
def test_fromBytearray_csrcList(self, value):
self.thisRTP.sequenceNumber = 0
self.thisRTP.ssrc = 0
payload = bytearray(
b'\x80\x60\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00')
payload[0] |= len(value)
for x in range(len(value)):
payload[12 + (4 * x):12 + (4 * x)] = value[x].to_bytes(
4, byteorder='big')
newRTP = RTP().fromBytearray(payload)
self.thisRTP.csrcList.extend(value)
self.assertEqual(newRTP, self.thisRTP)
def test_push(self, startKey, len):
fragments = []
for x in range(len):
seqNum = (startKey + x) % (MAX_SEQ_NUM + 1)
packet = RTP(sequenceNumber=seqNum)
fragments.append((seqNum, packet))
self.buffer.push(seqNum, packet)
for seqNum, packet in fragments[-5:]:
self.assertIn(seqNum, self.buffer._buffer)
self.assertEqual(packet, self.buffer._buffer[seqNum])
for seqNum, packet in fragments[:-5]:
self.assertNotIn(seqNum, self.buffer._buffer)
def test_fromBytearray_extension(self, startBits, headerExtension):
self.thisRTP.sequenceNumber = 0
self.thisRTP.ssrc = 0
newExt = Extension()
newExt.startBits = bytearray(startBits)
newExt.headerExtension = bytearray(headerExtension)
payload = bytearray(
b'\x80\x60\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00')
payload[0] |= 1 << 4
payload[12:12] = newExt.toBytearray()
newRTP = RTP().fromBytearray(payload)
self.thisRTP.extension = newExt
self.assertEqual(newRTP, self.thisRTP)
def _generateRTPPacket(self, doc: str, time: int, isFirst: bool,
marker: bool) -> RTP:
# Only include bom in first packet for doc
thisBOM = (isFirst and self._bom)
packet = RTP(timestamp=time,
sequenceNumber=self._nextSeqNum,
payload=RTPPayload_TTML(userDataWords=doc,
encoding=self._encoding,
bom=thisBOM).toBytearray(),
marker=marker,
payloadType=self._payloadType)
self._nextSeqNum += 1
return packet
def test_available(self, startKey, len):
self.assertFalse(self.buffer.available())
fragments = []
for x in range(len):
seqNum = (startKey + x) % (MAX_SEQ_NUM + 1)
packet = RTP(sequenceNumber=seqNum)
fragments.append((seqNum, packet))
self.buffer.push(seqNum, packet)
for _, packet in fragments[-5:]:
self.assertTrue(self.buffer.available())
self.buffer.pop()
self.assertFalse(self.buffer.available())
def test_processData(self, data):
doc, encoding, bom = data
payload = RTPPayload_TTML(userDataWords=doc,
encoding=encoding,
bom=bom).toBytearray()
packet = RTP(payload=payload, marker=True)
packetBytes = packet.toBytes()
with mock.patch("rtpTTML.ttmlReceiver.RTPPayload_TTML") as mockTTML:
thisReceiver = TTMLReceiver(0,
self.callback,
encoding=encoding,
bom=bom)
thisReceiver._processData(packetBytes)
mockTTML.assert_called_once_with(encoding=encoding, bom=bom)
def test_pushGetMissing(self, startKey, keepList):
self.assertFalse(self.buffer.available())
keepList += ([True] * 5)
expectedList = []
receivedList = []
for x in range(10):
seqNum = (startKey + x) % (MAX_SEQ_NUM + 1)
packet = RTP(sequenceNumber=seqNum)
if keepList[x]:
expectedList.append(packet)
ret = self.buffer.pushGet(seqNum, packet)
receivedList += ret
self.assertEqual(expectedList, receivedList)
self.assertFalse(self.buffer.available())
def test_pushGetSwapped(self, startKey, swap):
self.assertFalse(self.buffer.available())
expectedList = []
receivedList = []
for x in list(range(10)):
seqNum = (startKey + x) % (MAX_SEQ_NUM + 1)
packet = RTP(sequenceNumber=seqNum)
expectedList.append(packet)
swappedPackets = expectedList.copy()
swappedPackets[swap[0]], swappedPackets[swap[1]] = (
swappedPackets[swap[1]], swappedPackets[swap[0]])
for packet in swappedPackets:
ret = self.buffer.pushGet(packet.sequenceNumber, packet)
receivedList += ret
self.assertFalse(self.buffer.available())
self.assertEqual(len(expectedList), len(receivedList))
self.assertEqual(expectedList, receivedList)
def test_init(self, padding, marker, payloadType, sequenceNumber,
timestamp, ssrc, csrcList, payload):
newExt = Extension()
newRTP = RTP(version=2,
padding=padding,
marker=marker,
payloadType=payloadType,
sequenceNumber=sequenceNumber,
timestamp=timestamp,
ssrc=ssrc,
extension=newExt,
csrcList=csrcList,
payload=bytearray(payload))
self.assertEqual(newRTP.version, 2)
self.assertEqual(newRTP.padding, padding)
self.assertEqual(newRTP.marker, marker)
self.assertEqual(newRTP.payloadType, payloadType)
self.assertEqual(newRTP.sequenceNumber, sequenceNumber)
self.assertEqual(newRTP.timestamp, timestamp)
self.assertEqual(newRTP.ssrc, ssrc)
self.assertEqual(newRTP.extension, newExt)
self.assertEqual(newRTP.csrcList, csrcList)
self.assertEqual(newRTP.payload, payload)
def setUp(self):
self.thisRTP = RTP()
