git.cworth.org Git - apitrace/blob - gui/retracer.cpp

   1 #include "retracer.h"
   2
   3 #include "apitracecall.h"
   4 #include "thumbnail.h"
   5
   6 #include "image.hpp"
   7
   8 #include <QDebug>
   9 #include <QVariant>
  10 #include <QList>
  11 #include <QImage>
  12
  13 #include <qjson/parser.h>
  14
  15 /**
  16  * Wrapper around a QProcess which enforces IO to block .
  17  *
  18  * Several QIODevice users (notably QJSON) expect blocking semantics, e.g.,
  19  * they expect that QIODevice::read() will blocked until the requested ammount
  20  * of bytes is read or end of file is reached. But by default QProcess, does
  21  * not block.  And passing QIODevice::Unbuffered mitigates but does not fully
  22  * address the problem either.
  23  *
  24  * This class wraps around QProcess, providing QIODevice interface, while
  25  * ensuring that all reads block.
  26  *
  27  * This class also works around a bug in QProcess::atEnd() implementation.
  28  *
  29  * See also:
  30  * - http://qt-project.org/wiki/Simple_Crypt_IO_Device
  31  * - http://qt-project.org/wiki/Custom_IO_Device
  32  */
  33 class BlockingIODevice : public QIODevice
  34 {
  35     /* We don't use the Q_OBJECT in this class given we don't declare any
  36      * signals and slots or use any other services provided by Qt's meta-object
  37      * system. */
  38 public:
  39     BlockingIODevice(QProcess * io);
  40     bool isSequential() const;
  41     bool atEnd() const;
  42     bool waitForReadyRead(int msecs = -1);
  43
  44 protected:
  45     qint64 readData(char * data, qint64 maxSize);
  46     qint64 writeData(const char * data, qint64 maxSize);
  47
  48 private:
  49     QProcess *m_device;
  50 };
  51
  52 BlockingIODevice::BlockingIODevice(QProcess * io) :
  53     m_device(io)
  54 {
  55     /*
  56      * We pass QIODevice::Unbuffered to prevent the base QIODevice class to do
  57      * its own buffering on top of the overridden readData() method.
  58      *
  59      * The only buffering used will be to satisfy QIODevice::peek() and
  60      * QIODevice::ungetChar().
  61      */
  62     setOpenMode(ReadOnly | Unbuffered);
  63 }
  64
  65 bool BlockingIODevice::isSequential() const
  66 {
  67     return true;
  68 }
  69
  70 bool BlockingIODevice::atEnd() const
  71 {
  72     /*
  73      * XXX: QProcess::atEnd() documentation is wrong -- it will return true
  74      * even when the process is running --, so we try to workaround that here.
  75      */
  76     if (m_device->atEnd()) {
  77         if (m_device->state() == QProcess::Running) {
  78             if (!m_device->waitForReadyRead(-1)) {
  79                 return true;
  80             }
  81         }
  82     }
  83     return false;
  84 }
  85
  86 bool BlockingIODevice::waitForReadyRead(int msecs)
  87 {
  88     Q_UNUSED(msecs);
  89     return true;
  90 }
  91
  92 qint64 BlockingIODevice::readData(char * data, qint64 maxSize)
  93 {
  94     qint64 bytesToRead = maxSize;
  95     qint64 readSoFar = 0;
  96     do {
  97         qint64 chunkSize = m_device->read(data + readSoFar, bytesToRead);
  98         if (chunkSize < 0) {
  99             if (readSoFar) {
 100                 return readSoFar;
 101             } else {
 102                 return chunkSize;
 103             }
 104         }
 105         Q_ASSERT(chunkSize <= bytesToRead);
 106         bytesToRead -= chunkSize;
 107         readSoFar += chunkSize;
 108         if (bytesToRead) {
 109             if (!m_device->waitForReadyRead(-1)) {
 110                 qDebug() << "waitForReadyRead failed\n";
 111                 break;
 112             }
 113         }
 114     } while(bytesToRead);
 115
 116     return readSoFar;
 117 }
 118
 119 qint64 BlockingIODevice::writeData(const char * data, qint64 maxSize)
 120 {
 121     Q_ASSERT(false);
 122     return -1;
 123 }
 124
 125 Q_DECLARE_METATYPE(QList<ApiTraceError>);
 126
 127 Retracer::Retracer(QObject *parent)
 128     : QThread(parent),
 129       m_benchmarking(false),
 130       m_doubleBuffered(true),
 131       m_captureState(false),
 132       m_captureCall(0)
 133 {
 134     qRegisterMetaType<QList<ApiTraceError> >();
 135
 136 #ifdef Q_OS_WIN
 137     QString format = QLatin1String("%1;");
 138 #else
 139     QString format = QLatin1String("%1:");
 140 #endif
 141     QString buildPath = format.arg(APITRACE_BINARY_DIR);
 142     m_processEnvironment = QProcessEnvironment::systemEnvironment();
 143     m_processEnvironment.insert("PATH", buildPath +
 144                                 m_processEnvironment.value("PATH"));
 145
 146     qputenv("PATH",
 147             m_processEnvironment.value("PATH").toLatin1());
 148 }
 149
 150 QString Retracer::fileName() const
 151 {
 152     return m_fileName;
 153 }
 154
 155 void Retracer::setFileName(const QString &name)
 156 {
 157     m_fileName = name;
 158 }
 159
 160 void Retracer::setAPI(trace::API api)
 161 {
 162     m_api = api;
 163 }
 164
 165 bool Retracer::isBenchmarking() const
 166 {
 167     return m_benchmarking;
 168 }
 169
 170 void Retracer::setBenchmarking(bool bench)
 171 {
 172     m_benchmarking = bench;
 173 }
 174
 175 bool Retracer::isDoubleBuffered() const
 176 {
 177     return m_doubleBuffered;
 178 }
 179
 180 void Retracer::setDoubleBuffered(bool db)
 181 {
 182     m_doubleBuffered = db;
 183 }
 184
 185 void Retracer::setCaptureAtCallNumber(qlonglong num)
 186 {
 187     m_captureCall = num;
 188 }
 189
 190 qlonglong Retracer::captureAtCallNumber() const
 191 {
 192     return m_captureCall;
 193 }
 194
 195 bool Retracer::captureState() const
 196 {
 197     return m_captureState;
 198 }
 199
 200 void Retracer::setCaptureState(bool enable)
 201 {
 202     m_captureState = enable;
 203 }
 204
 205 bool Retracer::captureThumbnails() const
 206 {
 207     return m_captureThumbnails;
 208 }
 209
 210 void Retracer::setCaptureThumbnails(bool enable)
 211 {
 212     m_captureThumbnails = enable;
 213 }
 214
 215
 216 /**
 217  * Starting point for the retracing thread.
 218  *
 219  * Overrides QThread::run().
 220  */
 221 void Retracer::run()
 222 {
 223     QString msg = QLatin1String("Replay finished!");
 224
 225     /*
 226      * Construct command line
 227      */
 228
 229     QString prog;
 230     QStringList arguments;
 231
 232     if (m_api == trace::API_GL) {
 233         prog = QLatin1String("glretrace");
 234     } else if (m_api == trace::API_EGL) {
 235         prog = QLatin1String("eglretrace");
 236     } else {
 237         emit finished(QLatin1String("Unsupported API"));
 238         return;
 239     }
 240
 241     if (m_doubleBuffered) {
 242         arguments << QLatin1String("-db");
 243     } else {
 244         arguments << QLatin1String("-sb");
 245     }
 246
 247     if (m_captureState) {
 248         arguments << QLatin1String("-D");
 249         arguments << QString::number(m_captureCall);
 250     } else if (m_captureThumbnails) {
 251         arguments << QLatin1String("-s"); // emit snapshots
 252         arguments << QLatin1String("-"); // emit to stdout
 253     } else if (m_benchmarking) {
 254         arguments << QLatin1String("-b");
 255     }
 256
 257     arguments << m_fileName;
 258
 259     /*
 260      * Start the process.
 261      */
 262
 263     QProcess process;
 264
 265     process.start(prog, arguments, QIODevice::ReadOnly);
 266     if (!process.waitForStarted(-1)) {
 267         emit finished(QLatin1String("Could not start process"));
 268         return;
 269     }
 270
 271     /*
 272      * Process standard output
 273      */
 274
 275     QList<QImage> thumbnails;
 276     QVariantMap parsedJson;
 277
 278     process.setReadChannel(QProcess::StandardOutput);
 279     if (process.waitForReadyRead(-1)) {
 280         BlockingIODevice io(&process);
 281
 282         if (m_captureState) {
 283             /*
 284              * Parse JSON from the output.
 285              *
 286              * XXX: QJSON's scanner is inneficient as it abuses single
 287              * character QIODevice::peek (not cheap), instead of maintaining a
 288              * lookahead character on its own.
 289              */
 290
 291             bool ok = false;
 292             QJson::Parser jsonParser;
 293 #if 0
 294             parsedJson = jsonParser.parse(&io, &ok).toMap();
 295 #else
 296             /*
 297              * XXX: QJSON expects blocking IO, and it looks like
 298              * BlockingIODevice does not work reliably in all cases.
 299              */
 300             process.waitForFinished(-1);
 301             parsedJson = jsonParser.parse(&process, &ok).toMap();
 302 #endif
 303             if (!ok) {
 304                 msg = QLatin1String("failed to parse JSON");
 305             }
 306         } else if (m_captureThumbnails) {
 307             /*
 308              * Parse concatenated PNM images from output.
 309              */
 310
 311             while (!io.atEnd()) {
 312                 unsigned channels = 0;
 313                 unsigned width = 0;
 314                 unsigned height = 0;
 315
 316                 char header[512];
 317                 qint64 headerSize = 0;
 318                 int headerLines = 3; // assume no optional comment line
 319
 320                 for (int headerLine = 0; headerLine < headerLines; ++headerLine) {
 321                     qint64 headerRead = io.readLine(&header[headerSize], sizeof(header) - headerSize);
 322
 323                     // if header actually contains optional comment line, ...
 324                     if (headerLine == 1 && header[headerSize] == '#') {
 325                         ++headerLines;
 326                     }
 327
 328                     headerSize += headerRead;
 329                 }
 330
 331                 const char *headerEnd = image::readPNMHeader(header, headerSize, &channels, &width, &height);
 332
 333                 // if invalid PNM header was encountered, ...
 334                 if (header == headerEnd) {
 335                     qDebug() << "error: invalid snapshot stream encountered";
 336                     break;
 337                 }
 338
 339                 // qDebug() << "channels: " << channels << ", width: " << width << ", height: " << height";
 340
 341                 QImage snapshot = QImage(width, height, channels == 1 ? QImage::Format_Mono : QImage::Format_RGB888);
 342
 343                 int rowBytes = channels * width;
 344                 for (int y = 0; y < height; ++y) {
 345                     unsigned char *scanLine = snapshot.scanLine(y);
 346                     qint64 readBytes = io.read((char *) scanLine, rowBytes);
 347                     Q_ASSERT(readBytes == rowBytes);
 348                 }
 349
 350                 QImage thumb = thumbnail(snapshot);
 351                 thumbnails.append(thumb);
 352             }
 353
 354             Q_ASSERT(process.state() != QProcess::Running);
 355
 356         } else {
 357             QByteArray output;
 358             output = process.readAllStandardOutput();
 359             if (output.length() < 80) {
 360                 msg = QString::fromUtf8(output);
 361             }
 362         }
 363     }
 364
 365     /*
 366      * Wait for process termination
 367      */
 368
 369     process.waitForFinished(-1);
 370
 371     if (process.exitStatus() != QProcess::NormalExit) {
 372         msg = QLatin1String("Process crashed");
 373     } else if (process.exitCode() != 0) {
 374         msg = QLatin1String("Process exited with non zero exit code");
 375     }
 376
 377     /*
 378      * Parse errors.
 379      */
 380
 381     QList<ApiTraceError> errors;
 382     process.setReadChannel(QProcess::StandardError);
 383     QRegExp regexp("(^\\d+): +(\\b\\w+\\b): ([^\\r\\n]+)[\\r\\n]*$");
 384     while (!process.atEnd()) {
 385         QString line = process.readLine();
 386         if (regexp.indexIn(line) != -1) {
 387             ApiTraceError error;
 388             error.callIndex = regexp.cap(1).toInt();
 389             error.type = regexp.cap(2);
 390             error.message = regexp.cap(3);
 391             errors.append(error);
 392         }
 393     }
 394
 395     /*
 396      * Emit signals
 397      */
 398
 399     if (m_captureState) {
 400         ApiTraceState *state = new ApiTraceState(parsedJson);
 401         emit foundState(state);
 402         msg = QLatin1String("State fetched.");
 403     }
 404
 405     if (m_captureThumbnails && !thumbnails.isEmpty()) {
 406         emit foundThumbnails(thumbnails);
 407     }
 408
 409     if (!errors.isEmpty()) {
 410         emit retraceErrors(errors);
 411     }
 412
 413     emit finished(msg);
 414 }
 415
 416 #include "retracer.moc"