jernoble/CodedFrameProcessing.cpp

## CodedFrameProcessing.cpp
/* Copyright (c) 2014 Jer Noble
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in
 * all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 * THE SOFTWARE.
 */

#include <algorithm>
#include <cmath>
#include <iostream>
#include <limits>
#include <map>
#include <stdio.h>
#include <vector>

using namespace std;

static double unset()
{
    return numeric_limits<double>::quiet_NaN();
}

static bool isSet(const double& value)
{
    return !isnan(value);
}

static bool isUnset(const double& value)
{
    return isnan(value);
}


class CodedFrame {
public:
    CodedFrame(double presentationTimestamp, double decodeTimestamp, double duration, bool isRandomAccess, unsigned generation)
        : presentationTimestamp(presentationTimestamp)
        , decodeTimestamp(decodeTimestamp)
        , duration(duration)
        , isRandomAccess(isRandomAccess)
        , generation(generation)
    {
    }

    double presentationTimestamp;
    double decodeTimestamp;
    double duration;
    bool isRandomAccess;
    unsigned generation;
};

typedef multimap<double, CodedFrame> CodedFrameMap;

static bool codedFrameIsRandomAccess(CodedFrameMap::value_type pair)
{
    return pair.second.isRandomAccess;
}

class TrackBuffer {
public:
    TrackBuffer()
        : lastDecodeTimestamp(unset())
        , lastFrameDuration(unset())
        , highestPresentationTimestamp(unset())
        , needsRandomAccessFlag(true)
    {
    }

    double lastDecodeTimestamp;
    double lastFrameDuration;
    double highestPresentationTimestamp;
    double needsRandomAccessFlag;
    CodedFrameMap codedFrames; // in decode order
};

class SourceBuffer {
public:
    SourceBuffer()
        : presentationStartTime(0)
    {
    }

    enum ErrorCode { NoError, NetworkError, DecodeError };
    ErrorCode processCodedFrames(vector<CodedFrame> codedFrames);

    TrackBuffer trackBuffer;
    double presentationStartTime;
};

SourceBuffer::ErrorCode SourceBuffer::processCodedFrames(vector<CodedFrame> codedFrames)
{
    // When complete coded frames have been parsed by the segment parser loop then the following steps are run:

    // 1. For each coded frame in the media segment run the following steps:
    for (auto& codedFrame : codedFrames) {
        // 1. Loop top:
        loopTop:
        //   ↳ If generate timestamps flag equals true:
        //     1. Let presentation timestamp equal 0.
        //     2. Let decode timestamp equal 0.
        //     No-op.

        //   ↳ Otherwise:
        //     1. Let presentation timestamp be a double precision floating point representation
        //        of the coded frame's presentation timestamp in seconds.
        double presentationTimestamp = codedFrame.presentationTimestamp;
        //     2. Let decode timestamp be a double precision floating point representation
        //        of the coded frame's decode timestamp in seconds.
        double decodeTimestamp = codedFrame.decodeTimestamp;

        // 2. Let frame duration be a double precision floating point representation
        //    of the coded frame's duration in seconds.
        double frameDuration = codedFrame.duration;

        // 3. If mode equals "sequence" and group start timestamp is set, then run the following steps:
        // IGNORE: mode="sequence".

        // 4. If timestampOffset is not 0, then run the following steps:
        // IGNORE: timestampOffset.

        // 5. Let track buffer equal the track buffer that the coded frame will be added to.
        // ASSUME: a single track buffer, trackBuffer.

        // 6. ↳ If last decode timestamp for track buffer is set and decode timestamp
        //      is less than last decode timestamp:
        if ((isSet(trackBuffer.lastDecodeTimestamp) && decodeTimestamp < trackBuffer.lastDecodeTimestamp)
            //  OR
            ||
            // ↳ If last decode timestamp for track buffer is set and the difference
            //   between decode timestamp and last decode timestamp is greater than
            //   2 times last frame duration:
            (isSet(trackBuffer.lastDecodeTimestamp) && (abs(decodeTimestamp - trackBuffer.lastDecodeTimestamp) > (2 * trackBuffer.lastFrameDuration)))) {

            // 1. ↳ If mode equals "segments":
            //    ↳ If mode equals "sequence":
            // IGNORE: group end timestamp and group start timestamp

            // 2. Unset the last decode timestamp on all track buffers.
            trackBuffer.lastDecodeTimestamp = unset();

            // 3. Unset the last frame duration on all track buffers.
            trackBuffer.lastFrameDuration = unset();

            // 4. Unset the highest presentation timestamp on all track buffers.
            trackBuffer.highestPresentationTimestamp = unset();

            // 5. Set the need random access point flag on all track buffers to true.
            trackBuffer.needsRandomAccessFlag = true;

            // 6. Jump to the Loop Top step above to restart processing of the current coded frame.
            goto loopTop;
        }
        // ↳ Otherwise:
        //   Continue.

        // 7. If the presentation timestamp or decode timestamp is less than the presentation start time,
        //    then run the end of stream algorithm with the error parameter set to "decode", and abort
        //    these steps.
        if (presentationTimestamp < presentationStartTime || decodeTimestamp < presentationStartTime)
            return DecodeError;

        // 8. Let frame end timestamp equal the sum of presentation timestamp and frame duration.
        double frameEndTimestamp = presentationTimestamp + frameDuration;

        // 9. If presentation timestamp is less than appendWindowStart, then set the need random access point
        //    flag to true, drop the coded frame, and jump to the top of the loop to start processing the next
        //    coded frame.
        // 10. If frame end timestamp is greater than appendWindowEnd, then set the need random access point
        //     flag to true, drop the coded frame, and jump to the top of the loop to start processing the next
        //     coded frame.
        // IGNORE: append windows.

        // 11. If the need random access point flag on track buffer equals true, then run the following steps:
        if (trackBuffer.needsRandomAccessFlag) {
            // 1. If the coded frame is not a random access point, then drop the coded frame and jump to the
            //    top of the loop to start processing the next coded frame.
            if (!codedFrame.isRandomAccess)
                continue;

            // 2. Set the need random access point flag on track buffer to false.
            trackBuffer.needsRandomAccessFlag = false;
        }

        // 12. Let spliced audio frame be an unset variable for holding audio splice information
        // IGNORE: spliced audio.

        // 13. Let spliced timed text frame be an unset variable for holding timed text splice information
        // IGNORE: spliced text.

        // 14. If last decode timestamp for track buffer is unset and presentation timestamp falls within
        //     the presentation interval of a coded frame in track buffer,then run the following steps:
        auto timeFallsWithinPresentationInterval = [presentationTimestamp](CodedFrameMap::value_type pair) -> bool {
            CodedFrame& codedFrame = pair.second;
            // The presentation interval of a coded frame is the time interval from its presentation timestamp to
            // the presentation timestamp plus the coded frame's duration. Note that the start of the range is
            // inclusive, but the end of the range is exclusive.
            return presentationTimestamp >= codedFrame.presentationTimestamp
                && presentationTimestamp < codedFrame.presentationTimestamp + codedFrame.duration;
        };
        if (isUnset(trackBuffer.lastDecodeTimestamp) &&
            any_of(trackBuffer.codedFrames.begin(), trackBuffer.codedFrames.end(), timeFallsWithinPresentationInterval)) {
            // 1. Let overlapped frame be the coded frame in track buffer that matches the condition above.
            auto overlappedFrameIter = find_if(trackBuffer.codedFrames.begin(), trackBuffer.codedFrames.end(), timeFallsWithinPresentationInterval);
            CodedFrame& overlappedFrame = overlappedFrameIter->second;

            // 2. ↳ If track buffer contains audio coded frames:
            //    ↳ If track buffer contains timed text coded frames:
            //    ↳ If track buffer contains video coded frames:
            // ASSUME: video frames
            {
                // 1. Let overlapped frame presentation timestamp equal the presentation timestamp of
                //    overlapped frame.
                double overlappedFramePresentationTimestamp = overlappedFrame.presentationTimestamp;

                // 2. Let remove window timestamp equal overlapped frame presentation timestamp plus
                //    1 microsecond.
                double removeWindowTimestamp = overlappedFramePresentationTimestamp + 0.000001;

                // 3. If the presentation timestamp is less than the remove window timestamp, then
                //    remove overlapped frame and any coded frames that depend on it from track buffer.
                if (presentationTimestamp < removeWindowTimestamp) {
                    auto nextSyncSampleIter = overlappedFrameIter;
                    nextSyncSampleIter = find_if(++nextSyncSampleIter, trackBuffer.codedFrames.end(), codedFrameIsRandomAccess);

                    // NOTE: this will remove frames in decode order.
                    trackBuffer.codedFrames.erase(overlappedFrameIter, nextSyncSampleIter);
                }
            }
        }

        CodedFrameMap removedCodedFrames;
        // 15. Remove existing coded frames in track buffer:
        //     ↳ If highest presentation timestamp for track buffer is not set:
        if (isUnset(trackBuffer.highestPresentationTimestamp)) {
            // Remove all coded frames from track buffer that have a presentation timestamp greater
            // than or equal to presentation timestamp and less than frame end timestamp.
            CodedFrameMap replacementCodedFrames;
            for (auto& pair : trackBuffer.codedFrames) {
                CodedFrame& codedFrame = pair.second;
                if (codedFrame.presentationTimestamp >= presentationTimestamp && codedFrame.presentationTimestamp < frameEndTimestamp)
                    removedCodedFrames.insert(pair);
            }
            // Frames will be actually removed in step 16.
        }
        //     ↳ If highest presentation timestamp for track buffer is set and less than presentation timestamp
        if (isSet(trackBuffer.highestPresentationTimestamp) && trackBuffer.highestPresentationTimestamp < presentationTimestamp) {
            // Remove all coded frames from track buffer that have a presentation timestamp greater than
            // highest presentation timestamp and less than or equal to frame end timestamp.
            CodedFrameMap replacementCodedFrames;
            for (auto& pair : trackBuffer.codedFrames) {
                CodedFrame& codedFrame = pair.second;
                if (codedFrame.presentationTimestamp > trackBuffer.highestPresentationTimestamp && codedFrame.presentationTimestamp <= frameEndTimestamp)
                    removedCodedFrames.insert(pair);
            }
            // Frames will be actually removed in step 16.
        }

        // 16. Remove decoding dependencies of the coded frames removed in the previous step:
        //     ↳ If detailed information about decoding dependencies is available:
        // ASSUME: detailed dependancy information is unavailable.
        //     ↳ Otherwise:
        //       Remove all coded frames between the coded frames removed in the previous step and the
        //       next random access point after those removed frames.
        for (auto& pair : removedCodedFrames) {
            double removedCodedFrameDecodeTimestamp = pair.first;
            auto removedFrameIter = trackBuffer.codedFrames.find(removedCodedFrameDecodeTimestamp);

            // Coded frame may have been removed in a previous step.
            if (removedFrameIter == trackBuffer.codedFrames.end())
                continue;

            auto nextSyncSampleIter = removedFrameIter;
            nextSyncSampleIter = find_if(++nextSyncSampleIter, trackBuffer.codedFrames.end(), codedFrameIsRandomAccess);

            // NOTE: this will remove frames in decode order.
            trackBuffer.codedFrames.erase(removedFrameIter, nextSyncSampleIter);
        }

        // 17. ↳ If spliced audio frame is set:
        //     ↳ If spliced timed text frame is set:
        // IGNORE: splicing.
        //     ↳ Otherwise:
        //       Add the coded frame with the presentation timestamp, decode timestamp, and frame duration
        //       to the track buffer.
        trackBuffer.codedFrames.emplace(decodeTimestamp, codedFrame);

        // 18. Set last decode timestamp for track buffer to decode timestamp.
        trackBuffer.lastDecodeTimestamp = decodeTimestamp;

        // 19. Set last frame duration for track buffer to frame duration.
        trackBuffer.lastFrameDuration = frameDuration;

        // 20. If highest presentation timestamp for track buffer is unset or frame end timestamp is greater
        //     than highest presentation timestamp, then set highest presentation timestamp for track buffer
        //     to frame end timestamp.
        if (isUnset(trackBuffer.highestPresentationTimestamp) || frameEndTimestamp > trackBuffer.highestPresentationTimestamp)
            trackBuffer.highestPresentationTimestamp = frameEndTimestamp;

        // 21. If frame end timestamp is greater than group end timestamp, then set group end timestamp
        //     equal to frame end timestamp.
        // IGNORE: group end timestamp.

        // 22. If generate timestamps flag equals true, then set timestampOffset equal to frame end timestamp.
        // IGNORE: generate timestamps flag.
    }

    // 2. If the HTMLMediaElement.readyState attribute is HAVE_METADATA and the new coded frames cause all objects
    //    in activeSourceBuffers to have media data for the current playback position, then run the following steps:
    // 3. If the HTMLMediaElement.readyState attribute is HAVE_CURRENT_DATA and the new coded frames cause all objects
    //    in activeSourceBuffers to have media data beyond the current playback position, then run the following steps:
    // 4. If the HTMLMediaElement.readyState attribute is HAVE_FUTURE_DATA and the new coded frames cause all objects
    //    in activeSourceBuffers to have enough data to ensure uninterrupted playback, then run the following steps:
    // 5. If the media segment contains data beyond the current duration, then run the duration change algorithm with
    //    new duration set to the maximum of the current duration and the group end timestamp.
    // IGNORE: ready state changes.

    return NoError;
}

ostream& operator<<(ostream& stream, CodedFrame& sample)
{
    return stream
        << "{"
        << " PTS(" << sample.presentationTimestamp << ")"
        << " DTS(" << sample.decodeTimestamp << ")"
        << " duration(" << sample.duration << ")"
        << " isRandomAccess(" << sample.isRandomAccess << ")"
        << " generation(" << sample.generation << ")"
        << " }";
}

ostream& operator<<(ostream& stream, CodedFrameMap& map)
{
    for (auto& pair : map)
        stream << pair.second << endl;
    return stream;
}

int main(void)
{
    SourceBuffer sourceBuffer;

    sourceBuffer.processCodedFrames({
        CodedFrame(0, 0, 1, true,  1),
        CodedFrame(1, 1, 1, false, 1),
        CodedFrame(2, 2, 1, false, 1),
        CodedFrame(3, 3, 1, true,  1),
        CodedFrame(4, 4, 1, false, 1),
        CodedFrame(5, 5, 1, false, 1),
        });
    cout << "Round 1: initial state - length:" << sourceBuffer.trackBuffer.codedFrames.size() << endl
        << sourceBuffer.trackBuffer.codedFrames
        << endl;

    sourceBuffer.processCodedFrames({
        CodedFrame(0, 0, 1, true,  2),
        CodedFrame(1, 1, 1, false, 2),
        CodedFrame(2, 2, 1, false, 2),
        CodedFrame(3, 3, 1, true,  2),
        CodedFrame(4, 4, 1, false, 2),
        CodedFrame(5, 5, 1, false, 2),
    });
    cout << "Round 2: ordered P frames - length:" << sourceBuffer.trackBuffer.codedFrames.size() << endl
        << sourceBuffer.trackBuffer.codedFrames
        << endl;

    sourceBuffer.processCodedFrames({
        CodedFrame(0, 0, 1, true,  3),
        CodedFrame(2, 1, 1, false, 3),
        CodedFrame(1, 2, 1, false, 3),
        CodedFrame(3, 3, 1, true,  3),
        CodedFrame(5, 4, 1, false, 3),
        CodedFrame(4, 5, 1, false, 3),
    });
    cout << "Round 3: unordered P frames - length:" << sourceBuffer.trackBuffer.codedFrames.size() << endl
        << sourceBuffer.trackBuffer.codedFrames
        << endl;

    sourceBuffer.processCodedFrames({
        CodedFrame(0, 0, 1, true,  4),
        CodedFrame(2, 1, 1, false, 4),
        CodedFrame(1, 2, 1, false, 4),
        CodedFrame(3, 3, 1, true,  4),
        CodedFrame(5, 4, 1, false, 4),
        CodedFrame(4, 5, 1, false, 4),
    });
    cout << "Round 4: unordered P frames - length:" << sourceBuffer.trackBuffer.codedFrames.size() << endl
        << sourceBuffer.trackBuffer.codedFrames
        << endl;

    sourceBuffer.processCodedFrames({
        CodedFrame(2, 0, 1, true,  5),
        CodedFrame(0, 1, 1, false, 5),
        CodedFrame(1, 2, 1, false, 5),
        CodedFrame(5, 3, 1, true,  5),
        CodedFrame(3, 4, 1, false, 5),
        CodedFrame(4, 5, 1, false, 5),
    });
    cout << "Round 5: ordered B frames - length:" << sourceBuffer.trackBuffer.codedFrames.size() << endl
        << sourceBuffer.trackBuffer.codedFrames
        << endl;

    sourceBuffer.trackBuffer.codedFrames.clear();
    sourceBuffer.processCodedFrames({
        CodedFrame(0, 0, 1, true,  1),
        CodedFrame(1, 1, 1, false, 1),
        CodedFrame(2, 2, 1, false, 1),
        CodedFrame(3, 3, 1, true,  1),
        CodedFrame(4, 4, 1, false, 1),
        CodedFrame(5, 5, 1, false, 1),
        });

    sourceBuffer.processCodedFrames({
        CodedFrame(0.5, 0.5, 1, true,  6),
        CodedFrame(1.5, 1.5, 1, false, 6),
        CodedFrame(2.5, 2.5, 1, false, 6),
        CodedFrame(3.5, 3.5, 1, true,  6),
        CodedFrame(4.5, 4.5, 1, false, 6),
        CodedFrame(5.5, 5.5, 1, false, 6),
    });
    cout << "Round 6: ordered unaligned P frames - length:" << sourceBuffer.trackBuffer.codedFrames.size() << endl
        << sourceBuffer.trackBuffer.codedFrames
        << endl;
}
	/* Copyright (c) 2014 Jer Noble
	*
	* Permission is hereby granted, free of charge, to any person obtaining a copy
	* of this software and associated documentation files (the "Software"), to deal
	* in the Software without restriction, including without limitation the rights
	* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
	* copies of the Software, and to permit persons to whom the Software is
	* furnished to do so, subject to the following conditions:
	*
	* The above copyright notice and this permission notice shall be included in
	* all copies or substantial portions of the Software.
	*
	* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
	* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
	* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
	* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
	* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
	* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
	* THE SOFTWARE.
	*/

	#include <algorithm>
	#include <cmath>
	#include <iostream>
	#include <limits>
	#include <map>
	#include <stdio.h>
	#include <vector>

	using namespace std;

	static double unset()
	{
	return numeric_limits<double>::quiet_NaN();
	}

	static bool isSet(const double& value)
	{
	return !isnan(value);
	}

	static bool isUnset(const double& value)
	{
	return isnan(value);
	}


	class CodedFrame {
	public:
	CodedFrame(double presentationTimestamp, double decodeTimestamp, double duration, bool isRandomAccess, unsigned generation)
	: presentationTimestamp(presentationTimestamp)
	, decodeTimestamp(decodeTimestamp)
	, duration(duration)
	, isRandomAccess(isRandomAccess)
	, generation(generation)
	{
	}

	double presentationTimestamp;
	double decodeTimestamp;
	double duration;
	bool isRandomAccess;
	unsigned generation;
	};

	typedef multimap<double, CodedFrame> CodedFrameMap;

	static bool codedFrameIsRandomAccess(CodedFrameMap::value_type pair)
	{
	return pair.second.isRandomAccess;
	}

	class TrackBuffer {
	public:
	TrackBuffer()
	: lastDecodeTimestamp(unset())
	, lastFrameDuration(unset())
	, highestPresentationTimestamp(unset())
	, needsRandomAccessFlag(true)
	{
	}

	double lastDecodeTimestamp;
	double lastFrameDuration;
	double highestPresentationTimestamp;
	double needsRandomAccessFlag;
	CodedFrameMap codedFrames; // in decode order
	};

	class SourceBuffer {
	public:
	SourceBuffer()
	: presentationStartTime(0)
	{
	}

	enum ErrorCode { NoError, NetworkError, DecodeError };
	ErrorCode processCodedFrames(vector<CodedFrame> codedFrames);

	TrackBuffer trackBuffer;
	double presentationStartTime;
	};

	SourceBuffer::ErrorCode SourceBuffer::processCodedFrames(vector<CodedFrame> codedFrames)
	{
	// When complete coded frames have been parsed by the segment parser loop then the following steps are run:

	// 1. For each coded frame in the media segment run the following steps:
	for (auto& codedFrame : codedFrames) {
	// 1. Loop top:
	loopTop:
	// ↳ If generate timestamps flag equals true:
	// 1. Let presentation timestamp equal 0.
	// 2. Let decode timestamp equal 0.
	// No-op.

	// ↳ Otherwise:
	// 1. Let presentation timestamp be a double precision floating point representation
	// of the coded frame's presentation timestamp in seconds.
	double presentationTimestamp = codedFrame.presentationTimestamp;
	// 2. Let decode timestamp be a double precision floating point representation
	// of the coded frame's decode timestamp in seconds.
	double decodeTimestamp = codedFrame.decodeTimestamp;

	// 2. Let frame duration be a double precision floating point representation
	// of the coded frame's duration in seconds.
	double frameDuration = codedFrame.duration;

	// 3. If mode equals "sequence" and group start timestamp is set, then run the following steps:
	// IGNORE: mode="sequence".

	// 4. If timestampOffset is not 0, then run the following steps:
	// IGNORE: timestampOffset.

	// 5. Let track buffer equal the track buffer that the coded frame will be added to.
	// ASSUME: a single track buffer, trackBuffer.

	// 6. ↳ If last decode timestamp for track buffer is set and decode timestamp
	// is less than last decode timestamp:
	if ((isSet(trackBuffer.lastDecodeTimestamp) && decodeTimestamp < trackBuffer.lastDecodeTimestamp)
	// OR
	\|\|
	// ↳ If last decode timestamp for track buffer is set and the difference
	// between decode timestamp and last decode timestamp is greater than
	// 2 times last frame duration:
	(isSet(trackBuffer.lastDecodeTimestamp) && (abs(decodeTimestamp - trackBuffer.lastDecodeTimestamp) > (2 * trackBuffer.lastFrameDuration)))) {

	// 1. ↳ If mode equals "segments":
	// ↳ If mode equals "sequence":
	// IGNORE: group end timestamp and group start timestamp

	// 2. Unset the last decode timestamp on all track buffers.
	trackBuffer.lastDecodeTimestamp = unset();

	// 3. Unset the last frame duration on all track buffers.
	trackBuffer.lastFrameDuration = unset();

	// 4. Unset the highest presentation timestamp on all track buffers.
	trackBuffer.highestPresentationTimestamp = unset();

	// 5. Set the need random access point flag on all track buffers to true.
	trackBuffer.needsRandomAccessFlag = true;

	// 6. Jump to the Loop Top step above to restart processing of the current coded frame.
	goto loopTop;
	}
	// ↳ Otherwise:
	// Continue.

	// 7. If the presentation timestamp or decode timestamp is less than the presentation start time,
	// then run the end of stream algorithm with the error parameter set to "decode", and abort
	// these steps.
	if (presentationTimestamp < presentationStartTime \|\| decodeTimestamp < presentationStartTime)
	return DecodeError;

	// 8. Let frame end timestamp equal the sum of presentation timestamp and frame duration.
	double frameEndTimestamp = presentationTimestamp + frameDuration;

	// 9. If presentation timestamp is less than appendWindowStart, then set the need random access point
	// flag to true, drop the coded frame, and jump to the top of the loop to start processing the next
	// coded frame.
	// 10. If frame end timestamp is greater than appendWindowEnd, then set the need random access point
	// flag to true, drop the coded frame, and jump to the top of the loop to start processing the next
	// coded frame.
	// IGNORE: append windows.

	// 11. If the need random access point flag on track buffer equals true, then run the following steps:
	if (trackBuffer.needsRandomAccessFlag) {
	// 1. If the coded frame is not a random access point, then drop the coded frame and jump to the
	// top of the loop to start processing the next coded frame.
	if (!codedFrame.isRandomAccess)
	continue;

	// 2. Set the need random access point flag on track buffer to false.
	trackBuffer.needsRandomAccessFlag = false;
	}

	// 12. Let spliced audio frame be an unset variable for holding audio splice information
	// IGNORE: spliced audio.

	// 13. Let spliced timed text frame be an unset variable for holding timed text splice information
	// IGNORE: spliced text.

	// 14. If last decode timestamp for track buffer is unset and presentation timestamp falls within
	// the presentation interval of a coded frame in track buffer,then run the following steps:
	auto timeFallsWithinPresentationInterval = [presentationTimestamp](CodedFrameMap::value_type pair) -> bool {
	CodedFrame& codedFrame = pair.second;
	// The presentation interval of a coded frame is the time interval from its presentation timestamp to
	// the presentation timestamp plus the coded frame's duration. Note that the start of the range is
	// inclusive, but the end of the range is exclusive.
	return presentationTimestamp >= codedFrame.presentationTimestamp
	&& presentationTimestamp < codedFrame.presentationTimestamp + codedFrame.duration;
	};
	if (isUnset(trackBuffer.lastDecodeTimestamp) &&
	any_of(trackBuffer.codedFrames.begin(), trackBuffer.codedFrames.end(), timeFallsWithinPresentationInterval)) {
	// 1. Let overlapped frame be the coded frame in track buffer that matches the condition above.
	auto overlappedFrameIter = find_if(trackBuffer.codedFrames.begin(), trackBuffer.codedFrames.end(), timeFallsWithinPresentationInterval);
	CodedFrame& overlappedFrame = overlappedFrameIter->second;

	// 2. ↳ If track buffer contains audio coded frames:
	// ↳ If track buffer contains timed text coded frames:
	// ↳ If track buffer contains video coded frames:
	// ASSUME: video frames
	{
	// 1. Let overlapped frame presentation timestamp equal the presentation timestamp of
	// overlapped frame.
	double overlappedFramePresentationTimestamp = overlappedFrame.presentationTimestamp;

	// 2. Let remove window timestamp equal overlapped frame presentation timestamp plus
	// 1 microsecond.
	double removeWindowTimestamp = overlappedFramePresentationTimestamp + 0.000001;

	// 3. If the presentation timestamp is less than the remove window timestamp, then
	// remove overlapped frame and any coded frames that depend on it from track buffer.
	if (presentationTimestamp < removeWindowTimestamp) {
	auto nextSyncSampleIter = overlappedFrameIter;
	nextSyncSampleIter = find_if(++nextSyncSampleIter, trackBuffer.codedFrames.end(), codedFrameIsRandomAccess);

	// NOTE: this will remove frames in decode order.
	trackBuffer.codedFrames.erase(overlappedFrameIter, nextSyncSampleIter);
	}
	}
	}

	CodedFrameMap removedCodedFrames;
	// 15. Remove existing coded frames in track buffer:
	// ↳ If highest presentation timestamp for track buffer is not set:
	if (isUnset(trackBuffer.highestPresentationTimestamp)) {
	// Remove all coded frames from track buffer that have a presentation timestamp greater
	// than or equal to presentation timestamp and less than frame end timestamp.
	CodedFrameMap replacementCodedFrames;
	for (auto& pair : trackBuffer.codedFrames) {
	CodedFrame& codedFrame = pair.second;
	if (codedFrame.presentationTimestamp >= presentationTimestamp && codedFrame.presentationTimestamp < frameEndTimestamp)
	removedCodedFrames.insert(pair);
	}
	// Frames will be actually removed in step 16.
	}
	// ↳ If highest presentation timestamp for track buffer is set and less than presentation timestamp
	if (isSet(trackBuffer.highestPresentationTimestamp) && trackBuffer.highestPresentationTimestamp < presentationTimestamp) {
	// Remove all coded frames from track buffer that have a presentation timestamp greater than
	// highest presentation timestamp and less than or equal to frame end timestamp.
	CodedFrameMap replacementCodedFrames;
	for (auto& pair : trackBuffer.codedFrames) {
	CodedFrame& codedFrame = pair.second;
	if (codedFrame.presentationTimestamp > trackBuffer.highestPresentationTimestamp && codedFrame.presentationTimestamp <= frameEndTimestamp)
	removedCodedFrames.insert(pair);
	}
	// Frames will be actually removed in step 16.
	}

	// 16. Remove decoding dependencies of the coded frames removed in the previous step:
	// ↳ If detailed information about decoding dependencies is available:
	// ASSUME: detailed dependancy information is unavailable.
	// ↳ Otherwise:
	// Remove all coded frames between the coded frames removed in the previous step and the
	// next random access point after those removed frames.
	for (auto& pair : removedCodedFrames) {
	double removedCodedFrameDecodeTimestamp = pair.first;
	auto removedFrameIter = trackBuffer.codedFrames.find(removedCodedFrameDecodeTimestamp);

	// Coded frame may have been removed in a previous step.
	if (removedFrameIter == trackBuffer.codedFrames.end())
	continue;

	auto nextSyncSampleIter = removedFrameIter;
	nextSyncSampleIter = find_if(++nextSyncSampleIter, trackBuffer.codedFrames.end(), codedFrameIsRandomAccess);

	// NOTE: this will remove frames in decode order.
	trackBuffer.codedFrames.erase(removedFrameIter, nextSyncSampleIter);
	}

	// 17. ↳ If spliced audio frame is set:
	// ↳ If spliced timed text frame is set:
	// IGNORE: splicing.
	// ↳ Otherwise:
	// Add the coded frame with the presentation timestamp, decode timestamp, and frame duration
	// to the track buffer.
	trackBuffer.codedFrames.emplace(decodeTimestamp, codedFrame);

	// 18. Set last decode timestamp for track buffer to decode timestamp.
	trackBuffer.lastDecodeTimestamp = decodeTimestamp;

	// 19. Set last frame duration for track buffer to frame duration.
	trackBuffer.lastFrameDuration = frameDuration;

	// 20. If highest presentation timestamp for track buffer is unset or frame end timestamp is greater
	// than highest presentation timestamp, then set highest presentation timestamp for track buffer
	// to frame end timestamp.
	if (isUnset(trackBuffer.highestPresentationTimestamp) \|\| frameEndTimestamp > trackBuffer.highestPresentationTimestamp)
	trackBuffer.highestPresentationTimestamp = frameEndTimestamp;

	// 21. If frame end timestamp is greater than group end timestamp, then set group end timestamp
	// equal to frame end timestamp.
	// IGNORE: group end timestamp.

	// 22. If generate timestamps flag equals true, then set timestampOffset equal to frame end timestamp.
	// IGNORE: generate timestamps flag.
	}

	// 2. If the HTMLMediaElement.readyState attribute is HAVE_METADATA and the new coded frames cause all objects
	// in activeSourceBuffers to have media data for the current playback position, then run the following steps:
	// 3. If the HTMLMediaElement.readyState attribute is HAVE_CURRENT_DATA and the new coded frames cause all objects
	// in activeSourceBuffers to have media data beyond the current playback position, then run the following steps:
	// 4. If the HTMLMediaElement.readyState attribute is HAVE_FUTURE_DATA and the new coded frames cause all objects
	// in activeSourceBuffers to have enough data to ensure uninterrupted playback, then run the following steps:
	// 5. If the media segment contains data beyond the current duration, then run the duration change algorithm with
	// new duration set to the maximum of the current duration and the group end timestamp.
	// IGNORE: ready state changes.

	return NoError;
	}

	ostream& operator<<(ostream& stream, CodedFrame& sample)
	{
	return stream
	<< "{"
	<< " PTS(" << sample.presentationTimestamp << ")"
	<< " DTS(" << sample.decodeTimestamp << ")"
	<< " duration(" << sample.duration << ")"
	<< " isRandomAccess(" << sample.isRandomAccess << ")"
	<< " generation(" << sample.generation << ")"
	<< " }";
	}

	ostream& operator<<(ostream& stream, CodedFrameMap& map)
	{
	for (auto& pair : map)
	stream << pair.second << endl;
	return stream;
	}

	int main(void)
	{
	SourceBuffer sourceBuffer;

	sourceBuffer.processCodedFrames({
	CodedFrame(0, 0, 1, true, 1),
	CodedFrame(1, 1, 1, false, 1),
	CodedFrame(2, 2, 1, false, 1),
	CodedFrame(3, 3, 1, true, 1),
	CodedFrame(4, 4, 1, false, 1),
	CodedFrame(5, 5, 1, false, 1),
	});
	cout << "Round 1: initial state - length:" << sourceBuffer.trackBuffer.codedFrames.size() << endl
	<< sourceBuffer.trackBuffer.codedFrames
	<< endl;

	sourceBuffer.processCodedFrames({
	CodedFrame(0, 0, 1, true, 2),
	CodedFrame(1, 1, 1, false, 2),
	CodedFrame(2, 2, 1, false, 2),
	CodedFrame(3, 3, 1, true, 2),
	CodedFrame(4, 4, 1, false, 2),
	CodedFrame(5, 5, 1, false, 2),
	});
	cout << "Round 2: ordered P frames - length:" << sourceBuffer.trackBuffer.codedFrames.size() << endl
	<< sourceBuffer.trackBuffer.codedFrames
	<< endl;

	sourceBuffer.processCodedFrames({
	CodedFrame(0, 0, 1, true, 3),
	CodedFrame(2, 1, 1, false, 3),
	CodedFrame(1, 2, 1, false, 3),
	CodedFrame(3, 3, 1, true, 3),
	CodedFrame(5, 4, 1, false, 3),
	CodedFrame(4, 5, 1, false, 3),
	});
	cout << "Round 3: unordered P frames - length:" << sourceBuffer.trackBuffer.codedFrames.size() << endl
	<< sourceBuffer.trackBuffer.codedFrames
	<< endl;

	sourceBuffer.processCodedFrames({
	CodedFrame(0, 0, 1, true, 4),
	CodedFrame(2, 1, 1, false, 4),
	CodedFrame(1, 2, 1, false, 4),
	CodedFrame(3, 3, 1, true, 4),
	CodedFrame(5, 4, 1, false, 4),
	CodedFrame(4, 5, 1, false, 4),
	});
	cout << "Round 4: unordered P frames - length:" << sourceBuffer.trackBuffer.codedFrames.size() << endl
	<< sourceBuffer.trackBuffer.codedFrames
	<< endl;

	sourceBuffer.processCodedFrames({
	CodedFrame(2, 0, 1, true, 5),
	CodedFrame(0, 1, 1, false, 5),
	CodedFrame(1, 2, 1, false, 5),
	CodedFrame(5, 3, 1, true, 5),
	CodedFrame(3, 4, 1, false, 5),
	CodedFrame(4, 5, 1, false, 5),
	});
	cout << "Round 5: ordered B frames - length:" << sourceBuffer.trackBuffer.codedFrames.size() << endl
	<< sourceBuffer.trackBuffer.codedFrames
	<< endl;

	sourceBuffer.trackBuffer.codedFrames.clear();
	sourceBuffer.processCodedFrames({
	CodedFrame(0, 0, 1, true, 1),
	CodedFrame(1, 1, 1, false, 1),
	CodedFrame(2, 2, 1, false, 1),
	CodedFrame(3, 3, 1, true, 1),
	CodedFrame(4, 4, 1, false, 1),
	CodedFrame(5, 5, 1, false, 1),
	});

	sourceBuffer.processCodedFrames({
	CodedFrame(0.5, 0.5, 1, true, 6),
	CodedFrame(1.5, 1.5, 1, false, 6),
	CodedFrame(2.5, 2.5, 1, false, 6),
	CodedFrame(3.5, 3.5, 1, true, 6),
	CodedFrame(4.5, 4.5, 1, false, 6),
	CodedFrame(5.5, 5.5, 1, false, 6),
	});
	cout << "Round 6: ordered unaligned P frames - length:" << sourceBuffer.trackBuffer.codedFrames.size() << endl
	<< sourceBuffer.trackBuffer.codedFrames
	<< endl;
	}