int main(int argc, char ** argv){
wav_t wav;
int err = 0;
//Probamos que la arquitectura esta configurada correctamente.
assertSizes();
#ifdef RUNCRYPTOTESTS
cryptoRunTests();
#endif
cryptoHolder_t * cryptoHolder;
if((cryptoHolder = clparser(argc, argv)) == NULL || !checkCryptoHolder(cryptoHolder)) {
return 0;
}
dataHolder_t target;
wav = newWavFromFile(cryptoHolder->sourceFile);
if (wav == NULL)
return 1;
FMT_CK fmt = wavGetFMT(wav);
dataHolder_t soundData = wavGetData(wav);
int cryptoResult = 0;
if (!err) {
cryptoResult = crypto_Execute(cryptoHolder->encription, soundData, &target);
}
LOG("cryptoResult: %d\n", cryptoResult);
int result = 0;
if (cryptoResult != 0) {
wav_t wavAux = newWavFromData(fmt,target);
result = wavWriteToFile(wavAux, cryptoHolder->targetFile);
LOG("Save result: %s\n", (result)? "Success":"Fail");
freeWav(wavAux);
return !result;
}
freeWavFMT(fmt);
dataHolderFree(soundData);
freeWav(wav);
LOG("Ended\n");
return result;
}
int CComponentIDToolApp::Run()
{
const SCommandDefinition* cmd_def;
const int* cmd_opt;
{
CCommandLineParser clparser(GRID_APP_NAME, GRID_APP_VERSION_INFO,
"Generate and decode identifiers in CompoundID format.");
const SOptionDefinition* opt_def = s_OptionDefinitions;
int opt_id = 0;
do {
#ifdef _DEBUG
_ASSERT(opt_def->opt_id == opt_id &&
"EOption order must match positions in s_OptionDefinitions.");
#endif
clparser.AddOption(opt_def->type, opt_id,
opt_def->name_variants, opt_def->description ?
opt_def->description : kEmptyStr);
++opt_def;
} while (++opt_id < eNumberOfOptions);
cmd_def = s_CommandDefinitions;
for (int i = 0; i < TOTAL_NUMBER_OF_COMMANDS; ++i, ++cmd_def) {
clparser.AddCommand(i, cmd_def->name_variants,
cmd_def->synopsis, cmd_def->usage);
for (cmd_opt = cmd_def->options; *cmd_opt >= 0; ++cmd_opt)
clparser.AddAssociation(i, *cmd_opt);
}
try {
int cmd_id = clparser.Parse(m_ArgC, m_ArgV);
if (cmd_id < 0)
return 0;
cmd_def = s_CommandDefinitions + cmd_id;
}
catch (exception& e) {
NcbiCerr << e.what();
return 1;
}
for (cmd_opt = cmd_def->options; *cmd_opt >= 0; ++cmd_opt)
MarkOptionAsAccepted(*cmd_opt);
const char* opt_value;
while (clparser.NextOption(&opt_id, &opt_value)) {
MarkOptionAsExplicitlySet(opt_id);
switch (EOption(opt_id)) {
case eCID:
m_Opts.cid = opt_value;
break;
case eInputFile:
if ((m_Opts.input_stream = fopen(opt_value, "rb")) == NULL) {
fprintf(stderr, "%s: %s\n", opt_value, strerror(errno));
return 2;
}
break;
case eOutputFile:
if ((m_Opts.output_stream = fopen(opt_value, "wb")) == NULL) {
fprintf(stderr, "%s: %s\n", opt_value, strerror(errno));
return 2;
}
break;
default: // Just to silence the compiler.
break;
}
}
opt_id = eNumberOfOptions - 1;
do
if (IsOptionSet(opt_id))
for (const int* required_opt =
s_OptionDefinitions[opt_id].required_options;
*required_opt != -1; ++required_opt)
if (!IsOptionSet(*required_opt)) {
fprintf(stderr, GRID_APP_NAME
": option '--%s' requires option '--%s'.\n",
s_OptionDefinitions[opt_id].name_variants,
s_OptionDefinitions[
*required_opt].name_variants);
return 2;
}
while (--opt_id >= 0);
if (IsOptionAcceptedButNotSet(eInputFile)) {
m_Opts.input_stream = stdin;
}
if (IsOptionAcceptedButNotSet(eOutputFile)) {
m_Opts.output_stream = stdout;
}
}
try {
return (this->*cmd_def->cmd_proc)();
}
catch (CConfigException& e) {
fprintf(stderr, "%s\n", e.GetMsg().c_str());
return 2;
}
catch (CArgException& e) {
fprintf(stderr, GRID_APP_NAME " %s: %s\n",
cmd_def->name_variants, e.GetMsg().c_str());
return 2;
}
catch (CException& e) {
fprintf(stderr, "%s\n", e.what());
return 3;
}
catch (string& s) {
fprintf(stderr, "%s\n", s.c_str());
return 4;
}
}
int main(int argc, char *argv[]){
configuration_t *conf = clparser(argc, argv);
wav_t newCarrier;
wav_t carrierFile;
dataHolder_t carrierData;
if(conf != NULL)
showConfig(conf);
checkConfig(&conf);
if(conf != NULL) {
LOG("opening carrier file: %s\n", conf->carrierFile);
carrierFile = newWavFromFile(conf->carrierFile);
carrierData = wavGetData(carrierFile);
if(conf->embed == steg_embed){
fileContainer_t payload;
char *ext = NULL;
dataHolder_t payloadRawHolder, resultPayload;
FCRead(conf->sourceFile, &payload);
//Embeding
if(conf->encriptation == NULL){
//Embeding without encryptation.
resultPayload.data = payload.rawData;
resultPayload.size = payload.size;
ext = payload.extension;
} else {
//Embeding with encryptation.
typeConvertFCtoDH(&payload, &payloadRawHolder);
crypto_Execute(*conf->encriptation, payloadRawHolder, &resultPayload);
ext = NULL;
}
stegEmbed(&carrierData, &resultPayload, conf->stegMode, ext);
newCarrier = newWavFromData(wavGetFMT(carrierFile), carrierData);
wavWriteToFile(newCarrier, conf->targetFile);
} else {
fileContainer_t resultPayloadFile;
dataHolder_t payloadData;
if(conf->encriptation == NULL){
LOG("extracting without decryption\n");
//Extracting without decription
stegExtract(&carrierData, &payloadData, conf->stegMode, resultPayloadFile.extension);
resultPayloadFile.rawData = payloadData.data;
resultPayloadFile.size = payloadData.size;
LOG("got payload file size: %d, and extention %s\n", resultPayloadFile.size, resultPayloadFile.extension);
} else {
//Extracting with decription
LOG("extrating with encryption\n");
dataHolder_t cipherPayload;
stegExtract(&carrierData, &cipherPayload, conf->stegMode, NULL);
LOG("extracted cipherPayload({%d,%p})\n",cipherPayload.size, cipherPayload.data);
crypto_Execute(*conf->encriptation, cipherPayload, &payloadData);
typeConvertDHtoFC(&resultPayloadFile, &payloadData);
}
FCWrite(conf->targetFile, &resultPayloadFile);
}
} else {
printf("user -h for help\n");
}
return 0;
}
int main(int argc, char** argv)
{
// --------------------------------------------------------------------
// get job files and program options
std::vector<std::string> vecScans;
std::string strOutFile;
bool bFlip = 0;
std::string strVec0, strVec1;
t_vec vec0, vec1;
// normal args
opts::options_description args("Extracts scan positions into a figure");
args.add(boost::shared_ptr<opts::option_description>(
new opts::option_description("scan-file",
opts::value<decltype(vecScans)>(&vecScans), "scan file")));
args.add(boost::shared_ptr<opts::option_description>(
new opts::option_description("flip-y",
opts::bool_switch(&bFlip), "flip y axis")));
args.add(boost::shared_ptr<opts::option_description>(
new opts::option_description("out-file",
opts::value<decltype(strOutFile)>(&strOutFile), "output file")));
args.add(boost::shared_ptr<opts::option_description>(
new opts::option_description("vec0",
opts::value<decltype(strVec0)>(&strVec0), "first scattering plane vector")));
args.add(boost::shared_ptr<opts::option_description>(
new opts::option_description("vec1",
opts::value<decltype(strVec1)>(&strVec1), "second scattering plane vector")));
// positional args
opts::positional_options_description args_pos;
args_pos.add("scan-file", -1);
opts::basic_command_line_parser<char> clparser(argc, argv);
clparser.options(args);
clparser.positional(args_pos);
opts::basic_parsed_options<char> parsedopts = clparser.run();
opts::variables_map opts_map;
opts::store(parsedopts, opts_map);
opts::notify(opts_map);
if(argc <= 1)
{
std::ostringstream ostrHelp;
ostrHelp << "Usage: " << argv[0] << " [options] <scan-file 1> <scan-file 2> ... <scan-file n>\n";
ostrHelp << args;
tl::log_info(ostrHelp.str());
return -1;
}
if(vecScans.size() == 0)
{
tl::log_err("No scan files given.");
return -1;
}
if(strVec0.size())
vec0 = tl::str_to_var<decltype(vec0)>("[3](" + strVec0 + ")");
if(strVec1.size())
vec1 = tl::str_to_var<decltype(vec1)>("[3](" + strVec1 + ")");
// --------------------------------------------------------------------
// first scan file serves as reference
std::unique_ptr<tl::FileInstrBase<t_real>> ptrScan(
tl::FileInstrBase<t_real>::LoadInstr(vecScans[0].c_str()));
if(!ptrScan)
{
tl::log_err("Invalid scan file: \"", vecScans[0], "\".");
return -1;
}
// get scattering plane if not already given as program arg
if(vec0.size() != 3)
{
auto arrVec0 = ptrScan->GetScatterPlane0();
vec0 = tl::make_vec<t_vec>({arrVec0[0],arrVec0[1],arrVec0[2]});
}
if(vec1.size() != 3)
{
auto arrVec1 = ptrScan->GetScatterPlane1();
vec1 = tl::make_vec<t_vec>({arrVec1[0],arrVec1[1],arrVec1[2]});
}
if(bFlip) vec1 = -vec1;
tl::log_info("Scattering plane: ", vec0, ", ", vec1, ".");
std::vector<t_vec> vecAllHKL, vecAllPos;
vecAllHKL.reserve(argc-2);
vecAllPos.reserve(argc-2);
// first scan position
auto vecPos = get_coord<t_vec, t_real>(vec0, vec1, *ptrScan);
tl::log_info(vecPos.first, " rlu -> ", vecPos.second, ".");
if(vecPos.second.size() != 2)
{
tl::log_err("Invalid scan position for file \"", vecScans[0], "\".");
return -1;
}
vecAllHKL.push_back(vecPos.first);
vecAllPos.push_back(vecPos.second);
// load other files
for(int iFile=1; iFile<vecScans.size(); ++iFile)
{
std::unique_ptr<tl::FileInstrBase<t_real>> ptrScanOther(
tl::FileInstrBase<t_real>::LoadInstr(vecScans[iFile].c_str()));
if(!ptrScanOther)
{
tl::log_err("Invalid scan file: \"", vecScans[iFile], "\".");
continue;
}
// remaining scan positions
auto vecPosOther = get_coord<t_vec, t_real>(vec0, vec1, *ptrScanOther);
tl::log_info(vecPos.first, " rlu -> ", vecPos.second, ".");
if(vecPosOther.second.size() != 2)
{
tl::log_err("Invalid scan position for file \"", vecScans[iFile], "\".");
continue;
}
vecAllHKL.push_back(vecPosOther.first);
vecAllPos.push_back(vecPosOther.second);
}
if(!make_plot(strOutFile, vec0, vec1, vecAllHKL, vecAllPos, bFlip))
{
tl::log_err("No scan positions found.");
return -1;
}
return 0;
}
