mp4tagfield.h

Go to the documentation of this file.

#ifndef TAG_PARSER_MP4TAGATOM_H
#define TAG_PARSER_MP4TAGATOM_H
 
#include "../generictagfield.h"
 
#include <c++utilities/conversion/stringconversion.h>
#include <c++utilities/io/binarywriter.h>
 
#include <cstdint>
#include <sstream>
#include <vector>
 
namespace TagParser {
 
namespace RawDataType {
enum KnownValue : std::uint32_t {
    Reserved = 0, 
    Utf8 = 1, 
    Utf16 = 2, 
    Sjis = 3, 
    Utf8Sort = 4, 
    Utf16Sort = 5, 
    Html = 6, 
    Xml = 7, 
    Uuid = 8, 
    Isrc = 9, 
    Mi3p = 10, 
    Gif = 12, 
    Jpeg = 13, 
    Png = 14, 
    Url = 15, 
    Duration = 16, 
    DateTime = 17, 
    Genred = 18, 
    BeSignedInt = 21, 
    BeUnsignedInt = 22, 
    BeFloat32 = 23, 
    BeFloat64 = 24, 
    Upc = 25, 
    Bmp = 27, 
    QuickTimeMetadataAtom = 28, 
    Undefined = 255 
};
}
 
class Mp4TagField;
class Diagnostics;
 
template <> class TAG_PARSER_EXPORT TagFieldTraits<Mp4TagField> {
public:
    using IdentifierType = std::uint32_t;
    using TypeInfoType = std::uint32_t;
};
 
class Mp4Atom;
 
class TAG_PARSER_EXPORT Mp4TagFieldMaker {
    friend class Mp4TagField;
 
public:
    Mp4TagFieldMaker(Mp4TagFieldMaker &&) = default;
    void make(std::ostream &stream);
    const Mp4TagField &field() const;
    std::uint64_t requiredSize() const;
 
private:
    struct Data {
        Data();
        Data(Data &&) = default;
        std::string_view rawData;
        std::stringstream convertedData;
        std::uint64_t size = 0;
        std::uint32_t rawType = 0;
        std::uint16_t countryIndicator = 0;
        std::uint16_t languageIndicator = 0;
    };
 
    Mp4TagFieldMaker(Mp4TagField &field, Diagnostics &diag);
    std::uint64_t prepareDataAtom(
        const TagValue &value, std::uint16_t countryIndicator, std::uint16_t languageIndicator, const std::string &context, Diagnostics &diag);
 
    Mp4TagField &m_field;
    CppUtilities::BinaryWriter m_writer;
    std::vector<Data> m_data;
    std::uint64_t m_totalSize;
};
 
inline const Mp4TagField &Mp4TagFieldMaker::field() const
{
    return m_field;
}
 
inline std::uint64_t Mp4TagFieldMaker::requiredSize() const
{
    return m_totalSize;
}
 
class TAG_PARSER_EXPORT Mp4TagField : public TagField<Mp4TagField> {
    friend class TagField<Mp4TagField>;
 
public:
    struct AdditionalData {
        TagValue value;
        std::uint32_t rawDataType = 0;
        std::uint16_t countryIndicator = 0;
        std::uint16_t languageIndicator = 0;
    };
 
    Mp4TagField();
    Mp4TagField(IdentifierType id, const TagValue &value);
    Mp4TagField(std::string_view mean, std::string_view name, const TagValue &value);
 
    void reparse(Mp4Atom &ilstChild, Diagnostics &diag);
    Mp4TagFieldMaker prepareMaking(Diagnostics &diag);
    void make(std::ostream &stream, Diagnostics &diag);
 
    const std::vector<AdditionalData> &additionalData() const;
    std::vector<AdditionalData> &additionalData();
    bool isAdditionalTypeInfoUsed() const;
    const std::string &name() const;
    void setName(const std::string &name);
    const std::string &mean() const;
    void setMean(const std::string &mean);
    std::uint32_t parsedRawDataType() const;
    std::uint16_t countryIndicator() const;
    std::uint16_t languageIndicator() const;
    bool supportsNestedFields() const;
    std::vector<std::uint32_t> expectedRawDataTypes() const;
    std::uint32_t appropriateRawDataType() const;
    std::uint32_t appropriateRawDataTypeForValue(const TagValue &value) const;
 
    static IdentifierType fieldIdFromString(std::string_view idString);
    static std::string fieldIdToString(IdentifierType id);
 
private:
    void internallyClearValue();
    void internallyClearFurtherData();
    std::string m_name;
    std::string m_mean;
    std::vector<AdditionalData> m_additionalData;
    std::uint32_t m_parsedRawDataType;
    std::uint16_t m_countryIndicator;
    std::uint16_t m_langIndicator;
};
 
inline const std::vector<Mp4TagField::AdditionalData> &Mp4TagField::additionalData() const
{
    return m_additionalData;
}
 
inline std::vector<Mp4TagField::AdditionalData> &Mp4TagField::additionalData()
{
    return m_additionalData;
}
 
inline bool Mp4TagField::isAdditionalTypeInfoUsed() const
{
    return false;
}
 
inline const std::string &Mp4TagField::name() const
{
    return m_name;
}
 
inline void Mp4TagField::setName(const std::string &name)
{
    m_name = name;
}
 
inline const std::string &Mp4TagField::mean() const
{
    return m_mean;
}
 
inline void Mp4TagField::setMean(const std::string &mean)
{
    m_mean = mean;
}
 
inline std::uint32_t Mp4TagField::parsedRawDataType() const
{
    return m_parsedRawDataType;
}
 
inline std::uint16_t Mp4TagField::countryIndicator() const
{
    return m_countryIndicator;
}
 
inline std::uint16_t Mp4TagField::languageIndicator() const
{
    return m_langIndicator;
}
 
inline bool Mp4TagField::supportsNestedFields() const
{
    return false;
}
 
inline Mp4TagField::IdentifierType Mp4TagField::fieldIdFromString(std::string_view idString)
{
    const auto latin1 = CppUtilities::convertUtf8ToLatin1(idString.data(), idString.size());
    switch (latin1.second) {
    case 4:
        return CppUtilities::BE::toInt<std::uint32_t>(latin1.first.get());
    default:
        throw CppUtilities::ConversionException("MP4 ID must be exactly 4 chars");
    }
}
 
inline std::string Mp4TagField::fieldIdToString(Mp4TagField::IdentifierType id)
{
    const auto utf8 = CppUtilities::convertLatin1ToUtf8(CppUtilities::interpretIntegerAsString<std::uint32_t>(id).data(), 4);
    return std::string(utf8.first.get(), utf8.second);
}
 
} // namespace TagParser
 
#endif // TAG_PARSER_MP4TAGATOM_H