vorbiscommentfield.cpp

Go to the documentation of this file.

#include "./vorbiscommentfield.h"
#include "./vorbiscommentids.h"
 
#include "../flac/flacmetadata.h"
 
#include "../ogg/oggiterator.h"
 
#include "../diagnostics.h"
#include "../exceptions.h"
 
#include <c++utilities/conversion/binaryconversion.h>
#include <c++utilities/conversion/stringbuilder.h>
#include <c++utilities/conversion/stringconversion.h>
#include <c++utilities/io/binaryreader.h>
#include <c++utilities/io/binarywriter.h>
 
#include <iostream>
#include <memory>
 
using namespace std;
using namespace CppUtilities;
 
namespace TagParser {
 
VorbisCommentField::VorbisCommentField()
{
}
 
VorbisCommentField::VorbisCommentField(const IdentifierType &id, const TagValue &value)
    : TagField<VorbisCommentField>(id, value)
{
}
 
template <class StreamType> void VorbisCommentField::internalParse(StreamType &stream, std::uint64_t &maxSize, Diagnostics &diag)
{
    static const string context("parsing Vorbis comment  field");
    char buff[4];
    if (maxSize < 4) {
        diag.emplace_back(DiagLevel::Critical, argsToString("Field expected at ", static_cast<std::streamoff>(stream.tellg()), '.'), context);
        throw TruncatedDataException();
    } else {
        maxSize -= 4;
    }
    stream.read(buff, 4);
    if (const auto size = LE::toUInt32(buff)) { // read size
        if (size <= maxSize) {
            maxSize -= size;
            // read data
            auto data = make_unique<char[]>(size);
            stream.read(data.get(), size);
            std::uint32_t idSize = 0;
            for (const char *i = data.get(), *end = data.get() + size; i != end && *i != '='; ++i, ++idSize)
                ;
            // extract id
            setId(string(data.get(), idSize));
            if (!idSize) {
                // empty field ID
                diag.emplace_back(
                    DiagLevel::Critical, argsToString("The field ID at ", static_cast<std::streamoff>(stream.tellg()), " is empty."), context);
                throw InvalidDataException();
            } else if (id() == VorbisCommentIds::cover()) {
                // extract cover value
                try {
                    auto decoded = decodeBase64(data.get() + idSize + 1, size - idSize - 1);
                    stringstream bufferStream(ios_base::in | ios_base::out | ios_base::binary);
                    bufferStream.exceptions(ios_base::failbit | ios_base::badbit);
#if defined(__GLIBCXX__) && !defined(_LIBCPP_VERSION)
                    bufferStream.rdbuf()->pubsetbuf(reinterpret_cast<char *>(decoded.first.get()), decoded.second);
#else
                    bufferStream.write(reinterpret_cast<const char *>(decoded.first.get()), decoded.second);
#endif
                    FlacMetaDataBlockPicture pictureBlock(value());
                    pictureBlock.parse(bufferStream, decoded.second);
                    setTypeInfo(pictureBlock.pictureType());
                } catch (const TruncatedDataException &) {
                    diag.emplace_back(DiagLevel::Critical, "METADATA_BLOCK_PICTURE is truncated.", context);
                    throw;
                } catch (const ConversionException &) {
                    diag.emplace_back(DiagLevel::Critical, "Base64 coding of METADATA_BLOCK_PICTURE is invalid.", context);
                    throw InvalidDataException();
                } catch (const std::ios_base::failure &failure) {
                    diag.emplace_back(DiagLevel::Critical,
                        argsToString("An IO error occurred when reading the METADATA_BLOCK_PICTURE struct: ", failure.what()), context);
                    throw Failure();
                }
            } else if (id().size() + 1 < size) {
                const auto str = std::string_view(data.get() + idSize + 1, size - idSize - 1);
                if (id() == VorbisCommentIds::rating()) {
                    try {
                        // set rating as Popularity to preserve the scale information
                        value().assignPopularity(Popularity{ .rating = stringToNumber<double>(str), .scale = TagType::VorbisComment });
                    } catch (const ConversionException &) {
                        // fallback to text
                        value().assignText(str, TagTextEncoding::Utf8);
                        diag.emplace_back(DiagLevel::Warning, argsToString("The rating is not a number."), context);
                    }
                } else {
                    // extract other values (as string)
                    value().assignText(str, TagTextEncoding::Utf8);
                }
            }
        } else {
            diag.emplace_back(DiagLevel::Critical, argsToString("Field at ", static_cast<std::streamoff>(stream.tellg()), " is truncated."), context);
            throw TruncatedDataException();
        }
    }
}
 
void VorbisCommentField::parse(OggIterator &iterator, Diagnostics &diag)
{
    std::uint64_t maxSize = iterator.streamSize() - iterator.currentCharacterOffset();
    internalParse(iterator, maxSize, diag);
}
 
void VorbisCommentField::parse(OggIterator &iterator, std::uint64_t &maxSize, Diagnostics &diag)
{
    internalParse(iterator, maxSize, diag);
}
 
void VorbisCommentField::parse(istream &stream, std::uint64_t &maxSize, Diagnostics &diag)
{
    internalParse(stream, maxSize, diag);
}
 
bool VorbisCommentField::make(BinaryWriter &writer, VorbisCommentFlags flags, Diagnostics &diag)
{
    static const string context("making Vorbis comment  field");
    if (id().empty()) {
        diag.emplace_back(DiagLevel::Critical, "The field ID is empty.", context);
    }
    try {
        // try to convert value to string
        string valueString;
        if (id() == VorbisCommentIds::cover()) {
            if (flags & VorbisCommentFlags::NoCovers) {
                return false;
            }
            // make cover
            if (value().type() != TagDataType::Picture) {
                diag.emplace_back(DiagLevel::Critical, "Assigned value of cover field is not picture data.", context);
                throw InvalidDataException();
            }
            try {
                FlacMetaDataBlockPicture pictureBlock(value());
                pictureBlock.setPictureType(typeInfo());
 
                const auto requiredSize = pictureBlock.requiredSize();
                auto buffer = make_unique<char[]>(requiredSize);
                stringstream bufferStream(ios_base::in | ios_base::out | ios_base::binary);
                bufferStream.exceptions(ios_base::failbit | ios_base::badbit);
#if defined(__GLIBCXX__) && !defined(_LIBCPP_VERSION)
                bufferStream.rdbuf()->pubsetbuf(buffer.get(), requiredSize);
#endif
                pictureBlock.make(bufferStream);
#if !(defined(__GLIBCXX__) && !defined(_LIBCPP_VERSION))
                bufferStream.read(buffer.get(), static_cast<std::streamsize>(requiredSize));
#endif
                valueString = encodeBase64(reinterpret_cast<std::uint8_t *>(buffer.get()), requiredSize);
 
            } catch (const Failure &) {
                diag.emplace_back(DiagLevel::Critical, "Unable to make METADATA_BLOCK_PICTURE struct from the assigned value.", context);
                throw;
            } catch (const std::ios_base::failure &failure) {
                diag.emplace_back(DiagLevel::Critical,
                    argsToString("An IO error occurred when writing the METADATA_BLOCK_PICTURE struct: ", failure.what()), context);
                throw Failure();
            }
        } else if (value().type() == TagDataType::Popularity) {
            valueString = value().toScaledPopularity(TagType::VorbisComment).toString();
        } else {
            // make normal string value
            valueString = value().toString(TagTextEncoding::Utf8);
        }
        const auto size(valueString.size() + id().size() + 1);
        if (size > numeric_limits<std::uint32_t>::max()) {
            diag.emplace_back(DiagLevel::Critical, "Assigned value exceeds the maximum size.", context);
            throw InvalidDataException();
        }
        writer.writeUInt32LE(static_cast<std::uint32_t>(size));
        writer.writeString(id());
        writer.writeChar('=');
        writer.writeString(valueString);
    } catch (const ConversionException &) {
        diag.emplace_back(DiagLevel::Critical, "Assigned value can not be converted appropriately.", context);
        throw InvalidDataException();
    }
    return true;
}
 
} // namespace TagParser