int Scrollbar::thumbPosition()
{
if (!totalSize())
return 0;
int trackLen = trackLength();
float proportion = static_cast<float>(currentPos()) / totalSize();
return round(proportion * trackLen);
}
int Scrollbar::thumbLength()
{
int trackLen = trackLength();
if (!totalSize())
return trackLen;
float proportion = static_cast<float>(visibleSize()) / totalSize();
int length = round(proportion * trackLen);
length = std::min(std::max(length, minimumThumbLength()), trackLen);
return length;
}
void RemoteProtocol::listRoot()
{
KIO::UDSEntry entry;
KIO::UDSEntryList remote_entries;
m_impl.listRoot(remote_entries);
totalSize(remote_entries.count()+2);
m_impl.createTopLevelEntry(entry);
listEntry(entry, false);
m_impl.createWizardEntry(entry);
listEntry(entry, false);
KIO::UDSEntryList::ConstIterator it = remote_entries.constBegin();
const KIO::UDSEntryList::ConstIterator end = remote_entries.constEnd();
for(; it!=end; ++it)
{
listEntry(*it, false);
}
entry.clear();
listEntry(entry, true);
finished();
}
void BufferedTransport::setReadPos(size_t pos) {
ScopedMutexLock(lock_);
if(pos >= totalSize())
throw ProtocolException("readpos less than 0 by rewind");
readPos_ = pos;
}
void AbstractLut::reset( size_t dimSize, double* data /* = NULL */ )
{
if( _data && !_shared )
delete [] _data;
_dimSize = dimSize;
if( _data == NULL )
{
_data = new double[ totalSize() * 3 ];
memset( _data, 0, sizeof( double ) * totalSize() * 3 );
}
_data = data;
_shared = false;
if( _interpolator )
delete _interpolator;
_interpolator = new TrilinInterpolator();
}
// PD_TRACE_DECLARE_FUNCTION ( SDB__DMSSU_DUMPINFO2, "_dmsStorageUnit::dumpInfo" )
void _dmsStorageUnit::dumpInfo ( set<_monStorageUnit> &storageUnitList,
BOOLEAN sys )
{
monStorageUnit su ;
const dmsStorageUnitHeader *dataHeader = _pDataSu->getHeader() ;
PD_TRACE_ENTRY ( SDB__DMSSU_DUMPINFO2 ) ;
if ( !sys && dmsIsSysCSName( CSName() ) )
{
goto done ;
}
ossMemset ( su._name, 0, sizeof ( su._name ) ) ;
ossStrncpy ( su._name, CSName(), DMS_SU_NAME_SZ ) ;
su._pageSize = getPageSize() ;
su._lobPageSize = getLobPageSize() ;
su._sequence = CSSequence() ;
su._numCollections = dataHeader->_numMB ;
su._collectionHWM = dataHeader->_MBHWM ;
su._size = totalSize() ;
su._CSID = CSID() ;
su._logicalCSID = LogicalCSID() ;
storageUnitList.insert ( su ) ;
done :
PD_TRACE_EXIT ( SDB__DMSSU_DUMPINFO2 ) ;
}
void MainWindow::scaleImage(double factor)
{
ui->scrollArea->setWidgetResizable(false);
double scrollfactor = (scaleFactor + factor) / scaleFactor;
scaleFactor += factor;
for (int i = 0; i < camNumber; ++i)
{
frameProcessor[i].setOutScaleFactor(scaleFactor);
switch(i)
{
case 0:
ui->imageLabel1->resize(currentSize);
break;
case 1:
ui->imageLabel2->resize(currentSize);
break;
default:
throw std::logic_error("There is no camera with index" + std::to_string(i));
}
}
QSize totalSize(currentSize.width() * 2, currentSize.height());
ui->scrollArea->widget()->resize(totalSize);
adjustScrollBar(ui->scrollArea->horizontalScrollBar(), scrollfactor);
adjustScrollBar(ui->scrollArea->verticalScrollBar(), scrollfactor);
updateStatusBar();
}
// -----------------------------------------------------------------------------
// CHttpDownloadManagerServerEngine::AllDownloadsSizeInDriveL
// ?implementation_description
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//
TInt CHttpDownloadManagerServerEngine::AllDownloadsSizeInDriveL(const CHttpDownload *aDownload, TInt aDriveId) const
{
LOGGER_ENTERFN( "AllDownloadsSizeInDriveL" );
TInt allDownloadsSize( 0 );
TInt numClientApps = iClientApps->Count();
for( TInt apps = 0; apps < numClientApps; ++apps )
{
CArrayPtrFlat<CHttpDownload>* dlArray = (*iClientApps)[apps]->Downloads();
TInt numDownloads = dlArray->Count();
for( TInt dl = 0; dl < numDownloads; ++dl )
{
if( ( aDownload != (*dlArray)[dl]) && (*dlArray)[dl]->State() != EHttpDlMultipleMOCompleted
&& aDriveId == (*dlArray)[dl]->GetDestinationDriveID())
{
TInt32 totalSize(0);
TInt32 downloadedSize(0);
(*dlArray)[dl]->GetIntAttributeL(EDlAttrMultipleMOLength, totalSize);
(*dlArray)[dl]->GetIntAttributeL(EDlAttrMultipleMODownloadedSize, downloadedSize);
//Do not conside the downloads with unknown size
if(KDefaultContentLength != totalSize)
allDownloadsSize += (totalSize - downloadedSize);
}
}
}
return allDownloadsSize;
}
void MediaProtocol::listRoot()
{
KIO::UDSEntry entry;
KIO::UDSEntryList media_entries;
bool ok = m_impl.listMedia(media_entries);
if (!ok)
{
error( m_impl.lastErrorCode(), m_impl.lastErrorMessage() );
return;
}
totalSize(media_entries.count()+1);
m_impl.createTopLevelEntry(entry);
listEntry(entry, false);
KIO::UDSEntryListIterator it = media_entries.begin();
KIO::UDSEntryListIterator end = media_entries.end();
for(; it!=end; ++it)
{
listEntry(*it, false);
}
entry.clear();
listEntry(entry, true);
finished();
}
void AtlasTexture::commitFull(Image const &fullImage) const
{
DENG2_ASSERT(fullImage.size() == totalSize());
// While the Atlas is const, the texture isn't...
const_cast<AtlasTexture *>(this)->setImage(fullImage);
}
/**
* \brief Remove directories until total size > watermark
*/
void Scanner::removeDirs()
{
Directory *dir, *parent;
while (totalSize() > _watermark) {
dir = getDirToRemove();
if (!dir) {
MSG_WARNING(msg_module, "cannot remove data (only active directories)");
return;
}
MSG_DEBUG(msg_module, "remove %s", dir->getName().c_str());
_cleaner->removeDir(dir->getName());
/* Remove dir from its parent */
parent = dir->getParent();
parent->removeOldest();
/* Update parent's age to the second oldest subdir and correct it's size */
while (parent) {
parent->updateAge();
parent->setSize(parent->getSize() - dir->getSize());
parent = parent->getParent();
}
delete dir;
if (_multiple) {
/* Multiple data witers - sort top dirs so next time we remove the oldest dir again */
_rootdir->sortChildren();
}
}
}
//--------------------------------------------
// FUNCTION: printdir
// It prints the file list, given as an argument.
// The print format depends on flagl, if
// flagl is 0 prints only file names
// else if flagl is 1, it prints detailed information
// PARAMETERS:
// struct dirent **flist
// - The list of the files to be printed.
// int length
// - The length of the file list.
// char *dirpath
// - The path of the directory from which the file
// list comes. This path is needed to get
// file stats in -l mode.
//----------------------------------------------
void printdir(struct dirent **flist, int length, char *dirpath) {
int i;
struct stat fstat;
if(!flagl) {
if(flagmulti) {
printf("%s:\n", dirpath);
}
for (i = 0; i < length; ++i) {
printf("%s ", flist[i]->d_name);
}
printf("\n");
} else {
if(flagmulti) {
printf("%s:\n", dirpath);
}
// prints the total number of blocks, used in the directory
printf("total %d\n", totalSize(dirpath));
for(i = 0; i < length; ++i) {
char path[200];
strcpy(path, dirpath);
strcat(path, "/");
strcat(path,flist[i] -> d_name);
stat(path, &fstat);
// prints file permissions
printf((S_ISDIR(fstat.st_mode)) ? "d" : "-");
printf((fstat.st_mode & S_IRUSR) ? "r" : "-");
printf((fstat.st_mode & S_IWUSR) ? "w" : "-");
printf((fstat.st_mode & S_IXUSR) ? "x" : "-");
printf((fstat.st_mode & S_IRGRP) ? "r" : "-");
printf((fstat.st_mode & S_IWGRP) ? "w" : "-");
printf((fstat.st_mode & S_IXGRP) ? "x" : "-");
printf((fstat.st_mode & S_IROTH) ? "r" : "-");
printf((fstat.st_mode & S_IWOTH) ? "w" : "-");
printf((fstat.st_mode & S_IXOTH) ? "x" : "-");
// prints the number of links to this file
printf(" %d", (int) fstat.st_nlink);
// prints the owner name
printf(" %s", getpwuid(fstat.st_uid)->pw_name);
// prints the group name
printf(" %s", getgrgid(fstat.st_gid)->gr_name);
// prints the number of block used by this file
printf(" %5d", (int) fstat.st_size);
// prints the time of last modification
char mtime[20];
strftime(mtime, 20,"%b %d %R", localtime(&fstat.st_mtime));
printf(" %s", mtime);
// prints the file name
printf(" %s", flist[i] -> d_name);
printf("\n");
}
}
}
SnapshotItem(const IFileContainer *container, const Location &fileName, const struct RARHeaderDataEx &info, SnapshotItem *parent) :
::VFS::SnapshotItem(container, unpackedSize(info), parent)
{
m_data.path = QString::fromWCharArray(info.FileNameW);
m_data.fileName = fileName;
m_data.fileSize = totalSize();
m_data.lastModified = fromDosTime(info.FileTime);
}
void TrashProtocol::listDir(const KUrl& url)
{
INIT_IMPL;
kDebug() << "listdir: " << url;
if ( url.path(KUrl::AddTrailingSlash) == QLatin1String("/") ) {
listRoot();
return;
}
int trashId;
QString fileId;
QString relativePath;
bool ok = TrashImpl::parseURL( url, trashId, fileId, relativePath );
if ( !ok ) {
error( KIO::ERR_SLAVE_DEFINED, i18n( "Malformed URL %1", url.prettyUrl() ) );
return;
}
//was: const QString physicalPath = impl.physicalPath( trashId, fileId, relativePath );
// Get info for deleted directory - the date of deletion and orig path will be used
// for all the items in it, and we need the physicalPath.
TrashedFileInfo info;
ok = impl.infoForFile( trashId, fileId, info );
if ( !ok || info.physicalPath.isEmpty() ) {
error( impl.lastErrorCode(), impl.lastErrorMessage() );
return;
}
if ( !relativePath.isEmpty() ) {
info.physicalPath += QLatin1Char('/');
info.physicalPath += relativePath;
}
// List subdir. Can't use kio_file here since we provide our own info...
kDebug() << "listing " << info.physicalPath;
const QStringList entryNames = impl.listDir( info.physicalPath );
totalSize( entryNames.count() );
KIO::UDSEntry entry;
for ( QStringList::const_iterator entryIt = entryNames.begin(), entryEnd = entryNames.end();
entryIt != entryEnd ; ++entryIt )
{
const QString fileName = *entryIt;
if (fileName == QLatin1String(".."))
continue;
const QString filePath = info.physicalPath + QLatin1Char('/') + fileName;
// shouldn't be necessary
//const QString url = TrashImpl::makeURL( trashId, fileId, relativePath + '/' + fileName );
entry.clear();
TrashedFileInfo infoForItem( info );
infoForItem.origPath += QLatin1Char('/');
infoForItem.origPath += fileName;
if (createUDSEntry(filePath, fileName, fileName, entry, infoForItem)) {
listEntry( entry, false );
}
}
entry.clear();
listEntry( entry, true );
finished();
}
AlignedArray getAsArray() const {
AlignedArray ret(totalSize(), false);
size_t off = 0;
for (const AlignedArray& ary : v_) {
::memcpy(&ret[off], ary.data(), ary.size());
off += ary.size();
}
return ret;
}
void ApplicationsProtocol::listDir(const KUrl& url)
{
QString groupPath = url.path( KUrl::AddTrailingSlash );
groupPath.remove(0, 1); // remove starting '/'
KServiceGroup::Ptr grp = KServiceGroup::group(groupPath);
if (!grp || !grp->isValid()) {
error(KIO::ERR_DOES_NOT_EXIST, groupPath);
return;
}
unsigned int count = 0;
KIO::UDSEntry entry;
foreach (const KSycocaEntry::Ptr &e, grp->entries(true, true)) {
if (e->isType(KST_KServiceGroup)) {
KServiceGroup::Ptr g(KServiceGroup::Ptr::staticCast(e));
QString groupCaption = g->caption();
kDebug() << "ADDING SERVICE GROUP WITH PATH " << g->relPath();
// Avoid adding empty groups.
KServiceGroup::Ptr subMenuRoot = KServiceGroup::group(g->relPath());
if (subMenuRoot->childCount() == 0)
continue;
// Ignore dotfiles.
if ((g->name().at(0) == '.'))
continue;
QString relPath = g->relPath();
KUrl dirUrl = url; // preserve protocol, whether that's programs:/ or applications:/
dirUrl.setPath('/' + relPath);
dirUrl.adjustPath(KUrl::RemoveTrailingSlash);
kDebug() << "ApplicationsProtocol: adding entry" << dirUrl;
createDirEntry(entry, groupCaption, dirUrl.url(), "inode/directory", g->icon());
} else {
KService::Ptr service(KService::Ptr::staticCast(e));
kDebug() << "the entry name is" << service->desktopEntryName()
<< "with path" << service->entryPath();
if (!service->isApplication()) // how could this happen?
continue;
createFileEntry(entry, service, url);
}
listEntry(entry, false);
count++;
}
totalSize(count);
listEntry(entry, true);
finished();
}
void MainWindow::setImage(const QImage &img, int imgIndex)
{
currentQImage[imgIndex] = img;
QSize totalSize(currentSize.width() * 2, currentSize.height());
ui->scrollArea->widget()->resize(totalSize);
update();
updateActions();
}
grid(std::vector<size_t> & sz)
: size_tot(totalSize(sz)), sz(sz)
{
sz_s.resize(sz.size());
sz_s[0] = sz[0];
for (size_t i = 1 ; i < sz.size() ; i++)
{
sz_s[i] = sz[i]*sz_s[i-1];
}
};
void testEmpty(){
printf("Testing empty stack\n");
Stack s = NULL;
s = createStack();
assert(s != NULL);
printf("%d\n", numPancakes(s));
assert(numPancakes(s) == 0);
assert(totalSize(s) == 0);
printf("%d\n",totalSize(s));
eatPancake(s);
printToppings(s);
printf("\n");
consumeStack(s);
}
void AtlasTexture::commit(Image const &image, Vector2i const &topLeft) const
{
GLTexture *tex = const_cast<AtlasTexture *>(this);
if(size() == GLTexture::Size(0, 0))
{
// Hasn't been full-committed yet.
tex->setUndefinedImage(totalSize(), Image::RGBA_8888);
}
tex->setSubImage(image, topLeft);
}
void AtlasTexture::commit(Image const &fullImage, Rectanglei const &subregion) const
{
GLTexture *tex = const_cast<AtlasTexture *>(this);
if (size() == GLTexture::Size(0, 0))
{
// Hasn't been full-committed yet.
tex->setUndefinedImage(totalSize(), Image::RGBA_8888);
}
tex->setSubImage(fullImage, subregion);
}
void testOne(void){
printf("Testing one pancake\n");
Stack s = NULL;
s = createStack();
assert(s != NULL);
addPancake(s, "blueberry",10);
printf("%d\n", numPancakes(s));
assert(numPancakes(s) == 1);
assert(totalSize(s) == 10);
printf("%d\n",totalSize(s));
printToppings(s);
printf("\n");
eatPancake(s);
consumeStack(s);
}
/**
* \brief Main loop
*/
void Scanner::loop()
{
prctl(PR_SET_NAME, "fbitexp:Scanner\0", 0, 0, 0);
std::mutex mtx;
std::unique_lock<std::mutex> lock(mtx);
MSG_DEBUG(msg_module, "started");
while (!_done) {
/*
* This is before waiting because we want to check size on startup before
* any scan or add requests
*/
if (totalSize() > _max_size) {
removeDirs();
}
MSG_DEBUG(msg_module, "Total size: %s, Max: %s, Watermark: %s",
sizeToStr(totalSize()).c_str(), sizeToStr(_max_size).c_str(), sizeToStr(_watermark).c_str());
_cv.wait(lock, [&]{ return scanCount() > 0 || addCount() > 0 || _done || totalSize() > _max_size; });
if (_done) {
break;
}
/* Add dirs from queue */
if (addCount() > 0) {
addNewDirs();
}
/* Scan dirs in queue */
if (scanCount() > 0) {
rescanDirs();
}
}
MSG_DEBUG(msg_module, "closing thread");
}
void testTooManyPancakes(void){
printf("Testing too many blueberry pancakes\n");
Stack s = NULL;
s = createStack();
assert(s != NULL);
int i;
for(i = 0; i < MAX_PANCAKES+3; i++){
addPancake(s, "blueberry",10);
}
printf("%d\n", numPancakes(s));
assert(numPancakes(s) == 40);
assert(totalSize(s) == 400);
printf("%d\n",totalSize(s));
printToppings(s);
printf("\n");
consumeStack(s);
}
/*!
* \brief Parses the header read using the specified \a reader.
* \throws Throws InvalidDataException if the data read from the stream is
* no valid frame header.
*/
void AdtsFrame::parseHeader(IoUtilities::BinaryReader &reader)
{
m_header1 = reader.readUInt16BE();
// check whether syncword is present
if ((m_header1 & 0xFFF6u) != 0xFFF0u) {
throw InvalidDataException();
}
m_header2 = hasCrc() ? reader.readUInt56BE() : (reader.readUInt40BE() << 16);
// check whether frame length is ok
if (totalSize() < headerSize()) {
throw InvalidDataException();
}
}
//////////////////////////////////////////////////////////////////////////
//cross entropy
float CrossEntropyFunctor::getLoss(const std::shared_ptr<DataBucket> labelDataBucket,
const std::shared_ptr<DataBucket> outputDataBucket)
{
const auto outputSize = outputDataBucket->getSize();
const float* labelData = labelDataBucket->getData().get();
const float* outputData = outputDataBucket->getData().get();
float loss = 0.0f;
for (size_t i = 0; i < outputSize.totalSize(); i++)
{
const float curLoss = -labelData[i] * std::log(outputData[i]);
loss = moving_average(loss, i+1, curLoss);
}
return loss*outputSize._3DSize();
}
Point2d OverlayCategory::doGetTotalSize()const
{
OverlaySPtr parent = getOverlay().getParent();
Size renderSize = getOverlay().getEngine()->getOverlayCache().getRenderer()->getSize();
Point2d totalSize( renderSize.getWidth(), renderSize.getHeight() );
if ( parent )
{
Point2d parentSize = parent->getAbsoluteSize();
totalSize[0] = parentSize[0] * totalSize[0];
totalSize[1] = parentSize[1] * totalSize[1];
}
return totalSize;
}
void KJob::setTotalAmount(Unit unit, qulonglong amount)
{
Q_D(KJob);
bool should_emit = (d->totalAmount[unit] != amount);
d->totalAmount[unit] = amount;
if ( should_emit )
{
emit totalAmount(this, unit, amount);
if (unit==d->progressUnit) {
emit totalSize(this, amount);
emitPercent(d->processedAmount[unit], d->totalAmount[unit]);
}
}
}
bool YUVScoper::init(GrYUVProvider* provider, SkYUVPlanesCache::Info* yuvInfo, void* planes[3],
bool useCache) {
if (useCache) {
fCachedData.reset(SkYUVPlanesCache::FindAndRef(provider->onGetID(), yuvInfo));
}
if (fCachedData.get()) {
planes[0] = (void*)fCachedData->data();
planes[1] = (uint8_t*)planes[0] + (yuvInfo->fSizeInfo.fWidthBytes[SkYUVSizeInfo::kY] *
yuvInfo->fSizeInfo.fSizes[SkYUVSizeInfo::kY].fHeight);
planes[2] = (uint8_t*)planes[1] + (yuvInfo->fSizeInfo.fWidthBytes[SkYUVSizeInfo::kU] *
yuvInfo->fSizeInfo.fSizes[SkYUVSizeInfo::kU].fHeight);
} else {
// Fetch yuv plane sizes for memory allocation.
if (!provider->onQueryYUV8(&yuvInfo->fSizeInfo, &yuvInfo->fColorSpace)) {
return false;
}
// Allocate the memory for YUV
size_t totalSize(0);
for (int i = 0; i < 3; i++) {
totalSize += yuvInfo->fSizeInfo.fWidthBytes[i] * yuvInfo->fSizeInfo.fSizes[i].fHeight;
}
if (useCache) {
fCachedData.reset(SkResourceCache::NewCachedData(totalSize));
planes[0] = fCachedData->writable_data();
} else {
fStorage.reset(totalSize);
planes[0] = fStorage.get();
}
planes[1] = (uint8_t*)planes[0] + (yuvInfo->fSizeInfo.fWidthBytes[SkYUVSizeInfo::kY] *
yuvInfo->fSizeInfo.fSizes[SkYUVSizeInfo::kY].fHeight);
planes[2] = (uint8_t*)planes[1] + (yuvInfo->fSizeInfo.fWidthBytes[SkYUVSizeInfo::kU] *
yuvInfo->fSizeInfo.fSizes[SkYUVSizeInfo::kU].fHeight);
// Get the YUV planes.
if (!provider->onGetYUV8Planes(yuvInfo->fSizeInfo, planes)) {
return false;
}
if (useCache) {
// Decoding is done, cache the resulting YUV planes
SkYUVPlanesCache::Add(provider->onGetID(), fCachedData, yuvInfo);
}
}
return true;
}
bool YUVScoper::init(GrYUVProvider* provider, SkYUVPlanesCache::Info* yuvInfo, void* planes[3],
bool useCache) {
if (useCache) {
fCachedData.reset(SkYUVPlanesCache::FindAndRef(provider->onGetID(), yuvInfo));
}
if (fCachedData.get()) {
planes[0] = (void*)fCachedData->data();
planes[1] = (uint8_t*)planes[0] + yuvInfo->fSizeInMemory[0];
planes[2] = (uint8_t*)planes[1] + yuvInfo->fSizeInMemory[1];
} else {
// Fetch yuv plane sizes for memory allocation. Here, width and height can be
// rounded up to JPEG block size and be larger than the image's width and height.
if (!provider->onGetYUVSizes(yuvInfo->fSize)) {
return false;
}
// Allocate the memory for YUV
size_t totalSize(0);
for (int i = 0; i < GrYUVProvider::kPlaneCount; ++i) {
yuvInfo->fRowBytes[i] = yuvInfo->fSize[i].fWidth; // we assume snug fit: rb == width
yuvInfo->fSizeInMemory[i] = yuvInfo->fRowBytes[i] * yuvInfo->fSize[i].fHeight;
totalSize += yuvInfo->fSizeInMemory[i];
}
if (useCache) {
fCachedData.reset(SkResourceCache::NewCachedData(totalSize));
planes[0] = fCachedData->writable_data();
} else {
fStorage.reset(totalSize);
planes[0] = fStorage.get();
}
planes[1] = (uint8_t*)planes[0] + yuvInfo->fSizeInMemory[0];
planes[2] = (uint8_t*)planes[1] + yuvInfo->fSizeInMemory[1];
// Get the YUV planes and update plane sizes to actual image size
if (!provider->onGetYUVPlanes(yuvInfo->fSize, planes, yuvInfo->fRowBytes,
&yuvInfo->fColorSpace)) {
return false;
}
if (useCache) {
// Decoding is done, cache the resulting YUV planes
SkYUVPlanesCache::Add(provider->onGetID(), fCachedData, yuvInfo);
}
}
return true;
}
