Skip to content
GitLab
Projects
Groups
Snippets
/
Help
Help
Support
Community forum
Keyboard shortcuts
?
Submit feedback
Contribute to GitLab
Sign in
Toggle navigation
Menu
Open sidebar
LARN
PRRT
Commits
ba9d6c5b
Commit
ba9d6c5b
authored
Mar 02, 2016
by
Andreas Schmidt
Browse files
Refactoring.
parent
edf0c135
Changes
8
Hide whitespace changes
Inline
Side-by-side
src/prrt/block.c
View file @
ba9d6c5b
...
...
@@ -43,7 +43,7 @@ void clear_list(gf *const *src, uint8_t k)
}
}
void
PrrtBlock_
free
(
PrrtBlock
*
mblock
)
void
PrrtBlock_
destroy
(
PrrtBlock
*
mblock
)
{
while
(
List_count
(
mblock
->
dataPackets
)
>
0
)
{
PrrtPacket
*
pkt
=
List_shift
(
mblock
->
dataPackets
);
...
...
@@ -60,7 +60,7 @@ void PrrtBlock_free(PrrtBlock *mblock)
free
(
mblock
);
}
int
PrrtBlock_
alloc
(
PrrtBlock
*
mblock
,
const
PrrtCodingParams
*
cpar
,
uint16_t
base_seqno
)
int
PrrtBlock_
create
(
PrrtBlock
*
mblock
,
const
PrrtCodingParams
*
cpar
,
uint16_t
base_seqno
)
{
mblock
->
codingParams
=
*
cpar
;
mblock
->
dataPackets
=
List_create
();
...
...
@@ -186,9 +186,7 @@ void PrrtBlock_decode(PrrtBlock *block_ptr)
PrrtCoder_decode
(
coder
,
fec
,
idx_p
,
length
);
for
(
j
=
0
;
j
<
k
;
j
++
)
{
PrrtPacket
*
packet
=
calloc
(
1
,
sizeof
(
PrrtPacket
));
check_mem
(
packet
);
PrrtPacket_create_data_packet
(
packet
,
0
,
fec
[
j
],
length
,
(
uint16_t
)
(
block_ptr
->
baseSequenceNumber
+
j
));
PrrtPacket
*
packet
=
PrrtPacket_create_data_packet
(
0
,
fec
[
j
],
length
,
(
uint16_t
)
(
block_ptr
->
baseSequenceNumber
+
j
));
PrrtBlock_insert_data_packet
(
block_ptr
,
packet
);
}
...
...
src/prrt/block.h
View file @
ba9d6c5b
...
...
@@ -18,12 +18,12 @@ typedef struct {
/**
* Allocate space for a block.
*/
int
PrrtBlock_
alloc
(
PrrtBlock
*
mblock
,
const
PrrtCodingParams
*
cpar
,
uint16_t
base_seqno
);
int
PrrtBlock_
create
(
PrrtBlock
*
mblock
,
const
PrrtCodingParams
*
cpar
,
uint16_t
base_seqno
);
/**
* Frees the PrrtBlock data structure.
*/
void
PrrtBlock_
free
(
PrrtBlock
*
mblock
);
void
PrrtBlock_
destroy
(
PrrtBlock
*
mblock
);
int
PrrtBlock_insert_data_packet
(
PrrtBlock
*
prrtBlock
,
const
PrrtPacket
*
prrtPacket
);
int
PrrtBlock_insert_redundancy_packet
(
PrrtBlock
*
prrtBlock
,
const
PrrtPacket
*
prrtPacket
);
...
...
src/prrt/packet.c
View file @
ba9d6c5b
...
...
@@ -15,11 +15,11 @@ void *encode_redundancy_header(void *buf_ptr, const void *payload);
void
*
encode_feedback_header
(
void
*
buf_ptr
,
const
void
*
payload
);
void
*
decode_data_header
(
void
*
buf_pt
r
,
const
void
*
payload_pt
r
);
void
*
decode_data_header
(
void
*
dstBuffe
r
,
const
void
*
srcBuffe
r
);
void
*
decode_redundancy_header
(
void
*
buf_pt
r
,
const
void
*
payload_pt
r
);
void
*
decode_redundancy_header
(
void
*
dstBuffe
r
,
const
void
*
srcBuffe
r
);
void
*
decode_feedback_header
(
void
*
buf_pt
r
,
const
void
*
payload_pt
r
);
void
*
decode_feedback_header
(
void
*
dstBuffe
r
,
const
void
*
srcBuffe
r
);
uint8_t
PrrtPacket_type
(
PrrtPacket
*
packet_ptr
)
{
...
...
@@ -106,6 +106,23 @@ PrrtPacket *PrrtPacket_copy(PrrtPacket *original)
PERROR
(
"Not enough memory for packet copies."
);
}
PrrtPacket
*
create_header
(
uint8_t
priority
,
uint16_t
seqno
,
uint32_t
size
,
uint8_t
type
,
uint8_t
index
)
{
PrrtPacket
*
packet
=
calloc
(
1
,
sizeof
(
PrrtPacket
));
check_mem
(
packet
);
packet
->
type_priority
=
type
<<
4
;
packet
->
type_priority
|=
priority
&
0x0F
;
packet
->
index
=
index
;
packet
->
seqno
=
seqno
;
packet
->
payload_len
=
size
;
return
packet
;
error:
PERROR
(
"Could not create packet.%s"
,
""
);
}
int
PrrtPacket_encode
(
void
*
buf_ptr
,
uint16_t
buf_size
,
PrrtPacket
*
packet_ptr
)
{
void
*
payload
=
packet_ptr
->
payload
;
...
...
@@ -243,33 +260,33 @@ void *encode_general_header(void *buf_ptr, const PrrtPacket *packet)
return
buf_ptr
;
}
int
PrrtPacket_decode
(
void
*
buf_pt
r
,
uint16_t
buf_s
ize
,
PrrtPacket
*
p
acket
_ptr
)
int
PrrtPacket_decode
(
void
*
srcBuffe
r
,
uint16_t
srcBufferS
ize
,
PrrtPacket
*
targetP
acket
)
{
uint32_t
payload_len
=
(
uint32_t
)
(
buf_s
ize
-
PRRT_PACKET_GENERAL_HEADER_SIZE
);
p
acket
_ptr
->
type_priority
=
*
(
uint8_t
*
)
buf_pt
r
;
buf_pt
r
+=
1
;
uint8_t
*
index_ptr
=
(
uint8_t
*
)
buf_pt
r
;
p
acket
_ptr
->
index
=
*
index_ptr
;
buf_pt
r
+=
1
;
uint16_t
*
seqno_prt
=
(
uint16_t
*
)
buf_pt
r
;
p
acket
_ptr
->
seqno
=
ntohs
(
*
seqno_prt
);
buf_pt
r
+=
2
;
uint32_t
payload_len
=
(
uint32_t
)
(
srcBufferS
ize
-
PRRT_PACKET_GENERAL_HEADER_SIZE
);
targetP
acket
->
type_priority
=
*
(
uint8_t
*
)
srcBuffe
r
;
srcBuffe
r
+=
1
;
uint8_t
*
index_ptr
=
(
uint8_t
*
)
srcBuffe
r
;
targetP
acket
->
index
=
*
index_ptr
;
srcBuffe
r
+=
1
;
uint16_t
*
seqno_prt
=
(
uint16_t
*
)
srcBuffe
r
;
targetP
acket
->
seqno
=
ntohs
(
*
seqno_prt
);
srcBuffe
r
+=
2
;
void
*
payload_buffer
=
calloc
(
1
,
payload_len
);
check_mem
(
payload_buffer
);
p
acket
_ptr
->
payload
=
payload_buffer
;
p
acket
_ptr
->
payload_len
=
payload_len
;
if
(
PrrtPacket_type
(
p
acket
_ptr
)
==
PACKET_TYPE_DATA
)
{
buf_pt
r
=
decode_data_header
(
buf_pt
r
,
payload_buffer
);
PrrtPacket_copy_buffer_to_payload
(
packet_ptr
,
buf_pt
r
,
PRRT_PACKET_DATA_HEADER_SIZE
);
}
else
if
(
PrrtPacket_type
(
p
acket
_ptr
))
{
buf_pt
r
=
decode_redundancy_header
(
buf_pt
r
,
payload_buffer
);
PrrtPacket_copy_buffer_to_payload
(
packet_ptr
,
buf_pt
r
,
PRRT_PACKET_REDUNDANCY_HEADER_SIZE
);
}
else
if
(
PrrtPacket_type
(
p
acket
_ptr
)
==
PACKET_TYPE_FEEDBACK
)
{
buf_pt
r
=
decode_feedback_header
(
buf_pt
r
,
payload_buffer
);
PrrtPacket_copy_buffer_to_payload
(
packet_ptr
,
buf_pt
r
,
PRRT_PACKET_FEEDBACK_HEADER_SIZE
);
targetP
acket
->
payload
=
payload_buffer
;
targetP
acket
->
payload_len
=
payload_len
;
if
(
PrrtPacket_type
(
targetP
acket
)
==
PACKET_TYPE_DATA
)
{
srcBuffe
r
=
decode_data_header
(
srcBuffe
r
,
payload_buffer
);
PrrtPacket_copy_buffer_to_payload
(
targetPacket
,
srcBuffe
r
,
PRRT_PACKET_DATA_HEADER_SIZE
);
}
else
if
(
PrrtPacket_type
(
targetP
acket
))
{
srcBuffe
r
=
decode_redundancy_header
(
srcBuffe
r
,
payload_buffer
);
PrrtPacket_copy_buffer_to_payload
(
targetPacket
,
srcBuffe
r
,
PRRT_PACKET_REDUNDANCY_HEADER_SIZE
);
}
else
if
(
PrrtPacket_type
(
targetP
acket
)
==
PACKET_TYPE_FEEDBACK
)
{
srcBuffe
r
=
decode_feedback_header
(
srcBuffe
r
,
payload_buffer
);
PrrtPacket_copy_buffer_to_payload
(
targetPacket
,
srcBuffe
r
,
PRRT_PACKET_FEEDBACK_HEADER_SIZE
);
}
else
{
printf
(
"NOT IMPLEMENTED
\n
"
);
}
...
...
@@ -279,203 +296,181 @@ int PrrtPacket_decode(void *buf_ptr, uint16_t buf_size, PrrtPacket *packet_ptr)
return
EXIT_FAILURE
;
}
void
*
decode_redundancy_header
(
void
*
buf_pt
r
,
const
void
*
payload_pt
r
)
void
*
decode_redundancy_header
(
void
*
dstBuffe
r
,
const
void
*
srcBuffe
r
)
{
PrrtPacketRedundancyPayload
*
redundancyPayload
=
(
PrrtPacketRedundancyPayload
*
)
payload_pt
r
;
PrrtPacketRedundancyPayload
*
redundancyPayload
=
(
PrrtPacketRedundancyPayload
*
)
srcBuffe
r
;
uint16_t
*
baseSeqNo
=
(
uint16_t
*
)
buf_pt
r
;
uint16_t
*
baseSeqNo
=
(
uint16_t
*
)
dstBuffe
r
;
redundancyPayload
->
base_seqno
=
ntohs
(
*
baseSeqNo
);
buf_pt
r
+=
2
;
dstBuffe
r
+=
2
;
uint8_t
*
n
=
(
uint8_t
*
)
buf_pt
r
;
uint8_t
*
n
=
(
uint8_t
*
)
dstBuffe
r
;
redundancyPayload
->
n
=
*
n
;
buf_pt
r
+=
1
;
dstBuffe
r
+=
1
;
uint8_t
*
k
=
(
uint8_t
*
)
buf_pt
r
;
uint8_t
*
k
=
(
uint8_t
*
)
dstBuffe
r
;
redundancyPayload
->
k
=
*
k
;
buf_pt
r
+=
1
;
dstBuffe
r
+=
1
;
return
buf_pt
r
;
return
dstBuffe
r
;
}
void
*
decode_feedback_header
(
void
*
buf_pt
r
,
const
void
*
payload_pt
r
)
void
*
decode_feedback_header
(
void
*
dstBuffe
r
,
const
void
*
srcBuffe
r
)
{
PrrtPacketFeedbackPayload
*
feedback_payload
=
(
PrrtPacketFeedbackPayload
*
)
payload_pt
r
;
PrrtPacketFeedbackPayload
*
feedback_payload
=
(
PrrtPacketFeedbackPayload
*
)
srcBuffe
r
;
uint32_t
*
receiver
_a
ddr
=
(
uint32_t
*
)
buf_pt
r
;
feedback_payload
->
receiver_addr
=
ntohl
(
*
receiver
_a
ddr
);
buf_pt
r
+=
4
;
uint32_t
*
receiver
A
ddr
=
(
uint32_t
*
)
dstBuffe
r
;
feedback_payload
->
receiver_addr
=
ntohl
(
*
receiver
A
ddr
);
dstBuffe
r
+=
4
;
uint32_t
*
group
_r
ound
_t
rip
_t
ime
=
(
uint32_t
*
)
buf_pt
r
;
feedback_payload
->
group_round_trip_time
=
ntohl
(
*
group
_r
ound
_t
rip
_t
ime
);
buf_pt
r
+=
4
;
uint32_t
*
group
R
ound
T
rip
T
ime
=
(
uint32_t
*
)
dstBuffe
r
;
feedback_payload
->
group_round_trip_time
=
ntohl
(
*
group
R
ound
T
rip
T
ime
);
dstBuffe
r
+=
4
;
uint32_t
*
forward
_t
rip
_t
ime
=
(
uint32_t
*
)
buf_pt
r
;
feedback_payload
->
forward_trip_time
=
ntohl
(
*
forward
_t
rip
_t
ime
);
buf_pt
r
+=
4
;
uint32_t
*
forward
T
rip
T
ime
=
(
uint32_t
*
)
dstBuffe
r
;
feedback_payload
->
forward_trip_time
=
ntohl
(
*
forward
T
rip
T
ime
);
dstBuffe
r
+=
4
;
uint32_t
*
packet
_l
oss
_r
ate
=
(
uint32_t
*
)
buf_pt
r
;
feedback_payload
->
packet_loss_rate
=
ntohl
(
*
packet
_l
oss
_r
ate
);
buf_pt
r
+=
4
;
uint32_t
*
packet
L
oss
R
ate
=
(
uint32_t
*
)
dstBuffe
r
;
feedback_payload
->
packet_loss_rate
=
ntohl
(
*
packet
L
oss
R
ate
);
dstBuffe
r
+=
4
;
uint16_t
*
gap
=
(
uint16_t
*
)
buf_pt
r
;
uint16_t
*
gap
=
(
uint16_t
*
)
dstBuffe
r
;
feedback_payload
->
gap
=
ntohs
(
*
gap
);
buf_pt
r
+=
2
;
dstBuffe
r
+=
2
;
uint16_t
*
ngap
=
(
uint16_t
*
)
buf_pt
r
;
uint16_t
*
ngap
=
(
uint16_t
*
)
dstBuffe
r
;
feedback_payload
->
ngap
=
ntohs
(
*
ngap
);
buf_pt
r
+=
2
;
dstBuffe
r
+=
2
;
uint16_t
*
burst
=
(
uint16_t
*
)
buf_pt
r
;
uint16_t
*
burst
=
(
uint16_t
*
)
dstBuffe
r
;
feedback_payload
->
burst
=
ntohs
(
*
burst
);
buf_pt
r
+=
2
;
dstBuffe
r
+=
2
;
uint16_t
*
nburst
=
(
uint16_t
*
)
buf_pt
r
;
uint16_t
*
nburst
=
(
uint16_t
*
)
dstBuffe
r
;
feedback_payload
->
nburst
=
ntohs
(
*
nburst
);
buf_pt
r
+=
2
;
dstBuffe
r
+=
2
;
uint32_t
*
bandwidth
_e
stimate
=
(
uint32_t
*
)
buf_pt
r
;
feedback_payload
->
bandwidth_estimate
=
ntohl
(
*
bandwidth
_e
stimate
);
buf_pt
r
+=
4
;
uint32_t
*
bandwidth
E
stimate
=
(
uint32_t
*
)
dstBuffe
r
;
feedback_payload
->
bandwidth_estimate
=
ntohl
(
*
bandwidth
E
stimate
);
dstBuffe
r
+=
4
;
uint32_t
*
buffer
_f
eedback
=
(
uint32_t
*
)
buf_pt
r
;
feedback_payload
->
buffer_feedback
=
ntohl
(
*
buffer
_f
eedback
);
buf_pt
r
+=
4
;
uint32_t
*
buffer
F
eedback
=
(
uint32_t
*
)
dstBuffe
r
;
feedback_payload
->
buffer_feedback
=
ntohl
(
*
buffer
F
eedback
);
dstBuffe
r
+=
4
;
return
buf_pt
r
;
return
dstBuffe
r
;
}
void
*
decode_data_header
(
void
*
buf_pt
r
,
const
void
*
payload_pt
r
)
void
*
decode_data_header
(
void
*
dstBuffe
r
,
const
void
*
srcBuffe
r
)
{
PrrtPacketDataPayload
*
data_payload
=
(
PrrtPacketDataPayload
*
)
payload_pt
r
;
PrrtPacketDataPayload
*
data_payload
=
(
PrrtPacketDataPayload
*
)
srcBuffe
r
;
uint32_t
*
timestamp
=
(
uint32_t
*
)
buf_pt
r
;
uint32_t
*
timestamp
=
(
uint32_t
*
)
dstBuffe
r
;
data_payload
->
timestamp
=
ntohl
(
*
timestamp
);
buf_pt
r
+=
4
;
dstBuffe
r
+=
4
;
uint16_t
*
group_round_trip_time
=
(
uint16_t
*
)
buf_pt
r
;
uint16_t
*
group_round_trip_time
=
(
uint16_t
*
)
dstBuffe
r
;
data_payload
->
group_round_trip_time
=
ntohs
(
*
group_round_trip_time
);
buf_pt
r
+=
2
;
dstBuffe
r
+=
2
;
uint16_t
*
packet_timeout
=
(
uint16_t
*
)
buf_pt
r
;
uint16_t
*
packet_timeout
=
(
uint16_t
*
)
dstBuffe
r
;
data_payload
->
packet_timeout
=
ntohs
(
*
packet_timeout
);
buf_pt
r
+=
2
;
dstBuffe
r
+=
2
;
uint16_t
*
decoding_timeout
=
(
uint16_t
*
)
buf_pt
r
;
uint16_t
*
decoding_timeout
=
(
uint16_t
*
)
dstBuffe
r
;
data_payload
->
decoding_timeout
=
ntohs
(
*
decoding_timeout
);
buf_pt
r
+=
2
;
dstBuffe
r
+=
2
;
uint16_t
*
feedback_timeout
=
(
uint16_t
*
)
buf_pt
r
;
uint16_t
*
feedback_timeout
=
(
uint16_t
*
)
dstBuffe
r
;
data_payload
->
feedback_timeout
=
ntohs
(
*
feedback_timeout
);
buf_pt
r
+=
2
;
return
buf_pt
r
;
dstBuffe
r
+=
2
;
return
dstBuffe
r
;
}
int
PrrtPacket_destroy
(
PrrtPacket
*
packet
_ptr
)
int
PrrtPacket_destroy
(
PrrtPacket
*
packet
)
{
if
(
packet
_ptr
->
payload
!=
NULL
)
{
free
(
packet
_ptr
->
payload
);
if
(
packet
->
payload
!=
NULL
)
{
free
(
packet
->
payload
);
}
free
(
packet
_ptr
);
free
(
packet
);
return
0
;
}
in
t
PrrtPacket_create_data_packet
(
PrrtPacket
*
packet_ptr
,
uint8_t
priority
,
const
void
*
data_ptr
,
uint32_t
data_len
,
uint16_t
seq
no
)
PrrtPacke
t
*
PrrtPacket_create_data_packet
(
uint8_t
priority
,
const
void
*
payloadPointer
,
uint32_t
payloadLength
,
uint16_t
seq
uenceNumber
)
{
uint32_t
payload_length
=
(
uint32_t
)
(
data_len
+
PRRT_PACKET_DATA_HEADER_SIZE
);
packet_ptr
->
type_priority
=
PACKET_TYPE_DATA
<<
4
;
packet_ptr
->
type_priority
|=
priority
&
0x0F
;
packet_ptr
->
index
=
0
;
packet_ptr
->
seqno
=
seqno
;
PrrtPacket
*
packet
=
create_header
(
priority
,
sequenceNumber
,
(
uint32_t
)
(
payloadLength
+
PRRT_PACKET_DATA_HEADER_SIZE
),
PACKET_TYPE_DATA
,
0
);
void
*
content_buf
=
calloc
(
1
,
payload_length
);
check_mem
(
content_buf
);
PrrtPacketDataPayload
*
source_payload
=
content_buf
;
PrrtPacketDataPayload
*
dataPayload
=
calloc
(
1
,
packet
->
payload_len
);
check_mem
(
dataPayload
);
packet
->
payload
=
dataPayload
;
struct
timeval
tv
;
gettimeofday
(
&
tv
,
NULL
);
unsigned
long
time_in_micros
=
(
unsigned
long
)
(
1000000
*
tv
.
tv_sec
+
tv
.
tv_usec
);
source_payload
->
timestamp
=
(
uint32_t
)
time_in_micros
;
source_payload
->
group_round_trip_time
=
95
;
// TODO: payload->rtt = CURRENT ESTIMATE
source_payload
->
packet_timeout
=
110
;
// TODO: payload->packet_timeout = NOW + maximum delay
source_payload
->
decoding_timeout
=
150
;
// TODO: payload->decoding_timeout
source_payload
->
feedback_timeout
=
170
;
// TODO: payload->feedback_timer
dataPayload
->
timestamp
=
(
uint32_t
)
time_in_micros
;
dataPayload
->
group_round_trip_time
=
95
;
// TODO: payload->rtt = CURRENT ESTIMATE
dataPayload
->
packet_timeout
=
110
;
// TODO: payload->packet_timeout = NOW + maximum delay
dataPayload
->
decoding_timeout
=
150
;
// TODO: payload->decoding_timeout
dataPayload
->
feedback_timeout
=
170
;
// TODO: payload->feedback_timer
PrrtPacket_copy_buffer_to_payload
(
packet
,
payloadPointer
,
PRRT_PACKET_DATA_HEADER_SIZE
)
packet_ptr
->
payload
=
content_buf
;
packet_ptr
->
payload_len
=
payload_length
;
PrrtPacket_copy_buffer_to_payload
(
packet_ptr
,
data_ptr
,
PRRT_PACKET_DATA_HEADER_SIZE
)
return
packet
;
error:
return
-
1
;
PERROR
(
"Could not create packet."
)
;
}
PrrtPacket
*
PrrtPacket_create_redundancy_packet
(
uint8_t
priority
,
void
*
data_ptr
,
uint32_t
data_len
,
uint16_t
seq
no
,
uint8_t
index
,
uint16_t
base
_seqno
,
PrrtPacket
*
PrrtPacket_create_redundancy_packet
(
uint8_t
priority
,
void
*
payloadPointer
,
uint32_t
payloadLength
,
uint16_t
seq
uenceNumber
,
uint8_t
index
,
uint16_t
base
SequenceNumber
,
PrrtCodingParams
codingParams
)
{
uint32_t
payload_length
=
(
uint32_t
)
(
data_len
+
PRRT_PACKET_REDUNDANCY_HEADER_SIZE
);
PrrtPacket
*
packet_ptr
=
calloc
(
1
,
sizeof
(
PrrtPacket
));
check_mem
(
packet_ptr
);
packet_ptr
->
type_priority
=
PACKET_TYPE_REDUNDANCY
<<
4
;
packet_ptr
->
type_priority
|=
priority
&
0x0F
;
packet_ptr
->
index
=
index
;
packet_ptr
->
seqno
=
seqno
;
PrrtPacket
*
packet
=
create_header
(
priority
,
sequenceNumber
,
(
uint32_t
)
(
payloadLength
+
PRRT_PACKET_REDUNDANCY_HEADER_SIZE
),
PACKET_TYPE_REDUNDANCY
,
index
);
void
*
content_buf
=
calloc
(
1
,
PRRT_PACKET_REDUNDANCY_HEADER_SIZE
+
data_len
);
check_mem
(
content_buf
);
PrrtPacketRedundancyPayload
*
redundancyPayload
=
calloc
(
1
,
packet
->
payload_len
);
check_mem
(
redundancyPayload
);
packet
->
payload
=
redundancyPayload
;
PrrtPacketRedundancyPayload
*
redundancy_payload
=
content_buf
;
redundancyPayload
->
base_seqno
=
baseSequenceNumber
;
redundancyPayload
->
k
=
codingParams
.
k
;
redundancyPayload
->
n
=
codingParams
.
n
;
PrrtPacket_copy_buffer_to_payload
(
packet
,
payloadPointer
,
PRRT_PACKET_REDUNDANCY_HEADER_SIZE
);
redundancy_payload
->
base_seqno
=
base_seqno
;
redundancy_payload
->
k
=
codingParams
.
k
;
redundancy_payload
->
n
=
codingParams
.
n
;
packet_ptr
->
payload
=
content_buf
;
packet_ptr
->
payload_len
=
payload_length
;
PrrtPacket_copy_buffer_to_payload
(
packet_ptr
,
data_ptr
,
PRRT_PACKET_REDUNDANCY_HEADER_SIZE
);
return
packet_ptr
;
return
packet
;
error:
return
NULL
;
}
PrrtPacket
*
PrrtPacket_create_feedback_packet
(
uint8_t
priority
,
uint8_t
index
,
uint16_t
seqno
,
uint32_t
round_trip_time
,
uint32_t
forward_trip_time
,
uint32_t
packet_loss_rate
,
uint16_t
gap
,
uint16_t
ngap
,
uint16_t
burst
,
uint16_t
nburst
,
uint32_t
bandwidth
,
uint32_t
buffer_feedback
)
PrrtPacket
*
PrrtPacket_create_feedback_packet
(
uint8_t
priority
,
uint8_t
index
,
uint16_t
sequenceNumber
,
uint32_t
roundTripTime
,
uint32_t
forwardTripTime
,
uint32_t
packetLossRate
,
uint16_t
gap
,
uint16_t
ngap
,
uint16_t
burst
,
uint16_t
nburst
,
uint32_t
bandwidth
,
uint32_t
bufferFeedback
)
{
PrrtPacket
*
packet_ptr
=
calloc
(
1
,
sizeof
(
PrrtPacket
));
check_mem
(
packet_ptr
);
packet_ptr
->
type_priority
=
PACKET_TYPE_FEEDBACK
<<
4
;
packet_ptr
->
type_priority
|=
priority
&
0x0F
;
packet_ptr
->
index
=
index
;
packet_ptr
->
seqno
=
seqno
;
PrrtPacketFeedbackPayload
*
payload
=
calloc
(
1
,
PRRT_PACKET_FEEDBACK_HEADER_SIZE
);
PrrtPacket
*
packet
=
create_header
(
priority
,
sequenceNumber
,
PRRT_PACKET_FEEDBACK_HEADER_SIZE
,
PACKET_TYPE_FEEDBACK
,
index
);
PrrtPacketFeedbackPayload
*
payload
=
calloc
(
1
,
packet
->
payload_len
);
check_mem
(
payload
);
packet
->
payload
=
payload
;
payload
->
group_round_trip_time
=
round
_t
rip
_t
ime
;
payload
->
forward_trip_time
=
forward
_t
rip
_t
ime
;
payload
->
packet_loss_rate
=
packet
_l
oss
_r
ate
;
payload
->
group_round_trip_time
=
round
T
rip
T
ime
;
payload
->
forward_trip_time
=
forward
T
rip
T
ime
;
payload
->
packet_loss_rate
=
packet
L
oss
R
ate
;
payload
->
gap
=
gap
;
payload
->
ngap
=
ngap
;
payload
->
burst
=
burst
;
payload
->
nburst
=
nburst
;
payload
->
bandwidth_estimate
=
bandwidth
;
payload
->
buffer_feedback
=
buffer
_f
eedback
;
payload
->
buffer_feedback
=
buffer
F
eedback
;
packet_ptr
->
payload
=
(
void
*
)
payload
;
packet_ptr
->
payload_len
=
(
uint32_t
)
(
PRRT_PACKET_FEEDBACK_HEADER_SIZE
);
return
packet
_ptr
;
return
packet
;
error:
return
NULL
;
...
...
src/prrt/packet.h
View file @
ba9d6c5b
...
...
@@ -63,20 +63,19 @@ uint16_t PrrtPacket_size(PrrtPacket *packet_ptr);
int
PrrtPacket_print
(
PrrtPacket
*
packet_ptr
);
PrrtPacket
*
PrrtPacket_copy
(
PrrtPacket
*
original
);
int
PrrtPacket_create_data_packet
(
PrrtPacket
*
packet_ptr
,
uint8_t
priority
,
const
void
*
data_ptr
,
uint32_t
data_len
,
uint16_t
seqno
);
PrrtPacket
*
PrrtPacket_create_data_packet
(
uint8_t
priority
,
const
void
*
payloadPointer
,
uint32_t
payloadLength
,
uint16_t
sequenceNumber
);
PrrtPacket
*
PrrtPacket_create_feedback_packet
(
uint8_t
priority
,
uint8_t
index
,
uint16_t
seq
no
,
uint32_t
round
_t
rip
_t
ime
,
uint32_t
forward
_t
rip
_t
ime
,
uint32_t
packet
_l
oss
_r
ate
,
uint16_t
gap
,
PrrtPacket
*
PrrtPacket_create_feedback_packet
(
uint8_t
priority
,
uint8_t
index
,
uint16_t
seq
uenceNumber
,
uint32_t
round
T
rip
T
ime
,
uint32_t
forward
T
rip
T
ime
,
uint32_t
packet
L
oss
R
ate
,
uint16_t
gap
,
uint16_t
ngap
,
uint16_t
burst
,
uint16_t
nburst
,
uint32_t
bandwidth
,
uint32_t
buffer
_f
eedback
);
uint32_t
buffer
F
eedback
);
PrrtPacket
*
PrrtPacket_create_redundancy_packet
(
uint8_t
priority
,
void
*
data_ptr
,
uint32_t
data_len
,
uint16_t
seq
no
,
uint8_t
index
,
uint16_t
base
_seqno
,
PrrtCodingParams
codingParams
);
PrrtPacket
*
PrrtPacket_create_redundancy_packet
(
uint8_t
priority
,
void
*
payloadPointer
,
uint32_t
payloadLength
,
uint16_t
seq
uenceNumber
,
uint8_t
index
,
uint16_t
base
SequenceNumber
,
PrrtCodingParams
codingParams
);
int
PrrtPacket_decode
(
void
*
buf_pt
r
,
uint16_t
buf_s
ize
,
PrrtPacket
*
p
acket
_ptr
);
int
PrrtPacket_decode
(
void
*
srcBuffe
r
,
uint16_t
srcBufferS
ize
,
PrrtPacket
*
targetP
acket
);
int
PrrtPacket_encode
(
void
*
buf_ptr
,
uint16_t
buf_size
,
PrrtPacket
*
packet_ptr
);
int
PrrtPacket_destroy
(
PrrtPacket
*
packet
_ptr
);
int
PrrtPacket_destroy
(
PrrtPacket
*
packet
);
#define PrrtPacket_copy_payload_to_buffer(dst, packet, header_size) memcpy(dst, packet->payload + header_size, packet->payload_len - header_size);
#define PrrtPacket_copy_buffer_to_payload(packet, src, header_size) memcpy(packet->payload + header_size, src, packet->payload_len - header_size);
...
...
src/prrt/processes/data_receiver.c
View file @
ba9d6c5b
...
...
@@ -43,7 +43,7 @@ void decode_block(PrrtSocket *sock_ptr, uint16_t base_seqno)
}
}
PrrtBlock_
free
(
block
);
PrrtBlock_
destroy
(
block
);
sock_ptr
->
blockStore
=
BPTree_delete
(
sock_ptr
->
blockStore
,
base_seqno
);
}
...
...
@@ -142,7 +142,7 @@ void *receive_data_loop(void *ptr)
block
=
calloc
(
1
,
sizeof
(
PrrtBlock
));
check_mem
(
block
);
PrrtBlock_
alloc
(
block
,
cpar
,
redundancyPayload
->
base_seqno
);
PrrtBlock_
create
(
block
,
cpar
,
redundancyPayload
->
base_seqno
);
free
(
cpar
);
sock_ptr
->
blockStore
=
BPTree_insert
(
sock_ptr
->
blockStore
,
redundancyPayload
->
base_seqno
,
block
);
...
...
src/prrt/processes/data_transmitter.c
View file @
ba9d6c5b
...
...
@@ -57,7 +57,9 @@ void * send_data_loop(void *ptr) {
pthread_mutex_lock
(
&
sock_ptr
->
closingMutex
);
if
(
sock_ptr
->
closing
)
{
free
(
cpar
);
PrrtBlock_free
(
block
);
if
(
block
!=
NULL
)
{
PrrtBlock_destroy
(
block
);
}
block
=
NULL
;
pthread_mutex_unlock
(
&
sock_ptr
->
closingMutex
);
...
...
@@ -72,7 +74,7 @@ void * send_data_loop(void *ptr) {
block
=
calloc
(
1
,
sizeof
(
PrrtBlock
));
check_mem
(
block
);
PrrtBlock_
alloc
(
block
,
cpar
,
sock_ptr
->
sequenceNumberRedundancy
);
PrrtBlock_
create
(
block
,
cpar
,
sock_ptr
->
sequenceNumberRedundancy
);
}
PrrtPacket
*
packet
=
List_shift
(
sock_ptr
->
outQueue
);
...
...
@@ -95,7 +97,7 @@ void * send_data_loop(void *ptr) {
send_packet
(
sock_ptr
,
data_pkt
);
}
PrrtBlock_
free
(
block
);
PrrtBlock_
destroy
(
block
);
block
=
NULL
;
}
...
...
src/prrt/socket.c
View file @
ba9d6c5b
...
...
@@ -95,18 +95,13 @@ int PrrtSocket_connect(PrrtSocket *sock_ptr, const char *host, const uint16_t po
int
PrrtSocket_send
(
PrrtSocket
*
sock_ptr
,
const
void
*
data
,
const
size_t
data_len
)
{
pthread_mutex_lock
(
&
sock_ptr
->
outQueueFilledMutex
);
PrrtPacket
*
packet
=
calloc
(
1
,
sizeof
(
PrrtPacket
));
check_mem
(
packet
);
PrrtPacket_create_data_packet
(
packet
,
5
,
data
,
(
uint32_t
)
data_len
,
sock_ptr
->
sequenceNumberSource
++
);
PrrtPacket
*
packet
=
PrrtPacket_create_data_packet
(
5
,
data
,
(
uint32_t
)
data_len
,
sock_ptr
->
sequenceNumberSource
++
);
List_push
(
sock_ptr
->
outQueue
,
packet
);
pthread_cond_signal
(
&
sock_ptr
->
outQueueFilledCv
);
pthread_mutex_unlock
(
&
sock_ptr
->
outQueueFilledMutex
);
return
0
;
error:
return
-
1
;
}
int32_t
PrrtSocket_recv
(
PrrtSocket
*
sock_ptr
,
void
*
buf_ptr
)
{
...
...
@@ -199,7 +194,7 @@ int PrrtSocket_close(PrrtSocket *sock_ptr) {
BPTree_get_range
(
sock_ptr
->
blockStore
,
blockList
,
0
,
SEQNO_SPACE
-
1
);
while
(
List_count
(
blockList
)
>
0
)
{
PrrtBlock
*
block
=
List_shift
(
blockList
);
PrrtBlock_
free
(
block
);
PrrtBlock_
destroy
(
block
);
}
List_destroy
(
blockList
);
...
...
tests/PrrtBlock_tests.cpp
View file @
ba9d6c5b
#include
<gtest/gtest.h>
extern
"C"
{
#include
"src/prrt/block.h"
#include
"src/prrt/packet.h"
#include
"src/prrt/coding_params.h"
#include
"src/prrt/block.h"
#include
"src/prrt/packet.h"
#include
"src/prrt/coding_params.h"
}
class
PrrtBlockTest
:
public
::
testing
::
Test
{
protected:
virtual
void
SetUp
()
{
virtual
void
SetUp
()
{
encBlock
=
(
PrrtBlock
*
)
calloc
(
1
,
sizeof
(
PrrtBlock
));
decBlock
=
(
PrrtBlock
*
)
calloc
(
1
,
sizeof
(
PrrtBlock
));
PrrtCodingParams
*
cpar
=
(
PrrtCodingParams
*
)
calloc
(
1
,
sizeof
(
PrrtCodingParams
));
PrrtCodingParams_init
(
cpar
);
PrrtBlock_
alloc
(
encBlock
,
cpar
,
0
);
PrrtBlock_
alloc
(
decBlock
,
cpar
,
0
);
PrrtBlock_
create
(
encBlock
,
cpar
,
0
);
PrrtBlock_
create
(
decBlock
,
cpar
,
0
);
}
PrrtBlock
*
encBlock
;
PrrtBlock
*
decBlock
;
};
TEST_F
(
PrrtBlockTest
,
Encode
)
{
TEST_F
(
PrrtBlockTest
,
Encode
)
{
uint16_t
base
=
0
;
PrrtPacket
*
packets
=
(
PrrtPacket
*
)
calloc
(
2
,
sizeof
(
PrrtPacket
));
PrrtPacket
refPackets
[
2
];
memset
(
refPackets
,
0
,
2
*
sizeof
(
PrrtPacket
));
PrrtPacket
*
packets
[
2
];
PrrtPacket
*
refPackets
[
2
];
PrrtPacket
*
redPackets
=
(
PrrtPacket
*
)
calloc
(
2
,
sizeof
(
PrrtPacket
));
PrrtPacket
*
redPackets
=
(
PrrtPacket
*
)
calloc
(
2
,
sizeof
(
PrrtPacket
));
for
(
int
i
=
1
;
i
<
3
;
i
++
)
{
for
(
int
i
=
1
;
i
<
3
;
i
++
)
{
char
data
[
3
];
sprintf
(
data
,
"%d"
,
i
);