예제 #1
0
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);
}
예제 #2
0
/* 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();
}
예제 #3
0
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;
}
예제 #4
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);
}
예제 #6
0
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;
	}
}
예제 #8
0
    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;
    }
예제 #9
0
파일: EChoClient.cpp 프로젝트: szqh97/test
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);
}
예제 #10
0
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;
	}
}
예제 #11
0
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;
	}
예제 #12
0
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;
}
예제 #14
0
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(&notification_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;
    }
    
}