diff --git a/aac/aacframe.cpp b/aac/aacframe.cpp
index eb5b047..29ec4e9 100644
--- a/aac/aacframe.cpp
+++ b/aac/aacframe.cpp
@@ -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);
 }
 
diff --git a/aac/aacframe.h b/aac/aacframe.h
index ba72cf6..5b6bb62 100644
--- a/aac/aacframe.h
+++ b/aac/aacframe.h
@@ -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;
 }
 
diff --git a/abstractattachment.cpp b/abstractattachment.cpp
index 27c9236..1a69a69 100644
--- a/abstractattachment.cpp
+++ b/abstractattachment.cpp
@@ -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());
     }
 }
diff --git a/abstractattachment.h b/abstractattachment.h
index e2a3b1a..95ade0d 100644
--- a/abstractattachment.h
+++ b/abstractattachment.h
@@ -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;
 }
diff --git a/adts/adtsframe.h b/adts/adtsframe.h
index 1f3170c..214544a 100644
--- a/adts/adtsframe.h
+++ b/adts/adtsframe.h
@@ -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);
 }
 
 /*!
diff --git a/fieldbasedtag.h b/fieldbasedtag.h
index 571e175..ab090dd 100644
--- a/fieldbasedtag.h
+++ b/fieldbasedtag.h
@@ -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
diff --git a/flac/flacmetadata.cpp b/flac/flacmetadata.cpp
index f788f99..ae3f4e4 100644
--- a/flac/flacmetadata.cpp
+++ b/flac/flacmetadata.cpp
@@ -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));
 }
 
 /*!
diff --git a/genericcontainer.h b/genericcontainer.h
index 35aaf32..243021e 100644
--- a/genericcontainer.h
+++ b/genericcontainer.h
@@ -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;
             }
diff --git a/genericfileelement.h b/genericfileelement.h
index f27024a..7d2017d 100644
--- a/genericfileelement.h
+++ b/genericfileelement.h
@@ -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)),
diff --git a/id3/id3v1tag.cpp b/id3/id3v1tag.cpp
index 0cea11d..0681d3b 100644
--- a/id3/id3v1tag.cpp
+++ b/id3/id3v1tag.cpp
@@ -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;
diff --git a/id3/id3v1tag.h b/id3/id3v1tag.h
index ee25e3b..74f7a7f 100644
--- a/id3/id3v1tag.h
+++ b/id3/id3v1tag.h
@@ -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;
 
diff --git a/id3/id3v2tag.h b/id3/id3v2tag.h
index fb1feec..c5005d1 100644
--- a/id3/id3v2tag.h
+++ b/id3/id3v2tag.h
@@ -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;
 }
diff --git a/matroska/ebmlelement.cpp b/matroska/ebmlelement.cpp
index f71994b..d28ac3c 100644
--- a/matroska/ebmlelement.cpp
+++ b/matroska/ebmlelement.cpp
@@ -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
diff --git a/matroska/ebmlelement.h b/matroska/ebmlelement.h
index f780714..fd8abcc 100644
--- a/matroska/ebmlelement.h
+++ b/matroska/ebmlelement.h
@@ -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);
     }
 }
 
diff --git a/matroska/matroskaattachment.cpp b/matroska/matroskaattachment.cpp
index ca1f699..5ed0583 100644
--- a/matroska/matroskaattachment.cpp
+++ b/matroska/matroskaattachment.cpp
@@ -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()) {
diff --git a/matroska/matroskachapter.cpp b/matroska/matroskachapter.cpp
index 0450a8c..2d69601 100644
--- a/matroska/matroskachapter.cpp
+++ b/matroska/matroskachapter.cpp
@@ -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;
diff --git a/matroska/matroskacontainer.cpp b/matroska/matroskacontainer.cpp
index 4139071..cba5f66 100644
--- a/matroska/matroskacontainer.cpp
+++ b/matroska/matroskacontainer.cpp
@@ -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);
diff --git a/matroska/matroskacues.cpp b/matroska/matroskacues.cpp
index 70fa57e..b3a2b58 100644
--- a/matroska/matroskacues.cpp
+++ b/matroska/matroskacues.cpp
@@ -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));
diff --git a/matroska/matroskaseekinfo.cpp b/matroska/matroskaseekinfo.cpp
index 31ec84a..abd1614 100644
--- a/matroska/matroskaseekinfo.cpp
+++ b/matroska/matroskaseekinfo.cpp
@@ -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);
 }
 
 /*!
diff --git a/matroska/matroskatag.cpp b/matroska/matroskatag.cpp
index 8e5fac3..f5d06bb 100644
--- a/matroska/matroskatag.cpp
+++ b/matroska/matroskatag.cpp
@@ -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>>;
diff --git a/matroska/matroskatagfield.cpp b/matroska/matroskatagfield.cpp
index a78f2f2..331f5f3 100644
--- a/matroska/matroskatagfield.cpp
+++ b/matroska/matroskatagfield.cpp
@@ -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) {
diff --git a/matroska/matroskatrack.cpp b/matroska/matroskatrack.cpp
index 8c73555..70a16ef 100644
--- a/matroska/matroskatrack.cpp
+++ b/matroska/matroskatrack.cpp
@@ -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;
 }
 
 /*!
diff --git a/mediafileinfo.cpp b/mediafileinfo.cpp
index d732d30..2b3ffde 100644
--- a/mediafileinfo.cpp
+++ b/mediafileinfo.cpp
@@ -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
diff --git a/mp4/mp4container.cpp b/mp4/mp4container.cpp
index 63f1665..fe5127e 100644
--- a/mp4/mp4container.cpp
+++ b/mp4/mp4container.cpp
@@ -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:
diff --git a/mp4/mp4tag.cpp b/mp4/mp4tag.cpp
index 30dd210..718a59f 100644
--- a/mp4/mp4tag.cpp
+++ b/mp4/mp4tag.cpp
@@ -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.
diff --git a/mp4/mp4track.cpp b/mp4/mp4track.cpp
index f5537b5..b65ef34 100644
--- a/mp4/mp4track.cpp
+++ b/mp4/mp4track.cpp
@@ -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);
                                         }
                                     }
diff --git a/mp4/mpeg4descriptor.cpp b/mp4/mpeg4descriptor.cpp
index b8cc387..0d3bb29 100644
--- a/mp4/mpeg4descriptor.cpp
+++ b/mp4/mpeg4descriptor.cpp
@@ -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));
 }
 
 /*!
diff --git a/mpegaudio/mpegaudioframe.cpp b/mpegaudio/mpegaudioframe.cpp
index d17fa31..2da660f 100644
--- a/mpegaudio/mpegaudioframe.cpp
+++ b/mpegaudio/mpegaudioframe.cpp
@@ -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();
     }
diff --git a/ogg/oggiterator.cpp b/ogg/oggiterator.cpp
index a3effd6..6c61fa9 100644
--- a/ogg/oggiterator.cpp
+++ b/ogg/oggiterator.cpp
@@ -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) {
diff --git a/ogg/oggiterator.h b/ogg/oggiterator.h
index 3a786f3..9d7ce36 100644
--- a/ogg/oggiterator.h
+++ b/ogg/oggiterator.h
@@ -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;
 };
diff --git a/ogg/oggpage.h b/ogg/oggpage.h
index 9c58592..807aaa6 100644
--- a/ogg/oggpage.h
+++ b/ogg/oggpage.h
@@ -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
diff --git a/tag.cpp b/tag.cpp
index 1fce5e2..d50ef1a 100644
--- a/tag.cpp
+++ b/tag.cpp
@@ -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);
diff --git a/tag.h b/tag.h
index 4b359ab..08e68ae 100644
--- a/tag.h
+++ b/tag.h
@@ -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;
 }
diff --git a/tagvalue.cpp b/tagvalue.cpp
index 254c5ba..d9f1f20 100644
--- a/tagvalue.cpp
+++ b/tagvalue.cpp
@@ -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) {
diff --git a/tests/overallmkv.cpp b/tests/overallmkv.cpp
index d3fb64f..e8fb799 100644
--- a/tests/overallmkv.cpp
+++ b/tests/overallmkv.cpp
@@ -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()));
     }
diff --git a/tests/testfilecheck.cpp b/tests/testfilecheck.cpp
index 530069c..2bfea02 100644
--- a/tests/testfilecheck.cpp
+++ b/tests/testfilecheck.cpp
@@ -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();
     }
diff --git a/tests/utils.cpp b/tests/utils.cpp
index fa76df5..0e1f403 100644
--- a/tests/utils.cpp
+++ b/tests/utils.cpp
@@ -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);
diff --git a/vorbis/vorbiscomment.cpp b/vorbis/vorbiscomment.cpp
index cfc83f6..34ba788 100644
--- a/vorbis/vorbiscomment.cpp
+++ b/vorbis/vorbiscomment.cpp
@@ -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();
diff --git a/wav/waveaudiostream.cpp b/wav/waveaudiostream.cpp
index bf293a1..f17cb10 100644
--- a/wav/waveaudiostream.cpp
+++ b/wav/waveaudiostream.cpp
@@ -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;