Fix warnings

This commit is contained in:
Martchus 2021-03-20 21:26:25 +01:00
parent ec2f8213b0
commit 0a041f6ad2
39 changed files with 267 additions and 267 deletions

View File

@ -677,7 +677,7 @@ void AacFrameElementParser::decodeScaleFactorData(AacIcsInfo &ics)
break;
case IntensityHcb: // intensity books
case IntensityHcb2:
ics.scaleFactors[group][sfb] = static_cast<std::uint16_t>(isPosition += (parseHuffmanScaleFactor() - 60));
ics.scaleFactors[group][sfb] = static_cast<std::uint16_t>(isPosition += static_cast<std::int16_t>(parseHuffmanScaleFactor() - 60));
break;
case NoiseHcb: // noise books
if (noisePcmFlag) {
@ -689,7 +689,7 @@ void AacFrameElementParser::decodeScaleFactorData(AacIcsInfo &ics)
ics.scaleFactors[group][sfb] = static_cast<std::uint16_t>(noiseEnergy += tmp);
break;
default: // spectral books
scaleFactor += parseHuffmanScaleFactor() - 60;
scaleFactor += static_cast<std::int16_t>(parseHuffmanScaleFactor() - 60);
if (scaleFactor < 0 || scaleFactor > 255) {
throw InvalidDataException();
} else {
@ -976,7 +976,7 @@ void AacFrameElementParser::parseSbrGrid(std::shared_ptr<AacSbrInfo> &sbr, std::
sbr->relLeadCount[channel] = 0;
sbr->relTrailCount[channel] = bsEnvCount = m_reader.readBits<std::uint8_t>(2);
for (std::uint8_t rel = 0; rel < bsEnvCount; ++rel) {
sbr->bsRelBord[channel][rel] = 2 * m_reader.readBits<std::uint8_t>(2) + 2;
sbr->bsRelBord[channel][rel] = static_cast<std::uint8_t>(2 * m_reader.readBits<std::uint8_t>(2) + 2);
}
sbr->bsPointer[channel] = m_reader.readBits<std::uint8_t>(static_cast<std::uint8_t>(sbrLog2(static_cast<std::int8_t>(bsEnvCount + 2))));
for (std::uint8_t env = 0; env <= bsEnvCount; ++env) {
@ -989,7 +989,7 @@ void AacFrameElementParser::parseSbrGrid(std::shared_ptr<AacSbrInfo> &sbr, std::
sbr->relLeadCount[channel] = bsEnvCount = m_reader.readBits<std::uint8_t>(2);
sbr->relTrailCount[channel] = 0;
for (std::uint8_t rel = 0; rel < bsEnvCount; ++rel) {
sbr->bsRelBord[channel][rel] = 2 * m_reader.readBits<std::uint8_t>(2) + 2;
sbr->bsRelBord[channel][rel] = static_cast<std::uint8_t>(2 * m_reader.readBits<std::uint8_t>(2) + 2);
}
sbr->bsPointer[channel] = m_reader.readBits<std::uint8_t>(static_cast<std::uint8_t>(sbrLog2(static_cast<std::int8_t>(bsEnvCount + 2))));
for (std::uint8_t env = 0; env < bsEnvCount; ++env) {
@ -1002,12 +1002,12 @@ void AacFrameElementParser::parseSbrGrid(std::shared_ptr<AacSbrInfo> &sbr, std::
//bsRelCount0 = m_reader.readBits<std::uint8_t>(2);
//bsRelCount1 = m_reader.readBits<std::uint8_t>(2);
m_reader.skipBits(4);
bsEnvCount = min<std::uint8_t>(5, sbr->bsRelCount0[channel] + sbr->bsRelCount1[channel] + 1);
bsEnvCount = min<std::uint8_t>(5, static_cast<std::uint8_t>(sbr->bsRelCount0[channel] + sbr->bsRelCount1[channel] + 1));
for (std::uint8_t rel = 0; rel < sbr->bsRelCount0[channel]; ++rel) {
sbr->bsRelBord0[channel][rel] = 2 * m_reader.readBits<std::uint8_t>(2) + 2;
sbr->bsRelBord0[channel][rel] = static_cast<std::uint8_t>(2 * m_reader.readBits<std::uint8_t>(2) + 2);
}
for (std::uint8_t rel = 0; rel < sbr->bsRelCount1[channel]; ++rel) {
sbr->bsRelBord1[channel][rel] = 2 * m_reader.readBits<std::uint8_t>(2) + 2;
sbr->bsRelBord1[channel][rel] = static_cast<std::uint8_t>(2 * m_reader.readBits<std::uint8_t>(2) + 2);
}
sbr->bsPointer[channel] = m_reader.readBits<std::uint8_t>(
static_cast<std::uint8_t>(sbrLog2(static_cast<std::int8_t>(sbr->bsRelCount0[channel] + sbr->bsRelCount1[channel] + 2))));
@ -1513,7 +1513,7 @@ void AacFrameElementParser::huffmanBinaryPair(std::uint8_t cb, std::int16_t *sp)
{
std::uint16_t offset = 0;
while (!aacHcbBinTable[cb][offset].isLeaf) {
offset += aacHcbBinTable[cb][offset].data[m_reader.readBit()];
offset += static_cast<std::uint16_t>(aacHcbBinTable[cb][offset].data[m_reader.readBit()]);
}
if (offset > aacHcbBinTableSize[cb]) {
throw InvalidDataException();
@ -1967,6 +1967,7 @@ void AacFrameElementParser::parseFillElement(std::uint8_t sbrElement)
break;
case SbrDataCrc:
crcFlag = true;
[[fallthrough]];
case SbrData:
if (sbrElement == aacInvalidSbrElement) {
throw InvalidDataException();
@ -1986,7 +1987,7 @@ void AacFrameElementParser::parseFillElement(std::uint8_t sbrElement)
count = 0;
break;
case FillData:
m_reader.skipBits(4 + 8 * (count - 1));
m_reader.skipBits(static_cast<std::size_t>(4 + 8 * (count - 1)));
count = 0;
break;
case DataElement:
@ -1997,23 +1998,23 @@ void AacFrameElementParser::parseFillElement(std::uint8_t sbrElement)
std::uint16_t dataElementLengthPart;
do {
dataElementLengthPart = m_reader.readBits<std::uint8_t>(8);
dataElementLength += dataElementLengthPart;
dataElementLength += static_cast<std::uint8_t>(dataElementLengthPart);
++loopCounter;
} while (dataElementLengthPart == 0xFF);
for (std::uint16_t i = 0; i < dataElementLength; ++i) {
m_reader.skipBits(8); // data element byte
count -= dataElementLength + loopCounter + 1;
count -= static_cast<std::uint16_t>(dataElementLength + loopCounter + 1);
goto continueWhile;
// FIXME: loop will run at most once
}
}
m_reader.skipBits(8 * (count - 1));
m_reader.skipBits(static_cast<std::size_t>(8 * (count - 1)));
count = 0;
break;
case Fill:
case SacData:
default:
m_reader.skipBits(4 + 8 * (count - 1));
m_reader.skipBits(static_cast<std::size_t>(4 + 8 * (count - 1)));
count = 0;
}
}
@ -2104,7 +2105,7 @@ endOfBlock:;
void AacFrameElementParser::parse(const AdtsFrame &adtsFrame, std::istream &stream, std::size_t dataSize)
{
auto data = make_unique<char[]>(dataSize);
stream.read(data.get(), dataSize);
stream.read(data.get(), static_cast<std::streamsize>(dataSize));
parse(adtsFrame, data, dataSize);
}

View File

@ -529,7 +529,7 @@ inline AacFrameElementParser::AacFrameElementParser(std::uint8_t audioObjectId,
inline std::int8_t AacFrameElementParser::sbrLog2(const std::int8_t val)
{
static const int log2tab[] = { 0, 0, 1, 2, 2, 3, 3, 3, 3, 4 };
static const std::int8_t log2tab[] = { 0, 0, 1, 2, 2, 3, 3, 3, 3, 4 };
return (val < 10 && val >= 0) ? log2tab[val] : 0;
}

View File

@ -41,16 +41,16 @@ StreamDataBlock::StreamDataBlock()
*
* The object does NOT take ownership over the stream returned by the specified function.
*/
StreamDataBlock::StreamDataBlock(const std::function<std::istream &()> &stream, std::istream::off_type startOffset, std::ios_base::seekdir startDir,
std::istream::off_type endOffset, std::ios_base::seekdir endDir)
StreamDataBlock::StreamDataBlock(const std::function<std::istream &()> &stream, std::uint64_t startOffset, std::ios_base::seekdir startDir,
std::uint64_t endOffset, std::ios_base::seekdir endDir)
: m_stream(stream)
{
auto &s = stream();
auto currentPos = s.tellg();
s.seekg(startOffset, startDir);
m_startOffset = s.tellg();
s.seekg(endOffset, endDir);
m_endOffset = s.tellg();
s.seekg(static_cast<std::istream::off_type>(startOffset), startDir);
m_startOffset = static_cast<std::uint64_t>(s.tellg());
s.seekg(static_cast<std::istream::off_type>(endOffset), endDir);
m_endOffset = static_cast<std::uint64_t>(s.tellg());
s.seekg(currentPos);
if (m_endOffset < m_startOffset) {
throw std::ios_base::failure("End offset is less than start offset.");
@ -70,8 +70,8 @@ StreamDataBlock::~StreamDataBlock()
void StreamDataBlock::makeBuffer() const
{
m_buffer = make_unique<char[]>(size());
stream().seekg(startOffset());
stream().read(m_buffer.get(), size());
stream().seekg(static_cast<std::istream::off_type>(startOffset()));
stream().read(m_buffer.get(), static_cast<std::streamsize>(size()));
}
/*!
@ -81,10 +81,10 @@ void StreamDataBlock::makeBuffer() const
void StreamDataBlock::copyTo(ostream &stream) const
{
if (buffer()) {
stream.write(buffer().get(), size());
stream.write(buffer().get(), static_cast<std::streamsize>(size()));
} else {
CopyHelper<0x2000> copyHelper;
m_stream().seekg(startOffset());
m_stream().seekg(static_cast<std::streamsize>(startOffset()));
copyHelper.copy(m_stream(), stream, size());
}
}

View File

@ -15,15 +15,14 @@ class MediaFileInfo;
class TAG_PARSER_EXPORT StreamDataBlock {
public:
StreamDataBlock(const std::function<std::istream &()> &stream, std::istream::off_type startOffset = 0,
std::ios_base::seekdir startDir = std::ios_base::beg, std::istream::off_type endOffset = 0,
std::ios_base::seekdir endDir = std::ios_base::end);
StreamDataBlock(const std::function<std::istream &()> &stream, uint64_t startOffset = 0, std::ios_base::seekdir startDir = std::ios_base::beg,
uint64_t endOffset = 0, std::ios_base::seekdir endDir = std::ios_base::end);
virtual ~StreamDataBlock();
std::istream &stream() const;
std::istream::pos_type startOffset() const;
std::istream::pos_type endOffset() const;
std::istream::pos_type size() const;
std::uint64_t startOffset() const;
std::uint64_t endOffset() const;
std::uint64_t size() const;
const std::unique_ptr<char[]> &buffer() const;
void makeBuffer() const;
void discardBuffer();
@ -33,8 +32,8 @@ protected:
StreamDataBlock();
std::function<std::istream &()> m_stream;
std::istream::pos_type m_startOffset;
std::istream::pos_type m_endOffset;
std::uint64_t m_startOffset;
std::uint64_t m_endOffset;
mutable std::unique_ptr<char[]> m_buffer;
};
@ -51,7 +50,7 @@ inline std::istream &StreamDataBlock::stream() const
/*!
* \brief Returns the absolute start offset of the data block in the stream.
*/
inline std::istream::pos_type StreamDataBlock::startOffset() const
inline std::uint64_t StreamDataBlock::startOffset() const
{
return m_startOffset;
}
@ -59,7 +58,7 @@ inline std::istream::pos_type StreamDataBlock::startOffset() const
/*!
* \brief Returns the absolute end offset of the data block in the stream.
*/
inline std::istream::pos_type StreamDataBlock::endOffset() const
inline std::uint64_t StreamDataBlock::endOffset() const
{
return m_endOffset;
}
@ -67,7 +66,7 @@ inline std::istream::pos_type StreamDataBlock::endOffset() const
/*!
* \brief Returns the size of the data block.
*/
inline std::istream::pos_type StreamDataBlock::size() const
inline std::uint64_t StreamDataBlock::size() const
{
return m_endOffset - m_startOffset;
}

View File

@ -75,7 +75,7 @@ constexpr bool AdtsFrame::hasCrc() const
*/
constexpr std::uint8_t AdtsFrame::mpeg4AudioObjectId() const
{
return (m_header2 >> 0x36) + 0x1u;
return static_cast<std::uint8_t>((m_header2 >> 0x36) + 0x1u);
}
/*!
@ -84,7 +84,7 @@ constexpr std::uint8_t AdtsFrame::mpeg4AudioObjectId() const
*/
constexpr std::uint8_t AdtsFrame::mpeg4SamplingFrequencyIndex() const
{
return (m_header2 >> 0x32) & 0xFu;
return static_cast<std::uint8_t>((m_header2 >> 0x32) & 0xFu);
}
/*!
@ -94,7 +94,7 @@ constexpr std::uint8_t AdtsFrame::mpeg4SamplingFrequencyIndex() const
*/
constexpr std::uint8_t AdtsFrame::mpeg4ChannelConfig() const
{
return (m_header2 >> 0x2E) & 0x7u;
return static_cast<std::uint8_t>((m_header2 >> 0x2E) & 0x7u);
}
/*!
@ -102,7 +102,7 @@ constexpr std::uint8_t AdtsFrame::mpeg4ChannelConfig() const
*/
constexpr std::uint16_t AdtsFrame::totalSize() const
{
return (m_header2 >> 0x1D) & 0x1FFFu;
return static_cast<std::uint8_t>((m_header2 >> 0x1D) & 0x1FFFu);
}
/*!
@ -110,7 +110,7 @@ constexpr std::uint16_t AdtsFrame::totalSize() const
*/
constexpr std::uint8_t AdtsFrame::headerSize() const
{
return hasCrc() ? 9 : 7;
return static_cast<std::uint8_t>(hasCrc() ? 9 : 7);
}
/*!

View File

@ -54,14 +54,14 @@ public:
void removeAllFields();
const std::multimap<IdentifierType, FieldType, Compare> &fields() const;
std::multimap<IdentifierType, FieldType, Compare> &fields();
unsigned int fieldCount() const;
std::size_t fieldCount() const;
IdentifierType fieldId(KnownField value) const;
KnownField knownField(const IdentifierType &id) const;
bool supportsField(KnownField field) const;
using Tag::proposedDataType;
TagDataType proposedDataType(const IdentifierType &id) const;
int insertFields(const FieldMapBasedTag<ImplementationType> &from, bool overwrite);
unsigned int insertValues(const Tag &from, bool overwrite);
std::size_t insertFields(const FieldMapBasedTag<ImplementationType> &from, bool overwrite);
std::size_t insertValues(const Tag &from, bool overwrite);
void ensureTextValuesAreProperlyEncoded();
protected:
@ -316,9 +316,9 @@ template <class ImplementationType> inline auto FieldMapBasedTag<ImplementationT
return m_fields;
}
template <class ImplementationType> unsigned int FieldMapBasedTag<ImplementationType>::fieldCount() const
template <class ImplementationType> std::size_t FieldMapBasedTag<ImplementationType>::fieldCount() const
{
unsigned int count = 0;
auto count = std::size_t(0);
for (const auto &field : m_fields) {
if (!field.second.value().isEmpty()) {
++count;
@ -377,9 +377,9 @@ template <class ImplementationType> inline TagDataType FieldMapBasedTag<Implemen
* \return Returns the number of fields that have been inserted.
*/
template <class ImplementationType>
int FieldMapBasedTag<ImplementationType>::insertFields(const FieldMapBasedTag<ImplementationType> &from, bool overwrite)
std::size_t FieldMapBasedTag<ImplementationType>::insertFields(const FieldMapBasedTag<ImplementationType> &from, bool overwrite)
{
int fieldsInserted = 0;
auto fieldsInserted = std::size_t(0);
for (const auto &pair : from.fields()) {
const FieldType &fromField = pair.second;
if (fromField.value().isEmpty()) {
@ -407,7 +407,7 @@ int FieldMapBasedTag<ImplementationType>::insertFields(const FieldMapBasedTag<Im
return fieldsInserted;
}
template <class ImplementationType> unsigned int FieldMapBasedTag<ImplementationType>::insertValues(const Tag &from, bool overwrite)
template <class ImplementationType> std::size_t FieldMapBasedTag<ImplementationType>::insertValues(const Tag &from, bool overwrite)
{
if (type() == from.type()) {
// the tags are of the same type, we can insert the fields directly

View File

@ -28,8 +28,8 @@ namespace TagParser {
*/
void FlacMetaDataBlockHeader::parseHeader(std::string_view buffer)
{
m_last = buffer[0] & 0x80;
m_type = buffer[0] & (0x80 - 1);
m_last = static_cast<std::uint8_t>(buffer[0] & 0x80);
m_type = static_cast<std::uint8_t>(buffer[0] & (0x80 - 1));
m_dataSize = BE::toUInt24(buffer.data() + 1);
}
@ -66,7 +66,7 @@ void FlacMetaDataBlockStreamInfo::parse(std::string_view buffer)
m_channelCount = reader.readBits<std::uint8_t>(3) + 1;
m_bitsPerSample = reader.readBits<std::uint8_t>(5) + 1;
m_totalSampleCount = reader.readBits<std::uint64_t>(36);
std::memcpy(m_md5Sum, buffer.data() + 0x22 - sizeof(m_md5Sum), sizeof(m_md5Sum));
std::memcpy(m_md5Sum, buffer.data() + 0x22u - sizeof(m_md5Sum), sizeof(m_md5Sum));
}
/*!

View File

@ -319,8 +319,8 @@ bool GenericContainer<FileInfoType, TagType, TrackType, ElementType>::addTrack(T
// ensure ID is unique
auto id = track->id();
ensureIdIsUnique:
for (const auto &track : m_tracks) {
if (track->id() == id) {
for (const auto &existingTrack : m_tracks) {
if (existingTrack->id() == id) {
++id;
goto ensureIdIsUnique;
}

View File

@ -170,7 +170,7 @@ GenericFileElement<ImplementationType>::GenericFileElement(
m_maxSize = container.fileInfo().size();
if (m_maxSize > startOffset) {
m_maxSize -= startOffset;
stream().seekg(startOffset, std::ios_base::beg);
stream().seekg(static_cast<std::streamoff>(startOffset), std::ios_base::beg);
} else {
m_maxSize = 0;
}
@ -875,8 +875,8 @@ void GenericFileElement<ImplementationType>::copyEntirely(std::ostream &targetSt
template <class ImplementationType> void GenericFileElement<ImplementationType>::makeBuffer()
{
m_buffer = std::make_unique<char[]>(totalSize());
container().stream().seekg(startOffset());
container().stream().read(m_buffer.get(), totalSize());
container().stream().seekg(static_cast<std::streamoff>(startOffset()));
container().stream().read(m_buffer.get(), static_cast<std::streamsize>(totalSize()));
}
/*!
@ -893,7 +893,7 @@ template <class ImplementationType> inline void GenericFileElement<Implementatio
*/
template <class ImplementationType> inline void GenericFileElement<ImplementationType>::copyBuffer(std::ostream &targetStream)
{
targetStream.write(m_buffer.get(), totalSize());
targetStream.write(m_buffer.get(), static_cast<std::streamsize>(totalSize()));
}
/*!
@ -934,7 +934,7 @@ void GenericFileElement<ImplementationType>::copyInternal(
throw InvalidDataException();
}
auto &stream = container().stream();
stream.seekg(startOffset);
stream.seekg(static_cast<std::streamoff>(startOffset), std::ios_base::beg);
CppUtilities::CopyHelper<0x10000> copyHelper;
if (progress) {
copyHelper.callbackCopy(stream, targetStream, bytesToCopy, std::bind(&AbortableProgressFeedback::isAborted, std::ref(progress)),

View File

@ -231,9 +231,9 @@ void Id3v1Tag::removeAllFields()
m_genre.clearDataAndMetadata();
}
unsigned int Id3v1Tag::fieldCount() const
std::size_t Id3v1Tag::fieldCount() const
{
unsigned int count = 0;
auto count = std::size_t(0);
for (const auto &value : std::initializer_list<const TagValue *>{ &m_title, &m_artist, &m_album, &m_year, &m_comment, &m_trackPos, &m_genre }) {
if (!value->isEmpty()) {
++count;

View File

@ -21,7 +21,7 @@ public:
bool setValueConsideringTypeInfo(KnownField field, const TagValue &value, const std::string &typeInfo);
bool hasField(KnownField field) const override;
void removeAllFields() override;
unsigned int fieldCount() const override;
std::size_t fieldCount() const override;
bool supportsField(KnownField field) const override;
void ensureTextValuesAreProperlyEncoded() override;

View File

@ -89,7 +89,7 @@ public:
bool isExperimental() const;
bool hasFooter() const;
std::uint32_t extendedHeaderSize() const;
std::uint32_t paddingSize() const;
std::uint64_t paddingSize() const;
protected:
IdentifierType internallyGetFieldId(KnownField field) const;
@ -109,7 +109,7 @@ private:
std::uint8_t m_flags;
std::uint32_t m_sizeExcludingHeader;
std::uint32_t m_extendedHeaderSize;
std::uint32_t m_paddingSize;
std::uint64_t m_paddingSize;
};
/*!
@ -232,7 +232,7 @@ inline std::uint32_t Id3v2Tag::extendedHeaderSize() const
* \brief Returns the size of the padding between the tag and the first MPEG frame
* if one is present; otherwise returns 0.
*/
inline std::uint32_t Id3v2Tag::paddingSize() const
inline std::uint64_t Id3v2Tag::paddingSize() const
{
return m_paddingSize;
}

View File

@ -171,7 +171,7 @@ void EbmlElement::internalParse(Diagnostics &diag)
memset(buf, 0, sizeof(DataSizeType)); // reset buffer
reader().read(buf + (maximumSizeLengthSupported() - m_sizeLength), m_sizeLength);
// xor the first byte in buffer which has been read from the file with mask
*(buf + (maximumSizeLengthSupported() - m_sizeLength)) ^= mask;
*(buf + (maximumSizeLengthSupported() - m_sizeLength)) ^= static_cast<char>(mask);
m_dataSize = BE::toUInt64(buf);
// check if element is truncated
if (totalSize() > maxTotalSize()) {
@ -535,7 +535,7 @@ void EbmlElement::makeSimpleElement(std::ostream &stream, GenericFileElement::Id
stream.write(buff1, sizeLength);
sizeLength = EbmlElement::makeSizeDenotation(content.size(), buff1);
stream.write(buff1, sizeLength);
stream.write(content.data(), content.size());
stream.write(content.data(), static_cast<std::streamsize>(content.size()));
}
} // namespace TagParser

View File

@ -72,9 +72,9 @@ inline std::string EbmlElement::idToString() const
{
using namespace CppUtilities;
if (const auto name = matroskaIdName(id()); !name.empty()) {
return argsToString('0', 'x', numberToString(id(), 16), ' ', '\"', name, '\"');
return argsToString('0', 'x', numberToString(id(), 16u), ' ', '\"', name, '\"');
} else {
return "0x" + numberToString(id(), 16);
return "0x" + numberToString(id(), 16u);
}
}

View File

@ -116,7 +116,7 @@ MatroskaAttachmentMaker::MatroskaAttachmentMaker(MatroskaAttachment &attachment,
m_attachedFileElementSize = 2 + EbmlElement::calculateSizeDenotationLength(attachment.name().size()) + attachment.name().size() + 2
+ EbmlElement::calculateSizeDenotationLength(attachment.mimeType().size()) + attachment.mimeType().size() + 2 + 1
+ EbmlElement::calculateUIntegerLength(attachment.id());
if (auto dataSize = attachment.data() ? attachment.data()->size() : static_cast<istream::pos_type>(0)) {
if (auto dataSize = attachment.data() ? attachment.data()->size() : static_cast<std::uint64_t>(0)) {
m_attachedFileElementSize += 2 + EbmlElement::calculateSizeDenotationLength(dataSize) + dataSize;
}
if (!attachment.description().empty()) {

View File

@ -56,10 +56,10 @@ void MatroskaChapter::internalParse(Diagnostics &diag, AbortableProgressFeedback
case MatroskaIds::ChapterStringUID:
break;
case MatroskaIds::ChapterTimeStart:
m_startTime = TimeSpan(chapterAtomChild->readUInteger() / 100);
m_startTime = TimeSpan(static_cast<std::int64_t>(chapterAtomChild->readUInteger() / 100u));
break;
case MatroskaIds::ChapterTimeEnd:
m_endTime = TimeSpan(chapterAtomChild->readUInteger() / 100);
m_endTime = TimeSpan(static_cast<std::int64_t>(chapterAtomChild->readUInteger() / 100u));
break;
case MatroskaIds::ChapterFlagHidden:
m_hidden = chapterAtomChild->readUInteger() == 1;

View File

@ -520,7 +520,7 @@ void MatroskaContainer::internalParseHeader(Diagnostics &diag, AbortableProgress
diag.emplace_back(DiagLevel::Critical,
argsToString("ID of element ", element->idToString(), " at ", offset,
" does not match the ID denoted in the \"SeekHead\" element (0x",
numberToString(infoPair.first, 16), ")."),
numberToString(infoPair.first, 16u), ")."),
context);
}
switch (element->id()) {
@ -638,7 +638,7 @@ void MatroskaContainer::parseSegmentInfo(Diagnostics &diag)
m_titles.emplace_back();
}
if (rawDuration > 0.0) {
m_duration += TimeSpan::fromSeconds(rawDuration * timeScale / 1000000000);
m_duration += TimeSpan::fromSeconds(rawDuration * static_cast<double>(timeScale) / 1000000000.0);
}
}
}
@ -1387,7 +1387,7 @@ void MatroskaContainer::internalMakeFile(Diagnostics &diag, AbortableProgressFee
case EbmlIds::Crc32:
break;
case MatroskaIds::Position:
clusterSize += 1 + 1 + EbmlElement::calculateUIntegerLength(currentPosition + segment.totalDataSize);
clusterSize += 1u + 1u + EbmlElement::calculateUIntegerLength(currentPosition + segment.totalDataSize);
break;
default:
clusterSize += level2Element->totalSize();
@ -1395,7 +1395,7 @@ void MatroskaContainer::internalMakeFile(Diagnostics &diag, AbortableProgressFee
clusterReadSize += level2Element->totalSize();
}
segment.clusterSizes.push_back(clusterSize);
segment.totalDataSize += 4 + EbmlElement::calculateSizeDenotationLength(clusterSize) + clusterSize;
segment.totalDataSize += 4u + EbmlElement::calculateSizeDenotationLength(clusterSize) + clusterSize;
}
}
// check whether aborted (because this loop might take some seconds to process)
@ -1687,7 +1687,7 @@ void MatroskaContainer::internalMakeFile(Diagnostics &diag, AbortableProgressFee
std::uint64_t voidLength;
if (segment.newPadding < 64) {
sizeLength = 1;
*buff = static_cast<char>(voidLength = segment.newPadding - 2) | 0x80;
*buff = static_cast<char>(voidLength = segment.newPadding - 2) | static_cast<char>(0x80);
} else {
sizeLength = 8;
BE::getBytes(static_cast<std::uint64_t>((voidLength = segment.newPadding - 9) | 0x100000000000000), buff);

View File

@ -94,13 +94,13 @@ void MatroskaCuePositionUpdater::parse(EbmlElement *cuesElement, Diagnostics &di
break;
case MatroskaIds::CueClusterPosition:
pos = (cueClusterPositionElement = cueTrackPositionsChild)->readUInteger();
cueTrackPositionsElementSize += 2 + EbmlElement::calculateUIntegerLength(pos);
cueTrackPositionsElementSize += 2u + EbmlElement::calculateUIntegerLength(pos);
m_offsets.emplace(cueTrackPositionsChild, pos);
m_cueElementByOriginalOffset.emplace(pos, cueTrackPositionsChild);
break;
case MatroskaIds::CueCodecState:
statePos = cueTrackPositionsChild->readUInteger();
cueTrackPositionsElementSize += 2 + EbmlElement::calculateUIntegerLength(statePos);
cueTrackPositionsElementSize += 2u + EbmlElement::calculateUIntegerLength(statePos);
m_offsets.emplace(cueTrackPositionsChild, statePos);
m_cueElementByOriginalOffset.emplace(statePos, cueTrackPositionsChild);
break;
@ -122,7 +122,7 @@ void MatroskaCuePositionUpdater::parse(EbmlElement *cuesElement, Diagnostics &di
case MatroskaIds::CueRefCluster:
case MatroskaIds::CueRefCodecState:
statePos = cueReferenceChild->readUInteger();
cueReferenceElementSize += 2 + EbmlElement::calculateUIntegerLength(statePos);
cueReferenceElementSize += 2u + EbmlElement::calculateUIntegerLength(statePos);
m_offsets.emplace(cueReferenceChild, statePos);
m_cueElementByOriginalOffset.emplace(statePos, cueReferenceChild);
break;
@ -144,7 +144,7 @@ void MatroskaCuePositionUpdater::parse(EbmlElement *cuesElement, Diagnostics &di
diag.emplace_back(
DiagLevel::Critical, "\"CueTrackPositions\"-element does not contain mandatory \"CueClusterPosition\"-element.", context);
} else if (cueRelativePositionElement) {
cueTrackPositionsElementSize += 2 + EbmlElement::calculateUIntegerLength(relPos);
cueTrackPositionsElementSize += 2u + EbmlElement::calculateUIntegerLength(relPos);
m_relativeOffsets.emplace(piecewise_construct, forward_as_tuple(cueRelativePositionElement), forward_as_tuple(pos, relPos));
m_cueRelativePositionElementByOriginalOffsets.emplace(
piecewise_construct, forward_as_tuple(pos, relPos), forward_as_tuple(cueRelativePositionElement));

View File

@ -156,7 +156,7 @@ void MatroskaSeekInfo::make(ostream &stream, Diagnostics &diag)
// calculate size
for (const auto &info : m_info) {
// "Seek" element + "SeekID" element + "SeekPosition" element
totalSize += 2 + 1 + (2 + 1 + EbmlElement::calculateIdLength(get<0>(info))) + (2 + 1 + EbmlElement::calculateUIntegerLength(get<1>(info)));
totalSize += 2u + 1u + (2u + 1u + EbmlElement::calculateIdLength(info.first)) + (2u + 1u + EbmlElement::calculateUIntegerLength(info.second));
}
// write ID and size
BE::getBytes(static_cast<std::uint32_t>(MatroskaIds::SeekHead), buff0);
@ -166,8 +166,8 @@ void MatroskaSeekInfo::make(ostream &stream, Diagnostics &diag)
// write entries
for (const auto &info : m_info) {
// make values
sizeLength0 = EbmlElement::makeId(get<0>(info), buff0);
sizeLength1 = EbmlElement::makeUInteger(get<1>(info), buff1);
sizeLength0 = EbmlElement::makeId(info.first, buff0);
sizeLength1 = EbmlElement::makeUInteger(info.second, buff1);
// "Seek" header
BE::getBytes(static_cast<std::uint16_t>(MatroskaIds::Seek), buff2);
stream.write(buff2, 2);
@ -214,9 +214,10 @@ std::uint64_t MatroskaSeekInfo::actualSize() const
std::uint64_t totalSize = 0;
for (const auto &info : m_info) {
// "Seek" element + "SeekID" element + "SeekPosition" element
totalSize += 2 + 1 + (2 + 1 + EbmlElement::calculateIdLength(get<0>(info))) + (2 + 1 + EbmlElement::calculateUIntegerLength(get<1>(info)));
totalSize
+= 2u + 1u + (2 + 1 + EbmlElement::calculateIdLength(get<0>(info))) + (2u + 1u + EbmlElement::calculateUIntegerLength(get<1>(info)));
}
return totalSize += 4 + EbmlElement::calculateSizeDenotationLength(totalSize);
return totalSize += 4u + EbmlElement::calculateSizeDenotationLength(totalSize);
}
/*!

View File

@ -214,20 +214,20 @@ MatroskaTagMaker::MatroskaTagMaker(MatroskaTag &tag, Diagnostics &diag)
m_targetsSize = 0; // NOT including ID and size
if (m_tag.target().level() != 50) {
// size of "TargetTypeValue"
m_targetsSize += 2 + 1 + EbmlElement::calculateUIntegerLength(m_tag.target().level());
m_targetsSize += 2u + 1u + EbmlElement::calculateUIntegerLength(m_tag.target().level());
}
if (!m_tag.target().levelName().empty()) {
// size of "TargetType"
m_targetsSize += 2 + EbmlElement::calculateSizeDenotationLength(m_tag.target().levelName().size()) + m_tag.target().levelName().size();
m_targetsSize += 2u + EbmlElement::calculateSizeDenotationLength(m_tag.target().levelName().size()) + m_tag.target().levelName().size();
}
for (const auto &v : initializer_list<vector<std::uint64_t>>{
m_tag.target().tracks(), m_tag.target().editions(), m_tag.target().chapters(), m_tag.target().attachments() }) {
for (auto uid : v) {
// size of UID denotation
m_targetsSize += 2 + 1 + EbmlElement::calculateUIntegerLength(uid);
m_targetsSize += 2u + 1u + EbmlElement::calculateUIntegerLength(uid);
}
}
m_tagSize = 2 + EbmlElement::calculateSizeDenotationLength(m_targetsSize) + m_targetsSize;
m_tagSize = 2u + EbmlElement::calculateSizeDenotationLength(m_targetsSize) + m_targetsSize;
// calculate size of "SimpleTag" elements
m_maker.reserve(m_tag.fields().size());
m_simpleTagsSize = 0; // including ID and size
@ -239,7 +239,7 @@ MatroskaTagMaker::MatroskaTagMaker(MatroskaTag &tag, Diagnostics &diag)
}
}
m_tagSize += m_simpleTagsSize;
m_totalSize = 2 + EbmlElement::calculateSizeDenotationLength(m_tagSize) + m_tagSize;
m_totalSize = 2u + EbmlElement::calculateSizeDenotationLength(m_tagSize) + m_tagSize;
}
/*!
@ -277,7 +277,7 @@ void MatroskaTagMaker::make(ostream &stream) const
stream.write(buff, 2);
len = EbmlElement::makeSizeDenotation(t.levelName().size(), buff);
stream.write(buff, len);
stream.write(t.levelName().c_str(), t.levelName().size());
stream.write(t.levelName().c_str(), static_cast<std::streamsize>(t.levelName().size()));
}
// write UIDs
using p = pair<std::uint16_t, vector<std::uint64_t>>;

View File

@ -251,7 +251,7 @@ void MatroskaTagFieldMaker::make(ostream &stream) const
writer.writeUInt16BE(MatroskaIds::TagName);
sizeDenotationLen = EbmlElement::makeSizeDenotation(m_field.id().size(), buff);
stream.write(buff, sizeDenotationLen);
stream.write(m_field.id().c_str(), m_field.id().size());
stream.write(m_field.id().c_str(), static_cast<std::streamsize>(m_field.id().size()));
// write "TagLanguage" element
writer.writeUInt16BE(MatroskaIds::TagLanguage);
if (m_language.empty()) {
@ -260,14 +260,14 @@ void MatroskaTagFieldMaker::make(ostream &stream) const
} else {
sizeDenotationLen = EbmlElement::makeSizeDenotation(m_language.size(), buff);
stream.write(buff, sizeDenotationLen);
stream.write(m_language.data(), m_language.size());
stream.write(m_language.data(), static_cast<std::streamsize>(m_language.size()));
}
// write "TagLanguageIETF" element
if (!m_languageIETF.empty()) {
writer.writeUInt16BE(MatroskaIds::TagLanguageIETF);
sizeDenotationLen = EbmlElement::makeSizeDenotation(m_languageIETF.size(), buff);
stream.write(buff, sizeDenotationLen);
stream.write(m_languageIETF.data(), m_languageIETF.size());
stream.write(m_languageIETF.data(), static_cast<std::streamsize>(m_languageIETF.size()));
}
// write "TagDefault" element
writer.writeUInt16BE(MatroskaIds::TagDefault);
@ -278,12 +278,12 @@ void MatroskaTagFieldMaker::make(ostream &stream) const
writer.writeUInt16BE(MatroskaIds::TagBinary);
sizeDenotationLen = EbmlElement::makeSizeDenotation(m_field.value().dataSize(), buff);
stream.write(buff, sizeDenotationLen);
stream.write(m_field.value().dataPointer(), m_field.value().dataSize());
stream.write(m_field.value().dataPointer(), static_cast<std::streamsize>(m_field.value().dataSize()));
} else {
writer.writeUInt16BE(MatroskaIds::TagString);
sizeDenotationLen = EbmlElement::makeSizeDenotation(m_stringValue.size(), buff);
stream.write(buff, sizeDenotationLen);
stream.write(m_stringValue.data(), m_stringValue.size());
stream.write(m_stringValue.data(), static_cast<std::streamsize>(m_stringValue.size()));
}
// make nested tags
for (const auto &maker : m_nestedMaker) {

View File

@ -303,7 +303,7 @@ void MatroskaTrack::internalParseHeader(Diagnostics &diag, AbortableProgressFeed
diag.emplace_back(DiagLevel::Critical, "Unable to parse track information element.", context);
break;
}
std::uint32_t defaultDuration = 0;
std::uint64_t defaultDuration = 0;
switch (trackInfoElement->id()) {
case MatroskaIds::TrackType:
switch (trackInfoElement->readUInteger()) {
@ -336,37 +336,37 @@ void MatroskaTrack::internalParseHeader(Diagnostics &diag, AbortableProgressFeed
}
switch (subElement->id()) {
case MatroskaIds::DisplayWidth:
m_displaySize.setWidth(subElement->readUInteger());
m_displaySize.setWidth(static_cast<std::uint32_t>(subElement->readUInteger()));
break;
case MatroskaIds::DisplayHeight:
m_displaySize.setHeight(subElement->readUInteger());
m_displaySize.setHeight(static_cast<std::uint32_t>(subElement->readUInteger()));
break;
case MatroskaIds::PixelWidth:
m_pixelSize.setWidth(subElement->readUInteger());
m_pixelSize.setWidth(static_cast<std::uint32_t>(subElement->readUInteger()));
break;
case MatroskaIds::PixelHeight:
m_pixelSize.setHeight(subElement->readUInteger());
m_pixelSize.setHeight(static_cast<std::uint32_t>(subElement->readUInteger()));
break;
case MatroskaIds::PixelCropTop:
m_cropping.setTop(subElement->readUInteger());
m_cropping.setTop(static_cast<std::uint32_t>(subElement->readUInteger()));
break;
case MatroskaIds::PixelCropLeft:
m_cropping.setLeft(subElement->readUInteger());
m_cropping.setLeft(static_cast<std::uint32_t>(subElement->readUInteger()));
break;
case MatroskaIds::PixelCropBottom:
m_cropping.setBottom(subElement->readUInteger());
m_cropping.setBottom(static_cast<std::uint32_t>(subElement->readUInteger()));
break;
case MatroskaIds::PixelCropRight:
m_cropping.setRight(subElement->readUInteger());
m_cropping.setRight(static_cast<std::uint32_t>(subElement->readUInteger()));
break;
case MatroskaIds::FrameRate:
m_fps = subElement->readFloat();
m_fps = static_cast<std::uint32_t>(subElement->readFloat());
break;
case MatroskaIds::FlagInterlaced:
modFlagEnum(m_flags, TrackFlags::Interlaced, subElement->readUInteger());
break;
case MatroskaIds::ColorSpace:
m_colorSpace = subElement->readUInteger();
m_colorSpace = static_cast<std::uint32_t>(subElement->readUInteger());
break;
default:;
}
@ -382,19 +382,19 @@ void MatroskaTrack::internalParseHeader(Diagnostics &diag, AbortableProgressFeed
}
switch (subElement->id()) {
case MatroskaIds::BitDepth:
m_bitsPerSample = subElement->readUInteger();
m_bitsPerSample = static_cast<std::uint16_t>(subElement->readUInteger());
break;
case MatroskaIds::Channels:
m_channelCount = subElement->readUInteger();
m_channelCount = static_cast<std::uint16_t>(subElement->readUInteger());
break;
case MatroskaIds::SamplingFrequency:
if (!m_samplingFrequency) {
m_samplingFrequency = subElement->readFloat();
m_samplingFrequency = static_cast<std::uint32_t>(subElement->readFloat());
}
break;
case MatroskaIds::OutputSamplingFrequency:
if (!m_extensionSamplingFrequency) {
m_extensionSamplingFrequency = subElement->readFloat();
m_extensionSamplingFrequency = static_cast<std::uint32_t>(subElement->readFloat());
}
break;
default:;
@ -402,7 +402,7 @@ void MatroskaTrack::internalParseHeader(Diagnostics &diag, AbortableProgressFeed
}
break;
case MatroskaIds::TrackNumber:
m_trackNumber = trackInfoElement->readUInteger();
m_trackNumber = static_cast<std::uint32_t>(trackInfoElement->readUInteger());
break;
case MatroskaIds::TrackUID:
m_id = trackInfoElement->readUInteger();
@ -444,7 +444,7 @@ void MatroskaTrack::internalParseHeader(Diagnostics &diag, AbortableProgressFeed
switch (m_mediaType) {
case MediaType::Video:
if (!m_fps && defaultDuration) {
m_fps = 1000000000.0 / defaultDuration;
m_fps = static_cast<std::uint32_t>(1000000000.0 / static_cast<double>(defaultDuration));
}
break;
default:;
@ -565,13 +565,13 @@ MatroskaTrackHeaderMaker::MatroskaTrackHeaderMaker(const MatroskaTrack &track, D
CPP_UTILITIES_UNUSED(diag);
// calculate size for recognized elements
m_dataSize += 2 + 1 + EbmlElement::calculateUIntegerLength(m_track.id());
m_dataSize += 1 + 1 + EbmlElement::calculateUIntegerLength(m_track.trackNumber());
m_dataSize += 1 + 1 + EbmlElement::calculateUIntegerLength(m_track.isEnabled());
m_dataSize += 1 + 1 + EbmlElement::calculateUIntegerLength(m_track.isDefault());
m_dataSize += 2 + 1 + EbmlElement::calculateUIntegerLength(m_track.isForced());
m_dataSize += 2u + 1u + EbmlElement::calculateUIntegerLength(m_track.id());
m_dataSize += 1u + 1u + EbmlElement::calculateUIntegerLength(m_track.trackNumber());
m_dataSize += 1u + 1u + EbmlElement::calculateUIntegerLength(m_track.isEnabled());
m_dataSize += 1u + 1u + EbmlElement::calculateUIntegerLength(m_track.isDefault());
m_dataSize += 2u + 1u + EbmlElement::calculateUIntegerLength(m_track.isForced());
if (!m_track.name().empty()) {
m_dataSize += 2 + EbmlElement::calculateSizeDenotationLength(m_track.name().size()) + m_track.name().size();
m_dataSize += 2u + EbmlElement::calculateSizeDenotationLength(m_track.name().size()) + m_track.name().size();
}
// compute size of the mandatory "Language" element (if there's no language set, the 3 byte long value "und" is used)
@ -601,7 +601,7 @@ MatroskaTrackHeaderMaker::MatroskaTrackHeaderMaker(const MatroskaTrack &track, D
}
}
m_sizeDenotationLength = EbmlElement::calculateSizeDenotationLength(m_dataSize);
m_requiredSize = 1 + m_sizeDenotationLength + m_dataSize;
m_requiredSize = 1u + m_sizeDenotationLength + m_dataSize;
}
/*!

View File

@ -162,7 +162,7 @@ void MediaFileInfo::parseContainerFormat(Diagnostics &diag, AbortableProgressFee
// file size
m_paddingSize = 0;
m_containerOffset = 0;
size_t bytesSkippedBeforeContainer = 0;
std::size_t bytesSkippedBeforeContainer = 0;
// read signatrue
char buff[16];
@ -181,12 +181,12 @@ startParsingSignature:
// - Only skipping 4 or more consecutive zero bytes at this point because some signatures start with up to 4 zero bytes.
// - It seems that most players/tools¹ skip junk bytes, at least when reading MP3 files. Hence the tagparser library is following
// the same approach. (¹e.g. ffmpeg: "[mp3 @ 0x559e1f4cbd80] Skipping 1670 bytes of junk at 1165.")
size_t bytesSkipped = 0;
std::size_t bytesSkipped = 0;
for (buffOffset = buff; buffOffset != buffEnd && !(*buffOffset); ++buffOffset, ++bytesSkipped)
;
if (bytesSkipped >= 4) {
skipJunkBytes:
m_containerOffset += bytesSkipped;
m_containerOffset += static_cast<std::streamoff>(bytesSkipped);
m_paddingSize += bytesSkipped;
// give up after 0x800 bytes
@ -919,7 +919,7 @@ double MediaFileInfo::overallAverageBitrate() const
if (duration.isNull()) {
return 0.0;
}
return 0.0078125 * size() / duration.totalSeconds();
return 0.0078125 * static_cast<double>(size()) / duration.totalSeconds();
}
/*!
@ -1597,7 +1597,7 @@ void MediaFileInfo::makeMp3File(Diagnostics &diag, AbortableProgressFeedback &pr
// prepare ID3v2 tags
vector<Id3v2TagMaker> makers;
makers.reserve(m_id3v2Tags.size());
std::uint32_t tagsSize = 0;
std::uint64_t tagsSize = 0;
for (auto &tag : m_id3v2Tags) {
try {
makers.emplace_back(tag->prepareMaking(diag));
@ -1614,7 +1614,7 @@ void MediaFileInfo::makeMp3File(Diagnostics &diag, AbortableProgressFeedback &pr
if (flacStream) {
// if it is a raw FLAC stream, make FLAC metadata
startOfLastMetaDataBlock = flacStream->makeHeader(flacMetaData, diag);
tagsSize += flacMetaData.tellp();
tagsSize += static_cast<std::uint64_t>(flacMetaData.tellp());
streamOffset = flacStream->streamOffset();
} else {
// make no further metadata, just use the container offset as stream offset

View File

@ -136,8 +136,8 @@ void Mp4Container::internalParseTracks(Diagnostics &diag, AbortableProgressFeedb
m_duration = TimeSpan::fromSeconds(static_cast<double>(reader().readUInt32BE()) / static_cast<double>(m_timeScale));
break;
case 1:
m_creationTime = DateTime::fromDate(1904, 1, 1) + TimeSpan::fromSeconds(reader().readUInt64BE());
m_modificationTime = DateTime::fromDate(1904, 1, 1) + TimeSpan::fromSeconds(reader().readUInt64BE());
m_creationTime = DateTime::fromDate(1904, 1, 1) + TimeSpan::fromSeconds(static_cast<double>(reader().readUInt64BE()));
m_modificationTime = DateTime::fromDate(1904, 1, 1) + TimeSpan::fromSeconds(static_cast<double>(reader().readUInt64BE()));
m_timeScale = reader().readUInt32BE();
m_duration = TimeSpan::fromSeconds(static_cast<double>(reader().readUInt64BE()) / static_cast<double>(m_timeScale));
break;
@ -425,7 +425,7 @@ void Mp4Container::internalMakeFile(Diagnostics &diag, AbortableProgressFeedback
if (!rewriteRequired) {
newPaddingEnd = 0;
std::uint64_t currentSum = 0;
for (Mp4Atom *level0Atom = firstMediaDataAtom; level0Atom; level0Atom = level0Atom->nextSibling()) {
for (level0Atom = firstMediaDataAtom; level0Atom; level0Atom = level0Atom->nextSibling()) {
level0Atom->parse(diag);
switch (level0Atom->id()) {
case Mp4AtomIds::FileType:
@ -584,12 +584,11 @@ calculatePadding:
for (std::uint8_t pass = 0; pass != 2; ++pass) {
if (newTagPos == (pass ? ElementPosition::AfterData : ElementPosition::BeforeData)) {
// define function to write tracks
bool tracksWritten = false;
const auto writeTracks = [&] {
auto tracksWritten = false;
const auto writeTracks = [this, &diag, &tracksWritten] {
if (tracksWritten) {
return;
}
for (auto &track : tracks()) {
track->makeTrack(diag);
}
@ -597,8 +596,9 @@ calculatePadding:
};
// define function to write user data
bool userDataWritten = false;
const auto writeUserData = [&] {
auto userDataWritten = false;
auto writeUserData = [level0Atom, level1Atom, level2Atom, movieAtom, &userDataWritten, userDataAtomSize, &outputStream, &outputWriter,
&tagMaker, &diag]() mutable {
if (userDataWritten || !userDataAtomSize) {
return;
}
@ -608,10 +608,10 @@ calculatePadding:
// write children of user data atom
bool metaAtomWritten = false;
for (Mp4Atom *level0Atom = movieAtom; level0Atom; level0Atom = level0Atom->siblingById(Mp4AtomIds::Movie, diag)) {
for (Mp4Atom *level1Atom = level0Atom->childById(Mp4AtomIds::UserData, diag); level1Atom;
for (level0Atom = movieAtom; level0Atom; level0Atom = level0Atom->siblingById(Mp4AtomIds::Movie, diag)) {
for (level1Atom = level0Atom->childById(Mp4AtomIds::UserData, diag); level1Atom;
level1Atom = level1Atom->siblingById(Mp4AtomIds::UserData, diag)) {
for (Mp4Atom *level2Atom = level1Atom->firstChild(); level2Atom; level2Atom = level2Atom->nextSibling()) {
for (level2Atom = level1Atom->firstChild(); level2Atom; level2Atom = level2Atom->nextSibling()) {
switch (level2Atom->id()) {
case Mp4AtomIds::Meta:
// write meta atom
@ -787,7 +787,7 @@ calculatePadding:
} else {
// can't just skip next movie sibling
for (Mp4Atom *level0Atom = firstMediaDataAtom; level0Atom; level0Atom = level0Atom->nextSibling()) {
for (level0Atom = firstMediaDataAtom; level0Atom; level0Atom = level0Atom->nextSibling()) {
level0Atom->parse(diag);
switch (level0Atom->id()) {
case Mp4AtomIds::FileType:

View File

@ -85,14 +85,13 @@ const TagValue &Mp4Tag::value(KnownField field) const
std::vector<const TagValue *> Mp4Tag::values(KnownField field) const
{
auto values = FieldMapBasedTag<Mp4Tag>::values(field);
const Mp4ExtendedFieldId extendedId(field);
if (extendedId) {
if (const auto extendedId = Mp4ExtendedFieldId(field)) {
auto range = fields().equal_range(Mp4TagAtomIds::Extended);
for (auto i = range.first; i != range.second; ++i) {
const auto &field = i->second;
if (extendedId.matches(field)) {
values.emplace_back(&field.value());
for (const auto &additionalData : field.additionalData()) {
const auto &extendedField = i->second;
if (extendedId.matches(extendedField)) {
values.emplace_back(&extendedField.value());
for (const auto &additionalData : extendedField.additionalData()) {
values.emplace_back(&additionalData.value);
}
}
@ -259,16 +258,15 @@ bool Mp4Tag::setValue(KnownField field, const TagValue &value)
bool Mp4Tag::setValues(KnownField field, const std::vector<TagValue> &values)
{
const auto extendedId = Mp4ExtendedFieldId(field);
if (extendedId) {
if (const auto extendedId = Mp4ExtendedFieldId(field)) {
auto valuesIterator = values.cbegin();
auto range = fields().equal_range(Mp4TagAtomIds::Extended);
for (; valuesIterator != values.cend() && range.first != range.second;) {
if (!valuesIterator->isEmpty()) {
auto &field = range.first->second;
if (extendedId.matches(field) && (!extendedId.updateOnly || !field.value().isEmpty())) {
field.clearValue();
field.setValue(*valuesIterator);
auto &extendedField = range.first->second;
if (extendedId.matches(extendedField) && (!extendedId.updateOnly || !extendedField.value().isEmpty())) {
extendedField.clearValue();
extendedField.setValue(*valuesIterator);
// note: Not sure which extended tag fields support multiple data atoms and which don't. Let's simply use
// only one data atom per extended field here and get rid of any possibly assigned additional data
// atoms.

View File

@ -279,60 +279,60 @@ std::vector<std::uint64_t> Mp4Track::readChunkOffsets(bool parseFragments, Diagn
}
for (Mp4Atom *trunAtom = trafAtom->childById(Mp4AtomIds::TrackFragmentRun, diag); trunAtom;
trunAtom = trunAtom->siblingById(Mp4AtomIds::TrackFragmentRun, diag)) {
std::uint32_t calculatedDataSize = 8;
if (trunAtom->dataSize() < calculatedDataSize) {
std::uint32_t trunCalculatedDataSize = 8;
if (trunAtom->dataSize() < trunCalculatedDataSize) {
diag.emplace_back(DiagLevel::Critical, "trun atom is truncated.", context);
} else {
inputStream().seekg(static_cast<streamoff>(trunAtom->dataOffset() + 1));
std::uint32_t flags = reader().readUInt24BE();
std::uint32_t trunFlags = reader().readUInt24BE();
std::uint32_t sampleCount = reader().readUInt32BE();
m_sampleCount += sampleCount;
if (flags & 0x000001) { // data offset present
calculatedDataSize += 4;
if (trunFlags & 0x000001) { // data offset present
trunCalculatedDataSize += 4;
}
if (flags & 0x000004) { // first-sample-flags present
calculatedDataSize += 4;
if (trunFlags & 0x000004) { // first-sample-flags present
trunCalculatedDataSize += 4;
}
std::uint32_t entrySize = 0;
if (flags & 0x000100) { // sample-duration present
if (trunFlags & 0x000100) { // sample-duration present
entrySize += 4;
}
if (flags & 0x000200) { // sample-size present
if (trunFlags & 0x000200) { // sample-size present
entrySize += 4;
}
if (flags & 0x000400) { // sample-flags present
if (trunFlags & 0x000400) { // sample-flags present
entrySize += 4;
}
if (flags & 0x000800) { // sample-composition-time-offsets present
if (trunFlags & 0x000800) { // sample-composition-time-offsets present
entrySize += 4;
}
calculatedDataSize += entrySize * sampleCount;
if (trunAtom->dataSize() < calculatedDataSize) {
trunCalculatedDataSize += entrySize * sampleCount;
if (trunAtom->dataSize() < trunCalculatedDataSize) {
diag.emplace_back(DiagLevel::Critical, "trun atom is truncated (presence of fields denoted).", context);
} else {
if (flags & 0x000001) { // data offset present
if (trunFlags & 0x000001) { // data offset present
inputStream().seekg(4, ios_base::cur);
//int32 dataOffset = reader().readInt32BE();
}
if (flags & 0x000004) { // first-sample-flags present
if (trunFlags & 0x000004) { // first-sample-flags present
inputStream().seekg(4, ios_base::cur);
}
for (std::uint32_t i = 0; i < sampleCount; ++i) {
if (flags & 0x000100) { // sample-duration present
if (trunFlags & 0x000100) { // sample-duration present
totalDuration += reader().readUInt32BE();
} else {
totalDuration += defaultSampleDuration;
}
if (flags & 0x000200) { // sample-size present
if (trunFlags & 0x000200) { // sample-size present
m_sampleSizes.push_back(reader().readUInt32BE());
m_size += m_sampleSizes.back();
} else {
m_size += defaultSampleSize;
}
if (flags & 0x000400) { // sample-flags present
if (trunFlags & 0x000400) { // sample-flags present
inputStream().seekg(4, ios_base::cur);
}
if (flags & 0x000800) { // sample-composition-time-offsets present
if (trunFlags & 0x000800) { // sample-composition-time-offsets present
inputStream().seekg(4, ios_base::cur);
}
}
@ -909,7 +909,7 @@ void Mp4Track::updateChunkOffsets(const vector<std::int64_t> &oldMdatOffsets, co
off = m_reader.readUInt32BE();
for (i = 0, size = oldMdatOffsets.size(); i < size; ++i) {
if (off > static_cast<std::uint64_t>(oldMdatOffsets[i])) {
off += (newMdatOffsets[i] - oldMdatOffsets[i]);
off += static_cast<std::uint32_t>(newMdatOffsets[i] - oldMdatOffsets[i]);
break;
}
}
@ -925,7 +925,7 @@ void Mp4Track::updateChunkOffsets(const vector<std::int64_t> &oldMdatOffsets, co
off = m_reader.readUInt64BE();
for (i = 0, size = oldMdatOffsets.size(); i < size; ++i) {
if (off > static_cast<std::uint64_t>(oldMdatOffsets[i])) {
off += (newMdatOffsets[i] - oldMdatOffsets[i]);
off += static_cast<std::uint64_t>(newMdatOffsets[i] - oldMdatOffsets[i]);
break;
}
}
@ -1298,7 +1298,7 @@ void Mp4Track::makeMedia(Diagnostics &diag)
for (size_t charIndex = 0; charIndex != 3; ++charIndex) {
const char langChar = charIndex < language.size() ? language[charIndex] : 0;
if (langChar >= 'a' && langChar <= 'z') {
codedLanguage |= static_cast<std::uint16_t>(langChar - 0x60) << (0xA - charIndex * 0x5);
codedLanguage |= static_cast<std::uint16_t>((langChar - 0x60) << (0xA - charIndex * 0x5));
continue;
}
@ -1320,7 +1320,7 @@ void Mp4Track::makeMedia(Diagnostics &diag)
writer().writeUInt16BE(codedLanguage);
writer().writeUInt16BE(0); // pre defined
// write hdlr atom
writer().writeUInt32BE(33 + m_name.size()); // size
writer().writeUInt32BE(33 + static_cast<std::uint32_t>(m_name.size())); // size
writer().writeUInt32BE(Mp4AtomIds::HandlerReference);
writer().writeUInt64BE(0); // version, flags, pre defined
switch (m_mediaType) {
@ -1546,8 +1546,8 @@ void Mp4Track::internalParseHeader(Diagnostics &diag, AbortableProgressFeedback
m_id = reader.readUInt32BE();
break;
case 1:
m_creationTime = startDate + TimeSpan::fromSeconds(reader.readUInt64BE());
m_modificationTime = startDate + TimeSpan::fromSeconds(reader.readUInt64BE());
m_creationTime = startDate + TimeSpan::fromSeconds(static_cast<double>(reader.readUInt64BE()));
m_modificationTime = startDate + TimeSpan::fromSeconds(static_cast<double>(reader.readUInt64BE()));
m_id = reader.readUInt32BE();
break;
default:
@ -1571,8 +1571,8 @@ void Mp4Track::internalParseHeader(Diagnostics &diag, AbortableProgressFeedback
m_duration = TimeSpan::fromSeconds(static_cast<double>(reader.readUInt32BE()) / static_cast<double>(m_timeScale));
break;
case 1:
m_creationTime = startDate + TimeSpan::fromSeconds(reader.readUInt64BE());
m_modificationTime = startDate + TimeSpan::fromSeconds(reader.readUInt64BE());
m_creationTime = startDate + TimeSpan::fromSeconds(static_cast<double>(reader.readUInt64BE()));
m_modificationTime = startDate + TimeSpan::fromSeconds(static_cast<double>(reader.readUInt64BE()));
m_timeScale = reader.readUInt32BE();
m_duration = TimeSpan::fromSeconds(static_cast<double>(reader.readUInt64BE()) / static_cast<double>(m_timeScale));
break;
@ -1870,7 +1870,8 @@ void Mp4Track::internalParseHeader(Diagnostics &diag, AbortableProgressFeedback
m_size = constantSize * m_sampleCount;
} else {
auto actualSampleCount = m_sampleCount;
const auto calculatedSampleSizeTableSize = static_cast<std::uint64_t>(ceil((0.125 * fieldSize) * m_sampleCount));
const auto calculatedSampleSizeTableSize
= static_cast<std::uint64_t>(std::ceil((0.125 * fieldSize) * static_cast<double>(m_sampleCount)));
if (calculatedSampleSizeTableSize < actualSampleSizeTableSize) {
diag.emplace_back(
DiagLevel::Critical, "The stsz atom stores more entries as denoted. The additional entries will be ignored.", context);
@ -1934,21 +1935,21 @@ void Mp4Track::internalParseHeader(Diagnostics &diag, AbortableProgressFeedback
diag.emplace_back(DiagLevel::Critical, "tfhd atom is truncated.", context);
} else {
m_istream->seekg(static_cast<streamoff>(tfhdAtom->dataOffset() + 1));
std::uint32_t flags = reader.readUInt24BE();
std::uint32_t tfhdFlags = reader.readUInt24BE();
if (m_id == reader.readUInt32BE()) { // check track ID
if (flags & 0x000001) { // base-data-offset present
if (tfhdFlags & 0x000001) { // base-data-offset present
calculatedDataSize += 8;
}
if (flags & 0x000002) { // sample-description-index present
if (tfhdFlags & 0x000002) { // sample-description-index present
calculatedDataSize += 4;
}
if (flags & 0x000008) { // default-sample-duration present
if (tfhdFlags & 0x000008) { // default-sample-duration present
calculatedDataSize += 4;
}
if (flags & 0x000010) { // default-sample-size present
if (tfhdFlags & 0x000010) { // default-sample-size present
calculatedDataSize += 4;
}
if (flags & 0x000020) { // default-sample-flags present
if (tfhdFlags & 0x000020) { // default-sample-flags present
calculatedDataSize += 4;
}
//uint64 baseDataOffset = moofAtom->startOffset();
@ -1959,82 +1960,82 @@ void Mp4Track::internalParseHeader(Diagnostics &diag, AbortableProgressFeedback
if (tfhdAtom->dataSize() < calculatedDataSize) {
diag.emplace_back(DiagLevel::Critical, "tfhd atom is truncated (presence of fields denoted).", context);
} else {
if (flags & 0x000001) { // base-data-offset present
if (tfhdFlags & 0x000001) { // base-data-offset present
//baseDataOffset = reader.readUInt64();
m_istream->seekg(8, ios_base::cur);
}
if (flags & 0x000002) { // sample-description-index present
if (tfhdFlags & 0x000002) { // sample-description-index present
//defaultSampleDescriptionIndex = reader.readUInt32();
m_istream->seekg(4, ios_base::cur);
}
if (flags & 0x000008) { // default-sample-duration present
if (tfhdFlags & 0x000008) { // default-sample-duration present
defaultSampleDuration = reader.readUInt32BE();
//m_istream->seekg(4, ios_base::cur);
}
if (flags & 0x000010) { // default-sample-size present
if (tfhdFlags & 0x000010) { // default-sample-size present
defaultSampleSize = reader.readUInt32BE();
}
if (flags & 0x000020) { // default-sample-flags present
if (tfhdFlags & 0x000020) { // default-sample-flags present
//defaultSampleFlags = reader.readUInt32BE();
m_istream->seekg(4, ios_base::cur);
}
}
for (Mp4Atom *trunAtom = trafAtom->childById(TrackFragmentRun, diag); trunAtom;
trunAtom = trunAtom->siblingById(TrackFragmentRun, diag)) {
std::uint32_t calculatedDataSize = 8;
if (trunAtom->dataSize() < calculatedDataSize) {
std::uint32_t trunCalculatedDataSize = 8;
if (trunAtom->dataSize() < trunCalculatedDataSize) {
diag.emplace_back(DiagLevel::Critical, "trun atom is truncated.", context);
} else {
m_istream->seekg(static_cast<streamoff>(trunAtom->dataOffset() + 1));
std::uint32_t flags = reader.readUInt24BE();
std::uint32_t trunFlags = reader.readUInt24BE();
std::uint32_t sampleCount = reader.readUInt32BE();
m_sampleCount += sampleCount;
if (flags & 0x000001) { // data offset present
calculatedDataSize += 4;
if (trunFlags & 0x000001) { // data offset present
trunCalculatedDataSize += 4;
}
if (flags & 0x000004) { // first-sample-flags present
calculatedDataSize += 4;
if (trunFlags & 0x000004) { // first-sample-flags present
trunCalculatedDataSize += 4;
}
std::uint32_t entrySize = 0;
if (flags & 0x000100) { // sample-duration present
if (trunFlags & 0x000100) { // sample-duration present
entrySize += 4;
}
if (flags & 0x000200) { // sample-size present
if (trunFlags & 0x000200) { // sample-size present
entrySize += 4;
}
if (flags & 0x000400) { // sample-flags present
if (trunFlags & 0x000400) { // sample-flags present
entrySize += 4;
}
if (flags & 0x000800) { // sample-composition-time-offsets present
if (trunFlags & 0x000800) { // sample-composition-time-offsets present
entrySize += 4;
}
calculatedDataSize += entrySize * sampleCount;
if (trunAtom->dataSize() < calculatedDataSize) {
trunCalculatedDataSize += entrySize * sampleCount;
if (trunAtom->dataSize() < trunCalculatedDataSize) {
diag.emplace_back(DiagLevel::Critical, "trun atom is truncated (presence of fields denoted).", context);
} else {
if (flags & 0x000001) { // data offset present
if (trunFlags & 0x000001) { // data offset present
m_istream->seekg(4, ios_base::cur);
//int32 dataOffset = reader.readInt32();
}
if (flags & 0x000004) { // first-sample-flags present
if (trunFlags & 0x000004) { // first-sample-flags present
m_istream->seekg(4, ios_base::cur);
}
for (std::uint32_t i = 0; i < sampleCount; ++i) {
if (flags & 0x000100) { // sample-duration present
if (trunFlags & 0x000100) { // sample-duration present
totalDuration += reader.readUInt32BE();
} else {
totalDuration += defaultSampleDuration;
}
if (flags & 0x000200) { // sample-size present
if (trunFlags & 0x000200) { // sample-size present
m_sampleSizes.push_back(reader.readUInt32BE());
m_size += m_sampleSizes.back();
} else {
m_size += defaultSampleSize;
}
if (flags & 0x000400) { // sample-flags present
if (trunFlags & 0x000400) { // sample-flags present
m_istream->seekg(4, ios_base::cur);
}
if (flags & 0x000800) { // sample-composition-time-offsets present
if (trunFlags & 0x000800) { // sample-composition-time-offsets present
m_istream->seekg(4, ios_base::cur);
}
}

View File

@ -46,7 +46,7 @@ string Mpeg4Descriptor::parsingContext() const
*/
std::string Mpeg4Descriptor::idToString() const
{
return "0x" + numberToString(id(), 16);
return "0x" + numberToString(id(), static_cast<std::uint8_t>(16));
}
/*!

View File

@ -52,7 +52,7 @@ void MpegAudioFrame::parseHeader(BinaryReader &reader, Diagnostics &diag)
m_header = reader.readUInt32BE();
if (!isValid()) {
diag.emplace_back(DiagLevel::Critical,
"Frame 0x" % numberToString(m_header, 16) % " at 0x" % numberToString<std::int64_t>(reader.stream()->tellg() - 4l, 16) + " is invalid.",
"Frame 0x" % numberToString(m_header, 16u) % " at 0x" % numberToString<std::int64_t>(reader.stream()->tellg() - 4l, 16) + " is invalid.",
"parsing MPEG audio frame header");
throw InvalidDataException();
}

View File

@ -131,18 +131,18 @@ void OggIterator::previousSegment()
* \sa currentCharacterOffset()
* \sa seekForward()
*/
void OggIterator::read(char *buffer, size_t count)
void OggIterator::read(char *buffer, std::size_t count)
{
size_t bytesRead = 0;
std::size_t bytesRead = 0;
while (*this && count) {
const auto available = currentSegmentSize() - m_bytesRead;
stream().seekg(static_cast<streamoff>(currentCharacterOffset()));
stream().seekg(static_cast<std::streamoff>(currentCharacterOffset()));
if (count <= available) {
stream().read(buffer + bytesRead, static_cast<streamoff>(count));
stream().read(buffer + bytesRead, static_cast<std::streamsize>(count));
m_bytesRead += count;
return;
}
stream().read(buffer + bytesRead, available);
stream().read(buffer + bytesRead, static_cast<std::streamsize>(available));
nextSegment();
bytesRead += available;
count -= available;
@ -165,18 +165,18 @@ void OggIterator::read(char *buffer, size_t count)
* \sa currentCharacterOffset()
* \sa seekForward()
*/
size_t OggIterator::readAll(char *buffer, size_t max)
std::size_t OggIterator::readAll(char *buffer, std::size_t max)
{
size_t bytesRead = 0;
auto bytesRead = std::size_t(0);
while (*this && max) {
const std::uint32_t available = currentSegmentSize() - m_bytesRead;
stream().seekg(static_cast<streamoff>(currentCharacterOffset()));
const auto available = currentSegmentSize() - m_bytesRead;
stream().seekg(static_cast<std::streamoff>(currentCharacterOffset()), std::ios_base::beg);
if (max <= available) {
stream().read(buffer + bytesRead, static_cast<streamoff>(max));
stream().read(buffer + bytesRead, static_cast<std::streamsize>(max));
m_bytesRead += max;
return bytesRead + max;
} else {
stream().read(buffer + bytesRead, available);
stream().read(buffer + bytesRead, static_cast<std::streamsize>(available));
nextSegment();
bytesRead += available;
max -= available;
@ -195,9 +195,9 @@ size_t OggIterator::readAll(char *buffer, size_t max)
* \sa currentCharacterOffset()
* \sa read()
*/
void OggIterator::ignore(size_t count)
void OggIterator::ignore(std::size_t count)
{
std::uint32_t available = currentSegmentSize() - m_bytesRead;
auto available = currentSegmentSize() - m_bytesRead;
while (*this) {
available = currentSegmentSize() - m_bytesRead;
if (count <= available) {

View File

@ -59,7 +59,7 @@ private:
std::vector<OggPage>::size_type m_page;
std::vector<std::uint32_t>::size_type m_segment;
std::uint64_t m_offset;
std::uint32_t m_bytesRead;
std::uint64_t m_bytesRead;
bool m_hasIdFilter;
std::uint32_t m_idFilter;
};

View File

@ -35,7 +35,7 @@ public:
std::uint32_t headerSize() const;
std::uint32_t dataSize() const;
std::uint32_t totalSize() const;
std::uint64_t dataOffset(std::uint8_t segmentIndex = 0) const;
std::uint64_t dataOffset(std::vector<std::uint32_t>::size_type segmentIndex = 0) const;
static std::uint32_t makeSegmentSizeDenotation(std::ostream &stream, std::uint32_t size);
private:
@ -245,9 +245,11 @@ inline std::uint32_t OggPage::totalSize() const
* \sa startOffset()
* \sa headerSize()
*/
inline std::uint64_t OggPage::dataOffset(std::uint8_t segmentIndex) const
inline std::uint64_t OggPage::dataOffset(std::vector<std::uint32_t>::size_type segmentIndex) const
{
return startOffset() + headerSize() + std::accumulate(m_segmentSizes.cbegin(), m_segmentSizes.cbegin() + segmentIndex, 0);
return startOffset() + headerSize()
+ std::accumulate<decltype(m_segmentSizes)::const_iterator, std::uint64_t>(
m_segmentSizes.cbegin(), m_segmentSizes.cbegin() + static_cast<decltype(m_segmentSizes)::difference_type>(segmentIndex), 0u);
}
} // namespace TagParser

View File

@ -83,11 +83,11 @@ bool Tag::setValues(KnownField field, const std::vector<TagValue> &values)
* \remarks The encoding of the inserted text values might not be supported by the tag.
* To fix this, call ensureTextValuesAreProperlyEncoded() after insertion.
*/
unsigned int Tag::insertValues(const Tag &from, bool overwrite)
std::size_t Tag::insertValues(const Tag &from, bool overwrite)
{
unsigned int count = 0;
auto count = std::size_t(0);
for (int i = static_cast<int>(KnownField::Invalid) + 1, last = static_cast<int>(KnownField::Description); i <= last; ++i) {
KnownField field = static_cast<KnownField>(i);
auto field = static_cast<KnownField>(i);
const TagValue &ownValue = value(field);
if (overwrite || ownValue.isEmpty()) {
const TagValue &otherValue = from.value(field);

10
tag.h
View File

@ -121,7 +121,7 @@ public:
virtual bool hasField(KnownField field) const = 0;
virtual void removeAllFields() = 0;
const std::string &version() const;
std::uint32_t size() const;
std::uint64_t size() const;
virtual bool supportsTarget() const;
const TagTarget &target() const;
void setTarget(const TagTarget &target);
@ -129,20 +129,20 @@ public:
std::string_view targetLevelName() const;
bool isTargetingLevel(TagTargetLevel tagTargetLevel) const;
std::string targetString() const;
virtual unsigned int fieldCount() const = 0;
virtual std::size_t fieldCount() const = 0;
virtual bool supportsField(KnownField field) const = 0;
virtual TagDataType proposedDataType(KnownField field) const;
virtual bool supportsDescription(KnownField field) const;
virtual bool supportsMimeType(KnownField field) const;
virtual bool supportsMultipleValues(KnownField field) const;
virtual unsigned int insertValues(const Tag &from, bool overwrite);
virtual std::size_t insertValues(const Tag &from, bool overwrite);
virtual void ensureTextValuesAreProperlyEncoded() = 0;
protected:
Tag();
std::string m_version;
std::uint32_t m_size;
std::uint64_t m_size;
TagTarget m_target;
};
@ -171,7 +171,7 @@ inline const std::string &Tag::version() const
return m_version;
}
inline std::uint32_t Tag::size() const
inline std::uint64_t Tag::size() const
{
return m_size;
}

View File

@ -327,16 +327,15 @@ std::int32_t TagValue::toInteger() const
switch (m_type) {
case TagDataType::Text:
switch (m_encoding) {
case TagTextEncoding::Unspecified:
case TagTextEncoding::Latin1:
case TagTextEncoding::Utf8:
return bufferToNumber<std::int32_t>(m_ptr.get(), m_size);
case TagTextEncoding::Utf16LittleEndian:
case TagTextEncoding::Utf16BigEndian:
u16string u16str(reinterpret_cast<char16_t *>(m_ptr.get()), m_size / 2);
case TagTextEncoding::Utf16BigEndian: {
auto u16str = u16string(reinterpret_cast<char16_t *>(m_ptr.get()), m_size / 2);
ensureHostByteOrder(u16str, m_encoding);
return stringToNumber<std::int32_t>(u16str);
}
default:
return bufferToNumber<std::int32_t>(m_ptr.get(), m_size);
}
case TagDataType::PositionInSet:
if (m_size == sizeof(PositionInSet)) {
return *reinterpret_cast<std::int32_t *>(m_ptr.get());
@ -407,16 +406,15 @@ PositionInSet TagValue::toPositionInSet() const
switch (m_type) {
case TagDataType::Text:
switch (m_encoding) {
case TagTextEncoding::Unspecified:
case TagTextEncoding::Latin1:
case TagTextEncoding::Utf8:
return PositionInSet(string(m_ptr.get(), m_size));
case TagTextEncoding::Utf16LittleEndian:
case TagTextEncoding::Utf16BigEndian:
u16string u16str(reinterpret_cast<char16_t *>(m_ptr.get()), m_size / 2);
case TagTextEncoding::Utf16BigEndian: {
auto u16str = u16string(reinterpret_cast<char16_t *>(m_ptr.get()), m_size / 2);
ensureHostByteOrder(u16str, m_encoding);
return PositionInSet(u16str);
}
default:
return PositionInSet(string(m_ptr.get(), m_size));
}
case TagDataType::Integer:
case TagDataType::PositionInSet:
switch (m_size) {

View File

@ -553,7 +553,7 @@ void OverallTests::checkMkvTestMetaData()
}
CPPUNIT_ASSERT_EQUAL(m_testCover.size(), static_cast<size_t>(attachmentData->size()));
istream &attachmentSteam = attachmentData->stream();
attachmentSteam.seekg(attachmentData->startOffset());
attachmentSteam.seekg(static_cast<std::streamoff>(attachmentData->startOffset()), std::ios_base::beg);
for (char expectedChar : m_testCover) {
CPPUNIT_ASSERT_EQUAL(expectedChar, static_cast<char>(attachmentSteam.get()));
}

View File

@ -116,7 +116,7 @@ Sha256Checksum TestFile::computeSha256Sum() const
Sha256Checksum hexString;
char *hexStringIterator = hexString.checksum;
for (unsigned char hashNumber : hash) {
const string digits = numberToString(hashNumber, 16);
const string digits = numberToString(hashNumber, static_cast<unsigned char>(16));
*(hexStringIterator++) = digits.size() < 2 ? '0' : digits.front();
*(hexStringIterator++) = digits.back();
}

View File

@ -203,7 +203,7 @@ void UtilitiesTests::testProgressFeedback()
unsigned int stepPercentage;
unsigned int overallPercentage = 0;
ProgressFeedback progress(
ProgressFeedback progressFeedback(
[&](const ProgressFeedback &progress) {
++steps;
step = progress.step();
@ -215,20 +215,20 @@ void UtilitiesTests::testProgressFeedback()
overallPercentage = progress.overallPercentage();
});
CPPUNIT_ASSERT_EQUAL(0u, steps);
progress.updateOverallPercentage(25);
progressFeedback.updateOverallPercentage(25);
CPPUNIT_ASSERT_EQUAL(0u, steps);
CPPUNIT_ASSERT_EQUAL(25u, overallPercentage);
progress.updateStep("foo", 45);
progressFeedback.updateStep("foo", 45);
CPPUNIT_ASSERT_EQUAL(1u, steps);
CPPUNIT_ASSERT_EQUAL("foo"s, step);
CPPUNIT_ASSERT_EQUAL(45u, stepPercentage);
CPPUNIT_ASSERT_EQUAL(25u, overallPercentage);
progress.updateStepPercentage(60);
progressFeedback.updateStepPercentage(60);
CPPUNIT_ASSERT_EQUAL(1u, steps);
CPPUNIT_ASSERT_EQUAL("foo"s, step);
CPPUNIT_ASSERT_EQUAL(60u, stepPercentage);
CPPUNIT_ASSERT_EQUAL(25u, overallPercentage);
progress.updateStepPercentageFromFraction(0.75);
progressFeedback.updateStepPercentageFromFraction(0.75);
CPPUNIT_ASSERT_EQUAL(1u, steps);
CPPUNIT_ASSERT_EQUAL("foo"s, step);
CPPUNIT_ASSERT_EQUAL(75u, stepPercentage);
@ -242,7 +242,7 @@ void UtilitiesTests::testAbortableProgressFeedback()
unsigned int stepPercentage;
unsigned int overallPercentage = 0;
AbortableProgressFeedback progress(
AbortableProgressFeedback progressFeedback(
[&](const AbortableProgressFeedback &progress) {
++steps;
step = progress.step();
@ -253,25 +253,25 @@ void UtilitiesTests::testAbortableProgressFeedback()
stepPercentage = progress.stepPercentage();
overallPercentage = progress.overallPercentage();
});
CPPUNIT_ASSERT(!progress.isAborted());
CPPUNIT_ASSERT_NO_THROW_MESSAGE("stop does nothing if not aborted", progress.stopIfAborted());
CPPUNIT_ASSERT(!progressFeedback.isAborted());
CPPUNIT_ASSERT_NO_THROW_MESSAGE("stop does nothing if not aborted", progressFeedback.stopIfAborted());
CPPUNIT_ASSERT_EQUAL(0u, steps);
progress.updateOverallPercentage(25);
progressFeedback.updateOverallPercentage(25);
CPPUNIT_ASSERT_EQUAL(0u, steps);
CPPUNIT_ASSERT_EQUAL(25u, overallPercentage);
progress.updateStep("foo", 45);
progressFeedback.updateStep("foo", 45);
CPPUNIT_ASSERT_EQUAL(1u, steps);
CPPUNIT_ASSERT_EQUAL("foo"s, step);
CPPUNIT_ASSERT_EQUAL(45u, stepPercentage);
CPPUNIT_ASSERT_EQUAL(25u, overallPercentage);
CPPUNIT_ASSERT_NO_THROW_MESSAGE("next step continues if not aborted", progress.nextStepOrStop("bar", 33));
CPPUNIT_ASSERT_NO_THROW_MESSAGE("next step continues if not aborted", progressFeedback.nextStepOrStop("bar", 33));
CPPUNIT_ASSERT_EQUAL(2u, steps);
CPPUNIT_ASSERT_EQUAL("bar"s, step);
CPPUNIT_ASSERT_EQUAL(33u, stepPercentage);
CPPUNIT_ASSERT_EQUAL(25u, overallPercentage);
progress.tryToAbort();
CPPUNIT_ASSERT(progress.isAborted());
CPPUNIT_ASSERT_THROW(progress.nextStepOrStop("not going to happen", 33), OperationAbortedException);
progressFeedback.tryToAbort();
CPPUNIT_ASSERT(progressFeedback.isAborted());
CPPUNIT_ASSERT_THROW(progressFeedback.nextStepOrStop("not going to happen", 33), OperationAbortedException);
CPPUNIT_ASSERT_EQUAL(2u, steps);
CPPUNIT_ASSERT_EQUAL("bar"s, step);
CPPUNIT_ASSERT_EQUAL(33u, stepPercentage);

View File

@ -251,7 +251,7 @@ void VorbisComment::make(std::ostream &stream, VorbisCommentFlags flags, Diagnos
stream.write(sig, sizeof(sig));
}
// write vendor
writer.writeUInt32LE(vendor.size());
writer.writeUInt32LE(static_cast<std::uint32_t>(vendor.size()));
writer.writeString(vendor);
// write field count later
const auto fieldCountOffset = stream.tellp();

View File

@ -161,7 +161,7 @@ void WaveAudioStream::internalParseHeader(Diagnostics &diag, AbortableProgressFe
}
while (!m_dataOffset) {
const auto segmentId = m_reader.readUInt32BE();
auto restHeaderLen = m_reader.readUInt32LE();
auto restHeaderLen = static_cast<std::uint64_t>(m_reader.readUInt32LE());
switch (segmentId) {
case 0x666D7420u: { // format segment
WaveFormatHeader waveHeader;
@ -177,7 +177,7 @@ void WaveAudioStream::internalParseHeader(Diagnostics &diag, AbortableProgressFe
break;
default:;
}
m_istream->seekg(restHeaderLen, ios_base::cur);
m_istream->seekg(static_cast<std::streamoff>(restHeaderLen), ios_base::cur);
}
if (m_format.general != GeneralMediaFormat::Mpeg1Audio || !m_dataOffset) {
return;