abstracttrack.cpp

Go to the documentation of this file.

#include "./abstracttrack.h"
#include "./exceptions.h"
#include "./mediaformat.h"
 
#include "./mp4/mp4ids.h"
 
#include "mpegaudio/mpegaudioframe.h"
 
using namespace std;
using namespace CppUtilities;
 
namespace TagParser {
 
struct AbstractTrackPrivate {};
 
AbstractTrack::AbstractTrack(istream &inputStream, ostream &outputStream, std::uint64_t startOffset)
    : m_istream(&inputStream)
    , m_ostream(&outputStream)
    , m_reader(BinaryReader(&inputStream))
    , m_writer(BinaryWriter(&outputStream))
    , m_startOffset(startOffset)
    , m_flags(TrackFlags::Enabled | TrackFlags::UsedInPresentation | TrackFlags::UsedWhenPreviewing)
    , m_format()
    , m_mediaType(MediaType::Unknown)
    , m_version(0.0)
    , m_size(0)
    , m_trackNumber(0)
    , m_id(0)
    , m_bitrate(0.0)
    , m_maxBitrate(0.0)
    , m_samplingFrequency(0)
    , m_extensionSamplingFrequency(0)
    , m_bitsPerSample(0)
    , m_bytesPerSecond(0)
    , m_channelCount(0)
    , m_channelConfig(0)
    , m_extensionChannelConfig(0)
    , m_sampleCount(0)
    , m_quality(0)
    , m_depth(0)
    , m_fps(0)
    , m_timeScale(0)
    , m_colorSpace(0)
    , m_fieldOrder(FieldOrder::Undetermined)
    , m_stereoMode(StereoMode::Unknown)
    , m_alphaMode(AlphaMode::Unknown)
    , m_displayUnit(DisplayUnit::Unknown)
    , m_aspectRatioType(AspectRatioType::Unknown)
{
}
 
AbstractTrack::AbstractTrack(std::iostream &stream, std::uint64_t startOffset)
    : AbstractTrack(stream, stream, startOffset)
{
}
 
AbstractTrack::~AbstractTrack()
{
}
 
std::string_view AbstractTrack::channelConfigString() const
{
    switch (m_format.general) {
    case GeneralMediaFormat::Aac:
        return m_channelConfig ? Mpeg4ChannelConfigs::channelConfigString(m_channelConfig) : std::string_view();
    case GeneralMediaFormat::Mpeg1Audio:
    case GeneralMediaFormat::Mpeg2Audio:
        return mpegChannelModeString(static_cast<MpegChannelMode>(m_channelConfig));
    default:
        return std::string_view();
    }
}
 
std::uint8_t AbstractTrack::extensionChannelConfig() const
{
    return m_extensionChannelConfig;
}
 
std::string_view AbstractTrack::extensionChannelConfigString() const
{
    switch (m_format.general) {
    case GeneralMediaFormat::Aac:
        return m_extensionChannelConfig ? Mpeg4ChannelConfigs::channelConfigString(m_extensionChannelConfig) : std::string_view();
    default:
        return std::string_view();
    }
}
 
string AbstractTrack::label() const
{
    stringstream ss;
    ss << "ID: " << id();
    ss << ", type: " << mediaTypeName();
    if (!name().empty()) {
        ss << ", name: \"" << name() << "\"";
    }
    if (const auto &language = locale().fullOrSomeAbbreviatedName(); !language.empty()) {
        ss << ", language: " << language << "";
    }
    return ss.str();
}
 
string AbstractTrack::makeDescription(bool verbose) const
{
    // use abbreviated format
    const auto format = MediaFormat(m_format.general, verbose ? m_format.sub : 0, verbose ? m_format.extension : 0);
    auto formatName = format.shortAbbreviation();
    if (formatName.empty()) {
        // fall back to media type name if no abbreviation available
        formatName = mediaTypeName();
    }
 
    // find additional info and level
    auto additionalInfoRef = std::string_view();
    auto level = std::string();
    switch (m_mediaType) {
    case MediaType::Video:
        if (!pixelSize().isNull()) {
            additionalInfoRef = pixelSize().abbreviation();
        } else if (!displaySize().isNull()) {
            additionalInfoRef = displaySize().abbreviation();
        }
        if (verbose) {
            switch (format.general) {
            case GeneralMediaFormat::Mpeg4Video:
            case GeneralMediaFormat::Avc:
            case GeneralMediaFormat::Hevc:
                if (version() != 0.0) {
                    level = "@L" + numberToString(version());
                }
                break;
            default:;
            }
        }
        break;
    case MediaType::Audio:
    case MediaType::Text:
        if (channelCount()) {
            if (const auto &localeName = locale().someAbbreviatedName(); !localeName.empty()) {
                return argsToString(formatName, '-', channelCount(), "ch-", localeName);
            } else {
                return argsToString(formatName, '-', channelCount(), 'c', 'h');
            }
        } else if (const auto &localeName = locale().someAbbreviatedName(); !localeName.empty()) {
            additionalInfoRef = localeName;
        }
        break;
    default:;
    }
 
    if (!additionalInfoRef.empty()) {
        return argsToString(formatName, level, '-', additionalInfoRef);
    }
    return argsToString(formatName, level);
}
 
string AbstractTrack::description() const
{
    return makeDescription(true);
}
 
string AbstractTrack::shortDescription() const
{
    return makeDescription(false);
}
 
void AbstractTrack::parseHeader(Diagnostics &diag, AbortableProgressFeedback &progress)
{
    m_flags -= TrackFlags::HeaderValid;
    m_istream->seekg(static_cast<streamoff>(m_startOffset), ios_base::beg);
    try {
        internalParseHeader(diag, progress);
        m_flags += TrackFlags::HeaderValid;
    } catch (const Failure &) {
        throw;
    }
}
 
} // namespace TagParser