bool linuxswap::copy(Report& report, const QString& targetDeviceNode, const QString& sourceDeviceNode) const
{
const QString label = readLabel(sourceDeviceNode);
const QString uuid = readUUID(sourceDeviceNode);
QStringList args;
if (!label.isEmpty())
args << QStringLiteral("--label") << label;
if (!uuid.isEmpty())
args << QStringLiteral("--uuid") << uuid;
args << targetDeviceNode;
ExternalCommand cmd(report, QStringLiteral("mkswap"), args);
return cmd.run(-1) && cmd.exitCode() == 0;
}
bool linuxswap::resize(Report& report, const QString& deviceNode, qint64 length) const
{
const QString label = readLabel(deviceNode);
const QString uuid = readUUID(deviceNode);
QStringList args;
if (!label.isEmpty())
args << "-L" << label;
if (!uuid.isEmpty())
args << "-U" << uuid;
args << deviceNode << QString::number(length / 1024);
ExternalCommand cmd(report, "mkswap", args);
return cmd.run(-1) && cmd.exitCode() == 0;
}
bool linuxswap::resize(Report& report, const QString& deviceNode, qint64 length) const
{
Q_UNUSED(length);
const QString label = readLabel(deviceNode);
const QString uuid = readUUID(deviceNode);
QStringList args;
if (!label.isEmpty())
args << QStringLiteral("--label") << label;
if (!uuid.isEmpty())
args << QStringLiteral("--uuid") << uuid;
args << deviceNode;
ExternalCommand cmd(report, QStringLiteral("mkswap"), args);
return cmd.run(-1) && cmd.exitCode() == 0;
}
bool luks::cryptClose(const QString& deviceNode)
{
if (!m_isCryptOpen)
{
qWarning() << "Cannot close LUKS device" << deviceNode
<< "because it's not open.";
return false;
}
if (m_isMounted)
{
qWarning() << "Cannot close LUKS device" << deviceNode
<< "because the filesystem is mounted.";
return false;
}
ExternalCommand cmd(QStringLiteral("cryptsetup"),
{ QStringLiteral("close"), mapperName() });
if (!(cmd.run(-1) && cmd.exitCode() == 0))
return false;
delete m_innerFs;
m_innerFs = nullptr;
m_passphrase.clear();
setLabel({});
setUUID(readUUID(deviceNode));
setSectorsUsed(-1);
m_isCryptOpen = (m_innerFs != nullptr);
for (auto &p : LVM::pvList) // FIXME: qAsConst
if (!p.isLuks() && p.partition()->deviceNode() == deviceNode)
p.setLuks(true);
return true;
}
status WAVEFile::parseFormat(const Tag &id, uint32_t size)
{
Track *track = getTrack();
uint16_t formatTag;
readU16(&formatTag);
uint16_t channelCount;
readU16(&channelCount);
uint32_t sampleRate;
readU32(&sampleRate);
uint32_t averageBytesPerSecond;
readU32(&averageBytesPerSecond);
uint16_t blockAlign;
readU16(&blockAlign);
track->f.channelCount = channelCount;
track->f.sampleRate = sampleRate;
track->f.byteOrder = AF_BYTEORDER_LITTLEENDIAN;
/* Default to uncompressed audio data. */
track->f.compressionType = AF_COMPRESSION_NONE;
switch (formatTag)
{
case WAVE_FORMAT_PCM:
{
uint16_t bitsPerSample;
readU16(&bitsPerSample);
track->f.sampleWidth = bitsPerSample;
if (bitsPerSample == 0 || bitsPerSample > 32)
{
_af_error(AF_BAD_WIDTH,
"bad sample width of %d bits",
bitsPerSample);
return AF_FAIL;
}
if (bitsPerSample <= 8)
track->f.sampleFormat = AF_SAMPFMT_UNSIGNED;
else
track->f.sampleFormat = AF_SAMPFMT_TWOSCOMP;
}
break;
case WAVE_FORMAT_MULAW:
case IBM_FORMAT_MULAW:
track->f.sampleWidth = 16;
track->f.sampleFormat = AF_SAMPFMT_TWOSCOMP;
track->f.byteOrder = _AF_BYTEORDER_NATIVE;
track->f.compressionType = AF_COMPRESSION_G711_ULAW;
break;
case WAVE_FORMAT_ALAW:
case IBM_FORMAT_ALAW:
track->f.sampleWidth = 16;
track->f.sampleFormat = AF_SAMPFMT_TWOSCOMP;
track->f.byteOrder = _AF_BYTEORDER_NATIVE;
track->f.compressionType = AF_COMPRESSION_G711_ALAW;
break;
case WAVE_FORMAT_IEEE_FLOAT:
{
uint16_t bitsPerSample;
readU16(&bitsPerSample);
if (bitsPerSample == 64)
{
track->f.sampleWidth = 64;
track->f.sampleFormat = AF_SAMPFMT_DOUBLE;
}
else
{
track->f.sampleWidth = 32;
track->f.sampleFormat = AF_SAMPFMT_FLOAT;
}
}
break;
case WAVE_FORMAT_ADPCM:
{
uint16_t bitsPerSample, extraByteCount,
samplesPerBlock, numCoefficients;
if (track->f.channelCount != 1 &&
track->f.channelCount != 2)
{
_af_error(AF_BAD_CHANNELS,
"WAVE file with MS ADPCM compression "
"must have 1 or 2 channels");
}
readU16(&bitsPerSample);
readU16(&extraByteCount);
readU16(&samplesPerBlock);
readU16(&numCoefficients);
/* numCoefficients should be at least 7. */
assert(numCoefficients >= 7 && numCoefficients <= 255);
for (int i=0; i<numCoefficients; i++)
{
int16_t a0, a1;
readS16(&a0);
readS16(&a1);
msadpcmCoefficients[i][0] = a0;
msadpcmCoefficients[i][1] = a1;
}
track->f.sampleWidth = 16;
track->f.sampleFormat = AF_SAMPFMT_TWOSCOMP;
track->f.compressionType = AF_COMPRESSION_MS_ADPCM;
track->f.byteOrder = _AF_BYTEORDER_NATIVE;
/* Create the parameter list. */
long l;
void *v;
AUpvlist pv = AUpvnew(4);
AUpvsetparam(pv, 0, _AF_MS_ADPCM_NUM_COEFFICIENTS);
AUpvsetvaltype(pv, 0, AU_PVTYPE_LONG);
l = numCoefficients;
AUpvsetval(pv, 0, &l);
AUpvsetparam(pv, 1, _AF_MS_ADPCM_COEFFICIENTS);
AUpvsetvaltype(pv, 1, AU_PVTYPE_PTR);
v = msadpcmCoefficients;
AUpvsetval(pv, 1, &v);
AUpvsetparam(pv, 2, _AF_FRAMES_PER_BLOCK);
AUpvsetvaltype(pv, 2, AU_PVTYPE_LONG);
l = samplesPerBlock;
AUpvsetval(pv, 2, &l);
AUpvsetparam(pv, 3, _AF_BLOCK_SIZE);
AUpvsetvaltype(pv, 3, AU_PVTYPE_LONG);
l = blockAlign;
AUpvsetval(pv, 3, &l);
track->f.compressionParams = pv;
}
break;
case WAVE_FORMAT_DVI_ADPCM:
{
uint16_t bitsPerSample, extraByteCount, samplesPerBlock;
readU16(&bitsPerSample);
readU16(&extraByteCount);
readU16(&samplesPerBlock);
if (bitsPerSample != 4)
{
_af_error(AF_BAD_NOT_IMPLEMENTED,
"IMA ADPCM compression supports only 4 bits per sample");
}
int bytesPerBlock = (samplesPerBlock + 14) / 8 * 4 * channelCount;
if (bytesPerBlock > blockAlign || (samplesPerBlock % 8) != 1)
{
_af_error(AF_BAD_CODEC_CONFIG,
"Invalid samples per block for IMA ADPCM compression");
}
track->f.sampleWidth = 16;
track->f.sampleFormat = AF_SAMPFMT_TWOSCOMP;
track->f.compressionType = AF_COMPRESSION_IMA;
track->f.byteOrder = _AF_BYTEORDER_NATIVE;
/* Create the parameter list. */
long l;
AUpvlist pv = AUpvnew(2);
AUpvsetparam(pv, 0, _AF_FRAMES_PER_BLOCK);
AUpvsetvaltype(pv, 0, AU_PVTYPE_LONG);
l = samplesPerBlock;
AUpvsetval(pv, 0, &l);
AUpvsetparam(pv, 1, _AF_BLOCK_SIZE);
AUpvsetvaltype(pv, 1, AU_PVTYPE_LONG);
l = blockAlign;
AUpvsetval(pv, 1, &l);
track->f.compressionParams = pv;
}
break;
case WAVE_FORMAT_EXTENSIBLE:
{
uint16_t bitsPerSample;
readU16(&bitsPerSample);
uint16_t extraByteCount;
readU16(&extraByteCount);
uint16_t reserved;
readU16(&reserved);
uint32_t channelMask;
readU32(&channelMask);
UUID subformat;
readUUID(&subformat);
if (subformat == _af_wave_guid_pcm)
{
track->f.sampleWidth = bitsPerSample;
if (bitsPerSample == 0 || bitsPerSample > 32)
{
_af_error(AF_BAD_WIDTH,
"bad sample width of %d bits",
bitsPerSample);
return AF_FAIL;
}
// Use valid bits per sample if bytes per sample is the same.
if (reserved <= bitsPerSample &&
(reserved + 7) / 8 == (bitsPerSample + 7) / 8)
track->f.sampleWidth = reserved;
if (bitsPerSample <= 8)
track->f.sampleFormat = AF_SAMPFMT_UNSIGNED;
else
track->f.sampleFormat = AF_SAMPFMT_TWOSCOMP;
}
else if (subformat == _af_wave_guid_ieee_float)
{
if (bitsPerSample == 64)
{
track->f.sampleWidth = 64;
track->f.sampleFormat = AF_SAMPFMT_DOUBLE;
}
else
{
track->f.sampleWidth = 32;
track->f.sampleFormat = AF_SAMPFMT_FLOAT;
}
}
else if (subformat == _af_wave_guid_alaw ||
subformat == _af_wave_guid_ulaw)
{
track->f.compressionType = subformat == _af_wave_guid_alaw ?
AF_COMPRESSION_G711_ALAW : AF_COMPRESSION_G711_ULAW;
track->f.sampleWidth = 16;
track->f.sampleFormat = AF_SAMPFMT_TWOSCOMP;
track->f.byteOrder = _AF_BYTEORDER_NATIVE;
}
else
{
_af_error(AF_BAD_NOT_IMPLEMENTED, "WAVE extensible data format %s is not currently supported", subformat.name().c_str());
return AF_FAIL;
}
}
break;
case WAVE_FORMAT_YAMAHA_ADPCM:
case WAVE_FORMAT_OKI_ADPCM:
case WAVE_FORMAT_CREATIVE_ADPCM:
case IBM_FORMAT_ADPCM:
_af_error(AF_BAD_NOT_IMPLEMENTED, "WAVE ADPCM data format 0x%x is not currently supported", formatTag);
return AF_FAIL;
break;
case WAVE_FORMAT_MPEG:
_af_error(AF_BAD_NOT_IMPLEMENTED, "WAVE MPEG data format is not supported");
return AF_FAIL;
break;
case WAVE_FORMAT_MPEGLAYER3:
_af_error(AF_BAD_NOT_IMPLEMENTED, "WAVE MPEG layer 3 data format is not supported");
return AF_FAIL;
break;
default:
_af_error(AF_BAD_NOT_IMPLEMENTED, "WAVE file data format 0x%x not currently supported != 0xfffe ? %d, != EXTENSIBLE? %d", formatTag, formatTag != 0xfffe, formatTag != WAVE_FORMAT_EXTENSIBLE);
return AF_FAIL;
break;
}
_af_set_sample_format(&track->f, track->f.sampleFormat, track->f.sampleWidth);
return AF_SUCCEED;
}
BOOL LLPartSysCompressedPacket::toLLPartInitData(LLPartInitData *out, U32 *bytesUsed)
{
U32 currByte = 4;
gSetInitDataDefaults(out);
if(mData[0] & PART_SYS_KILL_P_MASK)
{
currByte = readKill_p(out, currByte);
}
if(mData[0] & PART_SYS_BOUNCE_P_MASK)
{
currByte = readBounce_p(out, currByte);
}
if(mData[0] & PART_SYS_BOUNCE_B_MASK)
{
currByte = readBounce_b(out, currByte);
}
if(mData[0] & PART_SYS_ALPHA_SCALE_DIFF_MASK)
{
currByte = readAlphaScaleDiffEqn_range(out, currByte);
}
if(mData[0] & PART_SYS_SCALE_RANGE_MASK)
{
currByte = readScale_range(out, currByte);
}
if(mData[0] & PART_SYS_VEL_OFFSET_MASK)
{
currByte = readVelocityOffset(out, currByte);
}
if(mData[0] & PART_SYS_M_IMAGE_UUID_MASK)
{
currByte = readUUID(out, currByte);
}
if(mData[3] & PART_SYS_BYTE_SPAWN_MASK)
{
currByte = readSpawn(out, currByte);
}
if(mData[3] & PART_SYS_BYTE_ENVIRONMENT_MASK)
{
currByte = readEnvironment(out, currByte);
}
if(mData[3] & PART_SYS_BYTE_LIFESPAN_MASK)
{
currByte = readLifespan(out, currByte);
}
if(mData[3] & PART_SYS_BYTE_DECAY_DAMP_MASK)
{
currByte = readDecayDamp(out, currByte);
}
if(mData[3] & PART_SYS_BYTE_WIND_DIFF_MASK)
{
currByte = readWindDiffusionFactor(out, currByte);
}
if(mData[2] & PART_SYS_BYTE_3_ALPHA_MASK)
{
currByte = readAlpha_range(out, currByte);
}
out->maxParticles = mData[currByte++];
out->initialParticles = mData[currByte++];
U32 flagFlag = 1; // flag indicating which flag bytes are non-zero
// yeah, I know, the name sounds funny
for(U32 i = 0; i < 8; i++)
{
flagFlag = 1<<i;
if((mData[1] & flagFlag))
{
out->mFlags[i] = mData[currByte++];
}
}
*bytesUsed = currByte;
return TRUE;
}