mediafileinfo.h

Go to the documentation of this file.

#ifndef TAG_PARSER_MEDIAINFO_H
#define TAG_PARSER_MEDIAINFO_H
 
#include "./abstractcontainer.h"
#include "./basicfileinfo.h"
#include "./settings.h"
#include "./signature.h"
 
#include <cstdint>
#include <memory>
#include <unordered_set>
#include <vector>
 
#include <c++utilities/misc/flagenumclass.h>
 
namespace TagParser {
 
class Tag;
class Id3v1Tag;
class Id3v2Tag;
class Mp4Container;
class Mp4Atom;
class Mp4Tag;
class MatroskaContainer;
class OggContainer;
class EbmlElement;
class MatroskaTag;
class AbstractTrack;
class VorbisComment;
class Diagnostics;
class AbortableProgressFeedback;
 
enum class MediaType : unsigned int;
enum class TagType : unsigned int;
 
enum class ParsingStatus : std::uint8_t {
    NotParsedYet, 
    Ok, 
    NotSupported, 
    CriticalFailure 
};
 
enum class MediaFileStructureFlags : std::uint64_t {
    None, 
    ActualExistingId3v1Tag = (1 << 0), 
};
 
enum class MediaFileHandlingFlags : std::uint64_t {
    None, 
    ForceFullParse
    = (1 << 0), 
    ForceRewrite = (1 << 1), 
    ForceTagPosition = (1 << 2), 
    ForceIndexPosition = (1 << 3), 
    NormalizeKnownTagFieldIds = (1 << 4), 
    PreserveRawTimingValues = (1 << 8), 
    PreserveMuxingApplication = (1 << 9), 
    PreserveWritingApplication = (1 << 10), 
};
 
} // namespace TagParser
 
CPP_UTILITIES_MARK_FLAG_ENUM_CLASS(TagParser, TagParser::MediaFileStructureFlags)
CPP_UTILITIES_MARK_FLAG_ENUM_CLASS(TagParser, TagParser::MediaFileHandlingFlags)
 
namespace TagParser {
 
struct MediaFileInfoPrivate;
 
class TAG_PARSER_EXPORT MediaFileInfo : public BasicFileInfo {
public:
    // constructor, destructor
    explicit MediaFileInfo();
    explicit MediaFileInfo(std::string_view path);
    explicit MediaFileInfo(std::string &&path);
    MediaFileInfo(const MediaFileInfo &) = delete;
    MediaFileInfo &operator=(const MediaFileInfo &) = delete;
    ~MediaFileInfo() override;
 
    // methods to parse file
    void parseContainerFormat(Diagnostics &diag, AbortableProgressFeedback &progress);
    void parseTracks(Diagnostics &diag, AbortableProgressFeedback &progress);
    void parseTags(Diagnostics &diag, AbortableProgressFeedback &progress);
    void parseChapters(Diagnostics &diag, AbortableProgressFeedback &progress);
    void parseAttachments(Diagnostics &diag, AbortableProgressFeedback &progress);
    void parseEverything(Diagnostics &diag, AbortableProgressFeedback &progress);
 
    // methods to apply changes
    void applyChanges(Diagnostics &diag, AbortableProgressFeedback &progress);
 
    // methods to get parsed information regarding ...
    // ... the container
    ContainerFormat containerFormat() const;
    std::string_view containerFormatName() const;
    std::string_view containerFormatAbbreviation() const;
    std::string_view containerFormatSubversion() const;
    std::string_view mimeType() const;
    std::uint64_t containerOffset() const;
    std::uint64_t paddingSize() const;
    std::uint64_t effectiveSize() const;
    AbstractContainer *container() const;
    ParsingStatus containerParsingStatus() const;
    // ... the chapters
    ParsingStatus chaptersParsingStatus() const;
    std::vector<AbstractChapter *> chapters() const;
    bool areChaptersSupported() const;
    // ... the attachments
    ParsingStatus attachmentsParsingStatus() const;
    std::vector<AbstractAttachment *> attachments() const;
    bool areAttachmentsSupported() const;
    // ... the tracks
    ParsingStatus tracksParsingStatus() const;
    std::size_t trackCount() const;
    std::vector<AbstractTrack *> tracks() const;
    bool hasTracksOfType(TagParser::MediaType type) const;
    CppUtilities::TimeSpan duration() const;
    double overallAverageBitrate() const;
    std::unordered_set<std::string> availableLanguages(TagParser::MediaType type = TagParser::MediaType::Audio) const;
    std::string technicalSummary() const;
    bool areTracksSupported() const;
    // ... the tags
    ParsingStatus tagsParsingStatus() const;
    bool hasId3v1Tag() const;
    bool hasId3v2Tag() const;
    bool hasAnyTag() const;
    Id3v1Tag *id3v1Tag() const;
    const std::vector<std::unique_ptr<Id3v2Tag>> &id3v2Tags() const;
    void tags(std::vector<Tag *> &tags) const;
    std::vector<Tag *> tags() const;
    void parsedTags(std::vector<Tag *> &tags) const;
    std::vector<Tag *> parsedTags() const;
    Mp4Tag *mp4Tag() const;
    const std::vector<std::unique_ptr<MatroskaTag>> &matroskaTags() const;
    VorbisComment *vorbisComment() const;
    bool areTagsSupported() const;
 
    // methods to create/remove tags
    bool createAppropriateTags(const TagCreationSettings &settings = TagCreationSettings());
    bool removeId3v1Tag();
    Id3v1Tag *createId3v1Tag();
    bool removeId3v2Tag(Id3v2Tag *tag);
    bool removeAllId3v2Tags();
    Id3v2Tag *createId3v2Tag();
    bool removeTag(Tag *tag);
    void removeAllTags();
    void mergeId3v2Tags();
    bool id3v1ToId3v2();
    bool id3v2ToId3v1();
    VorbisComment *createVorbisComment();
    bool removeVorbisComment();
    void clearParsingResults();
 
    // methods to get, set object behaviour
    const std::string &backupDirectory() const;
    void setBackupDirectory(std::string_view backupDirectory);
    void setBackupDirectory(std::string &&backupDirectory);
    const std::string &saveFilePath() const;
    void setSaveFilePath(std::string_view saveFilePath);
    void setSaveFilePath(std::string &&saveFilePath);
    const std::string &writingApplication() const;
    void setWritingApplication(std::string_view writingApplication);
    MediaFileHandlingFlags fileHandlingFlags();
    void setFileHandlingFlags(MediaFileHandlingFlags flags);
    bool isForcingFullParse() const;
    void setForceFullParse(bool forceFullParse);
    bool isForcingRewrite() const;
    void setForceRewrite(bool forceRewrite);
    std::size_t minPadding() const;
    void setMinPadding(std::size_t minPadding);
    std::size_t maxPadding() const;
    void setMaxPadding(std::size_t maxPadding);
    std::size_t preferredPadding() const;
    void setPreferredPadding(std::size_t preferredPadding);
    ElementPosition tagPosition() const;
    void setTagPosition(ElementPosition tagPosition);
    bool forceTagPosition() const;
    void setForceTagPosition(bool forceTagPosition);
    ElementPosition indexPosition() const;
    void setIndexPosition(ElementPosition indexPosition);
    bool forceIndexPosition() const;
    void setForceIndexPosition(bool forceTagPosition);
    std::uint64_t maxFullParseSize() const;
    void setMaxFullParseSize(std::uint64_t maxFullParseSize);
 
protected:
    void invalidated() override;
 
private:
    // private methods internally used when rewriting the file to apply new tag information
    // currently only the makeMp3File() methods is present; corresponding methods for
    // other formats are outsourced to container classes
    void makeMp3File(Diagnostics &diag, AbortableProgressFeedback &progress);
 
    // fields related to the container
    ParsingStatus m_containerParsingStatus;
    ContainerFormat m_containerFormat;
    std::streamoff m_containerOffset;
    std::uint64_t m_paddingSize;
    std::uint64_t m_effectiveSize;
    std::vector<std::streamoff> m_actualId3v2TagOffsets;
    std::unique_ptr<AbstractContainer> m_container;
    MediaFileStructureFlags m_fileStructureFlags;
 
    // fields related to the tracks
    ParsingStatus m_tracksParsingStatus;
    std::unique_ptr<AbstractTrack> m_singleTrack;
 
    // fields related to the tag
    ParsingStatus m_tagsParsingStatus;
    std::unique_ptr<Id3v1Tag> m_id3v1Tag;
    std::vector<std::unique_ptr<Id3v2Tag>> m_id3v2Tags;
 
    // fields related to the chapters and the attachments
    ParsingStatus m_chaptersParsingStatus;
    ParsingStatus m_attachmentsParsingStatus;
 
    // fields specifying object behaviour
    std::string m_backupDirectory;
    std::string m_saveFilePath;
    std::string m_writingApplication;
    std::size_t m_minPadding;
    std::size_t m_maxPadding;
    std::size_t m_preferredPadding;
    ElementPosition m_tagPosition;
    ElementPosition m_indexPosition;
    MediaFileHandlingFlags m_fileHandlingFlags;
    std::uint64_t m_maxFullParseSize;
    std::unique_ptr<MediaFileInfoPrivate> m_p;
};
 
inline ParsingStatus MediaFileInfo::containerParsingStatus() const
{
    return m_containerParsingStatus;
}
 
inline ContainerFormat MediaFileInfo::containerFormat() const
{
    return m_containerFormat;
}
 
inline std::string_view MediaFileInfo::containerFormatName() const
{
    return TagParser::containerFormatName(m_containerFormat);
}
 
inline std::string_view MediaFileInfo::containerFormatSubversion() const
{
    return TagParser::containerFormatSubversion(m_containerFormat);
}
 
inline std::uint64_t MediaFileInfo::containerOffset() const
{
    return static_cast<std::uint64_t>(m_containerOffset);
}
 
inline std::uint64_t MediaFileInfo::paddingSize() const
{
    return m_paddingSize;
}
 
inline std::uint64_t MediaFileInfo::effectiveSize() const
{
    return m_effectiveSize;
}
 
inline ParsingStatus MediaFileInfo::tagsParsingStatus() const
{
    return m_tagsParsingStatus;
}
 
inline ParsingStatus MediaFileInfo::tracksParsingStatus() const
{
    return m_tracksParsingStatus;
}
 
inline std::size_t MediaFileInfo::trackCount() const
{
    return m_singleTrack ? 1 : (m_container ? m_container->trackCount() : 0);
}
 
inline ParsingStatus MediaFileInfo::chaptersParsingStatus() const
{
    return m_chaptersParsingStatus;
}
 
inline ParsingStatus MediaFileInfo::attachmentsParsingStatus() const
{
    return m_attachmentsParsingStatus;
}
 
inline bool MediaFileInfo::hasId3v1Tag() const
{
    return m_id3v1Tag != nullptr;
}
 
inline bool MediaFileInfo::hasId3v2Tag() const
{
    return !m_id3v2Tags.empty();
}
 
inline Id3v1Tag *MediaFileInfo::id3v1Tag() const
{
    return m_id3v1Tag.get();
}
 
inline const std::vector<std::unique_ptr<Id3v2Tag>> &MediaFileInfo::id3v2Tags() const
{
    return m_id3v2Tags;
}
 
inline const std::string &MediaFileInfo::backupDirectory() const
{
    return m_backupDirectory;
}
 
inline void MediaFileInfo::setBackupDirectory(std::string_view backupDirectory)
{
    m_backupDirectory = backupDirectory;
}
 
inline void MediaFileInfo::setBackupDirectory(std::string &&backupDirectory)
{
    m_backupDirectory = std::move(backupDirectory);
}
 
inline const std::string &MediaFileInfo::saveFilePath() const
{
    return m_saveFilePath;
}
 
inline void MediaFileInfo::setSaveFilePath(std::string_view saveFilePath)
{
    m_saveFilePath = saveFilePath;
}
 
inline void MediaFileInfo::setSaveFilePath(std::string &&saveFilePath)
{
    m_saveFilePath = std::move(saveFilePath);
}
 
inline const std::string &MediaFileInfo::writingApplication() const
{
    return m_writingApplication;
}
 
inline void MediaFileInfo::setWritingApplication(std::string_view writingApplication)
{
    m_writingApplication = writingApplication;
}
 
inline AbstractContainer *MediaFileInfo::container() const
{
    return m_container.get();
}
 
inline MediaFileHandlingFlags MediaFileInfo::fileHandlingFlags()
{
    return m_fileHandlingFlags;
}
 
inline void MediaFileInfo::setFileHandlingFlags(MediaFileHandlingFlags flags)
{
    m_fileHandlingFlags = flags;
}
 
inline bool MediaFileInfo::isForcingFullParse() const
{
    return m_fileHandlingFlags & MediaFileHandlingFlags::ForceFullParse;
}
 
inline void MediaFileInfo::setForceFullParse(bool forceFullParse)
{
    CppUtilities::modFlagEnum(m_fileHandlingFlags, MediaFileHandlingFlags::ForceFullParse, forceFullParse);
}
 
inline bool MediaFileInfo::isForcingRewrite() const
{
    return m_fileHandlingFlags & MediaFileHandlingFlags::ForceRewrite;
}
 
inline void MediaFileInfo::setForceRewrite(bool forceRewrite)
{
    CppUtilities::modFlagEnum(m_fileHandlingFlags, MediaFileHandlingFlags::ForceRewrite, forceRewrite);
}
 
inline std::size_t MediaFileInfo::minPadding() const
{
    return m_minPadding;
}
 
inline void MediaFileInfo::setMinPadding(std::size_t minPadding)
{
    m_minPadding = minPadding;
}
 
inline std::size_t MediaFileInfo::maxPadding() const
{
    return m_maxPadding;
}
 
inline void MediaFileInfo::setMaxPadding(std::size_t maxPadding)
{
    m_maxPadding = maxPadding;
}
 
inline std::size_t MediaFileInfo::preferredPadding() const
{
    return m_preferredPadding;
}
 
inline void MediaFileInfo::setPreferredPadding(std::size_t preferredPadding)
{
    m_preferredPadding = preferredPadding;
}
 
inline ElementPosition MediaFileInfo::tagPosition() const
{
    return m_tagPosition;
}
 
inline void MediaFileInfo::setTagPosition(ElementPosition tagPosition)
{
    m_tagPosition = tagPosition;
}
 
inline bool MediaFileInfo::forceTagPosition() const
{
    return m_fileHandlingFlags & MediaFileHandlingFlags::ForceTagPosition;
}
 
inline void MediaFileInfo::setForceTagPosition(bool forceTagPosition)
{
    CppUtilities::modFlagEnum(m_fileHandlingFlags, MediaFileHandlingFlags::ForceTagPosition, forceTagPosition);
}
 
inline ElementPosition MediaFileInfo::indexPosition() const
{
    return m_indexPosition;
}
 
inline void MediaFileInfo::setIndexPosition(ElementPosition indexPosition)
{
    m_indexPosition = indexPosition;
}
 
inline bool MediaFileInfo::forceIndexPosition() const
{
    return m_fileHandlingFlags & MediaFileHandlingFlags::ForceIndexPosition;
}
 
inline void MediaFileInfo::setForceIndexPosition(bool forceIndexPosition)
{
    CppUtilities::modFlagEnum(m_fileHandlingFlags, MediaFileHandlingFlags::ForceIndexPosition, forceIndexPosition);
}
 
inline std::uint64_t MediaFileInfo::maxFullParseSize() const
{
    return m_maxFullParseSize;
}
 
inline void MediaFileInfo::setMaxFullParseSize(std::uint64_t maxFullParseSize)
{
    m_maxFullParseSize = maxFullParseSize;
}
 
} // namespace TagParser
 
#endif // TAG_PARSER_MEDIAINFO_H