#include "./mp4track.h"
#include "./mp4atom.h"
#include "./mp4container.h"
#include "./mp4ids.h"
#include "./mpeg4descriptor.h"

#include "../avc/avcconfiguration.h"

#include "../mpegaudio/mpegaudioframe.h"
#include "../mpegaudio/mpegaudioframestream.h"

#include "../exceptions.h"
#include "../mediaformat.h"

#include <c++utilities/conversion/stringbuilder.h>
#include <c++utilities/io/binaryreader.h>
#include <c++utilities/io/binarywriter.h>
#include <c++utilities/io/bitreader.h>
#include <c++utilities/io/catchiofailure.h>

#include <cmath>
#include <locale>

using namespace std;
using namespace IoUtilities;
using namespace ConversionUtilities;
using namespace ChronoUtilities;

namespace TagParser {

/*!
 * \brief The TrackHeaderInfo struct holds information about the present track header (tkhd atom) and
 *        information for making a new track header based on it.
 * \sa TrackHeaderInfo Mp4Track::verifyPresentTrackHeader() for obtaining an instance.
 * \remarks The struct is only used internally by the Mp4Track class.
 */
struct TrackHeaderInfo {
    friend class Mp4Track;

private:
    constexpr TrackHeaderInfo();

    /// \brief Specifies the size which is required for <i>making a new</i> track header based one the existing one.
    uint64 requiredSize;
    /// \brief Specifies whether there actually a track header exists and whether it can be used as basis for a new one.
    bool canUseExisting;
    /// \brief Specifies whether the existing track header is truncated.
    bool truncated;
    /// \brief Specifies the version of the existing track header.
    byte version;
    /// \brief Specifies whether the version of the existing track header is unknown (and assumed to be 1).
    bool versionUnknown;
    /// \brief Specifies the additional data offset of the existing header. Unspecified if canUseExisting is false.
    byte additionalDataOffset;
    /// \brief Specifies whether the buffered header data should be discarded when making a new track header.
    bool discardBuffer;
};

constexpr TrackHeaderInfo::TrackHeaderInfo()
    : requiredSize(100)
    , canUseExisting(false)
    , truncated(false)
    , version(0)
    , versionUnknown(false)
    , additionalDataOffset(0)
    , discardBuffer(false)
{
}

/// \brief Dates within MP4 tracks are expressed as the number of seconds since this date.
const DateTime startDate = DateTime::fromDate(1904, 1, 1);

/*!
 * \class Mpeg4AudioSpecificConfig
 * \brief The Mpeg4AudioSpecificConfig class holds MPEG-4 audio specific config parsed using Mp4Track::parseAudioSpecificConfig().
 * \remarks Is part of Mpeg4ElementaryStreamInfo (audio streams only).
 */

Mpeg4AudioSpecificConfig::Mpeg4AudioSpecificConfig()
    : audioObjectType(0)
    , sampleFrequencyIndex(0xF)
    , sampleFrequency(0)
    , channelConfiguration(0)
    , extensionAudioObjectType(0)
    , sbrPresent(false)
    , psPresent(false)
    , extensionSampleFrequencyIndex(0xF)
    , extensionSampleFrequency(0)
    , extensionChannelConfiguration(0)
    , frameLengthFlag(false)
    , dependsOnCoreCoder(false)
    , coreCoderDelay(0)
    , extensionFlag(0)
    , layerNr(0)
    , numOfSubFrame(0)
    , layerLength(0)
    , resilienceFlags(0)
    , epConfig(0)
{
}

/*!
 * \class Mpeg4VideoSpecificConfig
 * \brief The Mpeg4VideoSpecificConfig class holds MPEG-4 video specific config parsed using Mp4Track::parseVideoSpecificConfig().
 * \remarks
 *  - Is part of Mpeg4ElementaryStreamInfo (video streams only).
 *  - AVC configuration is another thing and covered by the AvcConfiguration class.
 */

Mpeg4VideoSpecificConfig::Mpeg4VideoSpecificConfig()
    : profile(0)
{
}

/*!
 * \class Mpeg4ElementaryStreamInfo
 * \brief The Mpeg4ElementaryStreamInfo class holds MPEG-4 elementary stream info parsed using Mp4Track::parseMpeg4ElementaryStreamInfo().
 */

/*!
 * \class TagParser::Mp4Track
 * \brief Implementation of TagParser::AbstractTrack for the MP4 container.
 */

/*!
 * \brief Constructs a new track for the specified \a trakAtom.
 *
 * "trak"-atoms are stored in the top-level atom "move". Each "trak"-atom holds
 * header information for one track in the MP4 file.
 */
Mp4Track::Mp4Track(Mp4Atom &trakAtom)
    : AbstractTrack(trakAtom.stream(), trakAtom.startOffset())
    , m_trakAtom(&trakAtom)
    , m_tkhdAtom(nullptr)
    , m_mdiaAtom(nullptr)
    , m_mdhdAtom(nullptr)
    , m_hdlrAtom(nullptr)
    , m_minfAtom(nullptr)
    , m_stblAtom(nullptr)
    , m_stsdAtom(nullptr)
    , m_stscAtom(nullptr)
    , m_stcoAtom(nullptr)
    , m_stszAtom(nullptr)
    ,
    //m_codecConfigAtom(nullptr),
    //m_esDescAtom(nullptr),
    m_framesPerSample(1)
    , m_chunkOffsetSize(4)
    , m_chunkCount(0)
    , m_sampleToChunkEntryCount(0)
{
}

/*!
 * \brief Destroys the track.
 */
Mp4Track::~Mp4Track()
{
}

TrackType Mp4Track::type() const
{
    return TrackType::Mp4Track;
}

/*!
 * \brief Reads the chunk offsets from the stco atom and fragments if \a parseFragments is true.
 * \returns Returns the chunk offset table for the track.
 * \throws Throws InvalidDataException when
 *          - there is no stream assigned.
 *          - the header has been considered as invalid when parsing the header information.
 *          - the determined chunk offset size is invalid.
 * \throws Throws std::ios_base::failure when an IO error occurs.
 * \sa readChunkSizes();
 */
std::vector<uint64> Mp4Track::readChunkOffsets(bool parseFragments, Diagnostics &diag)
{
    static const string context("reading chunk offset table of MP4 track");
    if (!isHeaderValid() || !m_istream) {
        diag.emplace_back(DiagLevel::Critical, "Track has not been parsed.", context);
        throw InvalidDataException();
    }
    vector<uint64> offsets;
    if (m_stcoAtom) {
        // verify integrity of the chunk offset table
        uint64 actualTableSize = m_stcoAtom->dataSize();
        if (actualTableSize < (8 + chunkOffsetSize())) {
            diag.emplace_back(DiagLevel::Critical, "The stco atom is truncated. There are no chunk offsets present.", context);
            throw InvalidDataException();
        } else {
            actualTableSize -= 8;
        }
        uint32 actualChunkCount = chunkCount();
        uint64 calculatedTableSize = chunkCount() * chunkOffsetSize();
        if (calculatedTableSize < actualTableSize) {
            diag.emplace_back(
                DiagLevel::Critical, "The stco atom stores more chunk offsets as denoted. The additional chunk offsets will be ignored.", context);
        } else if (calculatedTableSize > actualTableSize) {
            diag.emplace_back(DiagLevel::Critical, "The stco atom is truncated. It stores less chunk offsets as denoted.", context);
            actualChunkCount = floor(static_cast<double>(actualTableSize) / static_cast<double>(chunkOffsetSize()));
        }
        // read the table
        offsets.reserve(actualChunkCount);
        m_istream->seekg(m_stcoAtom->dataOffset() + 8);
        switch (chunkOffsetSize()) {
        case 4:
            for (uint32 i = 0; i < actualChunkCount; ++i) {
                offsets.push_back(reader().readUInt32BE());
            }
            break;
        case 8:
            for (uint32 i = 0; i < actualChunkCount; ++i) {
                offsets.push_back(reader().readUInt64BE());
            }
            break;
        default:
            diag.emplace_back(DiagLevel::Critical, "The determined chunk offset size is invalid.", context);
            throw InvalidDataException();
        }
    }
    // read sample offsets of fragments
    if (parseFragments) {
        uint64 totalDuration = 0;
        for (Mp4Atom *moofAtom = m_trakAtom->container().firstElement()->siblingByIdIncludingThis(Mp4AtomIds::MovieFragment, diag); moofAtom;
             moofAtom = moofAtom->siblingById(Mp4AtomIds::MovieFragment, diag)) {
            moofAtom->parse(diag);
            for (Mp4Atom *trafAtom = moofAtom->childById(Mp4AtomIds::TrackFragment, diag); trafAtom;
                 trafAtom = trafAtom->siblingById(Mp4AtomIds::TrackFragment, diag)) {
                trafAtom->parse(diag);
                for (Mp4Atom *tfhdAtom = trafAtom->childById(Mp4AtomIds::TrackFragmentHeader, diag); tfhdAtom;
                     tfhdAtom = tfhdAtom->siblingById(Mp4AtomIds::TrackFragmentHeader, diag)) {
                    tfhdAtom->parse(diag);
                    uint32 calculatedDataSize = 0;
                    if (tfhdAtom->dataSize() < calculatedDataSize) {
                        diag.emplace_back(DiagLevel::Critical, "tfhd atom is truncated.", context);
                    } else {
                        inputStream().seekg(tfhdAtom->dataOffset() + 1);
                        const uint32 flags = reader().readUInt24BE();
                        if (m_id == reader().readUInt32BE()) { // check track ID
                            if (flags & 0x000001) { // base-data-offset present
                                calculatedDataSize += 8;
                            }
                            if (flags & 0x000002) { // sample-description-index present
                                calculatedDataSize += 4;
                            }
                            if (flags & 0x000008) { // default-sample-duration present
                                calculatedDataSize += 4;
                            }
                            if (flags & 0x000010) { // default-sample-size present
                                calculatedDataSize += 4;
                            }
                            if (flags & 0x000020) { // default-sample-flags present
                                calculatedDataSize += 4;
                            }
                            // some variables are currently skipped because they are currently not interesting
                            //uint64 baseDataOffset = moofAtom->startOffset();
                            //uint32 defaultSampleDescriptionIndex = 0;
                            uint32 defaultSampleDuration = 0;
                            uint32 defaultSampleSize = 0;
                            //uint32 defaultSampleFlags = 0;
                            if (tfhdAtom->dataSize() < calculatedDataSize) {
                                diag.emplace_back(DiagLevel::Critical, "tfhd atom is truncated (presence of fields denoted).", context);
                            } else {
                                if (flags & 0x000001) { // base-data-offset present
                                    //baseDataOffset = reader.readUInt64();
                                    inputStream().seekg(8, ios_base::cur);
                                }
                                if (flags & 0x000002) { // sample-description-index present
                                    //defaultSampleDescriptionIndex = reader.readUInt32();
                                    inputStream().seekg(4, ios_base::cur);
                                }
                                if (flags & 0x000008) { // default-sample-duration present
                                    defaultSampleDuration = reader().readUInt32BE();
                                    //inputStream().seekg(4, ios_base::cur);
                                }
                                if (flags & 0x000010) { // default-sample-size present
                                    defaultSampleSize = reader().readUInt32BE();
                                }
                                if (flags & 0x000020) { // default-sample-flags present
                                    //defaultSampleFlags = reader().readUInt32BE();
                                    inputStream().seekg(4, ios_base::cur);
                                }
                            }
                            for (Mp4Atom *trunAtom = trafAtom->childById(Mp4AtomIds::TrackFragmentRun, diag); trunAtom;
                                 trunAtom = trunAtom->siblingById(Mp4AtomIds::TrackFragmentRun, diag)) {
                                uint32 calculatedDataSize = 8;
                                if (trunAtom->dataSize() < calculatedDataSize) {
                                    diag.emplace_back(DiagLevel::Critical, "trun atom is truncated.", context);
                                } else {
                                    inputStream().seekg(trunAtom->dataOffset() + 1);
                                    uint32 flags = reader().readUInt24BE();
                                    uint32 sampleCount = reader().readUInt32BE();
                                    m_sampleCount += sampleCount;
                                    if (flags & 0x000001) { // data offset present
                                        calculatedDataSize += 4;
                                    }
                                    if (flags & 0x000004) { // first-sample-flags present
                                        calculatedDataSize += 4;
                                    }
                                    uint32 entrySize = 0;
                                    if (flags & 0x000100) { // sample-duration present
                                        entrySize += 4;
                                    }
                                    if (flags & 0x000200) { // sample-size present
                                        entrySize += 4;
                                    }
                                    if (flags & 0x000400) { // sample-flags present
                                        entrySize += 4;
                                    }
                                    if (flags & 0x000800) { // sample-composition-time-offsets present
                                        entrySize += 4;
                                    }
                                    calculatedDataSize += entrySize * sampleCount;
                                    if (trunAtom->dataSize() < calculatedDataSize) {
                                        diag.emplace_back(DiagLevel::Critical, "trun atom is truncated (presence of fields denoted).", context);
                                    } else {
                                        if (flags & 0x000001) { // data offset present
                                            inputStream().seekg(4, ios_base::cur);
                                            //int32 dataOffset = reader().readInt32BE();
                                        }
                                        if (flags & 0x000004) { // first-sample-flags present
                                            inputStream().seekg(4, ios_base::cur);
                                        }
                                        for (uint32 i = 0; i < sampleCount; ++i) {
                                            if (flags & 0x000100) { // sample-duration present
                                                totalDuration += reader().readUInt32BE();
                                            } else {
                                                totalDuration += defaultSampleDuration;
                                            }
                                            if (flags & 0x000200) { // sample-size present
                                                m_sampleSizes.push_back(reader().readUInt32BE());
                                                m_size += m_sampleSizes.back();
                                            } else {
                                                m_size += defaultSampleSize;
                                            }
                                            if (flags & 0x000400) { // sample-flags present
                                                inputStream().seekg(4, ios_base::cur);
                                            }
                                            if (flags & 0x000800) { // sample-composition-time-offsets present
                                                inputStream().seekg(4, ios_base::cur);
                                            }
                                        }
                                    }
                                }
                            }
                            if (m_sampleSizes.empty() && defaultSampleSize) {
                                m_sampleSizes.push_back(defaultSampleSize);
                            }
                        }
                    }
                }
            }
        }
    }
    return offsets;
}

/*!
 * \brief Accumulates \a count sample sizes from the specified \a sampleSizeTable starting at the specified \a sampleIndex.
 * \remarks This helper function is used by the addChunkSizeEntries() method.
 */
uint64 Mp4Track::accumulateSampleSizes(size_t &sampleIndex, size_t count, Diagnostics &diag)
{
    if (sampleIndex + count <= m_sampleSizes.size()) {
        uint64 sum = 0;
        for (size_t end = sampleIndex + count; sampleIndex < end; ++sampleIndex) {
            sum += m_sampleSizes[sampleIndex];
        }
        return sum;
    } else if (m_sampleSizes.size() == 1) {
        sampleIndex += count;
        return static_cast<uint64>(m_sampleSizes.front()) * count;
    } else {
        diag.emplace_back(DiagLevel::Critical, "There are not as many sample size entries as samples.", "reading chunk sizes of MP4 track");
        throw InvalidDataException();
    }
}

/*!
 * \brief Adds chunks size entries to the specified \a chunkSizeTable.
 * \param chunkSizeTable Specifies the chunk size table. The chunks sizes will be added to this table.
 * \param count Specifies the number of chunks to be added. The size of \a chunkSizeTable is increased this value.
 * \param sampleIndex Specifies the index of the first sample in the \a sampleSizeTable; is increased by \a count * \a sampleCount.
 * \param sampleSizeTable Specifies the table holding the sample sizes.
 * \remarks This helper function is used by the readChunkSizes() method.
 */
void Mp4Track::addChunkSizeEntries(std::vector<uint64> &chunkSizeTable, size_t count, size_t &sampleIndex, uint32 sampleCount, Diagnostics &diag)
{
    for (size_t i = 0; i < count; ++i) {
        chunkSizeTable.push_back(accumulateSampleSizes(sampleIndex, sampleCount, diag));
    }
}

/*!
 * \brief Verifies the present track header (tkhd atom) and returns relevant information for making a new track header
 *        based on it.
 */
TrackHeaderInfo Mp4Track::verifyPresentTrackHeader() const
{
    TrackHeaderInfo info;

    // return the default TrackHeaderInfo in case there is no track header prsent
    if (!m_tkhdAtom) {
        return info;
    }

    // ensure the tkhd atom is buffered but mark the buffer to be discarded again if it has not been present
    info.discardBuffer = m_tkhdAtom->buffer() == nullptr;
    if (info.discardBuffer) {
        m_tkhdAtom->makeBuffer();
    }

    // check the version of the existing tkhd atom to determine where additional data starts
    switch (info.version = static_cast<byte>(m_tkhdAtom->buffer()[m_tkhdAtom->headerSize()])) {
    case 0:
        info.additionalDataOffset = 32;
        break;
    case 1:
        info.additionalDataOffset = 44;
        break;
    default:
        info.additionalDataOffset = 44;
        info.versionUnknown = true;
    }

    // check whether the existing tkhd atom is not truncated
    if (info.additionalDataOffset + 48u <= m_tkhdAtom->dataSize()) {
        info.canUseExisting = true;
    } else {
        info.truncated = true;
        info.canUseExisting = info.additionalDataOffset < m_tkhdAtom->dataSize();
        if (!info.canUseExisting && info.discardBuffer) {
            m_tkhdAtom->discardBuffer();
        }
    }

    // determine required size
    info.requiredSize = m_tkhdAtom->dataSize() + 8;
    if (info.version == 0) {
        // add 12 byte to size if the existing version is 0 because we always write version 1 which takes 12 byte more space
        info.requiredSize += 12;
    }
    if (info.requiredSize > numeric_limits<uint32>::max()) {
        // add 8 byte to the size because it must be denoted using a 64-bit integer
        info.requiredSize += 8;
    }
    return info;
}

/*!
 * \brief Reads the sample to chunk table.
 * \returns Returns a vector with the table entries wrapped using the tuple container. The first value
 *          is an integer that gives the first chunk that share the same samples count and sample description index.
 *          The second value is sample cound and the third value the sample description index.
 * \remarks The table is not validated.
 */
vector<tuple<uint32, uint32, uint32>> Mp4Track::readSampleToChunkTable(Diagnostics &diag)
{
    static const string context("reading sample to chunk table of MP4 track");
    if (!isHeaderValid() || !m_istream || !m_stscAtom) {
        diag.emplace_back(DiagLevel::Critical, "Track has not been parsed or is invalid.", context);
        throw InvalidDataException();
    }
    // verify integrity of the sample to chunk table
    uint64 actualTableSize = m_stscAtom->dataSize();
    if (actualTableSize < 20) {
        diag.emplace_back(DiagLevel::Critical, "The stsc atom is truncated. There are no \"sample to chunk\" entries present.", context);
        throw InvalidDataException();
    } else {
        actualTableSize -= 8;
    }
    uint32 actualSampleToChunkEntryCount = sampleToChunkEntryCount();
    uint64 calculatedTableSize = actualSampleToChunkEntryCount * 12;
    if (calculatedTableSize < actualTableSize) {
        diag.emplace_back(DiagLevel::Critical, "The stsc atom stores more entries as denoted. The additional entries will be ignored.", context);
    } else if (calculatedTableSize > actualTableSize) {
        diag.emplace_back(DiagLevel::Critical, "The stsc atom is truncated. It stores less entries as denoted.", context);
        // FIXME: floor and cast actually required?
        actualSampleToChunkEntryCount = floor(static_cast<double>(actualTableSize) / 12.0);
    }
    // prepare reading
    vector<tuple<uint32, uint32, uint32>> sampleToChunkTable;
    sampleToChunkTable.reserve(actualSampleToChunkEntryCount);
    m_istream->seekg(m_stscAtom->dataOffset() + 8);
    for (uint32 i = 0; i < actualSampleToChunkEntryCount; ++i) {
        // read entry
        uint32 firstChunk = reader().readUInt32BE();
        uint32 samplesPerChunk = reader().readUInt32BE();
        uint32 sampleDescriptionIndex = reader().readUInt32BE();
        sampleToChunkTable.emplace_back(firstChunk, samplesPerChunk, sampleDescriptionIndex);
    }
    return sampleToChunkTable;
}

/*!
 * \brief Reads the chunk sizes from the stsz (sample sizes) and stsc (samples per chunk) atom.
 * \returns Returns the chunk sizes for the track.
 *
 * \throws Throws InvalidDataException when
 *          - there is no stream assigned.
 *          - the header has been considered as invalid when parsing the header information.
 *          - the determined chunk offset size is invalid.
 * \throws Throws std::ios_base::failure when an IO error occurs.
 *
 * \sa readChunkOffsets();
 */
vector<uint64> Mp4Track::readChunkSizes(Diagnostics &diag)
{
    static const string context("reading chunk sizes of MP4 track");
    if (!isHeaderValid() || !m_istream || !m_stcoAtom) {
        diag.emplace_back(DiagLevel::Critical, "Track has not been parsed or is invalid.", context);
        throw InvalidDataException();
    }
    // read sample to chunk table
    const auto sampleToChunkTable = readSampleToChunkTable(diag);
    // accumulate chunk sizes from the table
    vector<uint64> chunkSizes;
    if (!sampleToChunkTable.empty()) {
        // prepare reading
        auto tableIterator = sampleToChunkTable.cbegin();
        chunkSizes.reserve(m_chunkCount);
        // read first entry
        size_t sampleIndex = 0;
        uint32 previousChunkIndex = get<0>(*tableIterator); // the first chunk has the index 1 and not zero!
        if (previousChunkIndex != 1) {
            diag.emplace_back(DiagLevel::Critical, "The first chunk of the first \"sample to chunk\" entry must be 1.", context);
            previousChunkIndex = 1; // try to read the entry anyway
        }
        uint32 samplesPerChunk = get<1>(*tableIterator);
        // read the following entries
        ++tableIterator;
        for (const auto tableEnd = sampleToChunkTable.cend(); tableIterator != tableEnd; ++tableIterator) {
            uint32 firstChunkIndex = get<0>(*tableIterator);
            if (firstChunkIndex > previousChunkIndex && firstChunkIndex <= m_chunkCount) {
                addChunkSizeEntries(chunkSizes, firstChunkIndex - previousChunkIndex, sampleIndex, samplesPerChunk, diag);
            } else {
                diag.emplace_back(DiagLevel::Critical,
                    "The first chunk index of a \"sample to chunk\" entry must be greather than the first chunk of the previous entry and not "
                    "greather than the chunk count.",
                    context);
                throw InvalidDataException();
            }
            previousChunkIndex = firstChunkIndex;
            samplesPerChunk = get<1>(*tableIterator);
        }
        if (m_chunkCount >= previousChunkIndex) {
            addChunkSizeEntries(chunkSizes, m_chunkCount + 1 - previousChunkIndex, sampleIndex, samplesPerChunk, diag);
        }
    }
    return chunkSizes;
}

/*!
 * \brief Reads the MPEG-4 elementary stream descriptor for the track.
 * \remarks
 *  - Notifications might be added.
 * \sa mpeg4ElementaryStreamInfo()
 */
std::unique_ptr<Mpeg4ElementaryStreamInfo> Mp4Track::parseMpeg4ElementaryStreamInfo(
    IoUtilities::BinaryReader &reader, Mp4Atom *esDescAtom, Diagnostics &diag)
{
    static const string context("parsing MPEG-4 elementary stream descriptor");
    using namespace Mpeg4ElementaryStreamObjectIds;
    unique_ptr<Mpeg4ElementaryStreamInfo> esInfo;
    if (esDescAtom->dataSize() >= 12) {
        reader.stream()->seekg(esDescAtom->dataOffset());
        // read version/flags
        if (reader.readUInt32BE() != 0) {
            diag.emplace_back(DiagLevel::Warning, "Unknown version/flags.", context);
        }
        // read extended descriptor
        Mpeg4Descriptor esDesc(esDescAtom->container(), reader.stream()->tellg(), esDescAtom->dataSize() - 4);
        try {
            esDesc.parse(diag);
            // check ID
            if (esDesc.id() != Mpeg4DescriptorIds::ElementaryStreamDescr) {
                diag.emplace_back(DiagLevel::Critical, "Invalid descriptor found.", context);
                throw Failure();
            }
            // read stream info
            reader.stream()->seekg(esDesc.dataOffset());
            esInfo = make_unique<Mpeg4ElementaryStreamInfo>();
            esInfo->id = reader.readUInt16BE();
            esInfo->esDescFlags = reader.readByte();
            if (esInfo->dependencyFlag()) {
                esInfo->dependsOnId = reader.readUInt16BE();
            }
            if (esInfo->urlFlag()) {
                esInfo->url = reader.readString(reader.readByte());
            }
            if (esInfo->ocrFlag()) {
                esInfo->ocrId = reader.readUInt16BE();
            }
            for (Mpeg4Descriptor *esDescChild = esDesc.denoteFirstChild(static_cast<uint64>(reader.stream()->tellg()) - esDesc.startOffset());
                 esDescChild; esDescChild = esDescChild->nextSibling()) {
                esDescChild->parse(diag);
                switch (esDescChild->id()) {
                case Mpeg4DescriptorIds::DecoderConfigDescr:
                    // read decoder config descriptor
                    reader.stream()->seekg(esDescChild->dataOffset());
                    esInfo->objectTypeId = reader.readByte();
                    esInfo->decCfgDescFlags = reader.readByte();
                    esInfo->bufferSize = reader.readUInt24BE();
                    esInfo->maxBitrate = reader.readUInt32BE();
                    esInfo->averageBitrate = reader.readUInt32BE();
                    for (Mpeg4Descriptor *decCfgDescChild = esDescChild->denoteFirstChild(esDescChild->headerSize() + 13); decCfgDescChild;
                         decCfgDescChild = decCfgDescChild->nextSibling()) {
                        decCfgDescChild->parse(diag);
                        switch (decCfgDescChild->id()) {
                        case Mpeg4DescriptorIds::DecoderSpecificInfo:
                            // read decoder specific info
                            switch (esInfo->objectTypeId) {
                            case Aac:
                            case Mpeg2AacMainProfile:
                            case Mpeg2AacLowComplexityProfile:
                            case Mpeg2AacScaleableSamplingRateProfile:
                            case Mpeg2Audio:
                            case Mpeg1Audio:
                                esInfo->audioSpecificConfig
                                    = parseAudioSpecificConfig(*reader.stream(), decCfgDescChild->dataOffset(), decCfgDescChild->dataSize(), diag);
                                break;
                            case Mpeg4Visual:
                                esInfo->videoSpecificConfig
                                    = parseVideoSpecificConfig(reader, decCfgDescChild->dataOffset(), decCfgDescChild->dataSize(), diag);
                                break;
                            default:; // TODO: cover more object types
                            }
                            break;
                        }
                    }
                    break;
                case Mpeg4DescriptorIds::SlConfigDescr:
                    // uninteresting
                    break;
                }
            }
        } catch (const Failure &) {
            diag.emplace_back(DiagLevel::Critical, "The MPEG-4 descriptor element structure is invalid.", context);
        }
    } else {
        diag.emplace_back(DiagLevel::Warning, "Elementary stream descriptor atom (esds) is truncated.", context);
    }
    return esInfo;
}

/*!
 * \brief Parses the audio specific configuration for the track.
 * \remarks
 *  - Notifications might be added.
 * \sa mpeg4ElementaryStreamInfo()
 */
unique_ptr<Mpeg4AudioSpecificConfig> Mp4Track::parseAudioSpecificConfig(istream &stream, uint64 startOffset, uint64 size, Diagnostics &diag)
{
    static const string context("parsing MPEG-4 audio specific config from elementary stream descriptor");
    using namespace Mpeg4AudioObjectIds;
    // read config into buffer and construct BitReader for bitwise reading
    stream.seekg(startOffset);
    auto buff = make_unique<char[]>(size);
    stream.read(buff.get(), size);
    BitReader bitReader(buff.get(), size);
    auto audioCfg = make_unique<Mpeg4AudioSpecificConfig>();
    try {
        // read audio object type
        auto getAudioObjectType = [&bitReader] {
            byte objType = bitReader.readBits<byte>(5);
            if (objType == 31) {
                objType = 32 + bitReader.readBits<byte>(6);
            }
            return objType;
        };
        audioCfg->audioObjectType = getAudioObjectType();
        // read sampling frequency
        if ((audioCfg->sampleFrequencyIndex = bitReader.readBits<byte>(4)) == 0xF) {
            audioCfg->sampleFrequency = bitReader.readBits<uint32>(24);
        }
        // read channel config
        audioCfg->channelConfiguration = bitReader.readBits<byte>(4);
        // read extension header
        switch (audioCfg->audioObjectType) {
        case Sbr:
        case Ps:
            audioCfg->extensionAudioObjectType = audioCfg->audioObjectType;
            audioCfg->sbrPresent = true;
            if ((audioCfg->extensionSampleFrequencyIndex = bitReader.readBits<byte>(4)) == 0xF) {
                audioCfg->extensionSampleFrequency = bitReader.readBits<uint32>(24);
            }
            if ((audioCfg->audioObjectType = getAudioObjectType()) == ErBsac) {
                audioCfg->extensionChannelConfiguration = bitReader.readBits<byte>(4);
            }
            break;
        }
        switch (audioCfg->extensionAudioObjectType) {
        case Ps:
            audioCfg->psPresent = true;
            audioCfg->extensionChannelConfiguration = Mpeg4ChannelConfigs::FrontLeftFrontRight;
            break;
        }
        // read GA specific config
        switch (audioCfg->audioObjectType) {
        case AacMain:
        case AacLc:
        case AacLtp:
        case AacScalable:
        case TwinVq:
        case ErAacLc:
        case ErAacLtp:
        case ErAacScalable:
        case ErTwinVq:
        case ErBsac:
        case ErAacLd:
            audioCfg->frameLengthFlag = bitReader.readBits<byte>(1);
            if ((audioCfg->dependsOnCoreCoder = bitReader.readBit())) {
                audioCfg->coreCoderDelay = bitReader.readBits<byte>(14);
            }
            audioCfg->extensionFlag = bitReader.readBit();
            if (audioCfg->channelConfiguration == 0) {
                throw NotImplementedException(); // TODO: parse program_config_element
            }
            switch (audioCfg->audioObjectType) {
            case AacScalable:
            case ErAacScalable:
                audioCfg->layerNr = bitReader.readBits<byte>(3);
                break;
            default:;
            }
            if (audioCfg->extensionFlag == 1) {
                switch (audioCfg->audioObjectType) {
                case ErBsac:
                    audioCfg->numOfSubFrame = bitReader.readBits<byte>(5);
                    audioCfg->layerLength = bitReader.readBits<uint16>(11);
                    break;
                case ErAacLc:
                case ErAacLtp:
                case ErAacScalable:
                case ErAacLd:
                    audioCfg->resilienceFlags = bitReader.readBits<byte>(3);
                    break;
                default:;
                }
                if (bitReader.readBit() == 1) { // extension flag 3
                    throw NotImplementedException(); // TODO
                }
            }
            break;
        default:
            throw NotImplementedException(); // TODO: cover remaining object types
        }
        // read error specific config
        switch (audioCfg->audioObjectType) {
        case ErAacLc:
        case ErAacLtp:
        case ErAacScalable:
        case ErTwinVq:
        case ErBsac:
        case ErAacLd:
        case ErCelp:
        case ErHvxc:
        case ErHiln:
        case ErParametric:
        case ErAacEld:
            switch (audioCfg->epConfig = bitReader.readBits<byte>(2)) {
            case 2:
                break;
            case 3:
                bitReader.skipBits(1);
                break;
            default:
                throw NotImplementedException(); // TODO
            }
            break;
        }
        if (audioCfg->extensionAudioObjectType != Sbr && audioCfg->extensionAudioObjectType != Ps && bitReader.bitsAvailable() >= 16) {
            uint16 syncExtensionType = bitReader.readBits<uint16>(11);
            if (syncExtensionType == 0x2B7) {
                if ((audioCfg->extensionAudioObjectType = getAudioObjectType()) == Sbr) {
                    if ((audioCfg->sbrPresent = bitReader.readBit())) {
                        if ((audioCfg->extensionSampleFrequencyIndex = bitReader.readBits<byte>(4)) == 0xF) {
                            audioCfg->extensionSampleFrequency = bitReader.readBits<uint32>(24);
                        }
                        if (bitReader.bitsAvailable() >= 12) {
                            if ((syncExtensionType = bitReader.readBits<uint16>(11)) == 0x548) {
                                audioCfg->psPresent = bitReader.readBits<byte>(1);
                            }
                        }
                    }
                } else if (audioCfg->extensionAudioObjectType == ErBsac) {
                    if ((audioCfg->sbrPresent = bitReader.readBit())) {
                        if ((audioCfg->extensionSampleFrequencyIndex = bitReader.readBits<byte>(4)) == 0xF) {
                            audioCfg->extensionSampleFrequency = bitReader.readBits<uint32>(24);
                        }
                    }
                    audioCfg->extensionChannelConfiguration = bitReader.readBits<byte>(4);
                }
            } else if (syncExtensionType == 0x548) {
                audioCfg->psPresent = bitReader.readBit();
            }
        }
    } catch (const NotImplementedException &) {
        diag.emplace_back(DiagLevel::Information, "Not implemented for the format of audio track.", context);
    } catch (...) {
        const char *what = catchIoFailure();
        if (stream.fail()) {
            // IO error caused by input stream
            throwIoFailure(what);
        } else {
            // IO error caused by bitReader
            diag.emplace_back(DiagLevel::Critical, "Audio specific configuration is truncated.", context);
        }
    }
    return audioCfg;
}

/*!
 * \brief Parses the video specific configuration for the track.
 * \remarks
 *  - Notifications might be added.
 * \sa mpeg4ElementaryStreamInfo()
 */
std::unique_ptr<Mpeg4VideoSpecificConfig> Mp4Track::parseVideoSpecificConfig(BinaryReader &reader, uint64 startOffset, uint64 size, Diagnostics &diag)
{
    static const string context("parsing MPEG-4 video specific config from elementary stream descriptor");
    using namespace Mpeg4AudioObjectIds;
    auto videoCfg = make_unique<Mpeg4VideoSpecificConfig>();
    // seek to start
    reader.stream()->seekg(startOffset);
    if (size > 3 && (reader.readUInt24BE() == 1)) {
        size -= 3;
        uint32 buff1;
        while (size) {
            --size;
            switch (reader.readByte()) { // read start code
            case Mpeg4VideoCodes::VisualObjectSequenceStart:
                if (size) {
                    videoCfg->profile = reader.readByte();
                    --size;
                }
                break;
            case Mpeg4VideoCodes::VideoObjectLayerStart:

                break;
            case Mpeg4VideoCodes::UserDataStart:
                buff1 = 0;
                while (size >= 3) {
                    if ((buff1 = reader.readUInt24BE()) != 1) {
                        reader.stream()->seekg(-2, ios_base::cur);
                        videoCfg->userData.push_back(buff1 >> 16);
                        --size;
                    } else {
                        size -= 3;
                        break;
                    }
                }
                if (buff1 != 1 && size > 0) {
                    videoCfg->userData += reader.readString(size);
                    size = 0;
                }
                break;
            default:;
            }
            // skip remainging values to get the start of the next video object
            while (size >= 3) {
                if (reader.readUInt24BE() != 1) {
                    reader.stream()->seekg(-2, ios_base::cur);
                    --size;
                } else {
                    size -= 3;
                    break;
                }
            }
        }
    } else {
        diag.emplace_back(DiagLevel::Critical, "\"Visual Object Sequence Header\" not found.", context);
    }
    return videoCfg;
}

/*!
 * \brief Updates the chunk offsets of the track. This is necessary when the "mdat"-atom
 *        (which contains the actual chunk data) is moved.
 * \param oldMdatOffsets Specifies a vector holding the old offsets of the "mdat"-atoms.
 * \param newMdatOffsets Specifies a vector holding the new offsets of the "mdat"-atoms.
 *
 * \throws Throws InvalidDataException when
 *          - there is no stream assigned.
 *          - the header has been considered as invalid when parsing the header information.
 *          - \a oldMdatOffsets holds not the same number of offsets as \a newMdatOffsets.
 *          - there is no atom holding these offsets.
 *          - the ID of the atom holding these offsets is not "stco" or "co64"
 *
 * \throws Throws std::ios_base::failure when an IO error occurs.
 *
 * \remarks This method needs to be fixed.
 */
void Mp4Track::updateChunkOffsets(const vector<int64> &oldMdatOffsets, const vector<int64> &newMdatOffsets)
{
    if (!isHeaderValid() || !m_ostream || !m_istream || !m_stcoAtom) {
        throw InvalidDataException();
    }
    if (oldMdatOffsets.size() == 0 || oldMdatOffsets.size() != newMdatOffsets.size()) {
        throw InvalidDataException();
    }
    static const unsigned int stcoDataBegin = 8;
    uint64 startPos = m_stcoAtom->dataOffset() + stcoDataBegin;
    uint64 endPos = startPos + m_stcoAtom->dataSize() - stcoDataBegin;
    m_istream->seekg(startPos);
    m_ostream->seekp(startPos);
    vector<int64>::size_type i;
    vector<int64>::size_type size;
    uint64 currentPos = m_istream->tellg();
    switch (m_stcoAtom->id()) {
    case Mp4AtomIds::ChunkOffset: {
        uint32 off;
        while ((currentPos + 4) <= endPos) {
            off = m_reader.readUInt32BE();
            for (i = 0, size = oldMdatOffsets.size(); i < size; ++i) {
                if (off > static_cast<uint64>(oldMdatOffsets[i])) {
                    off += (newMdatOffsets[i] - oldMdatOffsets[i]);
                    break;
                }
            }
            m_ostream->seekp(currentPos);
            m_writer.writeUInt32BE(off);
            currentPos += m_istream->gcount();
        }
        break;
    }
    case Mp4AtomIds::ChunkOffset64: {
        uint64 off;
        while ((currentPos + 8) <= endPos) {
            off = m_reader.readUInt64BE();
            for (i = 0, size = oldMdatOffsets.size(); i < size; ++i) {
                if (off > static_cast<uint64>(oldMdatOffsets[i])) {
                    off += (newMdatOffsets[i] - oldMdatOffsets[i]);
                    break;
                }
            }
            m_ostream->seekp(currentPos);
            m_writer.writeUInt64BE(off);
            currentPos += m_istream->gcount();
        }
        break;
    }
    default:
        throw InvalidDataException();
    }
}

/*!
 * \brief Updates the chunk offsets of the track. This is necessary when the "mdat"-atom
 *        (which contains the actual chunk data) is moved.
 * \param chunkOffsets Specifies the new chunk offset table.
 *
 * \throws Throws InvalidDataException when
 *          - there is no stream assigned.
 *          - the header has been considered as invalid when parsing the header information.
 *          - the size of \a chunkOffsets does not match chunkCount().
 *          - there is no atom holding these offsets.
 *          - the ID of the atom holding these offsets is not "stco" or "co64".
 */
void Mp4Track::updateChunkOffsets(const std::vector<uint64> &chunkOffsets)
{
    if (!isHeaderValid() || !m_ostream || !m_istream || !m_stcoAtom) {
        throw InvalidDataException();
    }
    if (chunkOffsets.size() != chunkCount()) {
        throw InvalidDataException();
    }
    m_ostream->seekp(m_stcoAtom->dataOffset() + 8);
    switch (m_stcoAtom->id()) {
    case Mp4AtomIds::ChunkOffset:
        for (auto offset : chunkOffsets) {
            m_writer.writeUInt32BE(offset);
        }
        break;
    case Mp4AtomIds::ChunkOffset64:
        for (auto offset : chunkOffsets) {
            m_writer.writeUInt64BE(offset);
        }
    default:
        throw InvalidDataException();
    }
}

/*!
 * \brief Updates a particular chunk offset.
 * \param chunkIndex Specifies the index of the chunk offset to be updated.
 * \param offset Specifies the new chunk offset.
 * \remarks This method seems to be obsolete.
 * \throws Throws InvalidDataException when
 *          - there is no stream assigned.
 *          - the header has been considered as invalid when parsing the header information.
 *          - \a chunkIndex is not less than chunkCount().
 *          - there is no atom holding these offsets.
 *          - the ID of the atom holding these offsets is not "stco" or "co64".
 */
void Mp4Track::updateChunkOffset(uint32 chunkIndex, uint64 offset)
{
    if (!isHeaderValid() || !m_istream || !m_stcoAtom || chunkIndex >= m_chunkCount) {
        throw InvalidDataException();
    }
    m_ostream->seekp(m_stcoAtom->dataOffset() + 8 + chunkOffsetSize() * chunkIndex);
    switch (chunkOffsetSize()) {
    case 4:
        writer().writeUInt32BE(offset);
        break;
    case 8:
        writer().writeUInt64BE(offset);
        break;
    default:
        throw InvalidDataException();
    }
}

/*!
 * \brief Adds the information from the specified \a avcConfig to the specified \a track.
 */
void Mp4Track::addInfo(const AvcConfiguration &avcConfig, AbstractTrack &track)
{
    if (!avcConfig.spsInfos.empty()) {
        const SpsInfo &spsInfo = avcConfig.spsInfos.back();
        track.m_format.sub = spsInfo.profileIndication;
        track.m_version = static_cast<double>(spsInfo.levelIndication) / 10;
        track.m_cropping = spsInfo.cropping;
        track.m_pixelSize = spsInfo.pictureSize;
        switch (spsInfo.chromaFormatIndication) {
        case 0:
            track.m_chromaFormat = "monochrome";
            break;
        case 1:
            track.m_chromaFormat = "YUV 4:2:0";
            break;
        case 2:
            track.m_chromaFormat = "YUV 4:2:2";
            break;
        case 3:
            track.m_chromaFormat = "YUV 4:4:4";
            break;
        default:;
        }
        track.m_pixelAspectRatio = spsInfo.pixelAspectRatio;
    } else {
        track.m_format.sub = avcConfig.profileIndication;
        track.m_version = static_cast<double>(avcConfig.levelIndication) / 10;
    }
}

/*!
 * \brief Buffers all atoms required by the makeTrack() method.
 *
 * This allows to invoke makeTrack() also when the input stream is going to be
 * modified (eg. to apply changed tags without rewriting the file).
 */
void Mp4Track::bufferTrackAtoms(Diagnostics &diag)
{
    if (m_tkhdAtom) {
        m_tkhdAtom->makeBuffer();
    }
    if (Mp4Atom *trefAtom = m_trakAtom->childById(Mp4AtomIds::TrackReference, diag)) {
        trefAtom->makeBuffer();
    }
    if (Mp4Atom *edtsAtom = m_trakAtom->childById(Mp4AtomIds::Edit, diag)) {
        edtsAtom->makeBuffer();
    }
    if (m_minfAtom) {
        if (Mp4Atom *vmhdAtom = m_minfAtom->childById(Mp4AtomIds::VideoMediaHeader, diag)) {
            vmhdAtom->makeBuffer();
        }
        if (Mp4Atom *smhdAtom = m_minfAtom->childById(Mp4AtomIds::SoundMediaHeader, diag)) {
            smhdAtom->makeBuffer();
        }
        if (Mp4Atom *hmhdAtom = m_minfAtom->childById(Mp4AtomIds::HintMediaHeader, diag)) {
            hmhdAtom->makeBuffer();
        }
        if (Mp4Atom *nmhdAtom = m_minfAtom->childById(Mp4AtomIds::NullMediaHeaderBox, diag)) {
            nmhdAtom->makeBuffer();
        }
        if (Mp4Atom *dinfAtom = m_minfAtom->childById(Mp4AtomIds::DataInformation, diag)) {
            dinfAtom->makeBuffer();
        }
        if (Mp4Atom *stblAtom = m_minfAtom->childById(Mp4AtomIds::SampleTable, diag)) {
            stblAtom->makeBuffer();
        }
    }
}

/*!
 * \brief Returns the number of bytes written when calling makeTrack().
 */
uint64 Mp4Track::requiredSize(Diagnostics &diag) const
{
    // add size of
    // ... trak header
    uint64 size = 8;
    // ... tkhd atom (TODO: buffer TrackHeaderInfo in v7)
    size += verifyPresentTrackHeader().requiredSize;
    // ... tref atom (if one exists)
    if (Mp4Atom *trefAtom = m_trakAtom->childById(Mp4AtomIds::TrackReference, diag)) {
        size += trefAtom->totalSize();
    }
    // ... edts atom (if one exists)
    if (Mp4Atom *edtsAtom = m_trakAtom->childById(Mp4AtomIds::Edit, diag)) {
        size += edtsAtom->totalSize();
    }
    // ... mdia header + mdhd total size + hdlr total size + minf header
    size += 8 + 44 + (33 + m_name.size()) + 8;
    // ... minf childs
    bool dinfAtomWritten = false;
    if (m_minfAtom) {
        if (Mp4Atom *vmhdAtom = m_minfAtom->childById(Mp4AtomIds::VideoMediaHeader, diag)) {
            size += vmhdAtom->totalSize();
        }
        if (Mp4Atom *smhdAtom = m_minfAtom->childById(Mp4AtomIds::SoundMediaHeader, diag)) {
            size += smhdAtom->totalSize();
        }
        if (Mp4Atom *hmhdAtom = m_minfAtom->childById(Mp4AtomIds::HintMediaHeader, diag)) {
            size += hmhdAtom->totalSize();
        }
        if (Mp4Atom *nmhdAtom = m_minfAtom->childById(Mp4AtomIds::NullMediaHeaderBox, diag)) {
            size += nmhdAtom->totalSize();
        }
        if (Mp4Atom *dinfAtom = m_minfAtom->childById(Mp4AtomIds::DataInformation, diag)) {
            size += dinfAtom->totalSize();
            dinfAtomWritten = true;
        }
        if (Mp4Atom *stblAtom = m_minfAtom->childById(Mp4AtomIds::SampleTable, diag)) {
            size += stblAtom->totalSize();
        }
    }
    if (!dinfAtomWritten) {
        size += 36;
    }
    return size;
}

/*!
 * \brief Makes the track entry ("trak"-atom) for the track.
 *
 * The data is written to the assigned output stream at the current position. Note that this method
 * uses the assigned input stream to copy some parts from the source file. Hence the input stream must
 * still be valid when calling this method. To avoid this limitation call bufferTrackAtoms() before
 * invalidating the input stream.
 */
void Mp4Track::makeTrack(Diagnostics &diag)
{
    // write header
    ostream::pos_type trakStartOffset = outputStream().tellp();
    m_writer.writeUInt32BE(0); // write size later
    m_writer.writeUInt32BE(Mp4AtomIds::Track);
    // write tkhd atom
    makeTrackHeader(diag);
    // write tref atom (if one exists)
    if (Mp4Atom *trefAtom = trakAtom().childById(Mp4AtomIds::TrackReference, diag)) {
        trefAtom->copyPreferablyFromBuffer(outputStream(), diag, nullptr);
    }
    // write edts atom (if one exists)
    if (Mp4Atom *edtsAtom = trakAtom().childById(Mp4AtomIds::Edit, diag)) {
        edtsAtom->copyPreferablyFromBuffer(outputStream(), diag, nullptr);
    }
    // write mdia atom
    makeMedia(diag);
    // write size (of trak atom)
    Mp4Atom::seekBackAndWriteAtomSize(outputStream(), trakStartOffset, diag);
}

/*!
 * \brief Makes the track header (tkhd atom) for the track. The data is written to the assigned output stream
 *        at the current position.
 */
void Mp4Track::makeTrackHeader(Diagnostics &diag)
{
    // verify the existing track header to make the new one based on it (if possible)
    const TrackHeaderInfo info(verifyPresentTrackHeader());

    // add notifications in case the present track header could not be parsed
    if (info.versionUnknown) {
        diag.emplace_back(DiagLevel::Critical,
            argsToString("The version of the present \"tkhd\"-atom (", info.version, ") is unknown. Assuming version 1."),
            argsToString("making \"tkhd\"-atom of track ", m_id));
    }
    if (info.truncated) {
        diag.emplace_back(
            DiagLevel::Critical, argsToString("The present \"tkhd\"-atom is truncated."), argsToString("making \"tkhd\"-atom of track ", m_id));
    }

    // make size and element ID
    if (info.requiredSize > numeric_limits<uint32>::max()) {
        writer().writeUInt32BE(1);
        writer().writeUInt32BE(Mp4AtomIds::TrackHeader);
        writer().writeUInt64BE(info.requiredSize);
    } else {
        writer().writeUInt32BE(static_cast<uint32>(info.requiredSize));
        writer().writeUInt32BE(Mp4AtomIds::TrackHeader);
    }

    // make version and flags
    writer().writeByte(1);
    uint32 flags = 0;
    if (m_enabled) {
        flags |= 0x000001;
    }
    if (m_usedInPresentation) {
        flags |= 0x000002;
    }
    if (m_usedWhenPreviewing) {
        flags |= 0x000004;
    }
    writer().writeUInt24BE(flags);

    // make creation and modification time
    writer().writeUInt64BE(static_cast<uint64>((m_creationTime - startDate).totalSeconds()));
    writer().writeUInt64BE(static_cast<uint64>((m_modificationTime - startDate).totalSeconds()));

    // make track ID and duration
    writer().writeUInt32BE(static_cast<uint32>(m_id));
    writer().writeUInt32BE(0); // reserved
    writer().writeUInt64BE(static_cast<uint64>(m_duration.totalSeconds() * m_timeScale));
    writer().writeUInt32BE(0); // reserved
    writer().writeUInt32BE(0); // reserved

    // make further values, either from existing tkhd atom or just some defaults
    if (info.canUseExisting) {
        // write all bytes after the previously determined additionalDataOffset
        m_ostream->write(m_tkhdAtom->buffer().get() + m_tkhdAtom->headerSize() + info.additionalDataOffset,
            static_cast<streamoff>(m_tkhdAtom->dataSize() - info.additionalDataOffset));
        // discard the buffer again if it wasn't present before
        if (info.discardBuffer) {
            m_tkhdAtom->discardBuffer();
        }
    } else {
        // write default values
        writer().writeInt16BE(0); // layer
        writer().writeInt16BE(0); // alternate group
        writer().writeFixed8BE(1.0); // volume (fixed 8.8 - 2 byte)
        writer().writeUInt16BE(0); // reserved
        for (const int32 value : { 0x00010000, 0, 0, 0, 0x00010000, 0, 0, 0, 0x40000000 }) { // unity matrix
            writer().writeInt32BE(value);
        }
        writer().writeFixed16BE(1.0); // width
        writer().writeFixed16BE(1.0); // height
    }
}

/*!
 * \brief Makes the media information (mdia atom) for the track. The data is written to the assigned output stream
 *        at the current position.
 */
void Mp4Track::makeMedia(Diagnostics &diag)
{
    ostream::pos_type mdiaStartOffset = outputStream().tellp();
    writer().writeUInt32BE(0); // write size later
    writer().writeUInt32BE(Mp4AtomIds::Media);
    // write mdhd atom
    writer().writeUInt32BE(44); // size
    writer().writeUInt32BE(Mp4AtomIds::MediaHeader);
    writer().writeByte(1); // version
    writer().writeUInt24BE(0); // flags
    writer().writeUInt64BE(static_cast<uint64>((m_creationTime - startDate).totalSeconds()));
    writer().writeUInt64BE(static_cast<uint64>((m_modificationTime - startDate).totalSeconds()));
    writer().writeUInt32BE(m_timeScale);
    writer().writeUInt64BE(static_cast<uint64>(m_duration.totalSeconds() * m_timeScale));
    // convert and write language
    uint16 language = 0;
    for (size_t charIndex = 0; charIndex != 3; ++charIndex) {
        const char langChar = charIndex < m_language.size() ? m_language[charIndex] : 0;
        if (langChar >= 'a' && langChar <= 'z') {
            language |= static_cast<uint16>(langChar - 0x60) << (0xA - charIndex * 0x5);
        } else { // invalid character
            if (!m_language.empty()) {
                diag.emplace_back(
                    DiagLevel::Warning, "Assigned language \"" % m_language + "\" is of an invalid format and will be ignored.", "making mdhd atom");
            }
            language = 0x55C4; // und
            break;
        }
    }
    if (m_language.size() > 3) {
        diag.emplace_back(
            DiagLevel::Warning, "Assigned language \"" % m_language + "\" is longer than 3 byte and hence will be truncated.", "making mdhd atom");
    }
    writer().writeUInt16BE(language);
    writer().writeUInt16BE(0); // pre defined
    // write hdlr atom
    writer().writeUInt32BE(33 + m_name.size()); // size
    writer().writeUInt32BE(Mp4AtomIds::HandlerReference);
    writer().writeUInt64BE(0); // version, flags, pre defined
    switch (m_mediaType) {
    case MediaType::Video:
        outputStream().write("vide", 4);
        break;
    case MediaType::Audio:
        outputStream().write("soun", 4);
        break;
    case MediaType::Hint:
        outputStream().write("hint", 4);
        break;
    case MediaType::Text:
        outputStream().write("meta", 4);
        break;
    default:
        diag.emplace_back(DiagLevel::Critical, "Media type is invalid; The media type video is assumed.", "making hdlr atom");
        outputStream().write("vide", 4);
        break;
    }
    for (int i = 0; i < 3; ++i)
        writer().writeUInt32BE(0); // reserved
    writer().writeTerminatedString(m_name);
    // write minf atom
    makeMediaInfo(diag);
    // write size (of mdia atom)
    Mp4Atom::seekBackAndWriteAtomSize(outputStream(), mdiaStartOffset, diag);
}

/*!
 * \brief Makes a media information (minf atom) for the track. The data is written to the assigned output stream
 *        at the current position.
 */
void Mp4Track::makeMediaInfo(Diagnostics &diag)
{
    ostream::pos_type minfStartOffset = outputStream().tellp();
    writer().writeUInt32BE(0); // write size later
    writer().writeUInt32BE(Mp4AtomIds::MediaInformation);
    bool dinfAtomWritten = false;
    if (m_minfAtom) {
        // copy existing vmhd atom
        if (Mp4Atom *vmhdAtom = m_minfAtom->childById(Mp4AtomIds::VideoMediaHeader, diag)) {
            vmhdAtom->copyPreferablyFromBuffer(outputStream(), diag, nullptr);
        }
        // copy existing smhd atom
        if (Mp4Atom *smhdAtom = m_minfAtom->childById(Mp4AtomIds::SoundMediaHeader, diag)) {
            smhdAtom->copyPreferablyFromBuffer(outputStream(), diag, nullptr);
        }
        // copy existing hmhd atom
        if (Mp4Atom *hmhdAtom = m_minfAtom->childById(Mp4AtomIds::HintMediaHeader, diag)) {
            hmhdAtom->copyPreferablyFromBuffer(outputStream(), diag, nullptr);
        }
        // copy existing nmhd atom
        if (Mp4Atom *nmhdAtom = m_minfAtom->childById(Mp4AtomIds::NullMediaHeaderBox, diag)) {
            nmhdAtom->copyPreferablyFromBuffer(outputStream(), diag, nullptr);
        }
        // copy existing dinf atom
        if (Mp4Atom *dinfAtom = m_minfAtom->childById(Mp4AtomIds::DataInformation, diag)) {
            dinfAtom->copyPreferablyFromBuffer(outputStream(), diag, nullptr);
            dinfAtomWritten = true;
        }
    }
    // write dinf atom if not written yet
    if (!dinfAtomWritten) {
        writer().writeUInt32BE(36); // size
        writer().writeUInt32BE(Mp4AtomIds::DataInformation);
        // write dref atom
        writer().writeUInt32BE(28); // size
        writer().writeUInt32BE(Mp4AtomIds::DataReference);
        writer().writeUInt32BE(0); // version and flags
        writer().writeUInt32BE(1); // entry count
        // write url  atom
        writer().writeUInt32BE(12); // size
        writer().writeUInt32BE(Mp4AtomIds::DataEntryUrl);
        writer().writeByte(0); // version
        writer().writeUInt24BE(0x000001); // flags (media data is in the same file as the movie box)
    }
    // write stbl atom
    // -> just copy existing stbl atom because makeSampleTable() is not fully implemented (yet)
    bool stblAtomWritten = false;
    if (m_minfAtom) {
        if (Mp4Atom *stblAtom = m_minfAtom->childById(Mp4AtomIds::SampleTable, diag)) {
            stblAtom->copyPreferablyFromBuffer(outputStream(), diag, nullptr);
            stblAtomWritten = true;
        }
    }
    if (!stblAtomWritten) {
        diag.emplace_back(DiagLevel::Critical,
            "Source track does not contain mandatory stbl atom and the tagparser lib is unable to make one from scratch.", "making stbl atom");
    }
    // write size (of minf atom)
    Mp4Atom::seekBackAndWriteAtomSize(outputStream(), minfStartOffset, diag);
}

/*!
 * \brief Makes the sample table (stbl atom) for the track. The data is written to the assigned output stream
 *        at the current position.
 * \remarks Not fully implemented yet.
 */
void Mp4Track::makeSampleTable(Diagnostics &diag)
{
    ostream::pos_type stblStartOffset = outputStream().tellp();
    writer().writeUInt32BE(0); // write size later
    writer().writeUInt32BE(Mp4AtomIds::SampleTable);
    Mp4Atom *stblAtom = m_minfAtom ? m_minfAtom->childById(Mp4AtomIds::SampleTable, diag) : nullptr;
    // write stsd atom
    if (m_stsdAtom) {
        // copy existing stsd atom
        m_stsdAtom->copyEntirely(outputStream(), diag, nullptr);
    } else {
        diag.emplace_back(DiagLevel::Critical, "Unable to make stsd atom from scratch.", "making stsd atom");
        throw NotImplementedException();
    }
    // write stts and ctts atoms
    Mp4Atom *sttsAtom = stblAtom ? stblAtom->childById(Mp4AtomIds::DecodingTimeToSample, diag) : nullptr;
    if (sttsAtom) {
        // copy existing stts atom
        sttsAtom->copyEntirely(outputStream(), diag, nullptr);
    } else {
        diag.emplace_back(DiagLevel::Critical, "Unable to make stts atom from scratch.", "making stts atom");
        throw NotImplementedException();
    }
    Mp4Atom *cttsAtom = stblAtom ? stblAtom->childById(Mp4AtomIds::CompositionTimeToSample, diag) : nullptr;
    if (cttsAtom) {
        // copy existing ctts atom
        cttsAtom->copyEntirely(outputStream(), diag, nullptr);
    }
    // write stsc atom (sample-to-chunk table)
    throw NotImplementedException();

    // write stsz atom (sample sizes)

    // write stz2 atom (compact sample sizes)

    // write stco/co64 atom (chunk offset table)

    // write stss atom (sync sample table)

    // write stsh atom (shadow sync sample table)

    // write padb atom (sample padding bits)

    // write stdp atom (sample degradation priority)

    // write sdtp atom (independent and disposable samples)

    // write sbgp atom (sample group description)

    // write sbgp atom (sample-to-group)

    // write sgpd atom (sample group description)

    // write subs atom (sub-sample information)

    // write size (of stbl atom)
    Mp4Atom::seekBackAndWriteAtomSize(outputStream(), stblStartOffset, diag);
}

void Mp4Track::internalParseHeader(Diagnostics &diag)
{
    static const string context("parsing MP4 track");
    using namespace Mp4AtomIds;
    if (!m_trakAtom) {
        diag.emplace_back(DiagLevel::Critical, "\"trak\"-atom is null.", context);
        throw InvalidDataException();
    }

    // get atoms
    try {
        if (!(m_tkhdAtom = m_trakAtom->childById(TrackHeader, diag))) {
            diag.emplace_back(DiagLevel::Critical, "No \"tkhd\"-atom found.", context);
            throw InvalidDataException();
        }
        if (!(m_mdiaAtom = m_trakAtom->childById(Media, diag))) {
            diag.emplace_back(DiagLevel::Critical, "No \"mdia\"-atom found.", context);
            throw InvalidDataException();
        }
        if (!(m_mdhdAtom = m_mdiaAtom->childById(MediaHeader, diag))) {
            diag.emplace_back(DiagLevel::Critical, "No \"mdhd\"-atom found.", context);
            throw InvalidDataException();
        }
        if (!(m_hdlrAtom = m_mdiaAtom->childById(HandlerReference, diag))) {
            diag.emplace_back(DiagLevel::Critical, "No \"hdlr\"-atom found.", context);
            throw InvalidDataException();
        }
        if (!(m_minfAtom = m_mdiaAtom->childById(MediaInformation, diag))) {
            diag.emplace_back(DiagLevel::Critical, "No \"minf\"-atom found.", context);
            throw InvalidDataException();
        }
        if (!(m_stblAtom = m_minfAtom->childById(SampleTable, diag))) {
            diag.emplace_back(DiagLevel::Critical, "No \"stbl\"-atom found.", context);
            throw InvalidDataException();
        }
        if (!(m_stsdAtom = m_stblAtom->childById(SampleDescription, diag))) {
            diag.emplace_back(DiagLevel::Critical, "No \"stsd\"-atom found.", context);
            throw InvalidDataException();
        }
        if (!(m_stcoAtom = m_stblAtom->childById(ChunkOffset, diag)) && !(m_stcoAtom = m_stblAtom->childById(ChunkOffset64, diag))) {
            diag.emplace_back(DiagLevel::Critical, "No \"stco\"/\"co64\"-atom found.", context);
            throw InvalidDataException();
        }
        if (!(m_stscAtom = m_stblAtom->childById(SampleToChunk, diag))) {
            diag.emplace_back(DiagLevel::Critical, "No \"stsc\"-atom found.", context);
            throw InvalidDataException();
        }
        if (!(m_stszAtom = m_stblAtom->childById(SampleSize, diag)) && !(m_stszAtom = m_stblAtom->childById(CompactSampleSize, diag))) {
            diag.emplace_back(DiagLevel::Critical, "No \"stsz\"/\"stz2\"-atom found.", context);
            throw InvalidDataException();
        }
    } catch (const Failure &) {
        diag.emplace_back(DiagLevel::Critical, "Unable to parse relevant atoms.", context);
        throw InvalidDataException();
    }

    BinaryReader &reader = m_trakAtom->reader();

    // read tkhd atom
    m_istream->seekg(m_tkhdAtom->startOffset() + 8); // seek to beg, skip size and name
    byte atomVersion = reader.readByte(); // read version
    uint32 flags = reader.readUInt24BE();
    m_enabled = flags & 0x000001;
    m_usedInPresentation = flags & 0x000002;
    m_usedWhenPreviewing = flags & 0x000004;
    switch (atomVersion) {
    case 0:
        m_creationTime = startDate + TimeSpan::fromSeconds(reader.readUInt32BE());
        m_modificationTime = startDate + TimeSpan::fromSeconds(reader.readUInt32BE());
        m_id = reader.readUInt32BE();
        break;
    case 1:
        m_creationTime = startDate + TimeSpan::fromSeconds(reader.readUInt64BE());
        m_modificationTime = startDate + TimeSpan::fromSeconds(reader.readUInt64BE());
        m_id = reader.readUInt32BE();
        break;
    default:
        diag.emplace_back(DiagLevel::Critical,
            "Version of \"tkhd\"-atom not supported. It will be ignored. Track ID, creation time and modification time might not be be determined.",
            context);
        m_creationTime = DateTime();
        m_modificationTime = DateTime();
        m_id = 0;
    }

    // read mdhd atom
    m_istream->seekg(m_mdhdAtom->dataOffset()); // seek to beg, skip size and name
    atomVersion = reader.readByte(); // read version
    m_istream->seekg(3, ios_base::cur); // skip flags
    switch (atomVersion) {
    case 0:
        m_creationTime = startDate + TimeSpan::fromSeconds(reader.readUInt32BE());
        m_modificationTime = startDate + TimeSpan::fromSeconds(reader.readUInt32BE());
        m_timeScale = reader.readUInt32BE();
        m_duration = TimeSpan::fromSeconds(static_cast<double>(reader.readUInt32BE()) / static_cast<double>(m_timeScale));
        break;
    case 1:
        m_creationTime = startDate + TimeSpan::fromSeconds(reader.readUInt64BE());
        m_modificationTime = startDate + TimeSpan::fromSeconds(reader.readUInt64BE());
        m_timeScale = reader.readUInt32BE();
        m_duration = TimeSpan::fromSeconds(static_cast<double>(reader.readUInt64BE()) / static_cast<double>(m_timeScale));
        break;
    default:
        diag.emplace_back(DiagLevel::Warning,
            "Version of \"mdhd\"-atom not supported. It will be ignored. Creation time, modification time, time scale and duration might not be "
            "determined.",
            context);
        m_timeScale = 0;
        m_duration = TimeSpan();
    }
    uint16 tmp = reader.readUInt16BE();
    if (tmp) {
        const char buff[] = {
            static_cast<char>(((tmp & 0x7C00) >> 0xA) + 0x60),
            static_cast<char>(((tmp & 0x03E0) >> 0x5) + 0x60),
            static_cast<char>(((tmp & 0x001F) >> 0x0) + 0x60),
        };
        m_language = string(buff, 3);
    } else {
        m_language.clear();
    }

    // read hdlr atom
    // -> seek to begin skipping size, name, version, flags and reserved bytes
    m_istream->seekg(m_hdlrAtom->dataOffset() + 8);
    // -> track type
    switch (reader.readUInt32BE()) {
    case 0x76696465:
        m_mediaType = MediaType::Video;
        break;
    case 0x736F756E:
        m_mediaType = MediaType::Audio;
        break;
    case 0x68696E74:
        m_mediaType = MediaType::Hint;
        break;
    case 0x6D657461:
    case 0x74657874:
        m_mediaType = MediaType::Text;
        break;
    default:
        m_mediaType = MediaType::Unknown;
    }
    // -> name
    m_istream->seekg(12, ios_base::cur); // skip reserved bytes
    if ((tmp = m_istream->peek()) == m_hdlrAtom->dataSize() - 12 - 4 - 8 - 1) {
        // assume size prefixed string (seems to appear in QuickTime files)
        m_istream->seekg(1, ios_base::cur);
        m_name = reader.readString(tmp);
    } else {
        // assume null terminated string (appears in MP4 files)
        m_name = reader.readTerminatedString(m_hdlrAtom->dataSize() - 12 - 4 - 8, 0);
    }

    // read stco atom (only chunk count)
    m_chunkOffsetSize = (m_stcoAtom->id() == Mp4AtomIds::ChunkOffset64) ? 8 : 4;
    m_istream->seekg(m_stcoAtom->dataOffset() + 4);
    m_chunkCount = reader.readUInt32BE();

    // read stsd atom
    m_istream->seekg(m_stsdAtom->dataOffset() + 4); // seek to beg, skip size, name, version and flags
    uint32 entryCount = reader.readUInt32BE();
    Mp4Atom *esDescParentAtom = nullptr;
    if (entryCount) {
        try {
            for (Mp4Atom *codecConfigContainerAtom = m_stsdAtom->firstChild(); codecConfigContainerAtom;
                 codecConfigContainerAtom = codecConfigContainerAtom->nextSibling()) {
                codecConfigContainerAtom->parse(diag);
                // parse FOURCC
                m_formatId = interpretIntegerAsString<uint32>(codecConfigContainerAtom->id());
                m_format = FourccIds::fourccToMediaFormat(codecConfigContainerAtom->id());
                // parse codecConfigContainerAtom
                m_istream->seekg(codecConfigContainerAtom->dataOffset());
                switch (codecConfigContainerAtom->id()) {
                case FourccIds::Mpeg4Audio:
                case FourccIds::AmrNarrowband:
                case FourccIds::Amr:
                case FourccIds::Drms:
                case FourccIds::Alac:
                case FourccIds::WindowsMediaAudio:
                case FourccIds::Ac3:
                case FourccIds::EAc3:
                case FourccIds::DolbyMpl:
                case FourccIds::Dts:
                case FourccIds::DtsH:
                case FourccIds::DtsE:
                    m_istream->seekg(6 + 2, ios_base::cur); // skip reserved bytes, data reference index
                    tmp = reader.readUInt16BE(); // read sound version
                    m_istream->seekg(6, ios_base::cur);
                    m_channelCount = reader.readUInt16BE();
                    m_bitsPerSample = reader.readUInt16BE();
                    m_istream->seekg(4, ios_base::cur); // skip reserved bytes (again)
                    if (!m_samplingFrequency) {
                        m_samplingFrequency = reader.readUInt32BE() >> 16;
                        if (codecConfigContainerAtom->id() != FourccIds::DolbyMpl) {
                            m_samplingFrequency >>= 16;
                        }
                    } else {
                        m_istream->seekg(4, ios_base::cur);
                    }
                    if (codecConfigContainerAtom->id() != FourccIds::WindowsMediaAudio) {
                        switch (tmp) {
                        case 1:
                            codecConfigContainerAtom->denoteFirstChild(codecConfigContainerAtom->headerSize() + 28 + 16);
                            break;
                        case 2:
                            codecConfigContainerAtom->denoteFirstChild(codecConfigContainerAtom->headerSize() + 28 + 32);
                            break;
                        default:
                            codecConfigContainerAtom->denoteFirstChild(codecConfigContainerAtom->headerSize() + 28);
                        }
                        if (!esDescParentAtom) {
                            esDescParentAtom = codecConfigContainerAtom;
                        }
                    }
                    break;
                case FourccIds::Mpeg4Video:
                case FourccIds::H263Quicktime:
                case FourccIds::H2633GPP:
                case FourccIds::Avc1:
                case FourccIds::Avc2:
                case FourccIds::Avc3:
                case FourccIds::Avc4:
                case FourccIds::Drmi:
                case FourccIds::Hevc1:
                case FourccIds::Hevc2:
                    m_istream->seekg(6 + 2 + 16, ios_base::cur); // skip reserved bytes, data reference index, and reserved bytes (again)
                    m_pixelSize.setWidth(reader.readUInt16BE());
                    m_pixelSize.setHeight(reader.readUInt16BE());
                    m_resolution.setWidth(static_cast<uint32>(reader.readFixed16BE()));
                    m_resolution.setHeight(static_cast<uint32>(reader.readFixed16BE()));
                    m_istream->seekg(4, ios_base::cur); // skip reserved bytes
                    m_framesPerSample = reader.readUInt16BE();
                    tmp = reader.readByte();
                    m_compressorName = reader.readString(31);
                    if (tmp == 0) {
                        m_compressorName.clear();
                    } else if (tmp < 32) {
                        m_compressorName.resize(tmp);
                    }
                    m_depth = reader.readUInt16BE(); // 24: color without alpha
                    codecConfigContainerAtom->denoteFirstChild(codecConfigContainerAtom->headerSize() + 78);
                    if (!esDescParentAtom) {
                        esDescParentAtom = codecConfigContainerAtom;
                    }
                    break;
                case FourccIds::Mpeg4Sample:
                    // skip reserved bytes and data reference index
                    codecConfigContainerAtom->denoteFirstChild(codecConfigContainerAtom->headerSize() + 8);
                    if (!esDescParentAtom) {
                        esDescParentAtom = codecConfigContainerAtom;
                    }
                    break;
                case Mp4AtomIds::PixalAspectRatio:
                    break; // TODO
                case Mp4AtomIds::CleanAperature:
                    break; // TODO
                default:;
                }
            }

            if (esDescParentAtom) {
                // parse AVC configuration
                if (Mp4Atom *avcConfigAtom = esDescParentAtom->childById(Mp4AtomIds::AvcConfiguration, diag)) {
                    m_istream->seekg(avcConfigAtom->dataOffset());
                    m_avcConfig = make_unique<TagParser::AvcConfiguration>();
                    try {
                        m_avcConfig->parse(reader, avcConfigAtom->dataSize());
                        addInfo(*m_avcConfig, *this);
                    } catch (const TruncatedDataException &) {
                        diag.emplace_back(DiagLevel::Critical, "AVC configuration is truncated.", context);
                    } catch (const Failure &) {
                        diag.emplace_back(DiagLevel::Critical, "AVC configuration is invalid.", context);
                    }
                }

                // parse MPEG-4 elementary stream descriptor
                Mp4Atom *esDescAtom = esDescParentAtom->childById(Mp4FormatExtensionIds::Mpeg4ElementaryStreamDescriptor, diag);
                if (!esDescAtom) {
                    esDescAtom = esDescParentAtom->childById(Mp4FormatExtensionIds::Mpeg4ElementaryStreamDescriptor2, diag);
                }
                if (esDescAtom) {
                    try {
                        if ((m_esInfo = parseMpeg4ElementaryStreamInfo(m_reader, esDescAtom, diag))) {
                            m_format += Mpeg4ElementaryStreamObjectIds::streamObjectTypeFormat(m_esInfo->objectTypeId);
                            m_bitrate = static_cast<double>(m_esInfo->averageBitrate) / 1000;
                            m_maxBitrate = static_cast<double>(m_esInfo->maxBitrate) / 1000;
                            if (m_esInfo->audioSpecificConfig) {
                                // check the audio specific config for useful information
                                m_format += Mpeg4AudioObjectIds::idToMediaFormat(m_esInfo->audioSpecificConfig->audioObjectType,
                                    m_esInfo->audioSpecificConfig->sbrPresent, m_esInfo->audioSpecificConfig->psPresent);
                                if (m_esInfo->audioSpecificConfig->sampleFrequencyIndex == 0xF) {
                                    m_samplingFrequency = m_esInfo->audioSpecificConfig->sampleFrequency;
                                } else if (m_esInfo->audioSpecificConfig->sampleFrequencyIndex < sizeof(mpeg4SamplingFrequencyTable)) {
                                    m_samplingFrequency = mpeg4SamplingFrequencyTable[m_esInfo->audioSpecificConfig->sampleFrequencyIndex];
                                } else {
                                    diag.emplace_back(DiagLevel::Warning, "Audio specific config has invalid sample frequency index.", context);
                                }
                                if (m_esInfo->audioSpecificConfig->extensionSampleFrequencyIndex == 0xF) {
                                    m_extensionSamplingFrequency = m_esInfo->audioSpecificConfig->extensionSampleFrequency;
                                } else if (m_esInfo->audioSpecificConfig->extensionSampleFrequencyIndex < sizeof(mpeg4SamplingFrequencyTable)) {
                                    m_extensionSamplingFrequency
                                        = mpeg4SamplingFrequencyTable[m_esInfo->audioSpecificConfig->extensionSampleFrequencyIndex];
                                } else {
                                    diag.emplace_back(
                                        DiagLevel::Warning, "Audio specific config has invalid extension sample frequency index.", context);
                                }
                                m_channelConfig = m_esInfo->audioSpecificConfig->channelConfiguration;
                                m_extensionChannelConfig = m_esInfo->audioSpecificConfig->extensionChannelConfiguration;
                            }
                            if (m_esInfo->videoSpecificConfig) {
                                // check the video specific config for useful information
                                if (m_format.general == GeneralMediaFormat::Mpeg4Video && m_esInfo->videoSpecificConfig->profile) {
                                    m_format.sub = m_esInfo->videoSpecificConfig->profile;
                                    if (!m_esInfo->videoSpecificConfig->userData.empty()) {
                                        m_formatId += " / ";
                                        m_formatId += m_esInfo->videoSpecificConfig->userData;
                                    }
                                }
                            }
                            // check the stream data for missing information
                            switch (m_format.general) {
                            case GeneralMediaFormat::Mpeg1Audio:
                            case GeneralMediaFormat::Mpeg2Audio: {
                                MpegAudioFrame frame;
                                m_istream->seekg(m_stcoAtom->dataOffset() + 8);
                                m_istream->seekg(m_chunkOffsetSize == 8 ? reader.readUInt64BE() : reader.readUInt32BE());
                                frame.parseHeader(reader);
                                MpegAudioFrameStream::addInfo(frame, *this);
                                break;
                            }
                            default:;
                            }
                        }
                    } catch (const Failure &) {
                    }
                }
            }
        } catch (const Failure &) {
            diag.emplace_back(DiagLevel::Critical, "Unable to parse child atoms of \"stsd\"-atom.", context);
        }
    }

    // read stsz atom which holds the sample size table
    m_sampleSizes.clear();
    m_size = m_sampleCount = 0;
    uint64 actualSampleSizeTableSize = m_stszAtom->dataSize();
    if (actualSampleSizeTableSize < 12) {
        diag.emplace_back(DiagLevel::Critical,
            "The stsz atom is truncated. There are no sample sizes present. The size of the track can not be determined.", context);
    } else {
        actualSampleSizeTableSize -= 12; // subtract size of version and flags
        m_istream->seekg(m_stszAtom->dataOffset() + 4); // seek to beg, skip size, name, version and flags
        uint32 fieldSize;
        uint32 constantSize;
        if (m_stszAtom->id() == Mp4AtomIds::CompactSampleSize) {
            constantSize = 0;
            m_istream->seekg(3, ios_base::cur); // seek reserved bytes
            fieldSize = reader.readByte();
            m_sampleCount = reader.readUInt32BE();
        } else {
            constantSize = reader.readUInt32BE();
            m_sampleCount = reader.readUInt32BE();
            fieldSize = 32;
        }
        if (constantSize) {
            m_sampleSizes.push_back(constantSize);
            m_size = constantSize * m_sampleCount;
        } else {
            uint64 actualSampleCount = m_sampleCount;
            uint64 calculatedSampleSizeTableSize = ceil((0.125 * fieldSize) * m_sampleCount);
            if (calculatedSampleSizeTableSize < actualSampleSizeTableSize) {
                diag.emplace_back(
                    DiagLevel::Critical, "The stsz atom stores more entries as denoted. The additional entries will be ignored.", context);
            } else if (calculatedSampleSizeTableSize > actualSampleSizeTableSize) {
                diag.emplace_back(DiagLevel::Critical, "The stsz atom is truncated. It stores less entries as denoted.", context);
                actualSampleCount = floor(static_cast<double>(actualSampleSizeTableSize) / (0.125 * fieldSize));
            }
            m_sampleSizes.reserve(actualSampleCount);
            uint32 i = 1;
            switch (fieldSize) {
            case 4:
                for (; i <= actualSampleCount; i += 2) {
                    byte val = reader.readByte();
                    m_sampleSizes.push_back(val >> 4);
                    m_sampleSizes.push_back(val & 0xF0);
                    m_size += (val >> 4) + (val & 0xF0);
                }
                if (i <= actualSampleCount + 1) {
                    m_sampleSizes.push_back(reader.readByte() >> 4);
                    m_size += m_sampleSizes.back();
                }
                break;
            case 8:
                for (; i <= actualSampleCount; ++i) {
                    m_sampleSizes.push_back(reader.readByte());
                    m_size += m_sampleSizes.back();
                }
                break;
            case 16:
                for (; i <= actualSampleCount; ++i) {
                    m_sampleSizes.push_back(reader.readUInt16BE());
                    m_size += m_sampleSizes.back();
                }
                break;
            case 32:
                for (; i <= actualSampleCount; ++i) {
                    m_sampleSizes.push_back(reader.readUInt32BE());
                    m_size += m_sampleSizes.back();
                }
                break;
            default:
                diag.emplace_back(DiagLevel::Critical,
                    "The fieldsize used to store the sample sizes is not supported. The sample count and size of the track can not be determined.",
                    context);
            }
        }
    }

    // no sample sizes found, search for trun atoms
    uint64 totalDuration = 0;
    for (Mp4Atom *moofAtom = m_trakAtom->container().firstElement()->siblingByIdIncludingThis(MovieFragment, diag); moofAtom;
         moofAtom = moofAtom->siblingById(MovieFragment, diag)) {
        moofAtom->parse(diag);
        for (Mp4Atom *trafAtom = moofAtom->childById(TrackFragment, diag); trafAtom; trafAtom = trafAtom->siblingById(TrackFragment, diag)) {
            trafAtom->parse(diag);
            for (Mp4Atom *tfhdAtom = trafAtom->childById(TrackFragmentHeader, diag); tfhdAtom;
                 tfhdAtom = tfhdAtom->siblingById(TrackFragmentHeader, diag)) {
                tfhdAtom->parse(diag);
                uint32 calculatedDataSize = 0;
                if (tfhdAtom->dataSize() < calculatedDataSize) {
                    diag.emplace_back(DiagLevel::Critical, "tfhd atom is truncated.", context);
                } else {
                    m_istream->seekg(tfhdAtom->dataOffset() + 1);
                    uint32 flags = reader.readUInt24BE();
                    if (m_id == reader.readUInt32BE()) { // check track ID
                        if (flags & 0x000001) { // base-data-offset present
                            calculatedDataSize += 8;
                        }
                        if (flags & 0x000002) { // sample-description-index present
                            calculatedDataSize += 4;
                        }
                        if (flags & 0x000008) { // default-sample-duration present
                            calculatedDataSize += 4;
                        }
                        if (flags & 0x000010) { // default-sample-size present
                            calculatedDataSize += 4;
                        }
                        if (flags & 0x000020) { // default-sample-flags present
                            calculatedDataSize += 4;
                        }
                        //uint64 baseDataOffset = moofAtom->startOffset();
                        //uint32 defaultSampleDescriptionIndex = 0;
                        uint32 defaultSampleDuration = 0;
                        uint32 defaultSampleSize = 0;
                        //uint32 defaultSampleFlags = 0;
                        if (tfhdAtom->dataSize() < calculatedDataSize) {
                            diag.emplace_back(DiagLevel::Critical, "tfhd atom is truncated (presence of fields denoted).", context);
                        } else {
                            if (flags & 0x000001) { // base-data-offset present
                                //baseDataOffset = reader.readUInt64();
                                m_istream->seekg(8, ios_base::cur);
                            }
                            if (flags & 0x000002) { // sample-description-index present
                                //defaultSampleDescriptionIndex = reader.readUInt32();
                                m_istream->seekg(4, ios_base::cur);
                            }
                            if (flags & 0x000008) { // default-sample-duration present
                                defaultSampleDuration = reader.readUInt32BE();
                                //m_istream->seekg(4, ios_base::cur);
                            }
                            if (flags & 0x000010) { // default-sample-size present
                                defaultSampleSize = reader.readUInt32BE();
                            }
                            if (flags & 0x000020) { // default-sample-flags present
                                //defaultSampleFlags = reader.readUInt32BE();
                                m_istream->seekg(4, ios_base::cur);
                            }
                        }
                        for (Mp4Atom *trunAtom = trafAtom->childById(TrackFragmentRun, diag); trunAtom;
                             trunAtom = trunAtom->siblingById(TrackFragmentRun, diag)) {
                            uint32 calculatedDataSize = 8;
                            if (trunAtom->dataSize() < calculatedDataSize) {
                                diag.emplace_back(DiagLevel::Critical, "trun atom is truncated.", context);
                            } else {
                                m_istream->seekg(trunAtom->dataOffset() + 1);
                                uint32 flags = reader.readUInt24BE();
                                uint32 sampleCount = reader.readUInt32BE();
                                m_sampleCount += sampleCount;
                                if (flags & 0x000001) { // data offset present
                                    calculatedDataSize += 4;
                                }
                                if (flags & 0x000004) { // first-sample-flags present
                                    calculatedDataSize += 4;
                                }
                                uint32 entrySize = 0;
                                if (flags & 0x000100) { // sample-duration present
                                    entrySize += 4;
                                }
                                if (flags & 0x000200) { // sample-size present
                                    entrySize += 4;
                                }
                                if (flags & 0x000400) { // sample-flags present
                                    entrySize += 4;
                                }
                                if (flags & 0x000800) { // sample-composition-time-offsets present
                                    entrySize += 4;
                                }
                                calculatedDataSize += entrySize * sampleCount;
                                if (trunAtom->dataSize() < calculatedDataSize) {
                                    diag.emplace_back(DiagLevel::Critical, "trun atom is truncated (presence of fields denoted).", context);
                                } else {
                                    if (flags & 0x000001) { // data offset present
                                        m_istream->seekg(4, ios_base::cur);
                                        //int32 dataOffset = reader.readInt32();
                                    }
                                    if (flags & 0x000004) { // first-sample-flags present
                                        m_istream->seekg(4, ios_base::cur);
                                    }
                                    for (uint32 i = 0; i < sampleCount; ++i) {
                                        if (flags & 0x000100) { // sample-duration present
                                            totalDuration += reader.readUInt32BE();
                                        } else {
                                            totalDuration += defaultSampleDuration;
                                        }
                                        if (flags & 0x000200) { // sample-size present
                                            m_sampleSizes.push_back(reader.readUInt32BE());
                                            m_size += m_sampleSizes.back();
                                        } else {
                                            m_size += defaultSampleSize;
                                        }
                                        if (flags & 0x000400) { // sample-flags present
                                            m_istream->seekg(4, ios_base::cur);
                                        }
                                        if (flags & 0x000800) { // sample-composition-time-offsets present
                                            m_istream->seekg(4, ios_base::cur);
                                        }
                                    }
                                }
                            }
                        }
                        if (m_sampleSizes.empty() && defaultSampleSize) {
                            m_sampleSizes.push_back(defaultSampleSize);
                        }
                    }
                }
            }
        }
    }

    // set duration from "trun-information" if the duration has not been determined yet
    if (m_duration.isNull() && totalDuration) {
        uint32 timeScale = m_timeScale;
        if (!timeScale) {
            timeScale = trakAtom().container().timeScale();
        }
        if (timeScale) {
            m_duration = TimeSpan::fromSeconds(static_cast<double>(totalDuration) / static_cast<double>(timeScale));
        }
    }

    // caluculate average bitrate
    if (m_bitrate < 0.01 && m_bitrate > -0.01) {
        m_bitrate = (static_cast<double>(m_size) * 0.0078125) / m_duration.totalSeconds();
    }

    // read stsc atom (only number of entries)
    m_istream->seekg(m_stscAtom->dataOffset() + 4);
    m_sampleToChunkEntryCount = reader.readUInt32BE();
}

} // namespace TagParser