Fix warnings
This commit is contained in:
parent
ec2f8213b0
commit
0a041f6ad2
|
@ -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);
|
||||
}
|
||||
|
||||
|
|
|
@ -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;
|
||||
}
|
||||
|
||||
|
|
|
@ -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());
|
||||
}
|
||||
}
|
||||
|
|
|
@ -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;
|
||||
}
|
||||
|
|
|
@ -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);
|
||||
}
|
||||
|
||||
/*!
|
||||
|
|
|
@ -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
|
||||
|
|
|
@ -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));
|
||||
}
|
||||
|
||||
/*!
|
||||
|
|
|
@ -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;
|
||||
}
|
||||
|
|
|
@ -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)),
|
||||
|
|
|
@ -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;
|
||||
|
|
|
@ -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;
|
||||
|
||||
|
|
|
@ -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;
|
||||
}
|
||||
|
|
|
@ -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
|
||||
|
|
|
@ -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);
|
||||
}
|
||||
}
|
||||
|
||||
|
|
|
@ -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()) {
|
||||
|
|
|
@ -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;
|
||||
|
|
|
@ -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);
|
||||
|
|
|
@ -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));
|
||||
|
|
|
@ -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);
|
||||
}
|
||||
|
||||
/*!
|
||||
|
|
|
@ -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>>;
|
||||
|
|
|
@ -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) {
|
||||
|
|
|
@ -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;
|
||||
}
|
||||
|
||||
/*!
|
||||
|
|
|
@ -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
|
||||
|
|
|
@ -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:
|
||||
|
|
|
@ -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.
|
||||
|
|
117
mp4/mp4track.cpp
117
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);
|
||||
}
|
||||
}
|
||||
|
|
|
@ -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));
|
||||
}
|
||||
|
||||
/*!
|
||||
|
|
|
@ -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();
|
||||
}
|
||||
|
|
|
@ -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) {
|
||||
|
|
|
@ -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;
|
||||
};
|
||||
|
|
|
@ -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
|
||||
|
|
6
tag.cpp
6
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);
|
||||
|
|
10
tag.h
10
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;
|
||||
}
|
||||
|
|
22
tagvalue.cpp
22
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) {
|
||||
|
|
|
@ -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()));
|
||||
}
|
||||
|
|
|
@ -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();
|
||||
}
|
||||
|
|
|
@ -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);
|
||||
|
|
|
@ -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();
|
||||
|
|
|
@ -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;
|
||||
|
|
Loading…
Reference in New Issue