flacmetadata.h

Go to the documentation of this file.

#ifndef TAG_PARSER_FLACMETADATAHEADER_H
#define TAG_PARSER_FLACMETADATAHEADER_H
 
#include "../global.h"
 
#include <cstdint>
#include <iostream>
 
namespace TagParser {
 
class TagValue;
 
enum class FlacMetaDataBlockType : std::uint8_t { StreamInfo = 0, Padding, Application, SeekTable, VorbisComment, CuseSheet, Picture };
 
constexpr bool operator==(std::uint8_t lhs, FlacMetaDataBlockType type)
{
    return lhs == static_cast<std::uint8_t>(type);
}
 
constexpr bool operator!=(std::uint8_t lhs, FlacMetaDataBlockType type)
{
    return lhs != static_cast<std::uint8_t>(type);
}
 
class TAG_PARSER_EXPORT FlacMetaDataBlockHeader {
public:
    constexpr FlacMetaDataBlockHeader();
 
    void parseHeader(std::string_view buffer);
    void makeHeader(std::ostream &outputStream);
 
    constexpr std::uint8_t isLast() const;
    void setLast(std::uint8_t last);
    constexpr std::uint8_t type() const;
    void setType(FlacMetaDataBlockType type);
    constexpr std::uint32_t dataSize() const;
    void setDataSize(std::uint32_t dataSize);
 
private:
    std::uint8_t m_last;
    std::uint8_t m_type;
    std::uint32_t m_dataSize;
};
 
constexpr FlacMetaDataBlockHeader::FlacMetaDataBlockHeader()
    : m_last(0)
    , m_type(0)
    , m_dataSize(0)
{
}
 
constexpr std::uint8_t FlacMetaDataBlockHeader::isLast() const
{
    return m_last;
}
 
inline void FlacMetaDataBlockHeader::setLast(std::uint8_t last)
{
    m_last = last;
}
 
constexpr std::uint8_t FlacMetaDataBlockHeader::type() const
{
    return m_type;
}
 
inline void FlacMetaDataBlockHeader::setType(FlacMetaDataBlockType type)
{
    m_type = static_cast<std::uint8_t>(type);
}
 
constexpr std::uint32_t FlacMetaDataBlockHeader::dataSize() const
{
    return m_dataSize;
}
 
inline void FlacMetaDataBlockHeader::setDataSize(std::uint32_t dataSize)
{
    m_dataSize = dataSize;
}
 
class TAG_PARSER_EXPORT FlacMetaDataBlockStreamInfo {
public:
    constexpr FlacMetaDataBlockStreamInfo();
 
    void parse(std::string_view buffer);
 
    constexpr std::uint16_t minBlockSize() const;
    constexpr std::uint16_t maxBlockSize() const;
    constexpr std::uint32_t minFrameSize() const;
    constexpr std::uint32_t maxFrameSize() const;
    constexpr std::uint32_t samplingFrequency() const;
    constexpr std::uint8_t channelCount() const;
    constexpr std::uint8_t bitsPerSample() const;
    constexpr std::uint64_t totalSampleCount() const;
    constexpr const char *md5Sum() const;
 
private:
    std::uint16_t m_minBlockSize;
    std::uint16_t m_maxBlockSize;
    std::uint32_t m_minFrameSize;
    std::uint32_t m_maxFrameSize;
    std::uint32_t m_samplingFrequency;
    std::uint8_t m_channelCount;
    std::uint8_t m_bitsPerSample;
    std::uint64_t m_totalSampleCount;
    char m_md5Sum[16];
};
 
constexpr FlacMetaDataBlockStreamInfo::FlacMetaDataBlockStreamInfo()
    : m_minBlockSize(0)
    , m_maxBlockSize(0)
    , m_minFrameSize(0)
    , m_maxFrameSize(0)
    , m_samplingFrequency(0)
    , m_channelCount(0)
    , m_bitsPerSample(0)
    , m_totalSampleCount(0)
    , m_md5Sum{ 0 }
{
}
 
constexpr std::uint16_t FlacMetaDataBlockStreamInfo::minBlockSize() const
{
    return m_minBlockSize;
}
 
constexpr std::uint16_t FlacMetaDataBlockStreamInfo::maxBlockSize() const
{
    return m_maxBlockSize;
}
 
constexpr std::uint32_t FlacMetaDataBlockStreamInfo::minFrameSize() const
{
    return m_minFrameSize;
}
 
constexpr std::uint32_t FlacMetaDataBlockStreamInfo::maxFrameSize() const
{
    return m_maxFrameSize;
}
 
constexpr std::uint32_t FlacMetaDataBlockStreamInfo::samplingFrequency() const
{
    return m_samplingFrequency;
}
 
constexpr std::uint8_t FlacMetaDataBlockStreamInfo::channelCount() const
{
    return m_channelCount;
}
 
constexpr std::uint8_t FlacMetaDataBlockStreamInfo::bitsPerSample() const
{
    return m_bitsPerSample;
}
 
constexpr std::uint64_t FlacMetaDataBlockStreamInfo::totalSampleCount() const
{
    return m_totalSampleCount;
}
 
constexpr const char *FlacMetaDataBlockStreamInfo::md5Sum() const
{
    return m_md5Sum;
}
 
class TAG_PARSER_EXPORT FlacMetaDataBlockPicture {
public:
    FlacMetaDataBlockPicture(TagValue &tagValue);
 
    void parse(std::istream &inputStream, std::uint32_t maxSize);
    std::uint32_t requiredSize() const;
    void make(std::ostream &outputStream);
 
    std::uint32_t pictureType() const;
    void setPictureType(std::uint32_t pictureType);
    TagValue &value();
 
private:
    std::uint32_t m_pictureType;
    TagValue &m_value;
};
 
inline FlacMetaDataBlockPicture::FlacMetaDataBlockPicture(TagValue &tagValue)
    : m_pictureType(0)
    , m_value(tagValue)
{
}
 
inline std::uint32_t FlacMetaDataBlockPicture::pictureType() const
{
    return m_pictureType;
}
 
inline void FlacMetaDataBlockPicture::setPictureType(std::uint32_t pictureType)
{
    m_pictureType = pictureType;
}
 
inline TagValue &FlacMetaDataBlockPicture::value()
{
    return m_value;
}
 
} // namespace TagParser
 
#endif // TAG_PARSER_FLACMETADATAHEADER_H