#include "retracer.h"
+#include "apitracecall.h"
+#include "thumbnail.h"
+
+#include "image.hpp"
+
#include <QDebug>
+#include <QVariant>
+#include <QList>
+#include <QImage>
-Retracer::Retracer(QObject *parent)
- : QObject(parent),
- m_benchmarking(true),
- m_doubleBuffered(true),
- m_captureState(false),
- m_captureCall(0),
- m_process(0)
+#include <qjson/parser.h>
+
+/**
+ * Wrapper around a QProcess which enforces IO to block .
+ *
+ * Several QIODevice users (notably QJSON) expect blocking semantics, e.g.,
+ * they expect that QIODevice::read() will blocked until the requested ammount
+ * of bytes is read or end of file is reached. But by default QProcess, does
+ * not block. And passing QIODevice::Unbuffered mitigates but does not fully
+ * address the problem either.
+ *
+ * This class wraps around QProcess, providing QIODevice interface, while
+ * ensuring that all reads block.
+ *
+ * This class also works around a bug in QProcess::atEnd() implementation.
+ *
+ * See also:
+ * - http://qt-project.org/wiki/Simple_Crypt_IO_Device
+ * - http://qt-project.org/wiki/Custom_IO_Device
+ */
+class BlockingIODevice : public QIODevice
{
-}
+ /* We don't use the Q_OBJECT in this class given we don't declare any
+ * signals and slots or use any other services provided by Qt's meta-object
+ * system. */
+public:
+ BlockingIODevice(QProcess * io);
+ bool isSequential() const;
+ bool atEnd() const;
+ bool waitForReadyRead(int msecs = -1);
-QString Retracer::fileName() const
+protected:
+ qint64 readData(char * data, qint64 maxSize);
+ qint64 writeData(const char * data, qint64 maxSize);
+
+private:
+ QProcess *m_device;
+};
+
+BlockingIODevice::BlockingIODevice(QProcess * io) :
+ m_device(io)
{
- return m_fileName;
+ /*
+ * We pass QIODevice::Unbuffered to prevent the base QIODevice class to do
+ * its own buffering on top of the overridden readData() method.
+ *
+ * The only buffering used will be to satisfy QIODevice::peek() and
+ * QIODevice::ungetChar().
+ */
+ setOpenMode(ReadOnly | Unbuffered);
}
-void Retracer::setFileName(const QString &name)
+bool BlockingIODevice::isSequential() const
{
- m_fileName = name;
+ return true;
}
-bool Retracer::isBenchmarking() const
+bool BlockingIODevice::atEnd() const
{
- return m_benchmarking;
+ /*
+ * XXX: QProcess::atEnd() documentation is wrong -- it will return true
+ * even when the process is running --, so we try to workaround that here.
+ */
+ if (m_device->atEnd()) {
+ if (m_device->state() == QProcess::Running) {
+ if (!m_device->waitForReadyRead(-1)) {
+ return true;
+ }
+ }
+ }
+ return false;
}
-void Retracer::setBenchmarking(bool bench)
+bool BlockingIODevice::waitForReadyRead(int msecs)
{
- m_benchmarking = bench;
+ Q_UNUSED(msecs);
+ return true;
}
-bool Retracer::isDoubleBuffered() const
+qint64 BlockingIODevice::readData(char * data, qint64 maxSize)
{
- return m_doubleBuffered;
+ qint64 bytesToRead = maxSize;
+ qint64 readSoFar = 0;
+ do {
+ qint64 chunkSize = m_device->read(data + readSoFar, bytesToRead);
+ if (chunkSize < 0) {
+ if (readSoFar) {
+ return readSoFar;
+ } else {
+ return chunkSize;
+ }
+ }
+ Q_ASSERT(chunkSize <= bytesToRead);
+ bytesToRead -= chunkSize;
+ readSoFar += chunkSize;
+ if (bytesToRead) {
+ if (!m_device->waitForReadyRead(-1)) {
+ qDebug() << "waitForReadyRead failed\n";
+ break;
+ }
+ }
+ } while(bytesToRead);
+
+ return readSoFar;
}
-void Retracer::setDoubleBuffered(bool db)
+qint64 BlockingIODevice::writeData(const char * data, qint64 maxSize)
{
- m_doubleBuffered = db;
+ Q_ASSERT(false);
+ return -1;
}
-void Retracer::start()
+Q_DECLARE_METATYPE(QList<ApiTraceError>);
+
+Retracer::Retracer(QObject *parent)
+ : QThread(parent),
+ m_benchmarking(false),
+ m_doubleBuffered(true),
+ m_captureState(false),
+ m_captureCall(0)
{
- if (!m_process) {
+ qRegisterMetaType<QList<ApiTraceError> >();
+
#ifdef Q_OS_WIN
- QString format = QLatin1String("%1;");
+ QString format = QLatin1String("%1;");
#else
- QString format = QLatin1String("%1:");
+ QString format = QLatin1String("%1:");
#endif
- QString buildPath = format.arg(BUILD_DIR);
- QProcessEnvironment env = QProcessEnvironment::systemEnvironment();
- env.insert("PATH", buildPath + env.value("PATH"));
+ QString buildPath = format.arg(APITRACE_BINARY_DIR);
+ m_processEnvironment = QProcessEnvironment::systemEnvironment();
+ m_processEnvironment.insert("PATH", buildPath +
+ m_processEnvironment.value("PATH"));
- qputenv("PATH", env.value("PATH").toLatin1());
+ qputenv("PATH",
+ m_processEnvironment.value("PATH").toLatin1());
+}
- m_process = new QProcess(this);
- m_process->setProcessEnvironment(env);
+QString Retracer::fileName() const
+{
+ return m_fileName;
+}
- connect(m_process, SIGNAL(finished(int, QProcess::ExitStatus)),
- this, SLOT(replayFinished()));
- connect(m_process, SIGNAL(error(QProcess::ProcessError)),
- this, SLOT(replayError(QProcess::ProcessError)));
- }
+void Retracer::setFileName(const QString &name)
+{
+ m_fileName = name;
+}
- QStringList arguments;
+void Retracer::setAPI(trace::API api)
+{
+ m_api = api;
+}
- if (m_captureState) {
- arguments << QLatin1String("-D");
- arguments << QString::number(m_captureCall);
- } else {
- if (m_benchmarking) {
- arguments << QLatin1String("-b");
- }
- if (m_doubleBuffered) {
- arguments << QLatin1String("-db");
- }
- }
+bool Retracer::isBenchmarking() const
+{
+ return m_benchmarking;
+}
- arguments << m_fileName;
+void Retracer::setBenchmarking(bool bench)
+{
+ m_benchmarking = bench;
+}
- m_process->start(QLatin1String("glretrace"), arguments);
+bool Retracer::isDoubleBuffered() const
+{
+ return m_doubleBuffered;
}
-void Retracer::terminate()
+void Retracer::setDoubleBuffered(bool db)
{
- if (m_process) {
- m_process->terminate();
- }
+ m_doubleBuffered = db;
}
void Retracer::setCaptureAtCallNumber(qlonglong num)
m_captureState = enable;
}
-void Retracer::replayFinished()
+bool Retracer::captureThumbnails() const
{
- QByteArray output = m_process->readAllStandardOutput();
+ return m_captureThumbnails;
+}
-#if 0
- qDebug()<<"Process finished = ";
- qDebug()<<"\terr = "<<m_process->readAllStandardError();
- qDebug()<<"\tout = "<<output;
-#endif
- emit finished(output);
+void Retracer::setCaptureThumbnails(bool enable)
+{
+ m_captureThumbnails = enable;
}
-void Retracer::replayError(QProcess::ProcessError err)
+
+/**
+ * Starting point for the retracing thread.
+ *
+ * Overrides QThread::run().
+ */
+void Retracer::run()
{
- qDebug()<<"Process error = "<<err;
- qDebug()<<"\terr = "<<m_process->readAllStandardError();
- qDebug()<<"\tout = "<<m_process->readAllStandardOutput();
+ QString msg = QLatin1String("Replay finished!");
+
+ /*
+ * Construct command line
+ */
+
+ QString prog;
+ QStringList arguments;
+
+ switch (m_api) {
+ case trace::API_GL:
+ prog = QLatin1String("glretrace");
+ break;
+ case trace::API_EGL:
+ prog = QLatin1String("eglretrace");
+ break;
+ case trace::API_DX:
+ case trace::API_D3D7:
+ case trace::API_D3D8:
+ case trace::API_D3D9:
+ case trace::API_D3D10:
+ case trace::API_D3D10_1:
+ case trace::API_D3D11:
+#ifdef Q_OS_WIN
+ prog = QLatin1String("d3dretrace");
+#else
+ prog = QLatin1String("wine");
+ arguments << QLatin1String("d3dretrace.exe");
+#endif
+ break;
+ default:
+ emit finished(QLatin1String("Unsupported API"));
+ return;
+ }
+
+ if (m_doubleBuffered) {
+ arguments << QLatin1String("-db");
+ } else {
+ arguments << QLatin1String("-sb");
+ }
+
+ if (m_captureState) {
+ arguments << QLatin1String("-D");
+ arguments << QString::number(m_captureCall);
+ } else if (m_captureThumbnails) {
+ arguments << QLatin1String("-s"); // emit snapshots
+ arguments << QLatin1String("-"); // emit to stdout
+ } else if (m_benchmarking) {
+ arguments << QLatin1String("-b");
+ }
+
+ arguments << m_fileName;
+
+ /*
+ * Start the process.
+ */
+
+ QProcess process;
+
+ process.start(prog, arguments, QIODevice::ReadOnly);
+ if (!process.waitForStarted(-1)) {
+ emit finished(QLatin1String("Could not start process"));
+ return;
+ }
+
+ /*
+ * Process standard output
+ */
+
+ QList<QImage> thumbnails;
+ QVariantMap parsedJson;
+
+ process.setReadChannel(QProcess::StandardOutput);
+ if (process.waitForReadyRead(-1)) {
+ BlockingIODevice io(&process);
+
+ if (m_captureState) {
+ /*
+ * Parse JSON from the output.
+ *
+ * XXX: QJSON's scanner is inneficient as it abuses single
+ * character QIODevice::peek (not cheap), instead of maintaining a
+ * lookahead character on its own.
+ */
+
+ bool ok = false;
+ QJson::Parser jsonParser;
+#if 0
+ parsedJson = jsonParser.parse(&io, &ok).toMap();
+#else
+ /*
+ * XXX: QJSON expects blocking IO, and it looks like
+ * BlockingIODevice does not work reliably in all cases.
+ */
+ process.waitForFinished(-1);
+ parsedJson = jsonParser.parse(&process, &ok).toMap();
+#endif
+ if (!ok) {
+ msg = QLatin1String("failed to parse JSON");
+ }
+ } else if (m_captureThumbnails) {
+ /*
+ * Parse concatenated PNM images from output.
+ */
+
+ while (!io.atEnd()) {
+ unsigned channels = 0;
+ unsigned width = 0;
+ unsigned height = 0;
+
+ char header[512];
+ qint64 headerSize = 0;
+ int headerLines = 3; // assume no optional comment line
+
+ for (int headerLine = 0; headerLine < headerLines; ++headerLine) {
+ qint64 headerRead = io.readLine(&header[headerSize], sizeof(header) - headerSize);
+
+ // if header actually contains optional comment line, ...
+ if (headerLine == 1 && header[headerSize] == '#') {
+ ++headerLines;
+ }
+
+ headerSize += headerRead;
+ }
+
+ const char *headerEnd = image::readPNMHeader(header, headerSize, &channels, &width, &height);
+
+ // if invalid PNM header was encountered, ...
+ if (header == headerEnd) {
+ qDebug() << "error: invalid snapshot stream encountered";
+ break;
+ }
+
+ // qDebug() << "channels: " << channels << ", width: " << width << ", height: " << height";
+
+ QImage snapshot = QImage(width, height, channels == 1 ? QImage::Format_Mono : QImage::Format_RGB888);
+
+ int rowBytes = channels * width;
+ for (int y = 0; y < height; ++y) {
+ unsigned char *scanLine = snapshot.scanLine(y);
+ qint64 readBytes = io.read((char *) scanLine, rowBytes);
+ Q_ASSERT(readBytes == rowBytes);
+ }
+
+ QImage thumb = thumbnail(snapshot);
+ thumbnails.append(thumb);
+ }
+
+ Q_ASSERT(process.state() != QProcess::Running);
+
+ } else {
+ QByteArray output;
+ output = process.readAllStandardOutput();
+ if (output.length() < 80) {
+ msg = QString::fromUtf8(output);
+ }
+ }
+ }
+
+ /*
+ * Wait for process termination
+ */
+
+ process.waitForFinished(-1);
+
+ if (process.exitStatus() != QProcess::NormalExit) {
+ msg = QLatin1String("Process crashed");
+ } else if (process.exitCode() != 0) {
+ msg = QLatin1String("Process exited with non zero exit code");
+ }
+
+ /*
+ * Parse errors.
+ */
+
+ QList<ApiTraceError> errors;
+ process.setReadChannel(QProcess::StandardError);
+ QRegExp regexp("(^\\d+): +(\\b\\w+\\b): ([^\\r\\n]+)[\\r\\n]*$");
+ while (!process.atEnd()) {
+ QString line = process.readLine();
+ if (regexp.indexIn(line) != -1) {
+ ApiTraceError error;
+ error.callIndex = regexp.cap(1).toInt();
+ error.type = regexp.cap(2);
+ error.message = regexp.cap(3);
+ errors.append(error);
+ }
+ }
+
+ /*
+ * Emit signals
+ */
+
+ if (m_captureState) {
+ ApiTraceState *state = new ApiTraceState(parsedJson);
+ emit foundState(state);
+ msg = QLatin1String("State fetched.");
+ }
+
+ if (m_captureThumbnails && !thumbnails.isEmpty()) {
+ emit foundThumbnails(thumbnails);
+ }
+
+ if (!errors.isEmpty()) {
+ emit retraceErrors(errors);
+ }
- emit error(
- tr("Couldn't execute the replay file '%1'").arg(m_fileName));
+ emit finished(msg);
}
#include "retracer.moc"