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