void AccessConfig::assign(const AccessConfig& s) {
setUsername (s.getUsername() );
setPassword (s.getPassword() );
setSyncURL (s.getSyncURL() );
setProxyHost(s.getProxyHost());
setProxyPort(s.getProxyPort());
setUserAgent(s.getUserAgent());
setProxyUsername(s.getProxyUsername());
setProxyPassword(s.getProxyPassword());
setBeginSync(s.getBeginSync());
setEndSync(s.getEndSync());
setFirstTimeSyncMode(s.getFirstTimeSyncMode());
setServerAuthRequired(s.getServerAuthRequired());
setClientAuthType(s.getClientAuthType());
setServerAuthType(s.getServerAuthType());
setServerPWD(s.getServerPWD());
setServerID(s.getServerID());
setServerNonce(s.getServerNonce());
setClientNonce(s.getClientNonce());
setMaxMsgSize(s.getMaxMsgSize());
setReadBufferSize(s.getReadBufferSize());
setCheckConn(s.getCheckConn());
setResponseTimeout(s.getResponseTimeout());
setCompression(s.getCompression());
dirty = s.getDirty();
}
void DCDataSet::create(const CollectionType& colType,
hid_t group, const Dimensions size, uint32_t ndims, bool compression)
throw (DCException)
{
log_msg(2, "DCDataSet::create (%s, size %s)", name.c_str(), size.toString().c_str());
if (opened)
throw DCException(getExceptionString("create: dataset is already open"));
// if the dataset already exists, remove/unlink it
// note that this won't free the memory occupied by this
// dataset, however, there currently is no function to delete
// a dataset
if (!checkExistence || (checkExistence && H5Lexists(group, name.c_str(), H5P_LINK_ACCESS_DEFAULT)))
H5Ldelete(group, name.c_str(), H5P_LINK_ACCESS_DEFAULT);
this->ndims = ndims;
this->compression = compression;
this->datatype = colType.getDataType();
getLogicalSize().set(size);
setChunking(colType.getSize());
setCompression();
if (getPhysicalSize().getScalarSize() != 0)
{
hsize_t *max_dims = new hsize_t[ndims];
for (size_t i = 0; i < ndims; ++i)
max_dims[i] = H5F_UNLIMITED;
dataspace = H5Screate_simple(ndims, getPhysicalSize().getPointer(), max_dims);
delete[] max_dims;
max_dims = NULL;
} else
dataspace = H5Screate(H5S_NULL);
if (dataspace < 0)
throw DCException(getExceptionString("create: Failed to create dataspace"));
// create the new dataset
dataset = H5Dcreate(group, this->name.c_str(), this->datatype, dataspace,
H5P_DEFAULT, dsetProperties, H5P_DEFAULT);
if (dataset < 0)
throw DCException(getExceptionString("create: Failed to create dataset"));
isReference = false;
opened = true;
}
void parseMsg( const char * msg,
const size_t len )
{
if ( ! std::strncmp( msg, "(ok compression", 15 ) )
{
int level;
if ( std::sscanf( msg, " ( ok compression %d )", &level ) == 1 )
{
setCompression( level );
}
}
else if ( ! std::strncmp( msg, "(sense_body", 11 )
|| ! std::strncmp( msg, "(see_global", 11 )
|| ! std::strncmp( msg, "(init", 5 ) )
{
M_clean_cycle = true;
}
std::cout << std::string( msg, len - 1 ) << std::endl;
}
bool Zlib::setConfiguration(QHash<QString, QString> propertiesList)
{
bool res = TransformAbstract::setConfiguration(propertiesList);
bool ok = true;
int val = propertiesList.value(XMLLEVEL).toInt(&ok);
if (!ok || val < 0 || val > 9) { // min and max value for compression level
res = false;
emit error(tr("Invalid value for %1").arg(XMLLEVEL),id);
} else {
setCompression(val);
}
val = propertiesList.value(XMLREMOVEHEADER).toInt(&ok);
if (!ok || (val != 0 && val != 1)) {
res = false;
emit error(tr("Invalid value for %1").arg(XMLREMOVEHEADER),id);
} else {
setRemoveHeader(val == 1);
}
return res;
}
void ClusterImpl::init_from_stream(ifstream& in, offset_type offset)
{
log_trace("init_from_stream");
in.seekg(offset);
clear();
char c;
in.get(c);
setCompression(static_cast<CompressionType>(c));
switch (static_cast<CompressionType>(c))
{
case zimcompDefault:
case zimcompNone:
startOffset = read_header(in);
startOffset += sizeof(char) + offset;
set_lazy_read(&in);
break;
case zimcompZip:
{
#ifdef ENABLE_ZLIB
log_debug("uncompress data (zlib)");
zim::InflateStream is(in);
is.exceptions(std::ios::failbit | std::ios::badbit);
read_header(is);
read_content(is);
#else
throw std::runtime_error("zlib not enabled in this library");
#endif
break;
}
case zimcompBzip2:
{
#ifdef ENABLE_BZIP2
log_debug("uncompress data (bzip2)");
zim::Bunzip2Stream is(in);
is.exceptions(std::ios::failbit | std::ios::badbit);
read_header(is);
read_content(is);
#else
throw std::runtime_error("bzip2 not enabled in this library");
#endif
break;
}
case zimcompLzma:
{
#ifdef ENABLE_LZMA
log_debug("uncompress data (lzma)");
zim::UnlzmaStream is(in);
is.exceptions(std::ios::failbit | std::ios::badbit);
read_header(is);
read_content(is);
#else
throw std::runtime_error("lzma not enabled in this library");
#endif
break;
}
default:
log_error("invalid compression flag " << c);
in.setstate(std::ios::failbit);
break;
}
}
void OpenExrSaveOptionsDialog::reset()
{
setRange(static_cast<int>(imaginable::openEXR_Range::Float_2));
setCompression(static_cast<int>(imaginable::openEXR_Compression::ZIP));
}
jp2Writer(DD::Image::Write *iop)
: FIWriter(iop)
{
setCompression(16);
}
void ViMp3Codec::initialize()
{
//Names
setShortName("MPEG Audio Layer 3");
setLongName("Moving Picture Experts Group Audio Layer 3");
//Compression
setCompression(ViAudio::LossyCompression);
//Abbreviations
addAbbreviation("MP3");
addAbbreviation("MPEG3");
addAbbreviation("MPA3");
addAbbreviation("MPEGA3");
//Extensions
addExtension("mp3");
addExtension("bit");
/*******************************************************************/
/*******************************************************************/
/*******************************************************************/
//Sample Types
addSampleSize(8, "8 bit");
addSampleSize(16, "16 bit");
addSampleSize(32, "32 bit");
setDefaultSampleSize(16);
//Sample Rates
addSampleRate(8000, "8000 Hz");
addSampleRate(11025, "11025 Hz");
addSampleRate(16000, "16000 Hz");
addSampleRate(22050, "22050 Hz");
addSampleRate(32000, "32000 Hz");
addSampleRate(44056, "44056 Hz");
addSampleRate(44100, "44100 Hz");
addSampleRate(47250, "47250 Hz");
addSampleRate(48000, "48000 Hz");
addSampleRate(50000, "50000 Hz");
addSampleRate(50400, "50400 Hz");
addSampleRate(88200, "88200 Hz");
addSampleRate(96000, "96000 Hz");
setDefaultSampleRate(44100);
//Sample Types
addSampleType(ViAudioFormat::SignedInt, "Signed Integer");
setDefaultSampleType(ViAudioFormat::SignedInt);
//Endianness
addEndianness(ViAudioFormat::LittleEndian, "Little Endian");
setDefaultEndianness(ViAudioFormat::LittleEndian);
//Bitrates
addBitrate(8, "8 kbps");
addBitrate(16, "16 kbps");
addBitrate(24, "24 kbps");
addBitrate(32, "32 kbps");
addBitrate(40, "40 kbps");
addBitrate(48, "48 kbps");
addBitrate(56, "56 kbps");
addBitrate(64, "64 kbps");
addBitrate(72, "72 kbps");
addBitrate(80, "80 kbps");
addBitrate(88, "88 kbps");
addBitrate(96, "96 kbps");
addBitrate(104, "104 kbps");
addBitrate(112, "112 kbps");
addBitrate(120, "120 kbps");
addBitrate(128, "128 kbps");
addBitrate(136, "136 kbps");
addBitrate(144, "144 kbps");
addBitrate(152, "152 kbps");
addBitrate(160, "160 kbps");
addBitrate(168, "168 kbps");
addBitrate(176, "176 kbps");
addBitrate(184, "184 kbps");
addBitrate(192, "192 kbps");
addBitrate(200, "200 kbps");
addBitrate(208, "208 kbps");
addBitrate(216, "216 kbps");
addBitrate(224, "224 kbps");
addBitrate(232, "232 kbps");
addBitrate(240, "240 kbps");
addBitrate(248, "248 kbps");
addBitrate(256, "256 kbps");
addBitrate(264, "264 kbps");
addBitrate(272, "272 kbps");
addBitrate(280, "280 kbps");
addBitrate(288, "288 kbps");
addBitrate(296, "296 kbps");
addBitrate(304, "304 kbps");
addBitrate(312, "312 kbps");
addBitrate(320, "320 kbps");
addBitrate(330, "330 kbps");
addBitrate(340, "340 kbps");
addBitrate(350, "350 kbps");
addBitrate(360, "360 kbps");
addBitrate(370, "370 kbps");
addBitrate(380, "380 kbps");
addBitrate(390, "390 kbps");
addBitrate(400, "400 kbps");
addBitrate(410, "410 kbps");
addBitrate(420, "420 kbps");
addBitrate(430, "430 kbps");
addBitrate(440, "440 kbps");
addBitrate(450, "450 kbps");
addBitrate(460, "460 kbps");
addBitrate(470, "470 kbps");
addBitrate(480, "480 kbps");
addBitrate(490, "490 kbps");
addBitrate(500, "500 kbps");
setDefaultBitrate(192);
//Bitrate Modes
addBitrateMode(ViAudioBitrate::Constant, "Constant Bitrate");
addBitrateMode(ViAudioBitrate::Variable, "Variable Bitrate");
addBitrateMode(ViAudioBitrate::Average, "Average Bitrate");
setDefaultBitrateMode(ViAudioBitrate::Variable);
//Qualities
addQuality(ViAudioFormat::InsaneHigh, "Insane High");
addQuality(ViAudioFormat::ExtremeHigh, "Extreme High");
addQuality(ViAudioFormat::VeryHigh, "Very High");
addQuality(ViAudioFormat::High, "High");
addQuality(ViAudioFormat::AboveAverage, "Above Average");
addQuality(ViAudioFormat::Average, "Average");
addQuality(ViAudioFormat::BelowAverage, "Below Average");
addQuality(ViAudioFormat::Low, "Low");
addQuality(ViAudioFormat::VeryLow, "Very Low");
addQuality(ViAudioFormat::ExtremeLow, "Extreme Low");
setDefaultQuality(ViAudioFormat::High);
//Channels
addChannel(1, "Mono");
addChannel(2, "Stereo");
setDefaultChannel(2);
}
void QCamVesta::setBestQuality() {
setNoiseRemoval(0);
setSharpness(0);
setCompression(0);
}
