ReplayWidget(const QString &filename, int from, int to, bool single, int frame);

    QVector<uint> iterationTimes;

    int from;

    int to;

    bool single;

    int frame;

    int currentCommand;

    if (frame >= 0 && !updates.isEmpty())

        update(updates.at(frame));

    else if (!visibleUpdates.isEmpty())

const int singleFrameRepeatsPerCommand = 100;

const int singleFrameIterations = 4;

    QTimer::singleShot(0, this, SLOT(updateRect()));

    if (frame >= 0) {

        int start = buffer.frameStartIndex(frame);

        int end = buffer.frameEndIndex(frame);

        iterationTimes.resize(end - start);

        int saveRestoreStackDepth = buffer.processCommands(&p, start, start + currentCommand);

        for (int i = 0; i < saveRestoreStackDepth; ++i)

            p.restore();

        const int repeats = currentIteration >= 3 ? singleFrameRepeatsPerCommand : 1;

        ++currentFrame;

        if (currentFrame == repeats) {

            currentFrame = 0;

            if (currentIteration >= 3) {

                iterationTimes[currentCommand - 1] = qMin(iterationTimes[currentCommand - 1], uint(timer.elapsed()));

                timer.restart();

            }

            if (currentIteration >= singleFrameIterations + 3) {

                printf(" #    | ms      | description\n");

                printf("------+---------+------------------------------------------------------------\n");

		qSort(iterationTimes);

		int sum = 0;

                for (int i = 0; i < iterationTimes.size(); ++i) {

                    int delta = iterationTimes.at(i);

                    if (i > 0)

                        delta -= iterationTimes.at(i-1);

		    sum += delta;

                    qreal deltaF = delta / qreal(repeats);

                    printf("%.5d | %.5f | %s\n", i, deltaF, qPrintable(buffer.commandDescription(start + i)));

                }

                printf("Total | %.5f | Total frame time\n", sum / qreal(repeats));

                deleteLater();

                return;

            }

            if (start + currentCommand >= end) {

                currentCommand = 1;

		++currentIteration;

                if (currentIteration == 3) {

                    timer.start();

                    iterationTimes.fill(uint(-1));

                }

		if (currentIteration >= 3 && currentIteration < singleFrameIterations + 3)

                    printf("Profiling iteration %d of %d\n", currentIteration - 2, singleFrameIterations);

            } else {

                ++currentCommand;

	    }

        }

        return;

    }

        if (single) {

            deleteLater();

            return;

        }

void ReplayWidget::resizeEvent(QResizeEvent *)

    int first = qMax(0, from);

    int last = qMin(unsigned(to), unsigned(updates.size()));

    for (int i = first; i < last; ++i) {

    int range = last - first;

    if (visibleUpdates.size() != range)

        printf("Warning: skipped %d frames due to limited resolution\n", range - visibleUpdates.size());

ReplayWidget::ReplayWidget(const QString &filename_, int from_, int to_, bool single_, int frame_)

    , from(from_)

    , to(to_)

    , single(single_)

    , frame(frame_)

    , currentCommand(1)

    bool isTraceFile = size >= 7 && qstrncmp(data, "qttrace", 7) == 0;

    uint version = 0;

    if (size == 9 && qstrncmp(data, "qttraceV2", 9) == 0) {

        in.setFloatingPointPrecision(QDataStream::SinglePrecision);

        in >> version;

    }

    printf("Read paint buffer version %d with %d frames\n", version, buffer.numFrames());

        printf("Usage:\n  > %s [OPTIONS] [traceFile]\n", argv[0]);

        printf("OPTIONS\n"

               "   --range=from-to to specify a frame range.\n"

               "   --singlerun to do only one run (without statistics)\n"

               "   --instrumentframe=frame to instrument a single frame\n");

        return 1;

    }

    QFile file(app.arguments().last());

    if (!file.exists()) {

        printf("%s does not exist\n", qPrintable(app.arguments().last()));

    bool single = false;

    int frame = -1;

    int from = 0;

    int to = -1;

    for (int i = 1; i < app.arguments().size() - 1; ++i) {

        QString arg = app.arguments().at(i);

        if (arg.startsWith(QLatin1String("--range="))) {

            QString rest = arg.mid(8);

            QStringList components = rest.split(QLatin1Char('-'));

            bool ok1 = false;

            bool ok2 = false;

            int fromCandidate = 0;

            int toCandidate = 0;

            if (components.size() == 2) {

                fromCandidate = components.first().toInt(&ok1);

                toCandidate = components.last().toInt(&ok2);

            }

            if (ok1 && ok2) {

                from = fromCandidate;

                to = toCandidate;

            } else {

                printf("ERROR: malformed syntax in argument %s\n", qPrintable(arg));

            }

        } else if (arg == QLatin1String("--singlerun")) {

            single = true;

        } else if (arg.startsWith(QLatin1String("--instrumentframe="))) {

            QString rest = arg.mid(18);

            bool ok = false;

            int frameCandidate = rest.toInt(&ok);

            if (ok) {

                frame = frameCandidate;

            } else {

                printf("ERROR: malformed syntax in argument %s\n", qPrintable(arg));

            }

        } else {

            printf("Unrecognized argument: %s\n", qPrintable(arg));

            return 1;

        }

    ReplayWidget *widget = new ReplayWidget(app.arguments().last(), from, to, single, frame);