// This tells the PixelIop what channels to get to calculate a given // set of output channels. In order to calculate any color channel, it // needs all the color channels, because red (for instance) depends on // the green and blue. void in_channels(int input_number, ChannelSet& channels) const { // Must turn on the other color channels if any color channels are requested: ChannelSet done; foreach (z, channels) { if (colourIndex(z) < 3) { // it is red, green, or blue if (!(done & z)) { // save some time if we already turned this on done.addBrothers(z, 3); // add all three to the "done" set } } } channels += done; // add the colors to the channels we need }
void HttpClientHandler::MessageReceived(ChannelHandlerContext& ctx, MessageEvent<HTTPMessage>& e) { g_recved_res++; g_ratio_recved_res++; m_request_sent = false; if (!g_options.keepAlive) { ctx.GetChannel()->Close(); g_all_channels.erase(this); } else { g_ready_channels.insert(this); } try_send_request(); }
void writeProgagationSection(std::ostream& out, Config& config, ChannelSet& channels) { out << "# Propagation" << std::endl; for (size_t i=0; i<channels.size(); i++) { std::stringstream channel; channel << "[" << i << "]"; out << config.getParameter( std::string("PROPAGATION-CHANNEL-FREQUENCY") + channel.str()) << std::endl; out << config.getParameter( std::string("PROPAGATION-LIMIT") + channel.str()) << std::endl; out << config.getParameter( std::string("PROPAGATION-PATHLOSS-MODEL") + channel.str()) << std::endl; out << config.getParameter( std::string("PROPAGATION-SHADOWING-MODEL") + channel.str()) << std::endl; out << config.getParameter( std::string("PROPAGATION-SHADOWING-MEAN") + channel.str()) << std::endl; out << config.getParameter( std::string("PROPAGATION-FADING-MODEL") + channel.str()) << std::endl; out << std::endl; } }
void HttpClientHandler::ChannelConnected(ChannelHandlerContext& ctx, ChannelStateEvent& e) { m_connected = true; m_client = ctx.GetChannel(); g_ready_channels.insert(this); try_send_request(); }
void StatisticsFilter::LoadChannelSets( const Context& ioContext ) const { typedef ChannelSetSource::ChannelSet ChannelSet; typedef map<string, ChannelSet> ChannelSetContainer; ChannelSetContainer sets; const SignalProperties& Input = ioContext.signal->Properties(); const ParamRef& ChannelSets = Parameter( "ChannelSets" ); for( int i = 0; i < ChannelSets->NumRows(); ++i ) { string name = ChannelSets->RowLabels()[i], definition; for( int j = 0; j < ChannelSets->NumColumns(); ++j ) definition += string( ChannelSets( i, j ) ) + " "; istringstream iss( definition ); string entry; ChannelSet channelSet; while( iss >> ws >> entry ) { if( sets.find( entry ) != sets.end() ) { // A channel list with that name exists, copy it. for( size_t i = 0; i < sets[entry].size(); ++i ) channelSet.push_back( sets[entry][i] ); } else { IndexList s( entry, Input.ChannelLabels(), Input.ChannelUnit() ); string errors = s.Errors(); if( errors.empty() && s.Empty() ) errors = "entry \"" + entry + "\" does not match any channel"; if( errors.empty() ) for( int i = 0; i < s.Size(); ++i ) channelSet.push_back( static_cast<int>( s[i] ) ); else bcierr << "Channel set \"" << name << "\": " << errors; } } if( channelSet.empty() ) bcierr << "Empty channel set \"" << name << "\"" << endl; else sets[name] = channelSet; } for( ChannelSetContainer::const_iterator i = sets.begin(); i != sets.end(); ++i ) ioContext.sources->Add( new ChannelSetSource( i->first, i->second ) ); }
static void http_pipeline_init(ChannelPipeline* pipeline, void* data) { pipeline->AddLast("encoder", new HTTPMessageEncoder()); pipeline->AddLast("decoder", new HTTPMessageDecoder(false)); HttpClientHandler* handler = new HttpClientHandler; handler->m_client = (Channel*) data; pipeline->AddLast("handler", handler); g_all_channels.insert(handler); }
void HttpClientHandler::ChannelClosed(ChannelHandlerContext& ctx, ChannelStateEvent& e) { g_ready_channels.erase(this); g_all_channels.erase(this); if (!m_connected) { WARN_LOG( "Connect %s:%u failed!", g_options.host.c_str(), g_options.port); } try_send_request(); if (m_request_sent) { g_unanwsered_requests++; if (g_unanwsered_requests % 10000 == 0) { INFO_LOG("Recv %d xres.", g_unanwsered_requests); } } }
static int try_send_request() { if (g_limit > 0 && g_sent_count >= g_limit) { stop_serv(); return 0; } uint64 now = get_current_monotonic_millis(); if (g_tp10ms > 0 && g_count_in_10msperiod >= g_tp10ms) { if (g_period_task_id == -1) { if (g_count_in_1speriod >= g_options.tps) { uint64 delay_1s = 0; if (now >= g_1s_transc_start_time + 1000) { delay_1s = 0; } else { delay_1s = (g_1s_transc_start_time + 1000) - now; } g_period_task_id = g_serv->GetTimer().ScheduleHeapTask( make_fun_runnable(start_1s_period_task, true), delay_1s, -1); } else { uint64 delay_10ms = 0; if (now >= g_10ms_transc_start_time + 10) { delay_10ms = 0; } else { delay_10ms = (g_10ms_transc_start_time + 10) - now; } g_period_task_id = g_serv->GetTimer().ScheduleHeapTask( make_fun_runnable(start_10ms_period_task, true), delay_10ms, -1); } } return 0; } if (!g_ready_channels.empty()) { ChannelSet::iterator it = g_ready_channels.begin(); HttpClientHandler* client = *it; client->m_request_sent = true; Buffer& data = get_request_data(); client->m_client->Write(data); data.SetReadIndex(0); g_ready_channels.erase(it); g_count_in_10msperiod++; g_sent_count++; g_ratio_sent_req++; g_count_in_1speriod++; return 1; } else { if (g_all_channels.size() < g_options.concurrentConns) { http_client_connect(g_options.host.c_str(), g_options.port); } } return 0; }
void execute() { const int chanCount = num_channels(); ChannelSet channels = channel_mask(chanCount); const bool doAlpha = channels.contains(Chan_Alpha); iop->progressMessage("Preparing image"); input0().request(0, 0, width(), height(), channels, 1); if (aborted()) return; ImageSpec srcSpec(width(), height(), chanCount, TypeDesc::FLOAT); ImageBuf srcBuffer(srcSpec); Row row(0, width()); // Buffer for a channel-interleaved row after output LUT processing std::vector<float> lutBuffer(width() * chanCount); for (int y = 0; y < height(); y++) { iop->progressFraction(double(y) / height() * 0.85); get(height() - y - 1, 0, width(), channels, row); if (aborted()) return; const float* alpha = doAlpha ? row[Chan_Alpha] : NULL; for (int i = 0; i < chanCount; i++) to_float(i, &lutBuffer[i], row[channel(i)], alpha, width(), chanCount); for (int x = 0; x < width(); x++) srcBuffer.setpixel(x, y, &lutBuffer[x * chanCount]); } ImageSpec destSpec(width(), height(), chanCount, oiioBitDepths[bitDepth_]); setChannelNames(destSpec, channels); destSpec.attribute("maketx:filtername", gFilterNames[filter_]); switch (preset_) { case 0: destSpec.attribute("maketx:oiio_options", 1); break; case 1: destSpec.attribute("maketx:prman_options", 1); break; default: destSpec.tile_width = tileW_; destSpec.tile_height = tileH_; destSpec.attribute("planarconfig", planarMode_ ? "separate" : "contig"); break; } if (fixNan_) { if (nanFixType_) destSpec.attribute("maketx:fixnan", "box3"); else destSpec.attribute("maketx:fixnan", "black"); } else destSpec.attribute("maketx:fixnan", "none"); destSpec.attribute("maketx:checknan", checkNan_); destSpec.attribute("maketx:verbose", verbose_); destSpec.attribute("maketx:stats", stats_); OIIO::attribute("threads", (int)Thread::numCPUs); if (aborted()) return; iop->progressMessage("Writing %s", filename()); if (!ImageBufAlgo::make_texture(oiiotxMode[txMode_], srcBuffer, filename(), destSpec, &std::cout)) iop->critical("ImageBufAlgo::make_texture failed to write file %s", filename()); }
void _validate(bool for_real) { // do we need to open a port? if ( m_server.isConnected()==false && !m_inError && m_legit ) changePort(m_port); if (m_stat.progress > 0) status(m_stat.progress, m_stat.ram, m_stat.p_ram, m_stat.time); // handle any connection error if ( m_inError ) error(m_connectionError.c_str()); // setup format etc info_.format(*m_fmtp.fullSizeFormat()); info_.full_size_format(*m_fmtp.format()); // add aovs as nuke channels std::string rgba = "RGBA"; std::string z = "Z"; std::string n = "N"; std::string p = "P"; for(std::vector<std::string>::iterator it = m_aovs.begin(); it != m_aovs.end(); ++it) { if (it->compare(rgba)==0) { if (!m_channels.contains(Chan_Red)) { m_channels.insert(Chan_Red); m_channels.insert(Chan_Green); m_channels.insert(Chan_Blue); m_channels.insert(Chan_Alpha); } } else if (it->compare(z)==0) { if (!m_channels.contains(Chan_Z)) m_channels.insert( Chan_Z ); } else if (it->compare(n)==0 || it->compare(p)==0) { if (!m_channels.contains(channel((boost::format("%s.X")%it->c_str()).str().c_str()))) { m_channels.insert( channel((boost::format("%s.X")%it->c_str()).str().c_str()) ); m_channels.insert( channel((boost::format("%s.Y")%it->c_str()).str().c_str()) ); m_channels.insert( channel((boost::format("%s.Z")%it->c_str()).str().c_str()) ); } } else { if (!m_channels.contains( channel((boost::format("%s.red")%it->c_str()).str().c_str()))) { m_channels.insert( channel((boost::format("%s.red")%it->c_str()).str().c_str()) ); m_channels.insert( channel((boost::format("%s.blue")%it->c_str()).str().c_str()) ); m_channels.insert( channel((boost::format("%s.green")%it->c_str()).str().c_str()) ); } } } info_.channels( m_channels ); info_.set(info().format()); }