/* 'pos' parameter is in milliseconds. */ int video_seek(int pos, int flags) { gint64 len, cur; GstFormat fmt = GST_FORMAT_TIME; GstElement *sink = get_sink(); if (!sink) return VIDEO_ERROR; if (!(gst_element_query(sink, GST_QUERY_POSITION, &fmt, &cur) && gst_element_query(sink, GST_QUERY_TOTAL, &fmt, &len))) return VIDEO_ERROR; if (flags & VIDEO_SEEK_RELATIVE) cur += pos * GST_SECOND; else cur = pos * GST_SECOND; if (cur >= len) return video_stop(); if (cur <= 0) cur = 0; if (!gst_element_seek( sink, GST_SEEK_METHOD_SET | GST_SEEK_FLAG_FLUSH | GST_FORMAT_TIME, cur)) return VIDEO_ERROR; return VIDEO_OK; }
void sink_manager_heartbeat(ip_t ip, uint8_t *buf) { sink_t *sink = get_sink(ip); if (sink != NULL) { sink->last_heartbeat = util_time_now(); } else { sink_t new_sink; if (sink_initialize(&new_sink, ip, buf) != RET_OK) { return; } new_sink.last_heartbeat = util_time_now(); add_sink(new_sink); } purge_dead_sinks(); }
int video_get_pos_frames(unsigned long *_pos, unsigned long *_len) { gint64 len, pos; GstFormat fmt = GST_FORMAT_DEFAULT; GstElement *sink = get_sink(); if (!sink) return VIDEO_ERROR; if (gst_element_query (sink, GST_QUERY_POSITION, &fmt, &pos) && gst_element_query (sink, GST_QUERY_TOTAL, &fmt, &len)) { *_pos = pos; *_len = len; return VIDEO_OK; } return VIDEO_ERROR; }
int video_get_pos_msec(unsigned long *_pos, unsigned long *_len) { gint64 len, pos; GstFormat fmt = GST_FORMAT_TIME; GstElement *sink = get_sink(); if (!sink) return VIDEO_ERROR; if (gst_element_query (sink, GST_QUERY_POSITION, &fmt, &pos) && gst_element_query (sink, GST_QUERY_TOTAL, &fmt, &len)) { *_pos = ((pos) / GST_MSECOND); *_len = ((len) / GST_MSECOND); return VIDEO_OK; } return VIDEO_ERROR; }
bool Traffic_source::send(void) { #ifdef DEBUG assert(can_send()); #endif pLink link = (pLink) get_sink(); pFlit a_flit = get_flit(); link->receive(a_flit); if ( a_flit->is_header() ) { // Mark the time at which the packet leaves the source queue pPacket current_packet = a_flit->get_packet(); current_packet->set_sent_time(net_clock.get_clock()); } // Congestion monitor if ( (src_monitoring) && (net_clock.get_clock() > param.warmup_period) ) { if (a_flit->is_tail()) { unsigned int prev = src_congestion_monitor.back(); src_congestion_monitor.push_back(net_clock.get_clock()); src_congestion_monitor.push_back(prev-packet_size); } // if (a_flit.. pPacket p = a_flit->get_packet(); int flit_type = 1; //assume header if (a_flit->is_tail()) flit_type = 3; //tail else if (!a_flit->is_header()) flit_type = 2; //body buffer_monitor.push_back(p->get_id()); buffer_monitor.push_back(a_flit->get_sequence_id()); buffer_monitor.push_back(flit_type); buffer_monitor.push_back(net_clock.get_clock()); buffer_monitor.push_back(0); buffer_monitor.push_back(p->get_src_position().x); buffer_monitor.push_back(p->get_src_position().y); buffer_monitor.push_back(p->get_dst_position().x); buffer_monitor.push_back(p->get_dst_position().y); buffer_monitor.push_back(buffer.get_num_of_flits()); } // Congestion monitor return true; }
int MFGraph::decompose(const int componentID, std::ostream & patt_stream, std::string chr) { IdMap<ListDigraph, ListDigraph::Node> idmap(mfGraph); // compute total flow float total_flow = this->total_flow(); #ifndef NDEBUG std::cout << "total flow:: " << total_flow << std::endl; #endif int flownum = 0; // iterate while residual flow while (total_flow > 0.00001) { // compute residual flow for each arc ListDigraph::ArcMap<float> residual_flow(mfGraph); for (ListDigraph::ArcIt arc(mfGraph); arc != INVALID; ++arc) { residual_flow[arc] = (total_flow - flow_map[arc]); if(flow_map[arc] != 0){ // #ifndef NDEBUG // std::cout << "source: " << mfGraph.id(mfGraph.source(arc))<< ", target: " << mfGraph.id(mfGraph.target(arc)) << ", flow: " << flow_map[arc] <<std::endl; // #endif } } #ifndef NDEBUG std::cout << "run the min-max dijkstra algorithm " << std::endl; #endif // run the min-max dijkstra algorithm ListDigraph::NodeMap<float> dist(mfGraph); Dijkstra<ListDigraph, ListDigraph::ArcMap<float> > ::SetOperationTraits<DijkstraMinMaxOperationTraits<float> > ::Create dijkstra(mfGraph, residual_flow); dijkstra.distMap(dist); dijkstra.run(source, sink); #ifndef NDEBUG std::cout << "get the resulting path and it's flow " << std::endl; #endif // get the resulting path and it's flow Path<ListDigraph> shortestPath = dijkstra.path(sink); float path_flow = total_flow - dijkstra.dist(sink); // break out if this is not a valid path if (path_flow == 0) { #ifndef NDEBUG std::cout << "Found invalid path" << std::endl; #endif break; } // construct a meth fragment from path here // and remove path flow from each arc in path #ifndef NDEBUG std::cout << "dijkstra.dist: " << dijkstra.dist(sink) << ", path_flow:" << path_flow << ", total flow: " << total_flow << " length: " << shortestPath.length() << std::endl; #endif // it's a valid pattern, so increase number of paths found flownum++; std::stringstream region_list; MethylRead* pattern = NULL; int start, end; //MethylRead pattern = MethylRead(*read_map[source]); //int start = read_map[source]->start(); //int end = read_map[sink]->end(); for(Path<ListDigraph>::ArcIt arc(shortestPath); arc != INVALID; ++arc) { ListDigraph::Node s = mfGraph.source(arc); ListDigraph::Node t = mfGraph.target(arc); if (s == source) { pattern = new MethylRead(*read_map[t]); start = read_map[t]->start(); end = read_map[t]->end(); // end = read_map[sink]->end(); #ifndef NDEBUG std::cout << "Original pattern = " << pattern->getMethString() << std::endl; #endif break; } } #ifndef NDEBUG if (!pattern) { std::cout << "We should not hit this" << std::endl; for (Path<ListDigraph>::ArcIt arc(shortestPath); arc != INVALID; ++arc) { ListDigraph::Node s = mfGraph.source(arc); ListDigraph::Node t = mfGraph.target(arc); std::cout << mfGraph.id(s) << " -> " << mfGraph.id(t) << std::endl; } } #endif for(Path<ListDigraph>::ArcIt arc(shortestPath); arc != INVALID; ++arc) { // #ifndef NDEBUG // std::cout << " After finding a path, " << "source: " << mfGraph.id(mfGraph.source(arc))<< ", target: " << mfGraph.id(mfGraph.target(arc)) << ", flow: " << flow_map[arc] << " ,arc - pathFlow: " << flow_map[arc] - path_flow << std::endl; // #endif ListDigraph::Node s = mfGraph.source(arc); ListDigraph::Node t = mfGraph.target(arc); MethylRead *read = read_map[t]; // don't print the source node or nodes connected to sink if (s != source && t != get_sink()) { region_list << idmap[s]; if (!childless[t]) { region_list << ","; } } flow_map[arc] -= path_flow; // delete arc if no residual flow if (flow_map[arc] < 1e-6) { mfGraph.erase(arc); } if (s == source) { continue; } if (!read || t == get_sink()) { continue; } if (s != source && t != get_sink()) { pattern->merge(read); end = read->end(); //std::cout << "new pattern = " << pattern->getMethString() << std::endl; } // if (childless[t]) { // end = read->end(); // } } #ifndef NDEBUG std::cout << "new pattern = " << pattern->getMethString() << std::endl; #endif //Note we add source one nucleotide before every read patt_stream << chr << "\t" << start << "\t" << end; patt_stream << "\t" << componentID << "\t" << flownum << "\t" << path_flow; patt_stream << "\t" << pattern->getMethString() << "\t" << region_list.str() << std::endl; delete pattern; // recompute residual flow total_flow -= path_flow; } // all done return flownum; }
pConnector Traffic_source::get_receiver(void) const { pLink link = (pLink) get_sink(); return link->get_sink(); }