void ForwardEntity::start(std::string host, std::string highPort, std::string streamerPort) {
std::cout << "FE Started" << std::endl;
pFlowTable table(new FlowTable);
// std::unique_ptr<ComuactivClientSlot> slot(new ComuactivClientSlot(host, highPort, table));
ComuactivClientSlot slot(host, highPort, table);
UDPStreamer streamer(streamerPort, table);
}
/* LISTING_START(packetHandler): Packet Handler */
static void packet_handler (uint8_t packet_type, uint16_t channel, uint8_t *packet, uint16_t size){
int mtu;
switch (packet_type) {
case HCI_EVENT_PACKET:
switch (packet[0]) {
case HCI_EVENT_DISCONNECTION_COMPLETE:
le_notification_enabled = 0;
break;
case HCI_EVENT_LE_META:
switch (packet[2]) {
case HCI_SUBEVENT_LE_CONNECTION_COMPLETE:
test_data_len = ATT_DEFAULT_MTU - 3;
conn_handle = READ_BT_16(packet, 4);
// min con interval 20 ms
// res = gap_update_connection_parameters(conn_handle, 0x10, 0x10, 0, 0x0048);
// l2cap_le_request_connection_parameter_update(conn_handle, 0x10, 0x18, 0, 0x0048);
// printf("Connected, requesting conn param update for handle 0x%04x\n", conn_handle);
break;
}
break;
case ATT_MTU_EXCHANGE_COMPLETE:
mtu = READ_BT_16(packet, 4) - 3;
printf("ATT MTU = %u\n", mtu);
test_data_len = mtu - 3;
break;
}
}
// try sending whenever something happens
streamer();
}
int main(int argc, char** argv) {
checkOptions(options, argc, argv);
HumdrumStream streamer(options);
HumdrumFile infile;
if (summaryQ) {
Summary.setSize(1000);
Summary.setAll(0);
}
while (streamer.read(infile)) {
if (!streamer.eof()) {
// if there are multiple segments, store a segement marker
// for each segment. Do not store if only a single segment,
// unless --segement option is given.
SEGMENTS = 1;
}
processFile(infile, infile.getFileName());
}
if (summaryQ) {
printSummary(Summary);
}
return 0;
}
int main(int argc, char** argv)
{
Streamer streamer(argc, argv);
streamer.start();
return 0;
}
void WebVideoServer::handle_snapshot(const http_server::HttpRequest &request,
http_server::HttpConnectionPtr connection)
{
boost::shared_ptr<ImageStreamer> streamer(new JpegSnapshotStreamer(request, connection, image_transport_));
streamer->start();
boost::mutex::scoped_lock lock(subscriber_mutex_);
image_subscribers_.push_back(streamer);
}
int main(int argc, char** argv) {
// process the command-line options
checkOptions(options, argc, argv);
HumdrumStream streamer(options);
HumdrumFile hfile;
if (!streamer.read(hfile)) {
// no data could be read
exit(1);
}
hfile.analyzeRhythm("4");
printOutput(hfile);
return 0;
}
StreamerPtr OpenCVStreamerService::createStreamer(QDomElement root)
{
StringMap args = ImageStreamerOpenCVArguments().convertToCommandLineArguments(root);
StreamerPtr localServerStreamer = LocalServerStreamer::createStreamerIfEnabled(root, args);
if (localServerStreamer)
{
return localServerStreamer;
}
else
{
boost::shared_ptr<ImageStreamerOpenCV> streamer(new ImageStreamerOpenCV());
streamer->initialize(args);
return streamer;
}
}
bool SoundAsset::Load(const char* absolutePath, drfs_context* pVFS)
{
// For now we are just going to load a streamer and retrieve the information about the buffer. Later on we'll clean this up and do it properly.
m_dataInfo.pData = drfs_open_and_read_binary_file(pVFS, absolutePath, &m_dataInfo.dataSize);
if (m_dataInfo.pData != nullptr)
{
SoundStreamer streamer(m_dataInfo.pData, m_dataInfo.dataSize);
if (streamer.Initialize())
{
m_dataInfo.format = streamer.GetFormat();
m_dataInfo.channels = streamer.GetNumChannels();
m_dataInfo.sampleRate = streamer.GetSampleRate();
return true;
}
}
return false;
}
void EchoClient::start(int c)
{
ClientEchoPacketFactory factory;
tbnet::DefaultPacketStreamer streamer(&factory);
ClientEchoPacketHandler handler;
Connection **cons = (Connection**) malloc(c*sizeof(Connection*));
for (int i = 0; i < c ; ++c) {
cons[i] = transport.connect(_spec, &streamer, true);
if (cons[i] == NULL) {
TBSYS_LOG(ERROR, "connection error..");
return;
}
cons[i]->setDefaultPacketHandler(&handler);
cons[i]->setQueueLimit(500);
}
transport.start();
char buffer[DATA_MAX_SIZE + 1];
int sendcount = 0;
int pid = getpid();
TBSYS_LOG(INFO, "PID: %d", pid);
for (int i = 0; i < gsendcount; ++i) {
int len = 1988;
sprintf(buffer, "%010d_%010d", pid, i);
memset(buffer+21, 'a', len-21);
buffer[len] = '\0';
ClientEchoPacket *packet = new ClientEchoPacket();
packet->setIndex(i);
packet->setString(buffer);
if (!cons[i%c]->postPacket(packet, NULL, packet)) {
break;
}
gsendlen += len;
sendcount ++;
}
gsendcount = sendcount;
TBSYS_LOG(ERROR, "send finish.");
transport.wait();
free(cons);
}
StreamerPtr ImageFileStreamerService::createStreamer(QDomElement root)
{
// std::cout << "filecontent create streamer\n" << root.ownerDocument().toString().toStdString() << std::endl;
StringMap args = ImageStreamerDummyArguments().convertToCommandLineArguments(root);
StreamerPtr localServerStreamer = LocalServerStreamer::createStreamerIfEnabled(root, args);
if (localServerStreamer)
{
return localServerStreamer;
}
else
{
boost::shared_ptr<DummyImageStreamer> streamer(new DummyImageStreamer());
QString filename = ImageStreamerDummyArguments().getFilenameOption(root)->getValue();
bool secondary = ImageStreamerDummyArguments().getSecondaryOption(root)->getValue();
streamer->initialize(filename, secondary);
return streamer;
}
}
float getNormals(Eigen::Vector3f& a,Eigen::Vector3f& b,Eigen::Vector3f& c,std::string path)
{
std::ifstream file(path.c_str());
std::string line;
std::string words;
float value;
float normals[3][3];
std::getline(file,line);
std::istringstream streamer(line);
streamer>>words;
if(words.compare("VALUE")==0){
std::string nextline;
std::getline(file,nextline);
std::istringstream valuestream(nextline);
valuestream>>value;
}
void DEFAULTPACKETSTREAMERTF::testGetPacketInfo() {
DataBuffer buffer;
PacketHeader header;
DefaultPacketStreamer streamer(NULL);
bool broken;
buffer.writeInt32(ANET_PACKET_FLAG);
buffer.writeInt32(1111);
buffer.writeInt32(2222);
buffer.writeInt32(-1);
buffer.writeBytes("data for test", 16);
CPPUNIT_ASSERT(!streamer.getPacketInfo(&buffer, &header, &broken));
CPPUNIT_ASSERT_EQUAL(1111, (int)header._chid);
CPPUNIT_ASSERT_EQUAL(2222, (int)header._pcode);
CPPUNIT_ASSERT_EQUAL(-1, (int)header._dataLen);
CPPUNIT_ASSERT(broken);
buffer.drainData(buffer.getDataLen());
streamer._existPacketHeader = false;
CPPUNIT_ASSERT(!streamer.getPacketInfo(&buffer, &header, &broken));
}
ResourceStreamer WateringManImg::GetStream()
{
ResourceStreamer streamer(imageData, sizeof(imageData));
return streamer;
}
static void handle_gatt_client_event(uint8_t packet_type, uint16_t channel, uint8_t *packet, uint16_t size){
UNUSED(packet_type);
UNUSED(channel);
UNUSED(size);
uint16_t mtu;
switch(state){
case TC_W4_SERVICE_RESULT:
switch(hci_event_packet_get_type(packet)){
case GATT_EVENT_SERVICE_QUERY_RESULT:
// store service (we expect only one)
gatt_event_service_query_result_get_service(packet, &le_streamer_service);
break;
case GATT_EVENT_QUERY_COMPLETE:
if (packet[4] != 0){
printf("SERVICE_QUERY_RESULT - Error status %x.\n", packet[4]);
gap_disconnect(connection_handle);
break;
}
// service query complete, look for characteristic
state = TC_W4_CHARACTERISTIC_RX_RESULT;
printf("Search for LE Streamer RX characteristic.\n");
gatt_client_discover_characteristics_for_service_by_uuid128(handle_gatt_client_event, connection_handle, &le_streamer_service, le_streamer_characteristic_rx_uuid);
break;
default:
break;
}
break;
case TC_W4_CHARACTERISTIC_RX_RESULT:
switch(hci_event_packet_get_type(packet)){
case GATT_EVENT_CHARACTERISTIC_QUERY_RESULT:
gatt_event_characteristic_query_result_get_characteristic(packet, &le_streamer_characteristic_rx);
break;
case GATT_EVENT_QUERY_COMPLETE:
if (packet[4] != 0){
printf("CHARACTERISTIC_QUERY_RESULT - Error status %x.\n", packet[4]);
gap_disconnect(connection_handle);
break;
}
// rx characteristiic found, look for tx characteristic
state = TC_W4_CHARACTERISTIC_TX_RESULT;
printf("Search for LE Streamer TX characteristic.\n");
gatt_client_discover_characteristics_for_service_by_uuid128(handle_gatt_client_event, connection_handle, &le_streamer_service, le_streamer_characteristic_tx_uuid);
break;
default:
break;
}
break;
case TC_W4_CHARACTERISTIC_TX_RESULT:
switch(hci_event_packet_get_type(packet)){
case GATT_EVENT_CHARACTERISTIC_QUERY_RESULT:
gatt_event_characteristic_query_result_get_characteristic(packet, &le_streamer_characteristic_tx);
break;
case GATT_EVENT_QUERY_COMPLETE:
if (packet[4] != 0){
printf("CHARACTERISTIC_QUERY_RESULT - Error status %x.\n", packet[4]);
gap_disconnect(connection_handle);
break;
}
// register handler for notifications
listener_registered = 1;
gatt_client_listen_for_characteristic_value_updates(¬ification_listener, handle_gatt_client_event, connection_handle, &le_streamer_characteristic_tx);
// setup tracking
le_streamer_connection.name = 'A';
le_streamer_connection.test_data_len = ATT_DEFAULT_MTU - 3;
test_reset(&le_streamer_connection);
gatt_client_get_mtu(connection_handle, &mtu);
le_streamer_connection.test_data_len = btstack_min(mtu - 3, sizeof(le_streamer_connection.test_data));
printf("%c: ATT MTU = %u => use test data of len %u\n", le_streamer_connection.name, mtu, le_streamer_connection.test_data_len);
// enable notifications
#if (TEST_MODE & TEST_MODE_ENABLE_NOTIFICATIONS)
printf("Start streaming - enable notify on test characteristic.\n");
state = TC_W4_ENABLE_NOTIFICATIONS_COMPLETE;
gatt_client_write_client_characteristic_configuration(handle_gatt_client_event, connection_handle,
&le_streamer_characteristic_tx, GATT_CLIENT_CHARACTERISTICS_CONFIGURATION_NOTIFICATION);
break;
#endif
state = TC_W4_TEST_DATA;
#if (TEST_MODE & TEST_MODE_WRITE_WITHOUT_RESPONSE)
printf("Start streaming - request can send now.\n");
gatt_client_request_can_write_without_response_event(handle_gatt_client_event, connection_handle);
#endif
break;
default:
break;
}
break;
case TC_W4_ENABLE_NOTIFICATIONS_COMPLETE:
switch(hci_event_packet_get_type(packet)){
case GATT_EVENT_QUERY_COMPLETE:
printf("Notifications enabled, status %02x\n", gatt_event_query_complete_get_status(packet));
state = TC_W4_TEST_DATA;
#if (TEST_MODE & TEST_MODE_WRITE_WITHOUT_RESPONSE)
printf("Start streaming - request can send now.\n");
gatt_client_request_can_write_without_response_event(handle_gatt_client_event, connection_handle);
#endif
break;
default:
break;
}
break;
case TC_W4_TEST_DATA:
switch(hci_event_packet_get_type(packet)){
case GATT_EVENT_NOTIFICATION:
test_track_data(&le_streamer_connection, gatt_event_notification_get_value_length(packet));
break;
case GATT_EVENT_QUERY_COMPLETE:
break;
case GATT_EVENT_CAN_WRITE_WITHOUT_RESPONSE:
streamer(&le_streamer_connection);
break;
default:
printf("Unknown packet type %x\n", hci_event_packet_get_type(packet));
break;
}
break;
default:
printf("error\n");
break;
}
}
