/// 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; }