/* See if string is part of current argument list */
static void check_for_arg(char *name)
{
int i;
if (!is_arg(name))
return;
for (i = 0; i < arg_cnt; i++)
if (strcmp(arg_names[i], name) == 0)
return;
arg_names[arg_cnt++] = name;
}
void CmdLineOptions::add_optional(std::string const &name,
std::string const &description,
std::string const &default_value) {
std::unique_lock<std::mutex> l(mutex_);
if (is_arg(name) || is_switch(name)) {
throw OptionDefined();
}
std::string niceName(name);
trim(niceName);
argOptionList_.push_back(StringOption(niceName, description, default_value));
}
void CmdLineOptions::add_switch(std::string const &name,
std::string const &description,
bool default_setting) {
std::unique_lock<std::mutex> l(mutex_);
if (is_arg(name) || is_switch(name)) {
throw OptionDefined();
}
std::string niceName(name);
trim(niceName);
switchOptionList_.push_back(
BoolOption(niceName, description, default_setting));
}
void CmdLineOptions::add_required(std::string const &name,
std::string const &description) {
std::unique_lock<std::mutex> l(mutex_);
if (is_arg(name) || is_switch(name)) {
throw OptionDefined();
}
std::string niceName(name);
trim(niceName);
StringOption option(niceName, description, "");
option.set_required(true);
argOptionList_.push_back(option);
}
void CmdLineOptions::attach_validator(std::string const &arg_name,
CmdLineOptions::ValidatorFunction validator) {
std::unique_lock<std::mutex> l(mutex_);
if (!is_arg(arg_name)) {
throw UndefinedOption();
}
if (!validator) {
throw BadFunction();
}
ValidatorFunctionMap::iterator it = validatorFunctionMap_.find(arg_name);
if (it != validatorFunctionMap_.end()) {
it->second.push_back(validator);
} else {
ValidatorFunctionList list{validator};
std::pair<std::string, ValidatorFunctionList> validatorList
= std::make_pair(arg_name, list);
validatorFunctionMap_.insert(validatorList);
}
}
int main(int argc, char** argv) {
int i, retval;
bool one_pass = false;
check_stop_daemons();
for (i=1; i<argc; i++) {
if (is_arg(argv[i], "one_pass")) {
one_pass = true;
} else if (is_arg(argv[i], "d")) {
if (!argv[++i]) {
log_messages.printf(MSG_CRITICAL, "%s requires an argument\n\n", argv[--i]);
usage(argv[0]);
exit(1);
}
int dl = atoi(argv[i]);
log_messages.set_debug_level(dl);
if (dl == 4) g_print_queries = true;
} else if (is_arg(argv[i], "h") || is_arg(argv[i], "help")) {
usage(argv[0]);
exit(0);
} else if (is_arg(argv[i], "v") || is_arg(argv[i], "version")) {
printf("%s\n", SVN_VERSION);
exit(0);
} else {
log_messages.printf(MSG_CRITICAL, "unknown command line argument: %s\n\n", argv[i]);
usage(argv[0]);
exit(1);
}
}
retval = config.parse_file();
if (retval) {
log_messages.printf(MSG_CRITICAL,
"Can't parse config.xml: %s\n", boincerror(retval)
);
exit(1);
}
log_messages.printf(MSG_NORMAL, "Starting message handler\n");
install_stop_signal_handler();
main_loop(one_pass);
}
int main(int argc, char** argv) {
int i, retval;
char file_name[256];
int host_id;
host_id = 0;
strcpy(file_name, "");
check_stop_daemons();
for (i=1; i<argc; i++) {
if (is_arg(argv[i], "host_id")) {
if (!argv[++i]) {
fprintf(stderr, "%s requires an argument\n\n", argv[--i]);
usage(argv[0]);
exit(1);
}
host_id = atoi(argv[i]);
} else if (is_arg(argv[i], "file_name")) {
if (!argv[++i]) {
fprintf(stderr, "%s requires an argument\n\n", argv[--i]);
usage(argv[0]);
exit(1);
}
strcpy(file_name, argv[i]);
} else if (is_arg(argv[i], "help") || is_arg(argv[i], "h")) {
usage(argv[0]);
exit(0);
} else if (is_arg(argv[i], "version") || is_arg(argv[i], "v")) {
printf("%s\n", SVN_VERSION);
exit(0);
} else {
fprintf(stderr, "unknown command line argument: %s\n\n", argv[i]);
usage(argv[0]);
exit(1);
}
}
if (!strlen(file_name) || host_id == 0) {
usage(argv[0]);
exit(1);
}
retval = config.parse_file();
if (retval) {
fprintf(stderr, "Can't parse config.xml: %s\n", boincerror(retval));
exit(1);
}
retval = boinc_db.open(
config.db_name, config.db_host, config.db_user, config.db_passwd
);
if (retval) {
fprintf(stderr, "boinc_db.open failed: %s\n", boincerror(retval));
exit(1);
}
retval = create_delete_file_msg(host_id, file_name);
boinc_db.close();
return retval;
}
/* parse argument list. we assume that all unrecognized arguments are file names. */
void CommandLineInfo::ParseCommandLine(const WCHAR *cmdLine)
{
WStrVec argList;
ParseCmdLine(cmdLine, argList);
size_t argCount = argList.Count();
#define is_arg(txt) str::EqI(TEXT(txt), argument)
#define is_arg_with_param(txt) (is_arg(txt) && (argCount > n + 1))
#define additional_param() argList.At(n + 1)
#define has_additional_param() ((argCount > n + 1) && ('-' != additional_param()[0]))
#define handle_string_param(name) name.Set(str::Dup(argList.At(++n)))
#define handle_int_param(name) name = _wtoi(argList.At(++n))
for (size_t n = 1; n < argCount; n++) {
WCHAR *argument = argList.At(n);
if (is_arg("-register-for-pdf")) {
makeDefault = true;
exitImmediately = true;
return;
}
else if (is_arg("-silent")) {
// silences errors happening during -print-to and -print-to-default
silent = true;
}
else if (is_arg("-print-to-default")) {
printerName.Set(GetDefaultPrinterName());
if (!printerName)
printDialog = true;
exitWhenDone = true;
}
else if (is_arg_with_param("-print-to")) {
handle_string_param(printerName);
exitWhenDone = true;
}
else if (is_arg("-print-dialog")) {
printDialog = true;
}
else if (is_arg_with_param("-print-settings")) {
// argument is a comma separated list of page ranges and
// advanced options [even|odd] and [noscale|shrink|fit]
// e.g. -print-settings "1-3,5,10-8,odd,fit"
handle_string_param(printSettings);
str::RemoveChars(printSettings, L" ");
str::TransChars(printSettings, L";", L",");
}
else if (is_arg("-exit-when-done") || is_arg("-exit-on-print")) {
// only affects -print-dialog (-print-to and -print-to-default
// always exit on print) and -stress-test (useful for profiling)
exitWhenDone = true;
}
else if (is_arg_with_param("-inverse-search")) {
str::ReplacePtr(&gGlobalPrefs->inverseSearchCmdLine, argList.At(++n));
gGlobalPrefs->enableTeXEnhancements = true;
}
else if ((is_arg_with_param("-forward-search") ||
is_arg_with_param("-fwdsearch")) && argCount > n + 2) {
// -forward-search is for consistency with -inverse-search
// -fwdsearch is for consistency with -fwdsearch-*
handle_string_param(forwardSearchOrigin);
handle_int_param(forwardSearchLine);
}
else if (is_arg_with_param("-nameddest") || is_arg_with_param("-named-dest")) {
// -nameddest is for backwards compat (was used pre-1.3)
// -named-dest is for consistency
handle_string_param(destName);
}
else if (is_arg_with_param("-page")) {
handle_int_param(pageNumber);
}
else if (is_arg("-restrict")) {
restrictedUse = true;
}
else if (is_arg("-invertcolors") || is_arg("-invert-colors")) {
// -invertcolors is for backwards compat (was used pre-1.3)
// -invert-colors is for consistency
// -invert-colors used to be a shortcut for -set-color-range 0xFFFFFF 0x000000
// now it non-permanently swaps textColor and backgroundColor
gGlobalPrefs->fixedPageUI.invertColors = true;
}
else if (is_arg("-presentation")) {
enterPresentation = true;
}
else if (is_arg("-fullscreen")) {
enterFullScreen = true;
}
else if (is_arg_with_param("-view")) {
ParseViewMode(&startView, argList.At(++n));
}
else if (is_arg_with_param("-zoom")) {
ParseZoomValue(&startZoom, argList.At(++n));
}
else if (is_arg_with_param("-scroll")) {
ParseScrollValue(&startScroll, argList.At(++n));
}
else if (is_arg("-console")) {
showConsole = true;
}
else if (is_arg_with_param("-plugin")) {
// -plugin [<URL>] <parent HWND>
if (argCount > n + 2 && !str::IsDigit(*argList.At(n + 1)) && *argList.At(n + 2) != '-')
handle_string_param(pluginURL);
// the argument is a (numeric) window handle to
// become the parent of a frameless SumatraPDF
// (used e.g. for embedding it into a browser plugin)
hwndPluginParent = (HWND)_wtol(argList.At(++n));
}
else if (is_arg_with_param("-stress-test")) {
// -stress-test <file or dir path> [<file filter>] [<page/file range(s)>] [<cycle count>x]
// e.g. -stress-test file.pdf 25x for rendering file.pdf 25 times
// -stress-test file.pdf 1-3 render only pages 1, 2 and 3 of file.pdf
// -stress-test dir 301- 2x render all files in dir twice, skipping first 300
// -stress-test dir *.pdf;*.xps render all files in dir that are either PDF or XPS
handle_string_param(stressTestPath);
int num;
if (has_additional_param() && str::FindChar(additional_param(), '*'))
handle_string_param(stressTestFilter);
if (has_additional_param() && IsValidPageRange(additional_param()))
handle_string_param(stressTestRanges);
if (has_additional_param() && str::Parse(additional_param(), L"%dx%$", &num) && num > 0) {
stressTestCycles = num;
n++;
}
}
else if (is_arg_with_param("-n")) {
handle_int_param(stressParallelCount);
}
else if (is_arg("-rand")) {
stressRandomizeFiles = true;
}
else if (is_arg_with_param("-bench")) {
WCHAR *s = str::Dup(argList.At(++n));
pathsToBenchmark.Push(s);
s = NULL;
if (has_additional_param() && IsBenchPagesInfo(additional_param())) {
s = str::Dup(argList.At(++n));
}
pathsToBenchmark.Push(s);
exitImmediately = true;
} else if (is_arg("-crash-on-open")) {
// to make testing of crash reporting system in pre-release/release
// builds possible
crashOnOpen = true;
}
else if (is_arg("-reuse-instance")) {
// for backwards compatibility, -reuse-instance reuses whatever
// instance has registered as DDE server
reuseDdeInstance = true;
}
// TODO: remove the following deprecated options within a release or two
else if (is_arg("-esc-to-exit")) {
gGlobalPrefs->escToExit = true;
}
else if (is_arg_with_param("-bgcolor") || is_arg_with_param("-bg-color")) {
// -bgcolor is for backwards compat (was used pre-1.3)
// -bg-color is for consistency
ParseColor(&gGlobalPrefs->mainWindowBackground, argList.At(++n));
}
else if (is_arg_with_param("-lang")) {
lang.Set(str::conv::ToAnsi(argList.At(++n)));
}
else if (is_arg("-set-color-range") && argCount > n + 2) {
ParseColor(&gGlobalPrefs->fixedPageUI.textColor, argList.At(++n));
ParseColor(&gGlobalPrefs->fixedPageUI.backgroundColor, argList.At(++n));
}
else if (is_arg_with_param("-fwdsearch-offset")) {
handle_int_param(gGlobalPrefs->forwardSearch.highlightOffset);
gGlobalPrefs->enableTeXEnhancements = true;
}
else if (is_arg_with_param("-fwdsearch-width")) {
handle_int_param(gGlobalPrefs->forwardSearch.highlightWidth);
gGlobalPrefs->enableTeXEnhancements = true;
}
else if (is_arg_with_param("-fwdsearch-color")) {
ParseColor(&gGlobalPrefs->forwardSearch.highlightColor, argList.At(++n));
gGlobalPrefs->enableTeXEnhancements = true;
}
else if (is_arg_with_param("-fwdsearch-permanent")) {
handle_int_param(gGlobalPrefs->forwardSearch.highlightPermanent);
gGlobalPrefs->enableTeXEnhancements = true;
}
else if (is_arg_with_param("-manga-mode")) {
const WCHAR *s = argList.At(++n);
gGlobalPrefs->comicBookUI.cbxMangaMode = str::EqI(L"true", s) || str::Eq(L"1", s);
}
#if defined(SUPPORTS_AUTO_UPDATE) || defined(DEBUG)
else if (is_arg_with_param("-autoupdate")) {
n++; // this should have been handled already by AutoUpdateMain
}
#endif
#ifdef DEBUG
else if (is_arg("-enum-printers")) {
EnumeratePrinters();
/* this is for testing only, exit immediately */
exitImmediately = true;
return;
}
#endif
else {
// Remember this argument as a filename to open
WCHAR *filePath = NULL;
if (str::EndsWithI(argList.At(n), L".lnk"))
filePath = ResolveLnk(argList.At(n));
if (!filePath)
filePath = str::Dup(argList.At(n));
fileNames.Push(filePath);
}
}
#undef is_arg
#undef is_arg_with_param
#undef additional_param
#undef has_additional_param
#undef handle_string_param
#undef handle_int_param
}
int main(int argc, char** argv) {
int i, retval;
char path[MAXPATHLEN];
startup_time = time(0);
for (i=1; i<argc; i++) {
if (is_arg(argv[i], "one_pass")) {
one_pass = true;
} else if (is_arg(argv[i], "d")) {
if (!argv[++i]) {
log_messages.printf(MSG_CRITICAL, "%s requires an argument\n\n", argv[--i]);
usage(argv[0]);
exit(1);
}
int dl = atoi(argv[i]);
log_messages.set_debug_level(dl);
if (dl == 4) g_print_queries = true;
} else if (is_arg(argv[i], "mod")) {
if (!argv[i+1] || !argv[i+2]) {
log_messages.printf(MSG_CRITICAL, "%s requires two arguments\n\n", argv[i]);
usage(argv[0]);
exit(1);
}
mod_n = atoi(argv[++i]);
mod_i = atoi(argv[++i]);
do_mod = true;
} else if (is_arg(argv[i], "sleep_interval")) {
if (!argv[++i]) {
log_messages.printf(MSG_CRITICAL, "%s requires an argument\n\n", argv[--i]);
usage(argv[0]);
exit(1);
}
sleep_interval = atoi(argv[i]);
} else if (is_arg(argv[i], "h") || is_arg(argv[i], "help")) {
usage(argv[0]);
exit(0);
} else if (is_arg(argv[i], "v") || is_arg(argv[i], "version")) {
printf("%s\n", SVN_VERSION);
exit(0);
} else if (is_arg(argv[i], "wu_id")) {
wu_id = atoi(argv[++i]);
one_pass = true;
} else {
log_messages.printf(MSG_CRITICAL, "unknown command line argument: %s\n\n", argv[i]);
usage(argv[0]);
exit(1);
}
}
if (!one_pass) check_stop_daemons();
retval = config.parse_file();
if (retval) {
log_messages.printf(MSG_CRITICAL, "Can't parse config.xml: %s\n", boincerror(retval));
exit(1);
}
sprintf(path, "%s/upload_private", config.key_dir);
retval = read_key_file(path, key);
if (retval) {
log_messages.printf(MSG_CRITICAL, "can't read key\n");
exit(1);
}
log_messages.printf(MSG_NORMAL, "Starting\n");
install_stop_signal_handler();
main_loop();
}
int main(int argc, char *argv[])
{
if (argc < 3)
{
printf(
"AC3 Encoder\n"
"===========\n"
"This utility is a part of AC3Filter project (http://ac3filter.net)\n"
"Copyright (c) 2007-2009 by Alexander Vigovsky\n"
"\n"
"Usage:\n"
" ac3enc input.wav output.ac3 [-br:bitrate]\n"
);
return 1;
}
/////////////////////////////////////////////////////////
// Parse arguments
/////////////////////////////////////////////////////////
const char *input_filename = argv[1];
const char *output_filename = argv[2];
int bitrate = 448000;
for (int iarg = 3; iarg < argc; iarg++)
{
if (is_arg(argv[iarg], "br", argt_num))
{
bitrate = (int)arg_num(argv[iarg]);
continue;
}
printf("Error: unknown option: %s\n", argv[iarg]);
return 1;
}
/////////////////////////////////////////////////////////
// Open files
/////////////////////////////////////////////////////////
WAVSource src;
if (!src.open(input_filename, 65536))
{
printf("Cannot open file %s (not a PCM file?)\n", input_filename);
return 1;
}
RAWSink sink;
if (!sink.open(output_filename))
{
printf("Cannot open file %s for writing!\n", argv[2]);
return 1;
}
/////////////////////////////////////////////////////////
// Setup everything
/////////////////////////////////////////////////////////
Converter conv(2048);
AC3Enc enc;
FilterChain chain;
chain.add_back(&conv, "Converter");
chain.add_back(&enc, "Encoder");
conv.set_format(FORMAT_LINEAR);
conv.set_order(win_order);
if (!enc.set_bitrate(bitrate))
{
printf("Wrong bitrate (%i)!\n", bitrate);
return 1;
}
Speakers spk = src.get_output();
spk.format = FORMAT_LINEAR;
if (!enc.set_input(spk))
{
printf("Cannot encode this file (%s %iHz)!\n", spk.sample_rate);
return 1;
}
/////////////////////////////////////////////////////////
// Process
/////////////////////////////////////////////////////////
Chunk raw_chunk;
Chunk ac3_chunk;
CPUMeter cpu_usage;
CPUMeter cpu_total;
double ms = 0;
double old_ms = 0;
cpu_usage.start();
cpu_total.start();
fprintf(stderr, "0.0%% Frs/err: 0/0\tTime: 0:00.000i\tFPS: 0 CPU: 0%%\r");
int frames = 0;
while (!src.is_empty())
{
if (!src.get_chunk(&raw_chunk))
{
printf("Data load error!\n");
return 1;
}
if (!chain.process(&raw_chunk))
{
printf("Encoding error!\n");
return 1;
}
while (!chain.is_empty())
{
if (!chain.get_chunk(&ac3_chunk))
{
printf("Encoding error!\n");
return 1;
}
sink.process(&ac3_chunk);
frames++;
/////////////////////////////////////////////////////
// Statistics
ms = double(cpu_total.get_system_time() * 1000);
if (ms > old_ms + 100)
{
old_ms = ms;
// Statistics
fprintf(stderr, "%2.1f%% Frames: %i\tTime: %i:%02i.%03i\tFPS: %i CPU: %.1f%% \r",
double(src.pos()) * 100.0 / src.size(),
frames,
int(ms/60000), int(ms) % 60000/1000, int(ms) % 1000,
int(frames * 1000 / (ms+1)),
cpu_usage.usage() * 100);
} // if (ms > old_ms + 100)
}
}
fprintf(stderr, "%2.1f%% Frames: %i\tTime: %i:%02i.%03i\tFPS: %i CPU: %.1f%% \n",
double(src.pos()) * 100.0 / src.size(),
frames,
int(ms/60000), int(ms) % 60000/1000, int(ms) % 1000,
int(frames * 1000 / (ms+1)),
cpu_usage.usage() * 100);
cpu_usage.stop();
cpu_total.stop();
printf("System time: %ims\n", int(cpu_total.get_system_time() / 10000));
printf("Process time: %ims\n", int(cpu_total.get_thread_time() / 10000));
return 0;
}
int main(int argc, char** argv) {
int i, retval;
const char *usage =
"\nUsage: %s --app <app-name> [OPTIONS]\n"
"Start validator for application <app-name>\n\n"
"Optional arguments:\n"
" --one_pass_N_WU N Validate at most N WUs, then exit\n"
" --one_pass Make one pass through WU table, then exit\n"
" --dry_run Don't update db, just write logs (for debugging)\n"
" --mod n i Process only WUs with (id mod n) == i\n"
" --max_wu_id n Process only WUs with id <= n\n"
" --min_wu_id n Process only WUs with id >= n\n"
" --max_granted_credit X Grant no more than this amount of credit to a result\n"
" --update_credited_job Add record to credited_job table after granting credit\n"
" --credit_from_wu Credit is specified in WU XML\n"
" --credit_from_runtime X Grant credit based on runtime (max X seconds)and estimated FLOPS\n"
" --no_credit Don't grant credit\n"
" --sleep_interval n Set sleep-interval to n\n"
" --wu_id n Process WU with given ID\n"
" -d n, --debug_level n Set log verbosity level, 1-4\n"
" -h | --help Show this\n"
" -v | --version Show version information\n";
if (argc > 1) {
if (is_arg(argv[1], "h") || is_arg(argv[1], "help")) {
printf (usage, argv[0] );
exit(0);
} else if (is_arg(argv[1], "v") || is_arg(argv[1], "version")) {
printf("%s\n", SVN_VERSION);
exit(0);
}
}
check_stop_daemons();
for (i=1; i<argc; i++) {
if (is_arg(argv[i], "one_pass_N_WU")) {
one_pass_N_WU = atoi(argv[++i]);
one_pass = true;
} else if (is_arg(argv[i], "sleep_interval")) {
sleep_interval = atoi(argv[++i]);
} else if (is_arg(argv[i], "dry_run")) {
dry_run = true;
} else if (is_arg(argv[i], "one_pass")) {
one_pass = true;
} else if (is_arg(argv[i], "app")) {
safe_strcpy(app_name, argv[++i]);
} else if (is_arg(argv[i], "d") || is_arg(argv[i], "debug_level")) {
debug_level = atoi(argv[++i]);
log_messages.set_debug_level(debug_level);
if (debug_level == 4) g_print_queries = true;
} else if (is_arg(argv[i], "mod")) {
wu_id_modulus = atoi(argv[++i]);
wu_id_remainder = atoi(argv[++i]);
} else if (is_arg(argv[i], "min_wu_id")) {
wu_id_min = atoi(argv[++i]);
} else if (is_arg(argv[i], "max_wu_id")) {
wu_id_max = atoi(argv[++i]);
} else if (is_arg(argv[i], "max_granted_credit")) {
max_granted_credit = atof(argv[++i]);
} else if (is_arg(argv[i], "update_credited_job")) {
update_credited_job = true;
} else if (is_arg(argv[i], "credit_from_wu")) {
credit_from_wu = true;
} else if (is_arg(argv[i], "credit_from_runtime")) {
credit_from_runtime = true;
max_runtime = atof(argv[++i]);
} else if (is_arg(argv[i], "no_credit")) {
no_credit = true;
} else if (is_arg(argv[i], "wu_id")) {
wu_id = atoi(argv[++i]);
one_pass = true;
} else {
//log_messages.printf(MSG_CRITICAL, "unrecognized arg: %s\n", argv[i]);
}
}
g_argc = argc;
g_argv = argv;
if (app_name[0] == 0) {
log_messages.printf(MSG_CRITICAL,
"must use '--app' to specify an application\n"
);
printf (usage, argv[0] );
exit(1);
}
retval = config.parse_file();
if (retval) {
log_messages.printf(MSG_CRITICAL,
"Can't parse config.xml: %s\n", boincerror(retval)
);
exit(1);
}
retval = boinc_db.open(
config.db_name, config.db_host, config.db_user, config.db_passwd
);
if (retval) {
log_messages.printf(MSG_CRITICAL,
"boinc_db.open failed: %s\n", boincerror(retval)
);
exit(1);
}
log_messages.printf(MSG_NORMAL,
"Starting validator, debug level %d\n", log_messages.debug_level
);
if (credit_from_runtime) {
log_messages.printf(MSG_NORMAL,
"using credit from runtime, max runtime: %f\n", max_runtime
);
}
if (wu_id_modulus) {
log_messages.printf(MSG_NORMAL,
"Modulus %d, remainder %d\n", wu_id_modulus, wu_id_remainder
);
}
if (wu_id_min) {
log_messages.printf(MSG_NORMAL,
"min wu id %d\n", wu_id_min
);
}
if (wu_id_max) {
log_messages.printf(MSG_NORMAL,
"max wu id %d\n", wu_id_max
);
}
install_stop_signal_handler();
main_loop();
}
/**
* Pre-walker for connecting DAGs and counting.
*/
static void connect_dags(ir_node *node, void *env)
{
dag_env_t *dag_env = (dag_env_t*)env;
int i, arity;
ir_node *block;
dag_entry_t *entry;
ir_mode *mode;
if (is_Block(node))
return;
block = get_nodes_block(node);
/* ignore start end end blocks */
ir_graph *const irg = get_Block_irg(block);
if (block == get_irg_start_block(irg) || block == get_irg_end_block(irg))
return;
/* ignore Phi nodes */
if (is_Phi(node))
return;
if (dag_env->options & FIRMSTAT_ARGS_ARE_ROOTS && is_arg(node))
return;
mode = get_irn_mode(node);
if (mode == mode_X || mode == mode_M) {
/* do NOT count mode_X and mode_M nodes */
return;
}
/* if this option is set, Loads are always leaves */
if (dag_env->options & FIRMSTAT_LOAD_IS_LEAVE && is_Load(node))
return;
if (dag_env->options & FIRMSTAT_CALL_IS_LEAVE && is_Call(node))
return;
entry = get_irn_dag_entry(node);
if (! entry) {
/* found an unassigned node, maybe a new root */
entry = new_dag_entry(dag_env, node);
}
/* put the predecessors into the same DAG as the current */
for (i = 0, arity = get_irn_arity(node); i < arity; ++i) {
ir_node *prev = get_irn_n(node, i);
ir_mode *mode = get_irn_mode(prev);
if (is_Phi(prev))
continue;
if (mode == mode_X || mode == mode_M)
continue;
/*
* copy constants if requested into the DAG's
* beware, do NOT add a link, as this will result in
* wrong intersections
*/
if (dag_env->options & FIRMSTAT_COPY_CONSTANTS) {
if (is_irn_constlike(prev)) {
++entry->num_nodes;
++entry->num_inner_nodes;
}
}
/* only nodes from the same block goes into the DAG */
if (get_nodes_block(prev) == block) {
dag_entry_t *prev_entry = get_irn_dag_entry(prev);
if (! prev_entry) {
/* not assigned node, put it into the same DAG */
set_irn_dag_entry(prev, entry);
++entry->num_nodes;
++entry->num_inner_nodes;
} else {
if (prev_entry == entry) {
/* We found a node that is already assigned to this DAG.
This DAG is not a tree. */
entry->is_tree = 0;
} else {
/* two DAGs intersect: copy the data to one of them
and kill the other */
entry->num_roots += prev_entry->num_roots;
entry->num_nodes += prev_entry->num_nodes;
entry->num_inner_nodes += prev_entry->num_inner_nodes;
entry->is_tree &= prev_entry->is_tree;
--dag_env->num_of_dags;
prev_entry->is_dead = 1;
prev_entry->link = entry;
}
}
}
}
}
int main(int argc, char **argv)
{
if (argc < 3)
{
printf(
"Gain\n"
"====\n"
"Simple gain tool to amplify or attenuate an audio file.\n"
"This utility is a part of AC3Filter project (http://ac3filter.net)\n"
"Copyright (c) 2008-2009 by Alexander Vigovsky\n"
"\n"
"Usage:\n"
" > gain input.wav output.wav [-g[ain]:n]\n"
"\n"
"Options:\n"
" input.wav - file to process\n"
" output.wav - file to write the result to\n"
" -gain - gain to apply\n"
"\n"
"Example:\n"
" > gain a.wav b.wav -gain:-10\n"
" Attenuate by 10dB\n"
);
return 0;
}
const char *input_filename = argv[1];
const char *output_filename = argv[2];
double gain = 1.0;
/////////////////////////////////////////////////////////////////////////////
// Parse arguments
for (int iarg = 3; iarg < argc; iarg++)
{
// -gain
if (is_arg(argv[iarg], "gain", argt_num))
{
gain = db2value(arg_num(argv[iarg]));
continue;
}
printf("Error: unknown option: %s\n", argv[iarg]);
return -1;
}
/////////////////////////////////////////////////////////////////////////////
// Open files
WAVSource src(input_filename, block_size);
if (!src.is_open())
{
printf("Error: cannot open file: %s\n", input_filename);
return -1;
}
WAVSink sink(output_filename);
if (!sink.is_open())
{
printf("Error: cannot open file: %s\n", output_filename);
return -1;
}
Speakers spk = src.get_output();
/////////////////////////////////////////////////////////////////////////////
// Build the chain
Converter iconv(block_size);
Converter oconv(block_size);
iconv.set_format(FORMAT_LINEAR);
oconv.set_format(src.get_output().format);
Gain gain_filter;
AGC agc(1024);
gain_filter.gain = gain;
FilterChain chain;
chain.add_back(&iconv, "Input converter");
chain.add_back(&gain_filter, "Gain");
chain.add_back(&agc, "AGC");
chain.add_back(&oconv, "Output converter");
if (!chain.set_input(spk))
{
printf("Error: cannot start processing\n");
return -1;
}
/////////////////////////////////////////////////////////////////////////////
// Do the job
Chunk chunk;
printf("0%%\r");
vtime_t t = local_time() + 0.1;
while (!src.is_empty())
{
src.get_chunk(&chunk);
if (!chain.process_to(&chunk, &sink))
{
char buf[1024];
chain.chain_text(buf, array_size(buf));
printf("Processing error. Chain dump: %s\n", buf);
return -1;
}
if (local_time() > t)
{
t += 0.1;
double pos = double(src.pos()) * 100 / src.size();
printf("%i%%\r", (int)pos);
}
}
printf("100%%\n");
return 0;
}
/* parse argument list. we assume that all unrecognized arguments are file names. */
void CommandLineInfo::ParseCommandLine(WCHAR *cmdLine)
{
WStrVec argList;
ParseCmdLine(cmdLine, argList);
size_t argCount = argList.Count();
#define is_arg(txt) str::EqI(TEXT(txt), argument)
#define is_arg_with_param(txt) (is_arg(txt) && param != NULL)
#define additional_param() argList.At(n + 1)
#define has_additional_param() ((argCount > n + 1) && ('-' != additional_param()[0]))
for (size_t n = 1; n < argCount; n++) {
WCHAR *argument = argList.At(n);
WCHAR *param = NULL;
if (argCount > n + 1)
param = argList.At(n + 1);
if (is_arg("-register-for-pdf")) {
makeDefault = true;
exitImmediately = true;
return;
}
else if (is_arg("-silent")) {
// silences errors happening during -print-to and -print-to-default
silent = true;
}
else if (is_arg("-print-to-default")) {
WCHAR *name = GetDefaultPrinterName();
if (name) {
str::ReplacePtr(&printerName, name);
free(name);
}
exitWhenDone = true;
}
else if (is_arg_with_param("-print-to")) {
str::ReplacePtr(&printerName, argList.At(++n));
exitWhenDone = true;
}
else if (is_arg("-print-dialog")) {
printDialog = true;
}
else if (is_arg_with_param("-print-settings")) {
// argument is a comma separated list of page ranges and
// advanced options [even|odd] and [noscale|shrink|fit]
// e.g. -print-settings "1-3,5,10-8,odd,fit"
str::ReplacePtr(&printSettings, argList.At(++n));
str::RemoveChars(printSettings, L" ");
}
else if (is_arg("-exit-when-done") || is_arg("-exit-on-print")) {
// only affects -print-dialog (-print-to and -print-to-default
// always exit on print) and -stress-test (useful for profiling)
exitWhenDone = true;
}
else if (is_arg_with_param("-bgcolor") || is_arg_with_param("-bg-color")) {
// -bgcolor is for backwards compat (was used pre-1.3)
// -bg-color is for consistency
ParseColor(&bgColor, argList.At(++n));
}
else if (is_arg_with_param("-inverse-search")) {
str::ReplacePtr(&inverseSearchCmdLine, argList.At(++n));
}
else if ((is_arg_with_param("-forward-search") ||
is_arg_with_param("-fwdsearch")) && argCount > n + 2) {
// -forward-search is for consistency with -inverse-search
// -fwdsearch is for consistency with -fwdsearch-*
str::ReplacePtr(&forwardSearchOrigin, argList.At(++n));
forwardSearchLine = _wtoi(argList.At(++n));
}
else if (is_arg_with_param("-fwdsearch-offset")) {
fwdSearch.offset = _wtoi(argList.At(++n));
}
else if (is_arg_with_param("-fwdsearch-width")) {
fwdSearch.width = _wtoi(argList.At(++n));
}
else if (is_arg_with_param("-fwdsearch-color")) {
ParseColor(&fwdSearch.color, argList.At(++n));
}
else if (is_arg_with_param("-fwdsearch-permanent")) {
fwdSearch.permanent = _wtoi(argList.At(++n));
}
else if (is_arg("-esc-to-exit")) {
escToExit = true;
}
else if (is_arg("-reuse-instance")) {
// find the window handle of a running instance of SumatraPDF
// TODO: there should be a mutex here to reduce possibility of
// race condition and having more than one copy launch because
// FindWindow() in one process is called before a window is created
// in another process
reuseInstance = (FindWindow(FRAME_CLASS_NAME, 0) != NULL);
}
else if (is_arg_with_param("-lang")) {
free(lang);
lang = str::conv::ToAnsi(argList.At(++n));
}
else if (is_arg_with_param("-nameddest") || is_arg_with_param("-named-dest")) {
// -nameddest is for backwards compat (was used pre-1.3)
// -named-dest is for consistency
str::ReplacePtr(&destName, argList.At(++n));
}
else if (is_arg_with_param("-page")) {
pageNumber = _wtoi(argList.At(++n));
}
else if (is_arg("-restrict")) {
restrictedUse = true;
}
// TODO: remove -invert-colors and -set-color-range in favor
// of the UI settable gGlobalPrefs.useSysColors(?)
else if (is_arg("-invertcolors") || is_arg("-invert-colors")) {
// -invertcolors is for backwards compat (was used pre-1.3)
// -invert-colors is for consistency
// -invert-colors is a shortcut for -set-color-range 0xFFFFFF 0x000000
// (i.e. it sets white as foreground color and black as background color)
colorRange[0] = WIN_COL_WHITE;
colorRange[1] = WIN_COL_BLACK;
}
else if (is_arg("-set-color-range") && argCount > n + 2) {
STATIC_ASSERT(sizeof(colorRange[0]) == sizeof(int), colorref_as_int);
ParseColor((int *)&colorRange[0], argList.At(++n));
ParseColor((int *)&colorRange[1], argList.At(++n));
}
else if (is_arg("-presentation")) {
enterPresentation = true;
}
else if (is_arg("-fullscreen")) {
enterFullscreen = true;
}
else if (is_arg_with_param("-view")) {
ParseViewMode(&startView, argList.At(++n));
}
else if (is_arg_with_param("-zoom")) {
ParseZoomValue(&startZoom, argList.At(++n));
}
else if (is_arg_with_param("-scroll")) {
ParseScrollValue(&startScroll, argList.At(++n));
}
else if (is_arg("-console")) {
showConsole = true;
}
else if (is_arg_with_param("-plugin")) {
// -plugin [<URL>] <parent HWND>
if (!str::IsDigit(*param) && has_additional_param())
str::ReplacePtr(&pluginURL, argList.At(++n));
// the argument is a (numeric) window handle to
// become the parent of a frameless SumatraPDF
// (used e.g. for embedding it into a browser plugin)
hwndPluginParent = (HWND)_wtol(argList.At(++n));
}
else if (is_arg_with_param("-stress-test")) {
// -stress-test <file or dir path> [<file filter>] [<page/file range(s)>] [<cycle count>x]
// e.g. -stress-test file.pdf 25x for rendering file.pdf 25 times
// -stress-test file.pdf 1-3 render only pages 1, 2 and 3 of file.pdf
// -stress-test dir 301- 2x render all files in dir twice, skipping first 300
// -stress-test dir *.pdf;*.xps render all files in dir that are either PDF or XPS
str::ReplacePtr(&stressTestPath, argList.At(++n));
int num;
if (has_additional_param() && str::FindChar(additional_param(), '*')) {
str::ReplacePtr(&stressTestFilter, additional_param());
n++;
}
if (has_additional_param() && IsValidPageRange(additional_param())) {
str::ReplacePtr(&stressTestRanges, additional_param());
n++;
}
if (has_additional_param() && str::Parse(additional_param(), L"%dx%$", &num) && num > 0) {
stressTestCycles = num;
n++;
}
}
else if (is_arg_with_param("-n")) {
stressParallelCount = _wtoi(argList.At(++n));
}
else if (is_arg("-rand")) {
stressRandomizeFiles = true;
}
else if (is_arg_with_param("-bench")) {
WCHAR *s = str::Dup(argList.At(++n));
pathsToBenchmark.Push(s);
s = NULL;
if (has_additional_param() && IsBenchPagesInfo(additional_param())) {
s = str::Dup(additional_param());
n++;
}
pathsToBenchmark.Push(s);
exitImmediately = true;
} else if (is_arg("-crash-on-open")) {
// to make testing of crash reporting system in pre-release/release
// builds possible
crashOnOpen = true;
} else if (is_arg_with_param("-manga-mode")) {
// TODO: we should have a ui for this instead of remembering it globally
// in prefs
WCHAR *s = argList.At(++n);
cbxR2L = str::EqI(L"true", s) || str::Eq(L"1", s);
}
#if defined(SUPPORTS_AUTO_UPDATE) || defined(DEBUG)
else if (is_arg_with_param("-autoupdate")) {
n++; // this should have been handled already by AutoUpdateMain
}
#endif
#ifdef DEBUG
else if (is_arg("-enum-printers")) {
EnumeratePrinters();
/* this is for testing only, exit immediately */
exitImmediately = true;
return;
}
#endif
else {
// Remember this argument as a filename to open
WCHAR *filePath = NULL;
if (str::EndsWithI(argList.At(n), L".lnk"))
filePath = ResolveLnk(argList.At(n));
if (!filePath)
filePath = str::Dup(argList.At(n));
fileNames.Push(filePath);
}
}
#undef is_arg
#undef is_arg_with_param
#undef additional_param
#undef has_additional_param
}
int main(int argc, char** argv) {
int i, retval;
const char *usage =
"\nUsage: %s -app <app-name> [OPTIONS]\n"
"Start validator for application <app-name>\n\n"
"Optional arguments:\n"
" --one_pass_N_WU N Validate at most N WUs, then exit\n"
" --one_pass Make one pass through WU table, then exit\n"
" --mod n i Process only WUs with (id mod n) == i\n"
" --max_claimed_credit X If a result claims more credit than this, mark it as invalid\n"
" --max_granted_credit X Grant no more than this amount of credit to a result\n"
" --grant_claimed_credit Grant the claimed credit, regardless of what other results for this workunit claimed\n"
" --update_credited_job Add record to credited_job table after granting credit\n"
" --credit_from_wu Credit is specified in WU XML\n"
" --sleep_interval n Set sleep-interval to n\n"
" -d n, --debug_level n Set log verbosity level, 1-4\n"
" -h | --help Show this\n"
" -v | --version Show version information\n";
if ((argc > 1) && (!strcmp(argv[1], "-h") || !strcmp(argv[1], "--help"))) {
printf (usage, argv[0] );
exit(0);
}
check_stop_daemons();
for (i=1; i<argc; i++) {
if (is_arg(argv[i], "one_pass_N_WU")) {
one_pass_N_WU = atoi(argv[++i]);
one_pass = true;
} else if (is_arg(argv[i], "sleep_interval")) {
sleep_interval = atoi(argv[++i]);
} else if (is_arg(argv[i], "one_pass")) {
one_pass = true;
} else if (is_arg(argv[i], "app")) {
strcpy(app_name, argv[++i]);
} else if (is_arg(argv[i], "d") || is_arg(argv[i], "debug_level")) {
debug_level = atoi(argv[++i]);
log_messages.set_debug_level(debug_level);
if (debug_level == 4) g_print_queries = true;
} else if (is_arg(argv[i], "mod")) {
wu_id_modulus = atoi(argv[++i]);
wu_id_remainder = atoi(argv[++i]);
} else if (is_arg(argv[i], "max_granted_credit")) {
max_granted_credit = atof(argv[++i]);
} else if (is_arg(argv[i], "max_claimed_credit")) {
max_claimed_credit = atof(argv[++i]);
} else if (is_arg(argv[i], "grant_claimed_credit")) {
grant_claimed_credit = true;
} else if (is_arg(argv[i], "update_credited_job")) {
update_credited_job = true;
} else if (is_arg(argv[i], "credit_from_wu")) {
credit_from_wu = true;
} else if (is_arg(argv[i], "v") || is_arg(argv[i], "version")) {
printf("%s\n", SVN_VERSION);
exit(0);
} else if(!strcmp(argv[i], "-testmd5")) {
unsigned char hash[16];
char text[5] = "test";
MD5((unsigned char*)&text, 4, (unsigned char *)&hash);
string hex = HexToStr((const unsigned char *)&hash, 16);
printf("test = %s", hex.c_str());
} else {
fprintf(stderr,
"Invalid option '%s'\nTry `%s --help` for more information\n",
argv[i], argv[0]
);
log_messages.printf(MSG_CRITICAL, "unrecognized arg: %s\n", argv[i]);
exit(1);
}
}
if (app_name[0] == 0) {
log_messages.printf(MSG_CRITICAL,
"must use '--app' to specify an application\n"
);
printf (usage, argv[0] );
exit(1);
}
retval = config.parse_file();
if (retval) {
log_messages.printf(MSG_CRITICAL,
"Can't parse config.xml: %s\n", boincerror(retval)
);
exit(1);
}
log_messages.printf(MSG_NORMAL,
"Starting validator, debug level %d\n", log_messages.debug_level
);
if (wu_id_modulus) {
log_messages.printf(MSG_NORMAL,
"Modulus %d, remainder %d\n", wu_id_modulus, wu_id_remainder
);
}
install_stop_signal_handler();
main_loop();
}
int main(int argc, char** argv) {
int retval;
bool one_pass = false;
int i;
int sleep_sec = 600;
check_stop_daemons();
for (i=1; i<argc; i++) {
if (is_arg(argv[i], "one_pass")) {
one_pass = true;
} else if (is_arg(argv[i], "dont_delete")) {
dont_delete = true;
} else if (is_arg(argv[i], "d") || is_arg(argv[i], "debug_level")) {
if (!argv[++i]) {
log_messages.printf(MSG_CRITICAL, "%s requires an argument\n\n", argv[--i]);
usage(argv[0]);
exit(1);
}
int dl = atoi(argv[i]);
log_messages.set_debug_level(dl);
if (dl == 4) g_print_queries = true;
} else if (is_arg(argv[i], "min_age_days")) {
if (!argv[++i]) {
log_messages.printf(MSG_CRITICAL, "%s requires an argument\n\n", argv[--i]);
usage(argv[0]);
exit(1);
}
min_age_days = atof(argv[i]);
} else if (is_arg(argv[i], "max")) {
if (!argv[++i]) {
log_messages.printf(MSG_CRITICAL, "%s requires an argument\n\n", argv[--i]);
usage(argv[0]);
exit(1);
}
max_number_workunits_to_purge= atoi(argv[i]);
} else if (is_arg(argv[i], "daily_dir")) {
daily_dir=true;
} else if (is_arg(argv[i], "zip")) {
compression_type=COMPRESSION_ZIP;
} else if (is_arg(argv[i], "gzip")) {
compression_type=COMPRESSION_GZIP;
} else if (is_arg(argv[i], "max_wu_per_file")) {
if(!argv[++i]) {
log_messages.printf(MSG_CRITICAL, "%s requires an argument\n\n", argv[--i]);
usage(argv[0]);
exit(1);
}
max_wu_per_file = atoi(argv[i]);
} else if (is_arg(argv[i], "no_archive")) {
no_archive = true;
} else if (is_arg(argv[i], "-sleep")) {
if(!argv[++i]) {
log_messages.printf(MSG_CRITICAL, "%s requires an argument\n\n", argv[--i]);
usage(argv[0]);
exit(1);
}
sleep_sec = atoi(argv[i]);
if (sleep_sec < 1 || sleep_sec > 86400) {
log_messages.printf(MSG_CRITICAL,
"Unreasonable value of sleep interval: %d seconds\n",
sleep_sec
);
usage(argv[0]);
exit(1);
}
} else if (is_arg(argv[i], "--help") || is_arg(argv[i], "-help") || is_arg(argv[i], "-h")) {
usage(argv[0]);
return 0;
} else if (is_arg(argv[i], "--version") || is_arg(argv[i], "-version")) {
printf("%s\n", SVN_VERSION);
exit(0);
} else {
log_messages.printf(MSG_CRITICAL,
"unknown command line argument: %s\n\n", argv[i]
);
usage(argv[0]);
exit(1);
}
}
retval = config.parse_file();
if (retval) {
log_messages.printf(MSG_CRITICAL,
"Can't parse config.xml: %s\n", boincerror(retval)
);
exit(1);
}
log_messages.printf(MSG_NORMAL, "Starting\n");
retval = boinc_db.open(
config.db_name, config.db_host, config.db_user, config.db_passwd
);
if (retval) {
log_messages.printf(MSG_CRITICAL, "Can't open DB\n");
exit(2);
}
install_stop_signal_handler();
boinc_mkdir(config.project_path("archives"));
// on exit, either via the check_stop_daemons signal handler, or
// through a regular call to exit, these functions will be called
// in the opposite order of registration.
//
atexit(close_db_exit_handler);
atexit(close_all_archives);
while (1) {
if (time_to_quit()) {
break;
}
if (!do_pass() && !one_pass) {
log_messages.printf(MSG_NORMAL, "Sleeping....\n");
sleep(sleep_sec);
}
if (one_pass) {
break;
}
}
// files and database are closed by exit handler
exit(0);
}
int main(int argc, char** argv) {
// Инициализация подключения к dims
frontend_db = mysql_init(NULL);
if (frontend_db == NULL) {
log_messages.printf(MSG_CRITICAL, "Error %u: %s\n", mysql_errno(frontend_db), mysql_error(frontend_db));
exit(1);
}
// Подключение к БД dims
if (mysql_real_connect(frontend_db, "localhost", "boincadm", "password!stronk!", "dihm1", 0, NULL, 0) == NULL) {
log_messages.printf(MSG_CRITICAL, "Error %u: %s\n", mysql_errno(frontend_db), mysql_error(frontend_db));
exit(1);
}
int retval;
DB_APP app; // http://boinc.berkeley.edu/doxygen/server/html/classDB__APP.html
int i;
char buf[256];
strcpy(app.name, "");
check_stop_daemons();
g_argc = argc;
g_argv = argv;
for (i=1; i<argc; i++) {
if (is_arg(argv[i], "sleep_interval")) {
sleep_interval = atoi(argv[++i]);
} else if (is_arg(argv[i], "d") || is_arg(argv[i], "debug_level")) {
int dl = atoi(argv[++i]);
log_messages.set_debug_level(dl);
if (dl ==4) g_print_queries = true;
} else if (is_arg(argv[i], "app")) {
strcpy(app.name, argv[++i]);
} else if (is_arg(argv[i], "dont_update_db")) {
// This option is for testing your assimilator. When set,
// it ensures that the assimilator does not actually modify
// the assimilate_state of the workunits, so you can run
// your assimilator over and over again without affecting
// your project.
update_db = false;
} else if (is_arg(argv[i], "help") || is_arg(argv[i], "h")) {
// usage(argv);
} else {
log_messages.printf(MSG_CRITICAL, "Unrecognized arg: %s\n", argv[i]);
// usage(argv);
}
}
if (!strlen(app.name)) {
// usage(argv);
}
retval = config.parse_file();
if (retval) {
log_messages.printf(MSG_CRITICAL, "Can't parse config.xml: %s\n", boincerror(retval));
exit(1);
}
log_messages.printf(MSG_NORMAL, "Starting\n");
retval = boinc_db.open(config.db_name, config.db_host, config.db_user, config.db_passwd);
if (retval) {
log_messages.printf(MSG_CRITICAL, "Can't open DB\n");
exit(1);
}
sprintf(buf, "where name='%s'", app.name);
retval = app.lookup(buf);
if (retval) {
log_messages.printf(MSG_CRITICAL, "Can't find app\n");
exit(1);
}
install_stop_signal_handler();
main_loop(app);
}
int main(int argc, char** argv) {
int i, retval;
char buf[256];
if (!GetCurrentDir(cCurrentPath, sizeof(cCurrentPath)))
{
return 0;
}
cCurrentPath[sizeof(cCurrentPath) - 1] = '\0'; /* not really required */
for (i=1; i<argc; i++) {
if (is_arg(argv[i], "d")) {
if (!argv[++i]) {
log_messages.printf(MSG_CRITICAL, "%s requires an argument\n\n", argv[--i]);
usage(argv[0]);
exit(1);
}
int dl = atoi(argv[i]);
log_messages.set_debug_level(dl);
if (dl == 4) g_print_queries = true;
} else if (!strcmp(argv[i], "--app")) {
app_name = argv[++i];
} else if (!strcmp(argv[i], "--in_template_file")) {
in_template_file = argv[++i];
} else if (!strcmp(argv[i], "--out_template_file")) {
out_template_file = argv[++i];
} else if (is_arg(argv[i], "h") || is_arg(argv[i], "help")) {
usage(argv[0]);
exit(0);
} else if (is_arg(argv[i], "v") || is_arg(argv[i], "version")) {
printf("%s\n", SVN_VERSION);
exit(0);
} else {
log_messages.printf(MSG_CRITICAL, "unknown command line argument: %s\n\n", argv[i]);
usage(argv[0]);
exit(1);
}
}
retval = config.parse_file();
if (retval) {
log_messages.printf(MSG_CRITICAL,
"Can't parse config.xml: %s\n", boincerror(retval)
);
exit(1);
}
retval = boinc_db.open(
config.db_name, config.db_host, config.db_user, config.db_passwd
);
if (retval) {
log_messages.printf(MSG_CRITICAL, "can't open db\n");
exit(1);
}
sprintf(buf, "where name='%s'", app_name);
if (app.lookup(buf)) {
log_messages.printf(MSG_CRITICAL, "can't find app %s\n", app_name);
exit(1);
}
sprintf(buf, "templates/%s", in_template_file);
if (read_file_malloc(config.project_path(buf), in_template)) {
log_messages.printf(MSG_CRITICAL, "can't read input template %s\n", buf);
exit(1);
}
start_time = time(0);
log_messages.printf(MSG_NORMAL, "Starting\n");
get_graphs();
if(n1==n2)
main_loop();
else{
FILE *result = fopen("result.txt","w");
fprintf(result,"NOT ISOMORPHIC");
fclose(result);
}
//deleting memory allocated for arrays
}
int main(int argc, char** argv) {
int retval;
int i;
check_stop_daemons();
for (i=1; i<argc; i++) {
if (is_arg(argv[i], "d") || is_arg(argv[i], "debug_level")) {
if (!argv[++i]) {
log_messages.printf(MSG_CRITICAL, "%s requires an argument\n\n", argv[--i]);
usage(argv[0]);
exit(1);
}
int dl = atoi(argv[i]);
log_messages.set_debug_level(dl);
if (dl == 4) g_print_queries = true;
} else if (is_arg(argv[i], "dry_run")) {
antiques_deletion_dry_run = true;
} else if (is_arg(argv[i], "usleep")) {
antique_usleep = atoi(argv[++i]);
} else if (is_arg(argv[i], "h") || is_arg(argv[i], "help")) {
usage(argv[0]);
exit(0);
} else if (is_arg(argv[i], "v") || is_arg(argv[i], "version")) {
printf("%s\n", SVN_VERSION);
exit(0);
} else {
log_messages.printf(MSG_CRITICAL, "unknown command line argument: %s\n\n", argv[i]);
usage(argv[0]);
exit(1);
}
}
retval = config.parse_file();
if (retval) {
log_messages.printf(MSG_CRITICAL,
"Can't parse config.xml: %s\n", boincerror(retval)
);
exit(1);
}
log_messages.printf(MSG_NORMAL, "Starting\n");
retval = boinc_db.open(
config.replica_db_name,
config.replica_db_host,
config.replica_db_user,
config.replica_db_passwd
);
if (retval) {
log_messages.printf(MSG_CRITICAL, "can't open DB\n");
exit(1);
}
retval = boinc_db.set_isolation_level(READ_UNCOMMITTED);
if (retval) {
log_messages.printf(MSG_CRITICAL,
"boinc_db.set_isolation_level: %s; %s\n",
boincerror(retval), boinc_db.error_string()
);
}
install_stop_signal_handler();
retval = delete_antiques();
if (retval) {
log_messages.printf(MSG_CRITICAL,
"delete_antiques() returned with error %d\n",
retval
);
}
log_messages.printf(MSG_NORMAL, "Done\n");
return retval;
}
int main(int argc, char** argv) {
int i, retval;
bool one_pass = false;
check_stop_daemons();
int j=1;
for (i=1; i<argc; i++) {
if (is_arg(argv[i], "one_pass")) {
one_pass = true;
} else if (is_arg(argv[i], "variety")) {
if (!argv[++i]) {
log_messages.printf(MSG_CRITICAL,
"%s requires an argument\n\n", argv[--i]
);
usage(argv[0]);
exit(1);
}
safe_strcpy(variety, argv[i]);
} else if (!strcmp(argv[i], "-d")) {
if (!argv[++i]) {
log_messages.printf(MSG_CRITICAL,
"%s requires an argument\n\n", argv[--i]
);
usage(argv[0]);
exit(1);
}
int dl = atoi(argv[i]);
log_messages.set_debug_level(dl);
if (dl == 4) g_print_queries = true;
} else if (!strcmp(argv[i], "-v") || !strcmp(argv[i], "--version")) {
printf("%s\n", SVN_VERSION);
exit(0);
} else if (!strcmp(argv[i], "-h") || !strcmp(argv[i], "--help")) {
usage(argv[0]);
exit(0);
} else {
// unknown arg - pass to handler
argv[j++] = argv[i];
}
}
retval = config.parse_file();
if (retval) {
log_messages.printf(MSG_CRITICAL,
"Can't parse config.xml: %s\n", boincerror(retval)
);
exit(1);
}
retval = boinc_db.open(
config.db_name, config.db_host, config.db_user, config.db_passwd
);
if (retval) {
log_messages.printf(MSG_CRITICAL,
"boinc_db.open failed: %s\n", boincerror(retval)
);
exit(1);
}
argv[j] = 0;
retval = handle_trickle_init(j, argv);
if (retval) exit(1);
log_messages.printf(MSG_NORMAL, "Starting trickle handler\n");
install_stop_signal_handler();
main_loop(one_pass);
}
int main(int argc, char** argv) {
int i, retval;
char file_name[256];
int host_id;
vector<const char*> urls;
double max_latency = 7*86400;
double max_nbytes = 1e9;
strcpy(file_name, "");
host_id = 0;
check_stop_daemons();
for (i=1; i<argc; i++) {
if (is_arg(argv[i], "host_id")) {
if (!argv[++i]) {
usage();
exit(1);
}
host_id = atoi(argv[i]);
} else if (is_arg(argv[i], "file_name")) {
if (!argv[++i]) {
usage();
exit(1);
}
strcpy(file_name, argv[i]);
} else if (is_arg(argv[i], "h") || is_arg(argv[i], "help")) {
usage();
exit(0);
} else if (is_arg(argv[i], "v") || is_arg(argv[i], "version")) {
printf("%s\n", SVN_VERSION);
exit(0);
} else if (is_arg(argv[i], "url")) {
urls.push_back(argv[++i]);
} else if (is_arg(argv[i], "max_latency")) {
max_latency = atof(argv[++i]);
} else if (is_arg(argv[i], "max_nbytes")) {
max_nbytes = atof(argv[++i]);
} else {
usage();
exit(1);
}
}
if (!strlen(file_name) || host_id == 0) {
usage();
exit(1);
}
retval = config.parse_file();
if (retval) {
fprintf(stderr, "Can't parse config.xml: %s\n", boincerror(retval));
exit(1);
}
retval = boinc_db.open(
config.db_name, config.db_host, config.db_user, config.db_passwd
);
if (retval) {
fprintf(stderr, "boinc_db.open failed: %s\n", boincerror(retval));
exit(1);
}
if (urls.size() == 0) {
urls.push_back(config.upload_url);
}
R_RSA_PRIVATE_KEY key;
bool generate_upload_certificate = !config.dont_generate_upload_certificates;
if (generate_upload_certificate) {
char keypath[MAXPATHLEN];
sprintf(keypath, "%s/upload_private", config.key_dir);
retval = read_key_file(keypath, key);
if (retval) {
fprintf(stderr, "can't read key\n");
exit(1);
}
}
retval = create_get_file_msg(
host_id, file_name, urls, max_nbytes,
dtime() + max_latency,
generate_upload_certificate, key
);
if (retval) {
fprintf(stderr, "get_file() failed: %s\n", boincerror(retval));
}
boinc_db.close();
}
int main(int argc, char **argv)
{
if (argc < 3)
{
printf(
"Resample\n"
"========\n"
"Sample rate conversion utility\n"
"This utility is a part of AC3Filter project (http://ac3filter.net)\n"
"Copyright (c) 2008-2011 by Alexander Vigovsky\n"
"\n"
"Usage:\n"
" > resample input.wav output.wav [-r[ate]:n] [-q[uality]:n] [-a[ttenuation]:n] [-d[ither]]\n"
"\n"
"Options:\n"
" input.wav - file to convert\n"
" output.wav - file to write the result to\n"
" rate - new sample rate (deafult: 48000)\n"
" quality - passband width (default: 0.99)\n"
" attenuation - stopband attenuation in dB (default: 100)\n"
" dither - dither the result\n"
"\n"
"Example:\n"
" > resample input.wav output.wav -r:44100 -q:0.999 -a:150\n"
" Passband width in this example is 0.999. This means that only uppper 22Hz\n"
" of the destination bandwidth (22028Hz - 22050Hz) will be distorted.\n"
" Note, that attenuation is large here. Such attenuation is only sensible for\n"
" at least 24bit files.\n");
return 0;
}
const char *input_filename = argv[1];
const char *output_filename = argv[2];
int sample_rate = 48000;
double q = 0.99;
double a = 100;
bool do_dither = false;
for (int iarg = 3; iarg < argc; iarg++)
{
// -r[ate]
if (is_arg(argv[iarg], "r", argt_num) ||
is_arg(argv[iarg], "rate", argt_num))
{
sample_rate = (int)arg_num(argv[iarg]);
continue;
}
// -q[uality]
if (is_arg(argv[iarg], "q", argt_num) ||
is_arg(argv[iarg], "quality", argt_num))
{
q = arg_num(argv[iarg]);
continue;
}
// -a[ttenuation]
if (is_arg(argv[iarg], "a", argt_num) ||
is_arg(argv[iarg], "attenuation", argt_num))
{
a = arg_num(argv[iarg]);
continue;
}
// -d[ither]
if (is_arg(argv[iarg], "d", argt_bool) ||
is_arg(argv[iarg], "dither", argt_bool))
{
do_dither = arg_bool(argv[iarg]);
continue;
}
printf("Error: unknown option: %s\n", argv[iarg]);
return 1;
}
if (sample_rate == 0)
{
printf("Error: incorrect sample rate\n");
return -1;
}
WAVSource src(input_filename, block_size);
if (!src.is_open())
{
printf("Error: cannot open file: %s\n", input_filename);
return -1;
}
WAVSink sink(output_filename);
if (!sink.is_open())
{
printf("Error: cannot open file: %s\n", output_filename);
return -1;
}
Speakers spk = src.get_output();
Converter iconv(block_size);
Converter oconv(block_size);
Resample resample;
AGC agc(1024);
Dither dither;
iconv.set_format(FORMAT_LINEAR);
oconv.set_format(src.get_output().format);
if (!resample.set(sample_rate, a, q))
{
printf("Error: cannot do sample rate conversion with given parameters\n", output_filename);
return -1;
}
FilterChain chain;
chain.add_back(&iconv, "Input converter");
chain.add_back(&resample, "Resample");
if (do_dither && !spk.is_floating_point())
{
chain.add_back(&dither, "Dither");
dither.level = 0.5 / spk.level;
}
chain.add_back(&agc, "AGC");
chain.add_back(&oconv, "Output converter");
Chunk chunk;
printf("Conversion %i -> %i\n", src.get_output().sample_rate, sample_rate);
printf("0%%\r");
vtime_t t = local_time() + 0.1;
while (!src.is_empty())
{
src.get_chunk(&chunk);
if (!chain.process_to(&chunk, &sink))
{
char buf[1024];
chain.chain_text(buf, array_size(buf));
printf("Processing error. Chain dump: %s\n", buf);
return -1;
}
if (local_time() > t)
{
t += 0.1;
double pos = double(src.pos()) * 100 / src.size();
printf("%i%%\r", (int)pos);
}
}
printf("100%%\n");
return 0;
}
int main(int argc, char **argv)
{
bf_t *bf_desc_font;
bf_t *bf;
char *bdf_filename = NULL;
int is_verbose = 0;
char *map_str ="*";
char *desc_font_str = "";
unsigned y;
argv++;
/*
if ( *argv == NULL )
{
help();
exit(1);
}
*/
for(;;)
{
if ( *argv == NULL )
break;
if ( is_arg(&argv, 'h') != 0 )
{
help();
exit(1);
}
else if ( is_arg(&argv, 'v') != 0 )
{
is_verbose = 1;
}
else if ( is_arg(&argv, 'a') != 0 )
{
font_picture_extra_info = 1;
}
else if ( is_arg(&argv, 't') != 0 )
{
font_picture_test_string = 1;
}
else if ( is_arg(&argv, 'r') != 0 )
{
runtime_test = 1;
}
else if ( get_num_arg(&argv, 'b', &build_bbx_mode) != 0 )
{
}
else if ( get_num_arg(&argv, 'f', &font_format) != 0 )
{
}
else if ( get_num_arg(&argv, 'l', &left_margin) != 0 )
{
}
else if ( get_str_arg(&argv, 'd', &desc_font_str) != 0 )
{
}
else if ( get_str_arg(&argv, 'o', &c_filename) != 0 )
{
}
else if ( get_str_arg(&argv, 'n', &target_fontname) != 0 )
{
}
else if ( get_str_arg(&argv, 'm', &map_str) != 0 )
{
}
else
{
bdf_filename = *argv;
argv++;
}
}
if ( bdf_filename == NULL )
{
help();
exit(1);
}
bf_desc_font = NULL;
if ( desc_font_str[0] != '\0' )
{
bf_desc_font = bf_OpenFromFile(desc_font_str, 0, BDF_BBX_MODE_MINIMAL, "*", 0); /* assume format 0 for description */
if ( bf_desc_font == NULL )
{
exit(1);
}
}
if ( font_format == 1 )
{
build_bbx_mode = BDF_BBX_MODE_M8;
/* issue the following log message later, when there is a valid bf object */
/* bf_Log(bf, "Font mode 1: BBX mode set to 3"); */
}
bf = bf_OpenFromFile(bdf_filename, is_verbose, build_bbx_mode, map_str, font_format);
if ( bf == NULL )
{
exit(1);
}
if ( font_format == 1 )
{
/* now generate the log message */
bf_Log(bf, "Note: For font format 1 BBX mode has been set to 3");
}
if ( bf_desc_font != NULL )
{
tga_init(1024, 600);
y = tga_draw_font(0, bdf_filename, bf_desc_font, bf);
if ( runtime_test != 0 )
{
long i;
clock_t c = clock();
fd_t fd;
fd_init(&fd);
fd_set_font(&fd, bf->target_data);
for( i = 0; i < 10000; i++ )
fd_draw_string(&fd, left_margin, y, "Woven silk pyjamas exchanged for blue quartz.");
bf_Log(bf, "Runtime test: %.2lf sec", (double)(clock()-c)/(double)CLOCKS_PER_SEC);
}
tga_save("bdf.tga");
}
if ( c_filename != NULL )
{
/* write the encoded data in bf->target_data */
if ( font_format == 0 )
{
bf_WriteUCGCByFilename(bf, c_filename, target_fontname, " ");
}
else
{
bf_WriteU8G2CByFilename(bf, c_filename, target_fontname, " ");
}
}
bf_Close(bf);
return 0;
}
int main(int argc, char** argv) {
int retval;
bool one_pass = false;
int i;
DB_APP app;
check_stop_daemons();
*app.name='\0';
for (i=1; i<argc; i++) {
if (is_arg(argv[i], "one_pass")) {
one_pass = true;
} else if (is_arg(argv[i], "dont_retry_errors")) {
dont_retry_errors = true;
} else if (is_arg(argv[i], "preserve_wu_files")) {
preserve_wu_files = true;
} else if (is_arg(argv[i], "preserve_result_files")) {
preserve_result_files = true;
} else if (is_arg(argv[i], "app")) {
strcpy(app.name, argv[++i]);
} else if (is_arg(argv[i], "appid")) {
if (!argv[++i]) {
log_messages.printf(MSG_CRITICAL, "%s requires an argument\n\n", argv[--i]);
usage(argv[0]);
exit(1);
}
appid = atoi(argv[i]);
} else if (is_arg(argv[i], "d") || is_arg(argv[i], "debug_level")) {
if (!argv[++i]) {
log_messages.printf(MSG_CRITICAL, "%s requires an argument\n\n", argv[--i]);
usage(argv[0]);
exit(1);
}
int dl = atoi(argv[i]);
log_messages.set_debug_level(dl);
if (dl == 4) g_print_queries = true;
} else if (is_arg(argv[i], "mod")) {
if (!argv[i+1] || !argv[i+2]) {
log_messages.printf(MSG_CRITICAL, "%s requires two arguments\n\n", argv[i]);
usage(argv[0]);
exit(1);
}
id_modulus = atoi(argv[++i]);
id_remainder = atoi(argv[++i]);
} else if (is_arg(argv[i], "dont_delete_antiques")) {
dont_delete_antiques = true;
} else if (is_arg(argv[i], "delete_antiques_interval")) {
antique_interval = atoi(argv[++i]);
} else if (is_arg(argv[i], "delete_antiques_limit")) {
antique_limit = atoi(argv[++i]);
} else if (is_arg(argv[i], "dont_delete_batches")) {
dont_delete_batches = true;
} else if (is_arg(argv[i], "delete_antiques_now")) {
antique_delay = 0;
} else if (is_arg(argv[i], "input_files_only")) {
do_output_files = false;
dont_delete_antiques = true;
} else if (is_arg(argv[i], "output_files_only")) {
do_input_files = false;
} else if (is_arg(argv[i], "sleep_interval")) {
if (!argv[++i]) {
log_messages.printf(MSG_CRITICAL, "%s requires an argument\n\n", argv[--i]);
usage(argv[0]);
exit(1);
}
sleep_interval = atoi(argv[i]);
} else if (is_arg(argv[i], "h") || is_arg(argv[i], "help")) {
usage(argv[0]);
exit(0);
} else if (is_arg(argv[i], "v") || is_arg(argv[i], "version")) {
printf("%s\n", SVN_VERSION);
exit(0);
} else {
log_messages.printf(MSG_CRITICAL, "unknown command line argument: %s\n\n", argv[i]);
usage(argv[0]);
exit(1);
}
}
if (id_modulus) {
log_messages.printf(MSG_DEBUG,
"Using mod'ed WU/result enumeration. mod = %d rem = %d\n",
id_modulus, id_remainder
);
}
retval = config.parse_file();
if (retval) {
log_messages.printf(MSG_CRITICAL,
"Can't parse config.xml: %s\n", boincerror(retval)
);
exit(1);
}
log_messages.printf(MSG_NORMAL, "Starting\n");
retval = boinc_db.open(config.db_name, config.db_host, config.db_user, config.db_passwd);
if (retval) {
log_messages.printf(MSG_CRITICAL, "can't open DB\n");
exit(1);
}
retval = boinc_db.set_isolation_level(READ_UNCOMMITTED);
if (retval) {
log_messages.printf(MSG_CRITICAL,
"boinc_db.set_isolation_level: %s; %s\n",
boincerror(retval), boinc_db.error_string()
);
}
if (*app.name && !appid) {
char buf[256];
sprintf(buf, "where name='%s'", app.name);
retval = app.lookup(buf);
if (retval) {
log_messages.printf(MSG_CRITICAL, "Can't find app\n");
exit(1);
}
appid=app.id;
log_messages.printf(MSG_DEBUG, "Deleting files of appid %d\n",appid);
}
install_stop_signal_handler();
bool retry_errors_now = !dont_retry_errors;
double next_error_time=0;
double next_antique_time = dtime() + antique_delay;
while (1) {
bool got_any = do_pass(false);
if (retry_errors_now) {
bool got_any_errors = do_pass(true);
if (got_any_errors) {
got_any = true;
} else {
retry_errors_now = false;
next_error_time = dtime() + ERROR_INTERVAL;
log_messages.printf(MSG_DEBUG,
"ending retry of previous errors\n"
);
}
}
if (!got_any) {
if (one_pass) break;
sleep(sleep_interval);
}
if (!dont_delete_antiques && (dtime() > next_antique_time)) {
log_messages.printf(MSG_DEBUG,
"Doing antique deletion pass\n"
);
do_antique_pass();
next_antique_time = dtime() + antique_interval;
}
if (!dont_retry_errors && !retry_errors_now && (dtime() > next_error_time)) {
retry_errors_now = true;
log_messages.printf(MSG_DEBUG,
"starting retry of previous errors\n"
);
}
}
}
int main(int argc, char** argv) {
int i, retval;
char buf[256];
for (i=1; i<argc; i++) {
if (is_arg(argv[i], "d")) {
if (!argv[++i]) {
log_messages.printf(MSG_CRITICAL, "%s requires an argument\n\n", argv[--i]);
usage(argv[0]);
exit(1);
}
int dl = atoi(argv[i]);
log_messages.set_debug_level(dl);
if (dl == 4) g_print_queries = true;
} else if (!strcmp(argv[i], "--app")) {
app_name = argv[++i];
} else if (!strcmp(argv[i], "--in_template_file")) {
in_template_file = argv[++i];
} else if (!strcmp(argv[i], "--out_template_file")) {
out_template_file = argv[++i];
} else if (is_arg(argv[i], "h") || is_arg(argv[i], "help")) {
usage(argv[0]);
exit(0);
} else if (is_arg(argv[i], "v") || is_arg(argv[i], "version")) {
printf("%s\n", SVN_VERSION);
exit(0);
} else {
log_messages.printf(MSG_CRITICAL, "unknown command line argument: %s\n\n", argv[i]);
usage(argv[0]);
exit(1);
}
}
retval = config.parse_file();
if (retval) {
log_messages.printf(MSG_CRITICAL,
"Can't parse config.xml: %s\n", boincerror(retval)
);
exit(1);
}
retval = boinc_db.open(
config.db_name, config.db_host, config.db_user, config.db_passwd
);
if (retval) {
log_messages.printf(MSG_CRITICAL, "can't open db\n");
exit(1);
}
sprintf(buf, "where name='%s'", app_name);
if (app.lookup(buf)) {
log_messages.printf(MSG_CRITICAL, "can't find app %s\n", app_name);
exit(1);
}
sprintf(buf, "templates/%s", in_template_file);
if (read_file_malloc(config.project_path(buf), in_template)) {
log_messages.printf(MSG_CRITICAL, "can't read input template %s\n", buf);
exit(1);
}
start_time = time(0);
seqno = 0;
log_messages.printf(MSG_NORMAL, "Starting\n");
main_loop();
}
