id3v2frame.h

Go to the documentation of this file.

#ifndef TAG_PARSER_ID3V2FRAME_H
#define TAG_PARSER_ID3V2FRAME_H
 
#include "./id3v2frameids.h"
 
#include "../generictagfield.h"
#include "../tagvalue.h"
 
#include <c++utilities/conversion/stringconversion.h>
#include <c++utilities/io/binaryreader.h>
#include <c++utilities/io/binarywriter.h>
 
#include <iosfwd>
#include <string>
#include <vector>
 
namespace TagParser {
 
class Id3v2Frame;
class Diagnostics;
 
class TAG_PARSER_EXPORT Id3v2FrameMaker {
    friend class Id3v2Frame;
 
public:
    void make(CppUtilities::BinaryWriter &writer);
    const Id3v2Frame &field() const;
    const std::unique_ptr<char[]> &data() const;
    std::uint32_t dataSize() const;
    std::uint32_t requiredSize() const;
 
private:
    Id3v2FrameMaker(Id3v2Frame &frame, std::uint8_t version, Diagnostics &diag);
    void makeSubstring(const TagValue &value, Diagnostics &diag, const std::string &context);
 
    Id3v2Frame &m_frame;
    std::uint32_t m_frameId;
    const std::uint8_t m_version;
    std::unique_ptr<char[]> m_data;
    std::uint32_t m_dataSize;
    std::uint32_t m_decompressedSize;
    std::uint32_t m_requiredSize;
};
 
inline const Id3v2Frame &Id3v2FrameMaker::field() const
{
    return m_frame;
}
 
inline const std::unique_ptr<char[]> &Id3v2FrameMaker::data() const
{
    return m_data;
}
 
inline std::uint32_t Id3v2FrameMaker::dataSize() const
{
    return m_dataSize;
}
 
inline std::uint32_t Id3v2FrameMaker::requiredSize() const
{
    return m_requiredSize;
}
 
template <> class TAG_PARSER_EXPORT TagFieldTraits<Id3v2Frame> {
public:
    using IdentifierType = std::uint32_t;
    using TypeInfoType = std::uint8_t;
};
 
class TAG_PARSER_EXPORT Id3v2Frame : public TagField<Id3v2Frame> {
    friend class TagField<Id3v2Frame>;
    friend class Id3v2FrameMaker;
 
public:
    Id3v2Frame();
    Id3v2Frame(const IdentifierType &id, const TagValue &value, std::uint8_t group = 0, std::uint16_t flag = 0);
 
    // parsing/making
    void parse(CppUtilities::BinaryReader &reader, std::uint32_t version, std::uint32_t maximalSize, Diagnostics &diag);
    Id3v2FrameMaker prepareMaking(std::uint8_t version, Diagnostics &diag);
    void make(CppUtilities::BinaryWriter &writer, std::uint8_t version, Diagnostics &diag);
 
    // member access
    const std::vector<TagValue> &additionalValues() const;
    std::vector<TagValue> &additionalValues();
    bool isAdditionalTypeInfoUsed() const;
    bool isValid() const;
    bool hasPaddingReached() const;
    std::uint16_t flag() const;
    void setFlag(std::uint16_t value);
    std::uint32_t totalSize() const;
    std::uint32_t dataSize() const;
    bool toDiscardWhenUnknownAndTagIsAltered() const;
    bool toDiscardWhenUnknownAndFileIsAltered() const;
    bool isReadOnly() const;
    bool isCompressed() const;
    bool isEncrypted() const;
    bool hasGroupInformation() const;
    bool isUnsynchronized() const;
    bool hasDataLengthIndicator() const;
    std::uint8_t group() const;
    void setGroup(std::uint8_t value);
    std::uint32_t parsedVersion() const;
    bool supportsNestedFields() const;
 
    // parsing helper
    TagTextEncoding parseTextEncodingByte(std::uint8_t textEncodingByte, Diagnostics &diag);
    std::tuple<const char *, std::size_t, const char *> parseSubstring(
        const char *buffer, std::size_t maxSize, TagTextEncoding &encoding, bool addWarnings, Diagnostics &diag);
    std::string parseString(const char *buffer, std::size_t maxSize, TagTextEncoding &encoding, bool addWarnings, Diagnostics &diag);
    std::u16string parseWideString(const char *buffer, std::size_t dataSize, TagTextEncoding &encoding, bool addWarnings, Diagnostics &diag);
    void parseLegacyPicture(const char *buffer, std::size_t maxSize, TagValue &tagValue, std::uint8_t &typeInfo, Diagnostics &diag);
    void parsePicture(const char *buffer, std::size_t maxSize, TagValue &tagValue, std::uint8_t &typeInfo, Diagnostics &diag);
    void parseComment(const char *buffer, std::size_t maxSize, TagValue &tagValue, Diagnostics &diag);
    void parseBom(const char *buffer, std::size_t maxSize, TagTextEncoding &encoding, Diagnostics &diag);
 
    // making helper
    static std::uint8_t makeTextEncodingByte(TagTextEncoding textEncoding);
    static std::size_t makeBom(char *buffer, TagTextEncoding encoding);
    static void makeLegacyPicture(
        std::unique_ptr<char[]> &buffer, std::uint32_t &bufferSize, const TagValue &picture, std::uint8_t typeInfo, Diagnostics &diag);
    static void makePicture(std::unique_ptr<char[]> &buffer, std::uint32_t &bufferSize, const TagValue &picture, std::uint8_t typeInfo,
        std::uint8_t version, Diagnostics &diag);
    static void makeComment(
        std::unique_ptr<char[]> &buffer, std::uint32_t &bufferSize, const TagValue &comment, std::uint8_t version, Diagnostics &diag);
 
    static IdentifierType fieldIdFromString(std::string_view idString);
    static std::string fieldIdToString(IdentifierType id);
 
private:
    void internallyClearValue();
    void internallyClearFurtherData();
    std::string ignoreAdditionalValuesDiagMsg() const;
 
    std::vector<TagValue> m_additionalValues;
    std::uint32_t m_parsedVersion;
    std::uint32_t m_dataSize;
    std::uint32_t m_totalSize;
    std::uint16_t m_flag;
    std::uint8_t m_group;
    bool m_padding;
};
 
inline const std::vector<TagValue> &Id3v2Frame::additionalValues() const
{
    return m_additionalValues;
}
 
inline std::vector<TagValue> &Id3v2Frame::additionalValues()
{
    return m_additionalValues;
}
 
inline bool Id3v2Frame::isAdditionalTypeInfoUsed() const
{
    return id() == Id3v2FrameIds::lCover || id() == Id3v2FrameIds::sCover;
}
 
inline bool Id3v2Frame::isValid() const
{
    return !(id() == 0 || value().isEmpty() || m_padding);
}
 
inline bool Id3v2Frame::hasPaddingReached() const
{
    return m_padding;
}
 
inline std::uint16_t Id3v2Frame::flag() const
{
    return m_flag;
}
 
inline void Id3v2Frame::setFlag(std::uint16_t value)
{
    m_flag = value;
}
 
inline std::uint32_t Id3v2Frame::totalSize() const
{
    return m_totalSize;
}
 
inline std::uint32_t Id3v2Frame::dataSize() const
{
    return m_dataSize;
}
 
inline bool Id3v2Frame::toDiscardWhenUnknownAndTagIsAltered() const
{
    return m_flag & 0x8000;
}
 
inline bool Id3v2Frame::toDiscardWhenUnknownAndFileIsAltered() const
{
    return m_flag & 0x4000;
}
 
inline bool Id3v2Frame::isReadOnly() const
{
    return m_flag & 0x2000;
}
 
inline bool Id3v2Frame::isCompressed() const
{
    return m_parsedVersion >= 4 ? m_flag & 0x8 : m_flag & 0x80;
}
 
inline bool Id3v2Frame::isEncrypted() const
{
    return m_parsedVersion >= 4 ? m_flag & 0x4 : m_flag & 0x40;
}
 
inline bool Id3v2Frame::hasGroupInformation() const
{
    return m_parsedVersion >= 4 ? m_flag & 0x40 : m_flag & 0x20;
}
 
inline bool Id3v2Frame::isUnsynchronized() const
{
    return m_parsedVersion >= 4 ? m_flag & 0x2 : false;
}
 
inline bool Id3v2Frame::hasDataLengthIndicator() const
{
    return m_parsedVersion >= 4 ? m_flag & 0x1 : isCompressed();
}
 
inline std::uint8_t Id3v2Frame::group() const
{
    return m_group;
}
 
inline void Id3v2Frame::setGroup(std::uint8_t value)
{
    m_group = value;
}
 
inline std::uint32_t Id3v2Frame::parsedVersion() const
{
    return m_parsedVersion;
}
 
inline bool Id3v2Frame::supportsNestedFields() const
{
    return true;
}
 
inline Id3v2Frame::IdentifierType Id3v2Frame::fieldIdFromString(std::string_view idString)
{
    switch (idString.size()) {
    case 3:
        return CppUtilities::BE::toUInt24(idString.data());
    case 4:
        return CppUtilities::BE::toInt<std::uint32_t>(idString.data());
    default:
        throw CppUtilities::ConversionException("ID3v2 ID must be 3 or 4 chars");
    }
}
 
inline std::string Id3v2Frame::fieldIdToString(Id3v2Frame::IdentifierType id)
{
    return CppUtilities::interpretIntegerAsString<std::uint32_t>(id, Id3v2FrameIds::isLongId(id) ? 0 : 1);
}
 
} // namespace TagParser
 
#endif // TAG_PARSER_ID3V2FRAME_H