/// Allocate memory for a new packet in FIFO buffer. This is used by Packet_New and Packet_Resize.
///
/// Can optionally copy memory from old packet (used for Packet_Resize), in this case the last 3 parameters are needed.
/// @param[in] writer Should be NextWriter.
/// @param[in] lastReader Should be OutputReader
/// @param[in] len Length of new packet in byte.
/// @param[in] resize True if memory from `packet` should be copied (Packet_Resize), otherwise false (Packet_New)
/// @param[in] packet Ignored if `resize`==false, old packet whose memory should be copied to new memory
/// @param[in] oldLen Ignored if `resize`==false, length of memory to be copied from old packet
__attribute__((always_inline)) static inline Packet_t *allocateNew(Packet_t *writer, Packet_t *lastReader, uint16_t len, bool resize, Packet_t *packet, uint16_t oldLen)
{
Packet_t *nextPacket = getNextPacket(writer, len);
// Check if we can and have to jump to the beginning of the RingBuffer
if(writer >= lastReader)
{
if(nextPacket > RingBuffer.End)
{
nextPacket = getNextPacket(RingBuffer.Start, len);
// If RingBuffer is empty reset all readers and start from the beginning
if(writer == lastReader)
{
assert(nextPacket <= RingBuffer.End);
InputReader = RingBuffer.Start;
OutputReader = RingBuffer.Start;
}
// If there is enough space in the beginning of the RingBuffer,
// mark current end of RingBuffer with StartOver
else if(nextPacket < lastReader)
{
writer->state = StartOver;
} else {
return NULL; // Ringbuffer full
}
writer = RingBuffer.Start;
}
}
// We are in the beginning of the RingBuffer already, check if there is enough
// space before old entries at the end of the RingBuffer
else if(nextPacket >= lastReader)
{
return NULL;
}
writer->state = len;
// Next steps are only needed in case of packet resize
if(resize)
{
packet->state = Skip | oldLen; // before memmove, as memmove may override memory of old packet (correct)
// Copy old packet into new buffer (underlying memory could overlap)
memmove((void *)writer->data, (void *)packet->data, oldLen);
}
nextPacket->state = EndOfRing; // after memmove, as this may override memory which is only free after memmove
NextWriter = nextPacket;
return writer;
}
bool FFmpeg_Decoder::getAVAudioData()
{
int got_frame, len;
if((*mStream)->codec->codec_type != AVMEDIA_TYPE_AUDIO)
return false;
do {
if(mPacket.size == 0 && !getNextPacket())
return false;
/* Decode some data, and check for errors */
if((len=avcodec_decode_audio4((*mStream)->codec, mFrame, &got_frame, &mPacket)) < 0)
return false;
/* Move the unread data to the front and clear the end bits */
int remaining = mPacket.size - len;
if(remaining <= 0)
av_free_packet(&mPacket);
else
{
memmove(mPacket.data, &mPacket.data[len], remaining);
av_shrink_packet(&mPacket, remaining);
}
} while(got_frame == 0 || mFrame->nb_samples == 0);
mNextPts += (double)mFrame->nb_samples / (double)(*mStream)->codec->sample_rate;
return true;
}
PacketStream::~PacketStream() {
//We can't do assert(shutdown) in case PacketStream was never started.
assert(!isRunning());
//Clear out our queues.
Packet* temp = NULL;
//Empty out the outgoing queues.
outQCtrl.acquire();
while (!outRel.empty()) {
delete outRel.front();
outRel.pop();
}
while (!outUnrel.empty()) {
delete outUnrel.front();
outUnrel.pop();
}
outQCtrl.release();
//Empty the incoming queue.
while ((temp = getNextPacket()) != NULL)
delete temp;
gnedbgo(5, "destroyed");
}
/// Get a packet from the Output chain. If there is no ready packet, returns NULL.
Packet_t *Packet_GetOutput(void)
{
Packet_t *reader = OutputReader, *input = InputReader;
bool skipOutput = false, skipInput = false;
uint16_t state;
// Skip entries of type Skip
while(((state = reader->state) & Skip) == Skip)
{
skipOutput = true;
if(!skipInput && input == reader)
skipInput = true;
if(state == StartOver)
reader = RingBuffer.Start;
else
reader = getNextPacket(reader, Packet_getLen(state));
}
if(skipOutput)
{
OutputReader = reader;
if(skipInput)
InputReader = reader;
}
return (state & Output) ? reader : NULL;
}
/// Release packet from Input chain, free memory.
void Packet_ReleaseOutput(Packet_t *packet)
{
Packet_t *nextPacket = getNextPacket(packet, Packet_getLen(packet->state));
if(InputReader == packet)
InputReader = nextPacket;
OutputReader = nextPacket;
}
/// Get a packet from the Input chain. If there is no ready packet, returns NULL.
Packet_t *Packet_GetInput(void)
{
Packet_t *reader = InputReader;
bool skipInput = false, skipOutput = (OutputReader == reader);
uint16_t state;
// Skip entries of type Output or Skip
while((state = reader->state) & Output)
{
skipInput = true;
// Skip Output pointer entries only for skip entries
if(skipOutput && !(state & Input))
{
OutputReader = reader;
skipOutput = false;
}
if(state == StartOver)
reader = RingBuffer.Start;
else
reader = getNextPacket(reader, Packet_getLen(state));
}
if(skipInput)
{
InputReader = reader;
if(skipOutput)
OutputReader = reader;
}
return (state & Input) ? reader : NULL;
}
/// Reattach packet from the Input chain to Output chain.
void Packet_ReattachOutput(Packet_t *packet)
{
assert((packet->state & Skip) == Input);
uint16_t len = Packet_getLen(packet->state);
packet->state = len | Output;
InputReader = getNextPacket(packet, len);
}
/// Release packet from Input chain, free memory.
void Packet_ReleaseInput(Packet_t *packet)
{
Packet_t *nextPacket = getNextPacket(packet, Packet_getLen(packet->state));
InputReader = nextPacket;
if(OutputReader == packet)
OutputReader = nextPacket;
else
packet->state |= Skip;
}
bool FFmpeg_Decoder::getAVAudioData()
{
int got_frame;
if((*mStream)->codec->codec_type != AVMEDIA_TYPE_AUDIO)
return false;
do {
if(mPacket.size == 0 && !getNextPacket())
return false;
/* Decode some data, and check for errors */
int len = 0;
if((len=avcodec_decode_audio4((*mStream)->codec, mFrame, &got_frame, &mPacket)) < 0)
return false;
/* Move the unread data to the front and clear the end bits */
int remaining = mPacket.size - len;
if(remaining <= 0)
av_free_packet(&mPacket);
else
{
memmove(mPacket.data, &mPacket.data[len], remaining);
av_shrink_packet(&mPacket, remaining);
}
if (!got_frame || mFrame->nb_samples == 0)
continue;
if(mSwr)
{
if(!mDataBuf || mDataBufLen < mFrame->nb_samples)
{
av_freep(&mDataBuf);
if(av_samples_alloc(&mDataBuf, NULL, av_get_channel_layout_nb_channels(mOutputChannelLayout),
mFrame->nb_samples, mOutputSampleFormat, 0) < 0)
return false;
else
mDataBufLen = mFrame->nb_samples;
}
if(swr_convert(mSwr, (uint8_t**)&mDataBuf, mFrame->nb_samples,
(const uint8_t**)mFrame->extended_data, mFrame->nb_samples) < 0)
{
return false;
}
mFrameData = &mDataBuf;
}
else
mFrameData = &mFrame->data[0];
} while(got_frame == 0 || mFrame->nb_samples == 0);
mNextPts += (double)mFrame->nb_samples / (double)(*mStream)->codec->sample_rate;
return true;
}
/**
* Gets the next packet waiting from MIP for an APP
* @param ret Where returned packet is stored
* @param src Port to get packet from
*/
void getAppPacket(struct miptp_packet **ret, struct applist *src) {
//if(debug) fprintf(stderr, "MIPTP: getAppPacket(%p (%p), %p)\n", *ret, ret, src);
struct packetlist *toget;
getNextPacket(&toget, src->recvinfo->recvQueue);
struct miptp_packet *result;
miptpCreatepacket(lmip, toget->data->port, toget->datalen-sizeof(struct tp_packet)-toget->data->pl_bits, toget->data->content, &result);
*ret = result;
removeToSeqno(toget->data->seqno+1, src->recvinfo->recvQueue);
}
/// Resize packet in FIFO buffer.
Packet_t *Packet_Resize(Packet_t *packet, uint16_t len)
{
uint16_t oldLen = packet->state;
assert((oldLen & Skip) == 0);
Packet_t *nextPacket = getNextPacket(packet, len);
Packet_t *oldNextPacket = getNextPacket(packet, oldLen);
// Packet shrink, need to do something with remainder
if(oldNextPacket > nextPacket)
{
if(NextWriter == oldNextPacket) // Last element in ring, adjust next write position
NextWriter = nextPacket;
else // Otherwise mark remainder as Skip
nextPacket->state = Skip | ((uintptr_t)oldNextPacket - (uintptr_t)nextPacket->data);
}
// Packet shrink or same size
if(oldNextPacket >= nextPacket)
{
// even if oldNextPacket == nextPacket it's possible that len != oldLen
packet->state = len;
return packet;
}
// Packet extend
Packet_t *lastReader = OutputReader;
Packet_t *writer = NextWriter;
// Check if packet is last element in RingBuffer and we have enough space to append the extra bytes
if(oldNextPacket == writer && ((packet < lastReader) ? (nextPacket < lastReader) : (nextPacket <= RingBuffer.End)))
{
nextPacket->state = EndOfRing;
packet->state = len;
NextWriter = nextPacket;
return packet;
}
// We cannot append, create new packet of full length
return allocateNew(writer, lastReader, len, true, packet, oldLen);
}
/**
* Gets the next ACK packet to send from an APP
* @param ret Where the ACK packet is stored
* @param src Port to get ACK from
*/
void getAckPacket(struct mipd_packet **ret, struct applist *src) {
//if(debug) fprintf(stderr, "MIPTP: getAckPacket(%p (%p), %p)\n", *ret, ret, src);
struct packetlist *pl = NULL;
getNextPacket(&pl, src->recvinfo->ackQueue);
//if(debug) fprintf(stderr, "MIPTP: Creating mipd packet, size %d, to %d\n", pl->datalen, pl->dst_mip);
//if(debug) fprintf(stderr, "MIPTP: Created with port %d\n", pl->data->port);
mipdCreatepacket(pl->dst_mip, pl->datalen, (char *)pl->data, ret);
removeNextPacket(src->recvinfo->ackQueue);
}
/*! Vett keret feldolgozása */
void processReceive() {
Packet *packet = getNextPacket(); // az aktualis vett keret lekerese
if (!packet) // valaki szorakozik NULL ertek
return;
if (packet->address == clientAddress) { // jo a cim, fel kell dolgozni
switch (packet->cmd) {
case cmPing : replyPing(); // ping parancs jott
break;
case cmGetTerm : replyTerm(); // homerseklet lekerdezes parancs jott
break;
case cmGetPressure : replyPressure(); // nyomas lekerdezes parancs jott
break;
}
}
freePacket(); // jelzes, hogy fel van dolgozva, johet a kovetkezo keret
}
Test::TestResult ConnectionFilterTestSuite::execTest()
{
std::cout << "running tests on ConnectionFilter" << std::endl;
msg_init();
msg_setlevel(100);
captureDevice = pcap_open_offline("data/connectionfiltertest.pcap", errorBuffer);
if (!captureDevice) {
ERROR(errorBuffer);
}
Packet* p;
ConnectionFilter connFilter(5, 100, 10, 1000);
// first packet is a udp packet
p = getNextPacket(captureDevice);
REQUIRE(connFilter.processPacket(p) == false);
// process six packets that come from a connection that did not have any syn packet
p = getNextPacket(captureDevice);
REQUIRE(connFilter.processPacket(p) == false);
p = getNextPacket(captureDevice);
REQUIRE(connFilter.processPacket(p) == false);
p = getNextPacket(captureDevice);
REQUIRE(connFilter.processPacket(p) == false);
p = getNextPacket(captureDevice);
REQUIRE(connFilter.processPacket(p) == false);
p = getNextPacket(captureDevice);
REQUIRE(connFilter.processPacket(p) == false);
p = getNextPacket(captureDevice);
REQUIRE(connFilter.processPacket(p) == false);
// process a valid short 5 packets connection
p = getNextPacket(captureDevice);
REQUIRE(connFilter.processPacket(p) == false); // SYN
p = getNextPacket(captureDevice);
REQUIRE(connFilter.processPacket(p) == false); // SYN
p = getNextPacket(captureDevice);
REQUIRE(connFilter.processPacket(p) == true);
p = getNextPacket(captureDevice);
REQUIRE(connFilter.processPacket(p) == false); // FIN
p = getNextPacket(captureDevice);
REQUIRE(connFilter.processPacket(p) == false); // RST
// process a valid connection
// ignore the first syn packet
p = getNextPacket(captureDevice);
REQUIRE(connFilter.processPacket(p) == false); // SYN
p = getNextPacket(captureDevice);
REQUIRE(connFilter.processPacket(p) == false); // SYN
p = getNextPacket(captureDevice);
REQUIRE(connFilter.processPacket(p) == true);
p = getNextPacket(captureDevice);
REQUIRE(connFilter.processPacket(p) == true);
p = getNextPacket(captureDevice);
REQUIRE(connFilter.processPacket(p) == true);
p = getNextPacket(captureDevice);
REQUIRE(connFilter.processPacket(p) == false); // passed export limit
p = getNextPacket(captureDevice);
REQUIRE(connFilter.processPacket(p) == false);
p = getNextPacket(captureDevice);
REQUIRE(connFilter.processPacket(p) == false); // FIN
p = getNextPacket(captureDevice);
REQUIRE(connFilter.processPacket(p) == false); // FIN
p = getNextPacket(captureDevice);
REQUIRE(connFilter.processPacket(p) == false); // ACK
pcap_close(captureDevice);
std::cout << "All tests on ConnectionFilter passed" << std::endl;
return PASSED;
}
uint8_t *getAVAudioData(StreamPtr stream, size_t *length)
{
int got_frame;
int len;
if(length) *length = 0;
if(!stream || stream->CodecCtx->codec_type != AVMEDIA_TYPE_AUDIO)
return NULL;
next_packet:
if(!stream->Packets && !getNextPacket(stream->parent, stream->StreamIdx))
return NULL;
/* Decode some data, and check for errors */
avcodec_get_frame_defaults(stream->Frame);
while((len=avcodec_decode_audio4(stream->CodecCtx, stream->Frame,
&got_frame, &stream->Packets->pkt)) < 0)
{
struct PacketList *self;
/* Error? Drop it and try the next, I guess... */
self = stream->Packets;
stream->Packets = self->next;
av_free_packet(&self->pkt);
av_free(self);
if(!stream->Packets)
goto next_packet;
}
if(len < stream->Packets->pkt.size)
{
/* Move the unread data to the front and clear the end bits */
int remaining = stream->Packets->pkt.size - len;
memmove(stream->Packets->pkt.data, &stream->Packets->pkt.data[len],
remaining);
memset(&stream->Packets->pkt.data[remaining], 0,
stream->Packets->pkt.size - remaining);
stream->Packets->pkt.size -= len;
}
else
{
struct PacketList *self;
self = stream->Packets;
stream->Packets = self->next;
av_free_packet(&self->pkt);
av_free(self);
}
if(!got_frame || stream->Frame->nb_samples == 0)
goto next_packet;
/* Set the output buffer size */
*length = av_samples_get_buffer_size(NULL, stream->CodecCtx->channels,
stream->Frame->nb_samples,
stream->CodecCtx->sample_fmt, 1);
return stream->Frame->data[0];
}
Packet::sptr PacketStream::getNextPacketSp() {
return Packet::sptr( getNextPacket(), PacketParser::destroyPacket );
}
void *getAVAudioData(StreamPtr stream, size_t *length)
{
int size;
int len;
if(length) *length = 0;
if(!stream || stream->CodecCtx->codec_type != AVMEDIA_TYPE_AUDIO)
return NULL;
stream->DecodedDataSize = 0;
next_packet:
if(!stream->Packets && !getNextPacket(stream->parent, stream->StreamIdx))
return NULL;
/* Decode some data, and check for errors */
size = AVCODEC_MAX_AUDIO_FRAME_SIZE;
while((len=avcodec_decode_audio3(stream->CodecCtx,
(int16_t*)stream->DecodedData, &size,
&stream->Packets->pkt)) == 0)
{
struct PacketList *self;
if(size > 0)
break;
/* Packet went unread and no data was given? Drop it and try the next,
* I guess... */
self = stream->Packets;
stream->Packets = self->next;
av_free_packet(&self->pkt);
av_free(self);
if(!stream->Packets)
goto next_packet;
size = AVCODEC_MAX_AUDIO_FRAME_SIZE;
}
if(len < 0)
return NULL;
if(len < stream->Packets->pkt.size)
{
/* Move the unread data to the front and clear the end bits */
int remaining = stream->Packets->pkt.size - len;
memmove(stream->Packets->pkt.data, &stream->Packets->pkt.data[len],
remaining);
memset(&stream->Packets->pkt.data[remaining], 0,
stream->Packets->pkt.size - remaining);
stream->Packets->pkt.size -= len;
}
else
{
struct PacketList *self;
self = stream->Packets;
stream->Packets = self->next;
av_free_packet(&self->pkt);
av_free(self);
}
if(size == 0)
goto next_packet;
/* Set the output buffer size */
stream->DecodedDataSize = size;
if(length) *length = stream->DecodedDataSize;
return stream->DecodedData;
}
int main(int argc, char *argv[]) {
/* Initialize variables used by the Agent thread */
int p;
int a, aprime;
float s[DECAY_COUNT], sprime[DECAY_COUNT];
int reward;
int tile_array[feature_count];
unsigned int i;
double delta;
double Q[ACTION_COUNT];
// Learning parameters
double stepsize = 0.1 / (float) num_tilings;
double lambda = 0.9;
double gamma = 0.9;
struct sigaction act;
struct sigaction oldact;
act.sa_handler = endProgram;
sigemptyset(&act.sa_mask);
act.sa_flags = 0;
sigaction(SIGINT, &act, &oldact);
srand(0);
pthread_mutex_init(&pktNumMutex, NULL);
pthread_mutex_init(&actionMutex, NULL);
pthread_mutex_init(&rewardMusicMutex, NULL);
trajectoryFile.open("trajectory.txt");
if(!trajectoryFile.is_open())
printf("Trajectory file could not be opened.\n");
/* Set up variables used by individual policy components */
// --- begin initialize variables for Tians code
timeStep = 0;
leftCount=0, rightCount =0;
diff = 0;
actionToTake = 1;
count = 0;
alignPhase = 1;
notInRightMode = false;
// --- end initialize variables for Tians code
// --- begin initialize variables for Amirs code
cwTurn = 1;
// --- end initialize variables for Amirs code
// initialize weights
// first try to read the weight file and if there is no file, then initialize randomly
if(!read_weights(weights)){
for (i = 0; i < memory_size; i++) {
weights[i] = -100.0/num_tilings;
}
}
for (i = 0; i < memory_size; i++) {
e[i] = 0;
}
// Set up timing + packet number
p = pktNum;
// State based on IR byte
s[0] = redDecay;
s[1] = greenDecay;
s[2] = bumpDecay;
s[3] = leftDecay;
s[4] = rightDecay;
s[5] = forwardDecay;
s[6] = backwardDecay;
s[7] = stopDecay;
s[8] = chargeDecay;
a = sAPrime[p];//epsilonGreedy(weights, s, epsilon);
// Use a lock to ensure action is changed separately
pthread_mutex_lock( &actionMutex );
action = a; // sets up action to be taken by csp thread
pthread_mutex_unlock( &actionMutex );
prevPktNum = myPktNum;
// Main agent loop
while (TRUE) {
int rval = getNextPacket();
if (rval == -1) {
write_weights(weights);
printf("Complete! Weights saved to weights.txt. Ran %d episodes.", episode + 1);
break;
} else if (rval == 1) {
// Episode complete
for (i = 0; i < memory_size; i++) {
e[i] = 0;
}
episode++;
}
// Get the packet number
p = pktNum;
// Update decays
updateDecay(p, prevPktNum, myPktNum);
//printf("ir: %d\n", sIRbyte[p]);
// Reward of -1 per step
reward = -1;
// Determine the next observation
// TODO: Change this to new state representation
sprime[0] = redDecay;
sprime[1] = greenDecay;
sprime[2] = bumpDecay;
sprime[3] = leftDecay;
sprime[4] = rightDecay;
sprime[5] = forwardDecay;
sprime[6] = backwardDecay;
sprime[7] = stopDecay;
sprime[8] = chargeDecay;
aprime = sAPrime[p];//epsilonGreedy(weights, sprime, epsilon);
// Set action variable
pthread_mutex_lock( &actionMutex );
action = aprime; // sets up action to be taken by csp thread
pthread_mutex_unlock( &actionMutex );
// Get Q values
getQ(Q, s, weights, num_tilings, memory_size);
delta = reward - Q[a];
getQ(Q, sprime, weights, num_tilings, memory_size);
delta += gamma * Q[aprime];
// Update weights
get_tiles(s, a, tile_array, num_tilings, memory_size);
for (i = 0; i < feature_count; i++) {
e[tile_array[i]] = 1;
}
//printf("Docking: s a r s' a':%d %d %d %d %d\n", s, a, reward, sprime, aprime);
for (i = 0; i < memory_size; i++ ) {
weights[i] += stepsize * delta * e[i];
e[i] *= lambda;
}
// Decay sensor traces
performDecay();
for (i = 0; i < DECAY_COUNT; i++) {
s[i] = sprime[i];
}
a = aprime;
prevPktNum = myPktNum;
}
return 0;
}
