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 expects blocking IO.
 287              *
 288              * XXX: QJSON's scanner is inneficient as it abuses single
 289              * character QIODevice::peek (not cheap), instead of maintaining a
 290              * lookahead character on its own.
 291              */
 292
 293             bool ok = false;
 294             QJson::Parser jsonParser;
 295             parsedJson = jsonParser.parse(&io, &ok).toMap();
 296             if (!ok) {
 297                 msg = QLatin1String("failed to parse JSON");
 298             }
 299         } else if (m_captureThumbnails) {
 300             /*
 301              * Parse concatenated PNM images from output.
 302              */
 303
 304             while (!io.atEnd()) {
 305                 unsigned channels = 0;
 306                 unsigned width = 0;
 307                 unsigned height = 0;
 308
 309                 char header[512];
 310                 qint64 headerSize = 0;
 311                 int headerLines = 3; // assume no optional comment line
 312
 313                 for (int headerLine = 0; headerLine < headerLines; ++headerLine) {
 314                     qint64 headerRead = io.readLine(&header[headerSize], sizeof(header) - headerSize);
 315
 316                     // if header actually contains optional comment line, ...
 317                     if (headerLine == 1 && header[headerSize] == '#') {
 318                         ++headerLines;
 319                     }
 320
 321                     headerSize += headerRead;
 322                 }
 323
 324                 const char *headerEnd = image::readPNMHeader(header, headerSize, &channels, &width, &height);
 325
 326                 // if invalid PNM header was encountered, ...
 327                 if (header == headerEnd) {
 328                     qDebug() << "error: invalid snapshot stream encountered";
 329                     break;
 330                 }
 331
 332                 // qDebug() << "channels: " << channels << ", width: " << width << ", height: " << height";
 333
 334                 QImage snapshot = QImage(width, height, channels == 1 ? QImage::Format_Mono : QImage::Format_RGB888);
 335
 336                 int rowBytes = channels * width;
 337                 for (int y = 0; y < height; ++y) {
 338                     unsigned char *scanLine = snapshot.scanLine(y);
 339                     qint64 readBytes = io.read((char *) scanLine, rowBytes);
 340                     Q_ASSERT(readBytes == rowBytes);
 341                 }
 342
 343                 QImage thumb = thumbnail(snapshot);
 344                 thumbnails.append(thumb);
 345             }
 346
 347             Q_ASSERT(process.state() != QProcess::Running);
 348
 349         } else {
 350             QByteArray output;
 351             output = process.readAllStandardOutput();
 352             if (output.length() < 80) {
 353                 msg = QString::fromUtf8(output);
 354             }
 355         }
 356     }
 357
 358     /*
 359      * Wait for process termination
 360      */
 361
 362     process.waitForFinished(-1);
 363
 364     if (process.exitStatus() != QProcess::NormalExit) {
 365         msg = QLatin1String("Process crashed");
 366     } else if (process.exitCode() != 0) {
 367         msg = QLatin1String("Process exited with non zero exit code");
 368     }
 369
 370     /*
 371      * Parse errors.
 372      */
 373
 374     QList<ApiTraceError> errors;
 375     process.setReadChannel(QProcess::StandardError);
 376     QRegExp regexp("(^\\d+): +(\\b\\w+\\b): ([^\\r\\n]+)[\\r\\n]*$");
 377     while (!process.atEnd()) {
 378         QString line = process.readLine();
 379         if (regexp.indexIn(line) != -1) {
 380             ApiTraceError error;
 381             error.callIndex = regexp.cap(1).toInt();
 382             error.type = regexp.cap(2);
 383             error.message = regexp.cap(3);
 384             errors.append(error);
 385         }
 386     }
 387
 388     /*
 389      * Emit signals
 390      */
 391
 392     if (m_captureState) {
 393         ApiTraceState *state = new ApiTraceState(parsedJson);
 394         emit foundState(state);
 395         msg = QLatin1String("State fetched.");
 396     }
 397
 398     if (m_captureThumbnails && !thumbnails.isEmpty()) {
 399         emit foundThumbnails(thumbnails);
 400     }
 401
 402     if (!errors.isEmpty()) {
 403         emit retraceErrors(errors);
 404     }
 405
 406     emit finished(msg);
 407 }
 408
 409 #include "retracer.moc"