int main(int, char*[])
{
util::BackgroundScheduler poller;
util::WorkerThreadPool wtp(util::WorkerThreadPool::NORMAL);
util::http::Client wc;
util::http::Server ws(&poller, &wtp);
unsigned rc = ws.Init();
EchoContentFactory ecf;
ws.AddContentFactory("/", &ecf);
assert(rc == 0);
std::string url = (boost::format("http://127.0.0.1:%u/zootle/wurdle.html")
% ws.GetPort()
).str();
util::CountedPointer<FetchTask> ft(new FetchTask(url, &wc, &poller));
wtp.PushTask(util::Bind(ft).To<&FetchTask::Run>());
time_t start = time(NULL);
time_t finish = start+5;
time_t now;
do {
now = time(NULL);
if (now < finish)
{
// TRACE << "polling for " << (finish-now)*1000 << "ms\n";
poller.Poll((unsigned)(finish-now)*1000);
}
} while (now < finish && !ft->IsDone());
// TRACE << "Got '" << ft->GetContents() << "' (len "
// << strlen(ft->GetContents().c_str()) << " sz "
// << ft->GetContents().length() << ")\n";
assert(ft->GetContents() == "/zootle/wurdle.html");
return 0;
}
void Test2(util::WorkerThreadPool::Priority p, unsigned int n)
{
s_created = s_destroyed = s_run = 0;
util::WorkerThreadPool wtp(p, n);
// TRACE << "Created, pushing\n";
for (unsigned int i=0; i<n*2; ++i)
{
wtp.PushTask(util::Bind(SnoozePtr(new Snooze)).To<&Snooze::Run>());
}
// TRACE << "Shutting down\n";
wtp.Shutdown();
// TRACE << "Shutdown complete\n";
assert(s_created == s_destroyed);
// TRACE << "Test(" << n << ") done\n";
}
int main()
{
// cpu_set_t cpus;
// CPU_ZERO(&cpus);
// CPU_SET(0, &cpus);
// int rc0 = sched_setaffinity(0, sizeof(cpus), &cpus);
// TRACE << "ssa returned " << rc0 << "\n";
util::MemoryStream ms;
util::WorkerThreadPool wtp(util::WorkerThreadPool::NORMAL);
util::AsyncWriteBuffer asp(&ms, &wtp);
TestSeekableStream(&asp);
std::unique_ptr<util::Stream> fsp;
unsigned int rc = util::OpenFileStream("test2.tmp", util::TEMP, &fsp);
assert(rc == 0);
util::AsyncWriteBuffer asp2(fsp.get(), &wtp);
TestSeekableStream(&asp2);
return 0;
}
int main(int argc, char *argv[])
{
static const struct option options[] =
{
{ "help", no_argument, NULL, 'h' },
{ "karma", no_argument, NULL, 'k' },
{ "threads", required_argument, NULL, 't' },
{ "dbfile", required_argument, NULL, 'f' },
{ NULL, 0, NULL, 0 }
};
int nthreads = 0;
const char *dbfile = DEFAULT_DB_FILE;
bool karma = false;
int option_index;
int option;
while ((option = getopt_long(argc, argv, "ht:f:k", options, &option_index))
!= -1)
{
switch (option)
{
case 'h':
Usage(stdout);
return 0;
case 't':
nthreads = (int)strtoul(optarg, NULL, 10);
break;
case 'f':
dbfile = optarg;
break;
case 'k':
karma = true;
break;
default:
Usage(stderr);
return 1;
}
}
int nargs = argc-optind;
if (nargs < 2 || nargs > 3 || nthreads < 0)
{
Usage(stderr);
return 1;
}
if (!nthreads)
nthreads = util::CountCPUs() * 2;
const char *outputdir = argv[optind];
const char *mediaroot = argv[optind+1];
const char *flacroot = argv[optind+2];
if (!flacroot)
flacroot = "";
db::steam::Database sdb(mediadb::FIELD_COUNT);
sdb.SetFieldInfo(mediadb::ID,
db::steam::FIELD_INT|db::steam::FIELD_INDEXED);
sdb.SetFieldInfo(mediadb::PATH,
db::steam::FIELD_STRING|db::steam::FIELD_INDEXED);
TRACE << "reading\n";
mediadb::ReadXML(&sdb, "db.xml");
TRACE << "scanning\n";
util::WorkerThreadPool wtp(util::WorkerThreadPool::NORMAL, nthreads);
util::http::Client http_client;
db::local::Database ldb(&sdb, &http_client);
#if HAVE_TAGLIB
db::local::FileScanner ifs(mediaroot, flacroot, &sdb, &ldb, &wtp);
ifs.Scan();
TRACE << "writing\n";
FILE *f = fopen("db.xml", "wb");
mediadb::WriteXML(&sdb, 1, f);
fclose(f);
TRACE << "arranging\n";
WriteFIDStructure(outputdir, &sdb, karma);
#endif
return 0;
}
int Main(int argc, char *argv[])
{
QApplication app(argc, argv);
static const struct option options[] =
{
{ "help", no_argument, NULL, 'h' },
{ "threads", required_argument, NULL, 't' },
{ NULL, 0, NULL, 0 }
};
unsigned int nthreads = 32;
int option_index;
int option;
while ((option = getopt_long(argc, argv, "ht:", options, &option_index))
!= -1)
{
switch (option)
{
case 'h':
Usage(stdout);
return 0;
case 't':
nthreads = (unsigned int)strtoul(optarg, NULL, 10);
break;
default:
Usage(stderr);
return 1;
}
}
const char *media_root;
const char *flac_root = "";
switch ((int)(argc-optind)) // How many more arguments?
{
case 2:
media_root = argv[optind];
flac_root = argv[optind+1];
break;
case 1:
media_root = argv[optind];
break;
default:
Usage(stderr);
return 1;
}
util::http::Client http_client;
db::steam::Database sdb(mediadb::FIELD_COUNT);
sdb.SetFieldInfo(mediadb::ID,
db::steam::FIELD_INT|db::steam::FIELD_INDEXED);
sdb.SetFieldInfo(mediadb::PATH,
db::steam::FIELD_STRING|db::steam::FIELD_INDEXED);
sdb.SetFieldInfo(mediadb::ARTIST,
db::steam::FIELD_STRING|db::steam::FIELD_INDEXED);
sdb.SetFieldInfo(mediadb::ALBUM,
db::steam::FIELD_STRING|db::steam::FIELD_INDEXED);
sdb.SetFieldInfo(mediadb::GENRE,
db::steam::FIELD_STRING|db::steam::FIELD_INDEXED);
util::WorkerThreadPool wtp(util::WorkerThreadPool::LOW, nthreads);
db::local::Database db(&sdb, &http_client, &wtp);
db::local::FileScanner ifs(media_root, flac_root, &sdb, &db, &wtp);
mediadb::Registry registry;
ScanProgressDialog spd(&db, ®istry);
spd.show();
ifs.AddObserver(&spd);
unsigned int rc = ifs.StartScan();
assert(rc == 0);
if (rc)
{
fprintf(stderr, "Scanning failed: %u\n", rc);
exit(1);
}
return app.exec();
}
int main()
{
TestServiceImpl tsi;
DoTest(&tsi);
// Now via UPnP
util::WorkerThreadPool wtp(util::WorkerThreadPool::NORMAL);
util::BackgroundScheduler poller;
wtp.PushTask(util::SchedulerTask::Create(&poller));
util::http::Client wc;
util::http::Server ws(&poller, &wtp);
upnp::ssdp::Responder ssdp(&poller, NULL);
ws.Init();
upnp::Server server(&poller, &wc, &ws, &ssdp);
TestDevice dev;
dev.Init(&server, "/");
unsigned rc = server.Init();
assert(rc == 0);
std::string descurl = (boost::format("http://127.0.0.1:%u/upnp/description.xml")
% ws.GetPort()).str();
upnp::DeviceClient client(&wc, &ws, &poller);
rc = client.Init(descurl, dev.GetUDN());
assert(rc == 0);
upnp::TestServiceClient tsc(&client, s_test_service_id);
rc = tsc.Init();
assert(rc == 0);
DoTest(&tsc);
// Async version
upnp::DeviceClient client2(&wc, &ws, &poller);
AsyncTest at(&client2);
at.Run(descurl, dev.GetUDN());
int tries = 0;
for (;;)
{
if (at.IsDone())
break;
assert(++tries < 30);
#ifdef WIN32
Sleep(1000);
#else
sleep(1);
#endif
}
// TRACE << "Shutdown begins\n";
poller.Shutdown();
wtp.Shutdown();
return 0;
}
void DevilImageReader::updateResult(DataContainer& data) {
const std::string& url = p_url.getValue();
std::string directory = cgt::FileSystem::dirName(url);
std::string base = cgt::FileSystem::baseName(url);
std::string ext = cgt::FileSystem::fileExtension(url);
// check whether we open an image series
size_t suffixPos = base.find_last_not_of("0123456789");
if (suffixPos != std::string::npos)
++suffixPos;
size_t suffixLength = (suffixPos == std::string::npos) ? 0 : base.length() - suffixPos;
// assemble the list of files to read
std::vector<std::string> files;
if (suffixLength == 0 || !p_importSimilar.getValue()) {
files.push_back(url);
}
else {
std::string prefix = base.substr(0, suffixPos);
int index = StringUtils::fromString<int>(base.substr(suffixPos));
while (cgt::FileSystem::fileExists(directory + "/" + prefix + StringUtils::toString(index, suffixLength, '0') + "." + ext)) {
files.push_back(directory + "/" + prefix + StringUtils::toString(index, suffixLength, '0') + "." + ext);
++index;
}
}
if (files.empty())
return;
cgt::ivec3 imageSize(0, 0, static_cast<int>(files.size()));
uint8_t* buffer = nullptr;
ILint devilFormat = 0;
if (p_importType.getOptionValue() == "localIntensity")
devilFormat = IL_LUMINANCE;
else if (p_importType.getOptionValue() == "localIntensity3")
devilFormat = IL_RGB;
else if (p_importType.getOptionValue() == "rt")
devilFormat = IL_RGBA;
ILint devilDataType = 0;
WeaklyTypedPointer::BaseType campvisDataType = WeaklyTypedPointer::UINT8;
size_t numChannels = 1;
// start reading
for (size_t i = 0; i < files.size(); ++i) {
// prepare DevIL
ILuint img;
ilGenImages(1, &img);
ilBindImage(img);
// try load file
if (! ilLoadImage(files[i].c_str())) {
LERROR("Could not load image: " << files[i]);
delete [] buffer;
return;
}
// prepare buffer and perform dimensions check
if (i == 0) {
imageSize.x = ilGetInteger(IL_IMAGE_WIDTH);
imageSize.y = ilGetInteger(IL_IMAGE_HEIGHT);
if (devilFormat == 0)
devilFormat = ilGetInteger(IL_IMAGE_FORMAT);
switch (ilGetInteger(IL_IMAGE_TYPE)) {
case IL_UNSIGNED_BYTE:
devilDataType = IL_UNSIGNED_BYTE;
campvisDataType = WeaklyTypedPointer::UINT8;
break;
case IL_BYTE:
devilDataType = IL_BYTE;
campvisDataType = WeaklyTypedPointer::INT8;
break;
case IL_UNSIGNED_SHORT:
devilDataType = IL_UNSIGNED_SHORT;
campvisDataType = WeaklyTypedPointer::UINT16;
break;
case IL_SHORT:
devilDataType = IL_SHORT;
campvisDataType = WeaklyTypedPointer::INT16;
break;
case IL_UNSIGNED_INT:
devilDataType = IL_UNSIGNED_INT;
campvisDataType = WeaklyTypedPointer::UINT32;
break;
case IL_INT:
devilDataType = IL_INT;
campvisDataType = WeaklyTypedPointer::INT32;
break;
case IL_FLOAT:
devilDataType = IL_FLOAT;
campvisDataType = WeaklyTypedPointer::FLOAT;
break;
default:
LERROR("unsupported data type: " << ilGetInteger(IL_IMAGE_TYPE) << " (" << files[i] << ")");
return;
}
switch (devilFormat) {
case IL_LUMINANCE:
numChannels = 1;
break;
case IL_LUMINANCE_ALPHA:
numChannels = 2;
break;
case IL_RGB:
numChannels = 3;
break;
case IL_RGBA:
numChannels = 4;
break;
default:
LERROR("unsupported image format: " << devilFormat << " (" << files[i] << ")");
return;
}
buffer = new uint8_t[cgt::hmul(imageSize) * WeaklyTypedPointer::numBytes(campvisDataType, numChannels)];
}
else {
if (imageSize.x != ilGetInteger(IL_IMAGE_WIDTH)) {
LERROR("Could not load images: widths do not match!");
delete [] buffer;
return;
}
if (imageSize.y != ilGetInteger(IL_IMAGE_HEIGHT)) {
LERROR("Could not load images: heights do not match!");
delete [] buffer;
return;
}
}
// get data from image and transform to single intensity image:
ilCopyPixels(0, 0, 0, imageSize.x, imageSize.y, 1, devilFormat, devilDataType, buffer + (WeaklyTypedPointer::numBytes(campvisDataType, numChannels) * i * imageSize.x * imageSize.y));
ILint err = ilGetError();
if (err != IL_NO_ERROR) {
LERROR("Error during conversion: " << iluErrorString(err));
delete [] buffer;
return;
}
ilDeleteImage(img);
}
size_t dimensionality = 3;
if (imageSize.z == 1)
dimensionality = 2;
if (imageSize.y == 1)
dimensionality = 1;
ImageData* id = new ImageData(dimensionality, imageSize, numChannels);
WeaklyTypedPointer wtp(campvisDataType, numChannels, buffer);
ImageRepresentationLocal::create(id, wtp);
//id->setMappingInformation(ImageMappingInformation(imageSize, p_imageOffset.getValue(), p_voxelSize.getValue()));
if (p_importType.getOptionValue() == "rt") {
RenderData* rd = new RenderData();
rd->addColorTexture(id);
// create fake depth image
ImageData* idDepth = new ImageData(dimensionality, imageSize, 1);
float* ptr = new float[cgt::hmul(imageSize)];
memset(ptr, 0, cgt::hmul(imageSize) * sizeof(float));
WeaklyTypedPointer wtpDepth(campvisDataType, 1, ptr);
ImageRepresentationLocal::create(idDepth, wtpDepth);
rd->setDepthTexture(idDepth);
data.addData(p_targetImageID.getValue(), rd);
}
else {
data.addData(p_targetImageID.getValue(), id);
}
}
