int
process_dii(struct carousel *car, struct DownloadInfoIndication *dii, uint32_t transactionId)
{
unsigned int nmodules;
unsigned int i;
int processed = 0;
verbose("DownloadInfoIndication ");
verbose("transactionId: %u, ", transactionId);
verbose("downloadId: %u, ", ntohl(dii->downloadId));
nmodules = DII_numberOfModules(dii);
// verbose2("numberOfModules: %u, ", nmodules);
for(i=0; i<nmodules; i++)
{
struct DIIModule *mod;
mod = DII_module(dii, i);
vverbose("Module %u", i);
vverbose(" moduleId: %u", ntohs(mod->moduleId));
vverbose(" moduleVersion: %u", mod->moduleVersion);
vverbose(" moduleSize: %u", ntohl(mod->moduleSize));
if(find_module(car, ntohs(mod->moduleId), mod->moduleVersion, ntohl(dii->downloadId)) == NULL) {
vverbose("Adding module %u", i);
add_module(car, dii, mod);
processed = 1;
}
}
return processed;
}
/* Hash test: buffer of size byte. Run test n times. */
static void run_test(size_t size, unsigned int n, unsigned int l)
{
uint64_t t;
struct statistics stats;
TEEC_Operation op;
int n0 = n;
alloc_shm(size, algo);
if (!random_in)
memset((uint8_t *)in_shm.buffer + offset, 0, size);
memset(&op, 0, sizeof(op));
op.paramTypes = TEEC_PARAM_TYPES(TEEC_MEMREF_PARTIAL_INPUT,
TEEC_MEMREF_PARTIAL_OUTPUT,
TEEC_VALUE_INPUT, TEEC_NONE);
op.params[0].memref.parent = &in_shm;
op.params[0].memref.offset = 0;
op.params[0].memref.size = size + offset;
op.params[1].memref.parent = &out_shm;
op.params[1].memref.offset = 0;
op.params[1].memref.size = hash_size(algo);
op.params[2].value.a = l;
op.params[2].value.b = offset;
verbose("Starting test: %s, size=%zu bytes, ",
algo_str(algo), size);
verbose("random=%s, ", yesno(random_in));
verbose("unaligned=%s, ", yesno(offset));
verbose("inner loops=%u, loops=%u, warm-up=%u s\n", l, n, warmup);
if (warmup)
do_warmup();
memset(&stats, 0, sizeof(stats));
while (n-- > 0) {
t = run_test_once((uint8_t *)in_shm.buffer + offset, size, &op, l);
update_stats(&stats, t);
if (n % (n0/10) == 0)
vverbose("#");
}
vverbose("\n");
printf("min=%gμs max=%gμs mean=%gμs stddev=%gμs (%gMiB/s)\n",
stats.min/1000, stats.max/1000, stats.m/1000,
stddev(&stats)/1000, mb_per_sec(size, stats.m));
free_shm();
}
//---------------------------------------------------------------------------
// Read from xml
//---------------------------------------------------------------------------
bool VisusBorderAxis::fromXML(XMLNode& node)
{
if (strcmp(XML_TAG, node.getName()))
{
std::stringstream ss;
ss << "VisusBorderAxis did not receive its top level node. received (" << node.getName() << ")\n";
vwarning(ss.str().c_str());
vverbose(ss.str().c_str(), VISUS_XML_VERBOSE);
return false;
}
XMLNode child = node.getChildNode("label");
XMLNode text = child.getChildNode(0);
if (! mLabel.fromXML(text)) {
vwarning("Failed to retrieve label text for VisusBorderAxis");
return false;
}
mDrawLabels = xmltobool(node.getAttribute("drawLabel"), mDrawLabels);
mLabelPosition = (AXISSide) xmltoi(node.getAttribute("labelPosition"), mLabelPosition);
mLabelAlignment = (AXISAlignment) xmltoi(node.getAttribute("labelAlignment"), mLabelAlignment);
mLabelOffset = xmltof(node.getAttribute("labelOffset"), mLabelOffset);
child = node.getChildNode("legend");
text = child.getChildNode(0);
if (! mLegend.fromXML(text)) {
vwarning("Failed to retrieve label text for VisusBorderAxis");
return false;
}
mDrawLegend = xmltobool(node.getAttribute("drawLegend"), mDrawLegend);
mLegendPosition = (AXISSide) xmltoi(node.getAttribute("legendPosition"), mLegendPosition);
mLegendAlignment= (AXISAlignment) xmltoi(node.getAttribute("legendAlignment"), mLegendAlignment);
mLegendOffset = xmltof(node.getAttribute("legendOffset"), mLegendOffset);
mDrawTicks = xmltobool(node.getAttribute("drawTicks"), mDrawTicks);
mMajorTickLength = xmltof(node.getAttribute("majorTickLength"), mMajorTickLength);
mMajorTickThickness = xmltof(node.getAttribute("majorTickThickness"), mMajorTickThickness);
mMinorTickLength = xmltof(node.getAttribute("minorTickLength"), mMinorTickLength);
mMinorTickThickness = xmltof(node.getAttribute("minorTickThickness"), mMinorTickThickness);
mTickPosition = (AXISSide) xmltoi(node.getAttribute("tickPosition"), mTickPosition);
mMinValue = xmltof(node.getAttribute("min"), mMinValue);
mMaxValue = xmltof(node.getAttribute("max"), mMaxValue);
mMajorTicks = xmltoi(node.getAttribute("majorTicks"), mMajorTicks);
mMinorTicks = xmltoi(node.getAttribute("minorTicks"), mMinorTicks);
XMLNode tickColor = node.getChildNode("TickColor");
XMLNode color = tickColor.getChildNode(0);
if (! mTickColor.fromXML(color)) {
vwarning("Failed to retrieve tick color for VisusBorderAxis");
return false;
}
return true;
}
bool
read_pmt(char *demux, uint16_t service_id, unsigned int timeout, unsigned char *out)
{
char cache_item[PATH_MAX];
unsigned char pat[MAX_TABLE_LEN];
uint16_t section_length;
uint16_t offset;
uint16_t map_pid = 0;
bool found;
bool rc;
/* is it in the cache */
snprintf(cache_item, sizeof(cache_item), "pmt-%u", service_id);
if(cache_load(cache_item, out))
return true;
/* get the PAT */
if(!read_pat(demux, timeout, pat))
return false;
section_length = 3 + (((pat[1] & 0x0f) << 8) + pat[2]);
/* find the PMT for this service_id */
found = false;
offset = 8;
/* -4 for the CRC at the end */
while((offset < (section_length - 4)) && !found)
{
if((pat[offset] << 8) + pat[offset+1] == service_id)
{
map_pid = ((pat[offset+2] & 0x1f) << 8) + pat[offset+3];
found = true;
}
else
{
offset += 4;
}
}
if(!found)
fatal("Unable to find PMT PID for service_id %u", service_id);
vverbose("PMT PID: %u", map_pid);
/* get the PMT */
rc = read_table(demux, map_pid, TID_PMT, timeout, out, 0);
/* cache it */
if(rc)
cache_save(cache_item, out);
else
error("Unable to read PMT");
return rc;
}
VisusRenderer::VisusRenderer(const int width, const int height):
mWidth(width), mHeight(height), mSize(width*height), mValid(false)
{
mPerPixel = 3;
// Create Storage For Image
mImage = new unsigned char[mSize*mPerPixel];
for (int i=0; i<mSize; ++i) {
mImage[i] = 0;
}
vverbose("VisusRenderer::ctor: Width(%d) Height(%d)\n", 500, mWidth, mHeight);
init();
}
int
process_ddb(char* paramDir, struct carousel *car, struct DownloadDataBlock *ddb, uint32_t downloadId, uint32_t blockLength)
{
unsigned char *block;
struct module *mod;
int processed = 0;
verbose("DownloadDataBlock ");
vverbose("downloadId: %u", downloadId);
verbose("moduleId: %u", ntohs(ddb->moduleId));
vverbose("moduleVersion: %u", ddb->moduleVersion);
verbose("blockNumber: %u", ntohs(ddb->blockNumber));
vverbose("blockLength: %u", blockLength);
block = DDB_blockDataByte(ddb);
vhexdump(block, blockLength);
if((mod = find_module(car, ntohs(ddb->moduleId), ddb->moduleVersion, downloadId)) != NULL) {
download_block(paramDir, car, mod, ntohs(ddb->blockNumber), block, blockLength);
processed = 1;
}
return processed;
}
char *
zap_name(unsigned int adapter, unsigned int frontend)
{
char fe_dev[PATH_MAX];
int fe_fd;
struct dvb_frontend_info fe_info;
bool got_info;
/* see what type of DVB device the adapter is */
snprintf(fe_dev, sizeof(fe_dev), FE_DEVICE, adapter, frontend);
if((fe_fd = open(fe_dev, O_RDONLY | O_NONBLOCK)) < 0)
fatal("open '%s': %s", fe_dev, strerror(errno));
vverbose("Getting frontend info");
do
{
/* maybe interrupted by a signal */
got_info = (ioctl(fe_fd, FE_GET_INFO, &fe_info) >= 0);
if(!got_info && errno != EINTR)
fatal("ioctl FE_GET_INFO: %s", strerror(errno));
}
while(!got_info);
close(fe_fd);
if(fe_info.type == FE_OFDM)
{
vverbose("Adapter %u is a '%s' DVB-T card", adapter, fe_info.name);
return "tzap";
}
else if(fe_info.type == FE_QPSK)
{
vverbose("Adapter %u is a '%s' DVB-S card", adapter, fe_info.name);
return "szap";
}
else if(fe_info.type == FE_QAM)
{
vverbose("Adapter %u is a '%s' DVB-C card", adapter, fe_info.name);
return "czap";
}
else if(fe_info.type == FE_ATSC)
{
vverbose("Adapter %u is a '%s' ATSC card", adapter, fe_info.name);
return "azap";
}
else
{
vverbose("Adapter %u (%s); unknown card type %d", adapter, fe_info.name, fe_info.type);
return "";
}
}
int VisusAxisAlignedExtractor::produce()
{
VisusDataDescription dataset;
VisusFieldIndex field_index;
VisusGlobalTime current_time;
VisusDataRequest request;
VisusDataSource *old_source;
VisusBoundingBox query_region;
VisusBoundingBox bbox;
std::vector<double> left_lower; // Left lower corner of the domain bounding box
std::vector<double> right_upper; // Right upper corner o fthe domain bounding box
VisusUnit unit; // The physical unit of the domain
//fprintf(stderr,"VisusAxisAlignedExtractor::produce()\n");
// flag to indicate whether we should produce at all
bool must_produce = false;
/* The following code is very similar to the code in the
* extractinLoop except that the variables are used slighlty
* differently. In the extraction loop the local variables in the
* loop store the information of the previous extraction and the
* member variables are used to synchronize with the shared
* values. Here the opposite strategy is used. The member variables
* store the last request data etc. while the local variables are
* updated from the shared values.
*/
// Access the dataset, data request, and field index currently
// stored in our parameter list
getValue(dataset);
getValue(request);
getValue(field_index);
getValue(current_time);
// If the dataset has changed
if (mDataDescription != dataset) {
mDataDescription = dataset;
// store the out-dated data source
old_source = mDataSource;
// Create a new appropriate data source
mDataSource = VisusDataSourceFactory::make(dataset);
// Store the data source specific domain attribute
unit = mDataSource->unit();
// Get the new domain box
mDataSource->domainBoundingBox(bbox);
// And make sure that our bouding box is up to date
this->setValue(bbox);
// Get the new time parameters
mCurrentTime = mDataSource->timeInfo();
// And update the shared parameter accordingly
setValue(mCurrentTime);
// Delete the now obsolete data source
delete old_source;
// indicate that we have to produce new data
must_produce = true;
}
// If the current data source for some reason is not valid
if (!mDataSource->isValid()) {
vmessage("Data source not valid cannot produce.\nDataDescriptor:\n%s\n",dataset.c_str());
// We cannot do anything
return 0;
}
// If we have a valid data source we want to make sure that the
// request reflects the current bounding box.
mRequest.domainBBox(bbox);
setValue(mRequest);
// Store the data source specific domain attribute
unit = mDataSource->unit();
mDataSource->domainBoundingBox(left_lower,right_upper);
// If the scalar function has changed
if (mFieldIndex != field_index) {
mFieldIndex = field_index;
must_produce = true;
}
// If the field index is out of range
if ((field_index < 0) || (field_index >= mDataSource->numberOfFields())) {
vmessage("Field index %d out of range for this data set, cannot extract data",(int)field_index);
return 0;
}
/*
// See above for comments
// If the field index is out of range
if ((current_time < mDataSource->timeBegin()) ||
(current_time > mDataSource->timeEnd()))
{
vwarning("Current time out of range for this data set, cannot extract data");
return 0;
}
*/
// If current time has changed
if (mCurrentTime != current_time) {
mCurrentTime = current_time;
must_produce = true;
vverbose("VisusAxisAlignedExtractor - Time has changed!\n", VISUS_TIME_VERBOSE);
}
// If we have gotten a new request
if (mRequest != request) {
mRequest = request;
must_produce = true;
}
// If the current request is not valid
if (!request.valid()) {
vwarning("DataRequest invalid cannot extract data");
return 0;
}
if (must_produce) {
// Copy the data source dependent information into mData. Note
// that even though this information only changes when a new data
// source is opened the copy here is necessary. Currently, some
// data is passed on by swapping in which case the current unit
// and domain bounding box might be invalid for the new data we
// want to extract. Maybe for performance reasons this should be
// changed later.
mData.unit(unit);
//mData.setDomainBoundingBox(left_lower,right_upper);
// First we determined the actual bounding box of the query region
// Since this is an axis-aligned extractor we assume that the
// transformed extent is still axis aligned. Otherwise, we will
// inflate the bbox.
query_region = request.queryRegion();
// Access the data
if (mDataSource->accessAlignedData(query_region.leftLower(),query_region.rightUpper(),
request.startStrides(),request.endStrides(),request.endStrides(),
field_index, current_time.time(),
mData, this->mProductLock) != 0) {
// If the data access was successful then we have extracted a
// valid piece of data and the mProductLock is *locked*
// If the data is supposed to be lower dimensional we
// potentially have to compact the dimensions and adjust the
// matrices
if (request.requestType() == VISUS_1D_REQUEST)
mData.compactDimensions(1);
else if (request.requestType() == VISUS_2D_REQUEST)
mData.compactDimensions(2);
if (this->mProductLock.unlock() == 0)
vwarning("Could not unlock data after loading new data.");
}
else {
vwarning("Data access failed could not extract data.");
return 0;
}
}
return 1;
}
void* VisusAxisAlignedExtractor::extractionLoop(void *)
{
VisusDataDescription dataset; // The name of the data set we are
// working on
VisusFieldIndex field_index; // The index of the current field we
// are extracting
VisusGlobalTime current_time; // The time of field we are extracting
VisusDataRequest request; // The current request
VisusDataSource *old_source;
int stride_index;
std::vector<int> strides(3);
std::vector<double> extent(3);
VisusBoundingBox bbox; // The domain bounding box of the data
VisusUnit unit; // The physical unit of the domain
VisusBoundingBox query_region;
// Make sure the constructor of the thread is finished
while (mThread == NULL)
sleepmillisec(sUpdateInterval);
// Indicate that we have started processing
mThread->status(WORKING);
// Until we get an outside signal to stop we continue
while (!mThread->terminated()) {
////////////////////////////////////////////////////////////
////// Stage 1: Request Synchronization //////////
////////////////////////////////////////////////////////////
// Access the dataset, data request, and field index currently
// stored in our parameter list
getValue(mDataDescription);
getValue(mRequest);
getValue(mFieldIndex);
getValue(mCurrentTime);
// If the dataset has changed
if (mDataDescription != dataset) {
dataset = mDataDescription;
// store the out-dated data source
old_source = mDataSource;
// Indicate that we have not worked on this data at all
stride_index = -1;
// Create a new appropriate data source
mDataSource = VisusDataSourceFactory::make(dataset);
//sleepmillisec(100);
//fprintf(stderr,"Continue exraction\n");
// Store the data source specific domain attribute
unit = mDataSource->unit();
// Get the new domain box
mDataSource->domainBoundingBox(bbox);
// And make sure that our bouding box is up to date
this->setValue(bbox);
// Get the new time parameters
mCurrentTime = mDataSource->timeInfo();
// And update the shared parameter accordingly
setValue(mCurrentTime);
// Delete the now obsolete data source
delete old_source;
}
// If the current data source for some reason is not valid
if (!mDataSource->isValid()) {
// Indicate that we cannot work on anything
mStatus = VISUS_EXTRACTION_INVALID;
// Make clear that we have just verified our status
mSynchronizationFlag = false;
vmessage("Data source not valid extraction will hold.\nDataDescriptor:\n%s\n",dataset.c_str());
// Wait till hopefully new valid values come it
sleepmillisec(sUpdateInterval);
// and start over
continue;
}
// If we have a valid data source we want to make sure that the
// request reflects the current bounding box.
mRequest.domainBBox(bbox);
// Copy the data source dependent information into mData. Note
// that even though this information only changes when a new data
// source is opened the copy here is necessary. Currently, some
// data is passed on by swapping in which case the current unit
// and domain bounding box might be invalid for the new data we
// want to extract. Maybe for performance reasons this should be
// changed later.
mData.unit(unit);
// If the scalar function has changed
if (mFieldIndex != field_index) {
field_index = mFieldIndex;
stride_index = -1;
}
// If the field index is out of range
if ((field_index < 0) || (field_index >= mDataSource->numberOfFields())) {
// Indicate that we cannot work on anything
mStatus = VISUS_EXTRACTION_INVALID;
// Make clear that we have just verified our status
mSynchronizationFlag = false;
vmessage("Field index %d out of range for this data set, cannot extract data",(int)field_index);
// Wait till hopefully new valid values come it
sleepmillisec(sUpdateInterval);
// and start over
continue;
}
// If the current time requested has changed
if (mCurrentTime != current_time) {
current_time = mCurrentTime;
vverbose("VisusAxisAlignedExtractor - Time has changed!\n", VISUS_TIME_VERBOSE);
// Indicate that we have not worked on this data at all
stride_index = -1;
}
/*
// In the new implementation of VisusGlobalTime and the data
// source the data source will automatically clamp any illegal
// value to the closest valid one. Thus this test is no longer
// necessary. However, this might trigger a "busy" wait if the
// extractor continuously feeds incorrect data to the data
// source. If this ever becomes an issue (it shouldn't since the
// global shared time should reflect the data souce time) this
// code needs to be re-activated. (ptb 03/05/09)
// If the field index is out of range
if ((current_time < mDataSource->timeBegin()) ||
(current_time > mDataSource->timeEnd())) {
vwarning("Current time %s out of range for this data set, cannot extract data",current_time.time().toString().c_str());
// Indicate that we cannot work on anything
mStatus = VISUS_EXTRACTION_INVALID;
// Make clear that we have just verified our status
mSynchronizationFlag = false;
// Wait till hopefully new valid values come it
sleepmillisec(sUpdateInterval);
// and start over
continue;
}
*/
// If we have gotten a new request
if (mRequest != request) {
request = mRequest;
setValue(mRequest);
stride_index = -1;
}
// If the current request is not valid
if (!request.valid()) {
mStatus = VISUS_EXTRACTION_INVALID;
// Make clear that we have just verified our status
mSynchronizationFlag = false;
vwarning("DataRequest invalid cannot extract data");
sleepmillisec(sUpdateInterval);
continue;
}
////////////////////////////////////////////////////////////
////// Stage 2: Resolution Refinement //////////
////////////////////////////////////////////////////////////
// If we have already worked on the finest resolution requested
if (stride_index == request.numberOfResolutions()-1) {
// Indicate that we are done with the last request
mStatus = VISUS_EXTRACTION_FINISHED;
// Make clear that we have just verified our status
mSynchronizationFlag = false;
sleepmillisec(sUpdateInterval);
continue;
}
// Increase our target resolution
stride_index++;
// Set our status depending on whether we are starting or refining
// this request
if (stride_index == 0)
mStatus = VISUS_EXTRACTION_STARTED;
else
mStatus = VISUS_EXTRACTION_REFINING;
// Make clear that we just verified our status
mSynchronizationFlag = false;
strides = request.strides(stride_index);
////////////////////////////////////////////////////////////
////// Stage 4: Extracting Data //////////
////////////////////////////////////////////////////////////
// First we determined the actual bounding box of the query region
// Since this is an axis-aligned extractor we assume that the
// transformed extent is still axis aligned. Otherwise, we will
// inflate the bbox.
query_region = request.queryRegion();
/*
fprintf(stderr,"VisusAxisAlignedExtractor::extractionLoop accessing Data\n");
fprintf(stderr,"[%f,%f,%f] x [%f,%f,%f] at strides <%d,%d,%d>\n\n",
query_region.leftLower()[0],query_region.leftLower()[1],query_region.leftLower()[2],
query_region.rightUpper()[0],query_region.rightUpper()[1],query_region.rightUpper()[2],
strides[0],strides[1],strides[2]);
*/
// Access the data
if (mDataSource->accessAlignedData(query_region.leftLower(),query_region.rightUpper(),
request.startStrides(),request.endStrides(),strides,
field_index, current_time.time(),
mData, this->mProductLock) != 0) {
// If the data access was successful then we have extracted a
// valid piece of data and the mProductLock is *locked*
// If the data is supposed to be lower dimensional we
// potentially have to compact the dimensions and adjust the
// matrices
if (request.requestType() == VISUS_1D_REQUEST)
mData.compactDimensions(1);
else if (request.requestType() == VISUS_2D_REQUEST)
mData.compactDimensions(2);
if (this->mProductLock.unlock() == 0)
vwarning("Could not unlock data after loading new data.");
this->markAsDirty();
}
}
mThread->status(FINISHED);
return NULL;
}
int main(int argc, char *argv[])
{
int i;
struct timespec ts;
/* Parse command line */
for (i = 1; i < argc; i++) {
if (!strcmp(argv[i], "-h")) {
usage(argv[0]);
return 0;
}
}
for (i = 1; i < argc; i++) {
if (!strcmp(argv[i], "-l")) {
NEXT_ARG(i);
l = atoi(argv[i]);
} else if (!strcmp(argv[i], "-a")) {
NEXT_ARG(i);
if (!strcasecmp(argv[i], "SHA1"))
algo = TA_SHA_SHA1;
else if (!strcasecmp(argv[i], "SHA224"))
algo = TA_SHA_SHA224;
else if (!strcasecmp(argv[i], "SHA256"))
algo = TA_SHA_SHA256;
else if (!strcasecmp(argv[i], "SHA384"))
algo = TA_SHA_SHA384;
else if (!strcasecmp(argv[i], "SHA512"))
algo = TA_SHA_SHA512;
else {
fprintf(stderr, "%s, invalid algorithm\n",
argv[0]);
usage(argv[0]);
return 1;
}
} else if (!strcmp(argv[i], "-n")) {
NEXT_ARG(i);
n = atoi(argv[i]);
} else if (!strcmp(argv[i], "-r")) {
random_in = 1;
} else if (!strcmp(argv[i], "-s")) {
NEXT_ARG(i);
size = atoi(argv[i]);
} else if (!strcmp(argv[i], "-u")) {
offset = 1;
} else if (!strcmp(argv[i], "-v")) {
verbosity++;
} else if (!strcmp(argv[i], "-w")) {
NEXT_ARG(i);
warmup = atoi(argv[i]);
} else {
fprintf(stderr, "%s: invalid argument: %s\n",
argv[0], argv[i]);
usage(argv[0]);
return 1;
}
}
vverbose("sha-perf version %s\n", TO_STR(VERSION));
if (clock_getres(CLOCK_MONOTONIC, &ts) < 0) {
perror("clock_getres");
return 1;
}
vverbose("Clock resolution is %lu ns\n", ts.tv_sec*1000000000 +
ts.tv_nsec);
open_ta();
prepare_op();
run_test(size, n, l);
return 0;
}
bool
tune_service_id(unsigned int adapter, unsigned int frontend, unsigned int timeout, uint16_t service_id, int* tuner_fd)
{
char fe_dev[PATH_MAX];
bool got_info;
struct dvb_frontend_info fe_info;
struct dvb_frontend_parameters current_params;
struct dvb_frontend_parameters needed_params;
char polarity;
unsigned int sat_no;
bool hi_lo;
struct dvb_frontend_event event;
// fe_status_t status;
bool lock;
/* need to keep the frontend device open to stop it untuning itself */
static int fe_fd = -1;
static bool first_time = true;
#if 0
if (*tuner_fd = -1)
{
fe_fd = -1;
bool first_time = true;
}
#endif
if(fe_fd < 0)
{
snprintf(fe_dev, sizeof(fe_dev), FE_DEVICE, adapter, frontend);
/*
* need O_RDWR if you want to tune, O_RDONLY is okay for getting info
* if someone else is using the frontend, we can only open O_RDONLY
* => we can still download data, but just not retune
*/
if((fe_fd = open(fe_dev, O_RDWR | O_NONBLOCK)) < 0)
{
error("Unable to open '%s' read/write; you will not be able to retune", fe_dev);
if((fe_fd = open(fe_dev, O_RDONLY | O_NONBLOCK)) < 0)
fatal("open '%s': %s", fe_dev, strerror(errno));
/* don't try to tune in */
first_time = false;
}
}
vverbose("Getting frontend info");
do
{
/* maybe interrupted by a signal */
got_info = (ioctl(fe_fd, FE_GET_INFO, &fe_info) >= 0);
if(!got_info && errno != EINTR)
fatal("ioctl FE_GET_INFO: %s", strerror(errno));
}
while(!got_info);
/* see what we are currently tuned to */
if(ioctl(fe_fd, FE_GET_FRONTEND, ¤t_params) < 0)
fatal("ioctl FE_GET_FRONTEND: %s", strerror(errno));
/* find the tuning params for the service */
if(!get_tune_params(fe_info.type, service_id, &needed_params, &polarity, &sat_no))
{
error("service_id %u not found in channels.conf file", service_id);
return false;
}
/*
* if no-one was using the frontend when we open it
* FE_GET_FRONTEND may say we are tuned to the frequency we want
* but when we try to read any data, it fails
* checking if we have a lock doesn't seem to work
* so, always retune the first time we are called
*/
#if 0
if(ioctl(fe_fd, FE_READ_STATUS, &status) < 0)
lock = false;
else
lock = status & FE_HAS_LOCK;
#endif
/* are we already tuned to the right frequency */
vverbose("Current frequency %u; needed %u; first_time=%d", current_params.frequency, needed_params.frequency, first_time);
/* frequency resolution is up to 1 kHz */
if(first_time
|| abs(current_params.frequency - needed_params.frequency) >= ONE_kHz)
{
first_time = false;
verbose("Retuning to frequency %u", needed_params.frequency);
/* empty event queue */
while(ioctl(fe_fd, FE_GET_EVENT, &event) >= 0)
; /* do nothing */
/* do DISEQC (whatever that is) for DVB-S */
if(fe_info.type == FE_QPSK)
{
if(needed_params.frequency < SLOF)
{
needed_params.frequency -= LOF1;
hi_lo = false;
}
else
{
needed_params.frequency -= LOF2;
hi_lo = true;
}
if(do_diseqc(fe_fd, sat_no, polarity, hi_lo) < 0)
error("DISEQC command failed for service_id %u", service_id);
}
/* tune in */
if(ioctl(fe_fd, FE_SET_FRONTEND, &needed_params) < 0)
fatal("Unable to retune: ioctl FE_SET_FRONTEND: %s", strerror(errno));
/* wait for lock */
vverbose("Waiting for tuner to lock on");
/* TODO: use timeout value here */
struct timeval start, end;
gettimeofday(&start, NULL);
lock = false;
while(!lock)
{
if(ioctl(fe_fd, FE_GET_EVENT, &event) >= 0)
lock = event.status & FE_HAS_LOCK;
gettimeofday(&end, NULL);
if (end.tv_sec - start.tv_sec > 120)
return false;
}
vverbose("Retuned");
}
*tuner_fd = fe_fd;
return true;
}
void InputThread::verbose(_In_z_ _Printf_format_string_ TCHAR const * const format, ...) {
va_list argptr;
va_start(argptr, format);
vverbose(format, argptr);
va_end(argptr);
}
VisusSmartPointer<VisusGroup> VisusFactory::createNode(VisusNodeType nodeType)
{
switch (nodeType)
{
case VISUS_GROUP_NODE:
vverbose("creating group node\n", VISUS_XML_VERBOSE);
return constructNode<VisusGroup>();
case VISUS_SCENE_NODE:
vverbose("creating scene node\n", VISUS_XML_VERBOSE);
return constructNode<VisusSceneNode>();
case VISUS_ALIGNED_EXTRACTOR:
vverbose("creating aligned extractor node\n", VISUS_XML_VERBOSE);
return constructNode<VisusAxisAlignedExtractor>();
case VISUS_ORTHO_SLICE:
vverbose("creating orthogonal slice\n", VISUS_XML_VERBOSE);
return constructNode<VisusOrthogonalSlice>();
case VISUS_TEXT_NODE:
vverbose("creating text node\n", VISUS_XML_VERBOSE);
return constructNode<VisusTextNode>();
case VISUS_SPHERE_NODE:
vverbose("creating sphere node\n", VISUS_XML_VERBOSE);
return constructNode<VisusSphereNode>();
case VISUS_COLOR_BAR:
vverbose("creating color bar\n", VISUS_XML_VERBOSE);
return constructNode<VisusColorBar>();
case VISUS_TICK_MARKS:
vverbose("creating tick marks\n", VISUS_XML_VERBOSE);
return constructNode<VisusTickMarks>();
case VISUS_ISOSURFACE:
vverbose("creating isosurface\n", VISUS_XML_VERBOSE);
return constructNode<VisusIsoSurface>();
case VISUS_DATA_PROBE:
vverbose("creating data probe\n", VISUS_XML_VERBOSE);
return constructNode<VisusDataProbe>();
case VISUS_SHAPES_NODE:
vverbose("creating shapes\n", VISUS_XML_VERBOSE);
return constructNode<VisusShapesNode>();
case VISUS_MESH_NODE:
vverbose("creating mesh node\n", VISUS_XML_VERBOSE);
return constructNode<VisusMeshDisplay>();
case VISUS_LABEL_NODE:
vverbose("creating label node\n", VISUS_XML_VERBOSE);
return constructNode<VisusLabelNode>();
case VISUS_TEXTURE_VIEWER:
vverbose("creating texture viewer\n", VISUS_XML_VERBOSE);
return constructNode<VisusTextureViewer>();
case VISUS_EARTH_NODE:
vverbose("creating earth node\n", VISUS_XML_VERBOSE);
return constructNode<VisusEarthNode>();
case VISUS_SPHERE_SLICE:
vverbose("creating sphere slice\n", VISUS_XML_VERBOSE);
return constructNode<VisusSphereSlice>();
case VISUS_LINE_GRAPH:
vverbose("creating line graph\n", VISUS_XML_VERBOSE);
return constructNode<VisusLineGraph>();
case VISUS_HISTOGRAM:
vverbose("creating histogram\n", VISUS_XML_VERBOSE);
return constructNode<VisusHistogram>();
case VISUS_COLORED_ISOSURFACE:
vverbose("creating colored isosurface\n", VISUS_XML_VERBOSE);
return constructNode<VisusColoredIsoSurface>();
case VISUS_HEIGHT_FIELD:
vverbose("creating height field\n", VISUS_XML_VERBOSE);
return constructNode<VisusHeightField>();
default:
{
std::stringstream ss;
ss << "unknown type (" << nodeType << "). VisusFactory does not know how to create";
vwarning(ss.str().c_str());
}
}
return pVisusGroup();
}
