abstracttrack.h

Go to the documentation of this file.

#ifndef TAG_PARSER_ABSTRACTTRACK_H
#define TAG_PARSER_ABSTRACTTRACK_H
 
#include "./aspectratio.h"
#include "./diagnostics.h"
#include "./localehelper.h"
#include "./margin.h"
#include "./mediaformat.h"
#include "./size.h"
 
#include <c++utilities/chrono/datetime.h>
#include <c++utilities/chrono/timespan.h>
#include <c++utilities/io/binaryreader.h>
#include <c++utilities/io/binarywriter.h>
#include <c++utilities/misc/flagenumclass.h>
 
#include <iosfwd>
#include <memory>
#include <string>
#include <string_view>
 
namespace TagParser {
 
class AbortableProgressFeedback;
class MpegAudioFrameStream;
class WaveAudioStream;
class Mp4Track;
 
enum class TrackType {
    Unspecified, 
    MatroskaTrack, 
    MpegAudioFrameStream, 
    Mp4Track, 
    WaveAudioStream, 
    OggStream, 
    AdtsStream, 
    FlacStream, 
    IvfStream, 
};
 
enum class TrackFlags : std::uint64_t {
    None = 0, 
    HeaderValid = (1 << 0), 
    Enabled = (1 << 2), 
    Default = (1 << 3), 
    Forced = (1 << 4), 
    Lacing = (1 << 5), 
    Encrypted = (1 << 6), 
    UsedInPresentation = (1 << 7), 
    UsedWhenPreviewing = (1 << 8), 
    Interlaced = (1 << 9), 
};
 
enum class FieldOrder : std::uint64_t {
    Progressive = 0,
    Tff = 1,
    Undetermined = 2,
    Bff = 6,
    BffSwapped = 9,
    TffSwapped = 14,
};
 
enum class StereoMode : std::uint64_t {
    Unknown = std::numeric_limits<std::uint64_t>::max(),
};
 
enum class AlphaMode : std::uint64_t {
    Unknown = std::numeric_limits<std::uint64_t>::max(),
};
 
enum class DisplayUnit : std::uint64_t { Pixels, Centimeters, Inches, DisplayAspectRatio, Unknown };
 
enum class AspectRatioType : std::uint64_t {
    FreeResizing,
    KeepAspectRatio,
    Fixed,
    Unknown = std::numeric_limits<std::uint64_t>::max(),
};
 
} // namespace TagParser
 
CPP_UTILITIES_MARK_FLAG_ENUM_CLASS(TagParser, TagParser::TrackFlags)
 
namespace TagParser {
 
struct AbstractTrackPrivate;
 
class TAG_PARSER_EXPORT AbstractTrack {
    friend class MpegAudioFrameStream;
    friend class WaveAudioStream;
    friend class Mp4Track;
 
public:
    virtual ~AbstractTrack();
 
    virtual TrackType type() const;
    std::istream &inputStream();
    void setInputStream(std::istream &stream);
    std::ostream &outputStream();
    void setOutputStream(std::ostream &stream);
    CppUtilities::BinaryReader &reader();
    CppUtilities::BinaryWriter &writer();
    std::uint64_t startOffset() const;
    TrackFlags flags() const;
    MediaFormat format() const;
    double version() const;
    std::string_view formatName() const;
    std::string_view formatAbbreviation() const;
    const std::string &formatId() const;
    MediaType mediaType() const;
    std::string_view mediaTypeName() const;
    std::uint64_t size() const;
    void setSize(std::uint64_t size);
    std::uint32_t trackNumber() const;
    void setTrackNumber(std::uint32_t trackNumber);
    std::uint64_t id() const;
    void setId(std::uint64_t id);
    const std::string name() const;
    void setName(std::string_view name);
    const CppUtilities::TimeSpan &duration() const;
    double bitrate() const;
    double maxBitrate() const;
    const CppUtilities::DateTime &creationTime() const;
    const CppUtilities::DateTime &modificationTime() const;
    const Locale &locale() const;
    void setLocale(const Locale &locale);
    std::uint32_t samplingFrequency() const;
    std::uint32_t extensionSamplingFrequency() const;
    std::uint16_t bitsPerSample() const;
    std::uint16_t channelCount() const;
    std::uint8_t channelConfig() const;
    std::string_view channelConfigString() const;
    std::uint8_t extensionChannelConfig() const;
    std::string_view extensionChannelConfigString() const;
    std::uint64_t sampleCount() const;
    int quality() const;
    const Size &pixelSize() const;
    const Size &displaySize() const;
    const Size &resolution() const;
    const std::string &compressorName() const;
    void setCompressorName(std::string_view compressorName);
    std::uint16_t depth() const;
    std::uint32_t fps() const;
    std::string_view chromaFormat() const;
    const AspectRatio &pixelAspectRatio() const;
    bool isInterlaced() const;
    std::uint32_t timeScale() const;
    bool isEnabled() const;
    void setEnabled(bool enabled);
    bool isDefault() const;
    void setDefault(bool isDefault);
    bool isForced() const;
    void setForced(bool forced);
    bool hasLacing() const;
    bool isEncrypted() const;
    std::uint32_t colorSpace() const;
    const Margin &cropping() const;
    std::string label() const;
    std::string description() const;
    std::string shortDescription() const;
 
    void parseHeader(Diagnostics &diag, AbortableProgressFeedback &progress);
    bool isHeaderValid() const;
 
protected:
    AbstractTrack(std::istream &inputStream, std::ostream &outputStream, std::uint64_t startOffset);
    AbstractTrack(std::iostream &stream, std::uint64_t startOffset);
    virtual void internalParseHeader(Diagnostics &diag, AbortableProgressFeedback &progress) = 0;
 
    std::istream *m_istream;
    std::ostream *m_ostream;
    CppUtilities::BinaryReader m_reader;
    CppUtilities::BinaryWriter m_writer;
    std::uint64_t m_startOffset;
    TrackFlags m_flags;
    MediaFormat m_format;
    std::string m_formatId;
    std::string m_formatName;
    MediaType m_mediaType;
    double m_version;
    std::uint64_t m_size;
    std::uint32_t m_trackNumber;
    std::uint64_t m_id;
    std::string m_name;
    CppUtilities::TimeSpan m_duration;
    double m_bitrate;
    double m_maxBitrate;
    CppUtilities::DateTime m_creationTime;
    CppUtilities::DateTime m_modificationTime;
    Locale m_locale;
    std::uint32_t m_samplingFrequency;
    std::uint32_t m_extensionSamplingFrequency;
    std::uint16_t m_bitsPerSample;
    std::uint32_t m_bytesPerSecond;
    std::uint16_t m_channelCount;
    std::uint8_t m_channelConfig;
    std::uint8_t m_extensionChannelConfig;
    std::uint16_t m_chunkSize;
    std::uint64_t m_sampleCount;
    int m_quality;
    Size m_pixelSize;
    Size m_displaySize;
    Size m_resolution;
    std::string m_compressorName;
    std::uint16_t m_depth;
    std::uint32_t m_fps;
    std::string_view m_chromaFormat;
    AspectRatio m_pixelAspectRatio;
    std::uint32_t m_timeScale;
    std::uint32_t m_colorSpace;
    Margin m_cropping;
    FieldOrder m_fieldOrder;
    StereoMode m_stereoMode;
    AlphaMode m_alphaMode;
    DisplayUnit m_displayUnit;
    AspectRatioType m_aspectRatioType;
    std::unique_ptr<AbstractTrackPrivate> m_p;
 
private:
    std::string makeDescription(bool verbose) const;
};
 
inline std::istream &AbstractTrack::inputStream()
{
    return *m_istream;
}
 
inline void AbstractTrack::setInputStream(std::istream &stream)
{
    m_reader.setStream(m_istream = &stream);
}
 
inline std::ostream &AbstractTrack::outputStream()
{
    return *m_ostream;
}
 
inline void AbstractTrack::setOutputStream(std::ostream &stream)
{
    m_writer.setStream(m_ostream = &stream);
}
 
inline CppUtilities::BinaryReader &AbstractTrack::reader()
{
    return m_reader;
}
 
inline CppUtilities::BinaryWriter &AbstractTrack::writer()
{
    return m_writer;
}
 
inline TrackType AbstractTrack::type() const
{
    return TrackType::Unspecified;
}
 
inline std::uint64_t AbstractTrack::startOffset() const
{
    return m_startOffset;
}
 
inline TrackFlags AbstractTrack::flags() const
{
    return m_flags;
}
 
inline MediaFormat AbstractTrack::format() const
{
    return m_format;
}
 
inline double AbstractTrack::version() const
{
    return m_version;
}
 
inline std::string_view AbstractTrack::formatName() const
{
    return m_format || m_formatName.empty() ? m_format.name() : m_formatName;
}
 
inline std::string_view AbstractTrack::formatAbbreviation() const
{
    const auto abbr = m_format.abbreviation();
    return !abbr.empty() || m_formatId.empty() ? abbr : m_formatId;
}
 
inline const std::string &AbstractTrack::formatId() const
{
    return m_formatId;
}
 
inline MediaType AbstractTrack::mediaType() const
{
    return m_mediaType;
}
 
inline std::string_view AbstractTrack::mediaTypeName() const
{
    return ::TagParser::mediaTypeName(m_mediaType);
}
 
inline std::uint64_t AbstractTrack::size() const
{
    return m_size;
}
 
inline void AbstractTrack::setSize(std::uint64_t size)
{
    m_size = size;
}
 
inline std::uint32_t AbstractTrack::trackNumber() const
{
    return m_trackNumber;
}
 
inline void AbstractTrack::setTrackNumber(std::uint32_t trackNumber)
{
    m_trackNumber = trackNumber;
}
 
inline std::uint64_t AbstractTrack::id() const
{
    return m_id;
}
 
inline void AbstractTrack::setId(std::uint64_t id)
{
    m_id = id;
}
 
inline const std::string AbstractTrack::name() const
{
    return m_name;
}
 
inline void AbstractTrack::setName(std::string_view name)
{
    m_name = name;
}
 
inline const CppUtilities::TimeSpan &AbstractTrack::duration() const
{
    return m_duration;
}
 
inline double AbstractTrack::bitrate() const
{
    return m_bitrate;
}
 
inline double AbstractTrack::maxBitrate() const
{
    return m_maxBitrate;
}
 
inline const CppUtilities::DateTime &AbstractTrack::creationTime() const
{
    return m_creationTime;
}
 
inline const CppUtilities::DateTime &AbstractTrack::modificationTime() const
{
    return m_modificationTime;
}
 
inline const Locale &AbstractTrack::locale() const
{
    return m_locale;
}
 
inline void AbstractTrack::setLocale(const Locale &locale)
{
    m_locale = locale;
}
 
inline std::uint32_t AbstractTrack::samplingFrequency() const
{
    return m_samplingFrequency;
}
 
inline std::uint32_t AbstractTrack::extensionSamplingFrequency() const
{
    return m_extensionSamplingFrequency;
}
 
inline std::uint16_t AbstractTrack::bitsPerSample() const
{
    return m_bitsPerSample;
}
 
inline std::uint16_t AbstractTrack::channelCount() const
{
    return m_channelCount;
}
 
inline std::uint8_t AbstractTrack::channelConfig() const
{
    return m_channelConfig;
}
 
inline std::uint64_t AbstractTrack::sampleCount() const
{
    return m_sampleCount;
}
 
inline int AbstractTrack::quality() const
{
    return m_quality;
}
 
inline const Size &AbstractTrack::pixelSize() const
{
    return m_pixelSize;
}
 
inline const Size &AbstractTrack::displaySize() const
{
    return m_displaySize;
}
 
inline const Size &AbstractTrack::resolution() const
{
    return m_resolution;
}
 
inline const std::string &AbstractTrack::compressorName() const
{
    return m_compressorName;
}
 
inline void AbstractTrack::setCompressorName(std::string_view compressorName)
{
    m_compressorName = compressorName;
}
 
inline std::uint16_t AbstractTrack::depth() const
{
    return m_depth;
}
 
inline std::uint32_t AbstractTrack::fps() const
{
    return m_fps;
}
 
inline std::string_view AbstractTrack::chromaFormat() const
{
    return m_chromaFormat;
}
 
inline const AspectRatio &AbstractTrack::pixelAspectRatio() const
{
    return m_pixelAspectRatio;
}
 
inline bool AbstractTrack::isInterlaced() const
{
    return m_flags & TrackFlags::Interlaced;
}
 
inline std::uint32_t AbstractTrack::timeScale() const
{
    return m_timeScale;
}
 
inline bool AbstractTrack::isEnabled() const
{
    return m_flags & TrackFlags::Enabled;
}
 
inline void AbstractTrack::setEnabled(bool enabled)
{
    CppUtilities::modFlagEnum(m_flags, TrackFlags::Enabled, enabled);
}
 
inline bool AbstractTrack::isDefault() const
{
    return m_flags & TrackFlags::Default;
}
 
inline void AbstractTrack::setDefault(bool isDefault)
{
    CppUtilities::modFlagEnum(m_flags, TrackFlags::Default, isDefault);
}
 
inline bool AbstractTrack::isForced() const
{
    return m_flags & TrackFlags::Forced;
}
 
inline void AbstractTrack::setForced(bool forced)
{
    CppUtilities::modFlagEnum(m_flags, TrackFlags::Forced, forced);
}
 
inline bool AbstractTrack::hasLacing() const
{
    return m_flags & TrackFlags::Lacing;
}
 
inline bool AbstractTrack::isEncrypted() const
{
    return m_flags & TrackFlags::Encrypted;
}
 
inline std::uint32_t AbstractTrack::colorSpace() const
{
    return m_colorSpace;
}
 
inline const Margin &AbstractTrack::cropping() const
{
    return m_cropping;
}
 
inline bool AbstractTrack::isHeaderValid() const
{
    return m_flags & TrackFlags::HeaderValid;
}
 
} // namespace TagParser
 
#endif // TAG_PARSER_ABSTRACTTRACK_H