X-Git-Url: https://git.cworth.org/git?a=blobdiff_plain;f=gui%2Fapitracecall.cpp;h=79876351a12807039e76bd5aba16c9a3dfb1d591;hb=d9d9d22837705de6a2c42ad3f9b23223a2b98fe0;hp=bc88c3b4f29bc2c40fb4e78a8467d986fae64aff;hpb=d31700077ae75f450b12ad7d9276c08cbad57d1b;p=apitrace diff --git a/gui/apitracecall.cpp b/gui/apitracecall.cpp index bc88c3b..7987635 100644 --- a/gui/apitracecall.cpp +++ b/gui/apitracecall.cpp @@ -192,15 +192,13 @@ void VariantVisitor::visit(trace::Enum *e) sig = m_loader->enumSignature(e->sig->id); } if (!sig) { - sig = new ApiTraceEnumSignature( - QString::fromStdString(e->sig->name), - QVariant(e->sig->value)); + sig = new ApiTraceEnumSignature(e->sig); if (m_loader) { m_loader->addEnumSignature(e->sig->id, sig); } } - m_variant = QVariant::fromValue(ApiEnum(sig)); + m_variant = QVariant::fromValue(ApiEnum(sig, e->value)); } void VariantVisitor::visit(trace::Bitmask *bitmask) @@ -229,16 +227,45 @@ void VariantVisitor::visit(trace::Pointer *ptr) m_variant = QVariant::fromValue(ApiPointer(ptr->value)); } +void VariantVisitor::visit(trace::Repr *repr) +{ + /* TODO: Preserve both the human and machine value */ + repr->humanValue->visit(*this); +} + +ApiTraceEnumSignature::ApiTraceEnumSignature(const trace::EnumSig *sig) +{ + for (const trace::EnumValue *it = sig->values; + it != sig->values + sig->num_values; ++it) { + QPair pair; + + pair.first = QString::fromStdString(it->name); + pair.second = it->value; + + m_names.append(pair); + } +} + +QString ApiTraceEnumSignature::name(signed long long value) const +{ + for (ValueList::const_iterator it = m_names.begin(); + it != m_names.end(); ++it) { + if (value == it->second) { + return it->first; + } + } + return QString::fromLatin1("%1").arg(value); +} -ApiEnum::ApiEnum(ApiTraceEnumSignature *sig) - : m_sig(sig) +ApiEnum::ApiEnum(ApiTraceEnumSignature *sig, signed long long value) + : m_sig(sig), m_value(value) { } QString ApiEnum::toString() const { if (m_sig) { - return m_sig->name(); + return m_sig->name(m_value); } Q_ASSERT(!"should never happen"); return QString(); @@ -247,7 +274,7 @@ QString ApiEnum::toString() const QVariant ApiEnum::value() const { if (m_sig) { - return m_sig->value(); + return QVariant::fromValue(m_value); } Q_ASSERT(!"should never happen"); return QVariant(); @@ -256,7 +283,7 @@ QVariant ApiEnum::value() const QString ApiEnum::name() const { if (m_sig) { - return m_sig->name(); + return m_sig->name(m_value); } Q_ASSERT(!"should never happen"); return QString(); @@ -315,7 +342,6 @@ void ApiBitmask::init(const trace::Bitmask *bitmask) m_value = bitmask->value; for (const trace::BitmaskFlag *it = bitmask->sig->flags; it != bitmask->sig->flags + bitmask->sig->num_flags; ++it) { - assert(it->value); QPair pair; pair.first = QString::fromStdString(it->name); @@ -330,10 +356,10 @@ QString ApiBitmask::toString() const QString str; unsigned long long value = m_value; bool first = true; - for (Signature::const_iterator it = m_sig.begin(); - value != 0 && it != m_sig.end(); ++it) { - Q_ASSERT(it->second); - if ((value & it->second) == it->second) { + for (Signature::const_iterator it = m_sig.begin(); it != m_sig.end(); ++it) { + Q_ASSERT(it->second || first); + if ((it->second && (value & it->second) == it->second) || + (!it->second && value == 0)) { if (!first) { str += QLatin1String(" | "); } @@ -341,6 +367,9 @@ QString ApiBitmask::toString() const value &= ~it->second; first = false; } + if (value == 0) { + break; + } } if (value || first) { if (!first) { @@ -461,20 +490,11 @@ ApiTraceState::ApiTraceState(const QVariantMap &parsedJson) QSize size(image[QLatin1String("__width__")].toInt(), image[QLatin1String("__height__")].toInt()); QString cls = image[QLatin1String("__class__")].toString(); - QString type = image[QLatin1String("__type__")].toString(); - bool normalized = - image[QLatin1String("__normalized__")].toBool(); - int numChannels = - image[QLatin1String("__channels__")].toInt(); int depth = image[QLatin1String("__depth__")].toInt(); QString formatName = image[QLatin1String("__format__")].toString(); - Q_ASSERT(type == QLatin1String("uint8")); - Q_ASSERT(normalized == true); - Q_UNUSED(normalized); - QByteArray dataArray = image[QLatin1String("__data__")].toByteArray(); @@ -482,7 +502,6 @@ ApiTraceState::ApiTraceState(const QVariantMap &parsedJson) tex.setSize(size); tex.setDepth(depth); tex.setFormatName(formatName); - tex.setNumChannels(numChannels); tex.setLabel(itr.key()); tex.contentsFromBase64(dataArray); @@ -496,16 +515,9 @@ ApiTraceState::ApiTraceState(const QVariantMap &parsedJson) QSize size(buffer[QLatin1String("__width__")].toInt(), buffer[QLatin1String("__height__")].toInt()); QString cls = buffer[QLatin1String("__class__")].toString(); - QString type = buffer[QLatin1String("__type__")].toString(); - bool normalized = buffer[QLatin1String("__normalized__")].toBool(); - int numChannels = buffer[QLatin1String("__channels__")].toInt(); int depth = buffer[QLatin1String("__depth__")].toInt(); QString formatName = buffer[QLatin1String("__format__")].toString(); - Q_ASSERT(type == QLatin1String("uint8")); - Q_ASSERT(normalized == true); - Q_UNUSED(normalized); - QByteArray dataArray = buffer[QLatin1String("__data__")].toByteArray(); @@ -513,7 +525,6 @@ ApiTraceState::ApiTraceState(const QVariantMap &parsedJson) fbo.setSize(size); fbo.setDepth(depth); fbo.setFormatName(formatName); - fbo.setNumChannels(numChannels); fbo.setType(itr.key()); fbo.contentsFromBase64(dataArray); m_framebuffers.append(fbo); @@ -537,7 +548,10 @@ const QVariantMap & ApiTraceState::uniforms() const bool ApiTraceState::isEmpty() const { - return m_parameters.isEmpty(); + return m_parameters.isEmpty() && + m_shaderSources.isEmpty() && + m_textures.isEmpty() && + m_framebuffers.isEmpty(); } const QList & ApiTraceState::textures() const @@ -634,7 +648,31 @@ ApiTraceCall::ApiTraceCall(ApiTraceFrame *parentFrame, TraceLoader *loader, const trace::Call *call) : ApiTraceEvent(ApiTraceEvent::Call), - m_parentFrame(parentFrame) + m_parentFrame(parentFrame), + m_parentCall(0) +{ + loadData(loader, call); +} + +ApiTraceCall::ApiTraceCall(ApiTraceCall *parentCall, + TraceLoader *loader, + const trace::Call *call) + : ApiTraceEvent(ApiTraceEvent::Call), + m_parentFrame(parentCall->parentFrame()), + m_parentCall(parentCall) +{ + loadData(loader, call); +} + + +ApiTraceCall::~ApiTraceCall() +{ +} + + +void +ApiTraceCall::loadData(TraceLoader *loader, + const trace::Call *call) { m_index = call->no; @@ -657,9 +695,9 @@ ApiTraceCall::ApiTraceCall(ApiTraceFrame *parentFrame, } m_argValues.reserve(call->args.size()); for (int i = 0; i < call->args.size(); ++i) { - if (call->args[i]) { + if (call->args[i].value) { VariantVisitor argVisitor(loader); - call->args[i]->visit(argVisitor); + call->args[i].value->visit(argVisitor); m_argValues.append(argVisitor.variant()); if (m_argValues[i].type() == QVariant::ByteArray) { m_hasBinaryData = true; @@ -671,12 +709,73 @@ ApiTraceCall::ApiTraceCall(ApiTraceFrame *parentFrame, } m_argValues.squeeze(); m_flags = call->flags; + if (call->backtrace != NULL) { + QString qbacktrace; + for (int i = 0; i < call->backtrace->size(); i++) { + const trace::StackFrame * frame = (*call->backtrace)[i]; + if (frame->module != NULL) { + qbacktrace += QString("%1 ").arg(frame->module); + } + if (frame->function != NULL) { + qbacktrace += QString("at %1() ").arg(frame->function); + } + if (frame->filename != NULL) { + qbacktrace += QString("at %1").arg(frame->filename); + if (frame->linenumber >= 0) { + qbacktrace += QString(":%1 ").arg(frame->linenumber); + } + } + else { + if (frame->offset >= 0) { + qbacktrace += QString("[0x%1]").arg(frame->offset, 0, 16); + } + } + qbacktrace += "\n"; + } + this->setBacktrace(qbacktrace); + } } -ApiTraceCall::~ApiTraceCall() +ApiTraceCall * +ApiTraceCall::parentCall() const +{ + return m_parentCall; +} + + +ApiTraceEvent * +ApiTraceCall::parentEvent() const +{ + if (m_parentCall) + return m_parentCall; + else + return m_parentFrame; +} + +QVector +ApiTraceCall::children() const +{ + return m_children; +} + +void +ApiTraceCall::addChild(ApiTraceCall *call) +{ + m_children.append(call); +} + + +int +ApiTraceCall::callIndex(ApiTraceCall *call) const { + return m_children.indexOf(call); } +void +ApiTraceCall::finishedAddingChildren() +{ + m_children.squeeze(); +} bool ApiTraceCall::hasError() const { @@ -781,6 +880,15 @@ QVector ApiTraceCall::arguments() const return m_editedValues; } +ApiTraceEvent * +ApiTraceCall::eventAtRow(int row) const +{ + if (row < m_children.count()) + return m_children.value(row); + else + return NULL; +} + QVariant ApiTraceCall::returnValue() const { return m_returnValue; @@ -806,6 +914,16 @@ int ApiTraceCall::binaryDataIndex() const return m_binaryDataIndex; } +QString ApiTraceCall::backtrace() const +{ + return m_backtrace; +} + +void ApiTraceCall::setBacktrace(QString backtrace) +{ + m_backtrace = backtrace; +} + QStaticText ApiTraceCall::staticText() const { if (m_staticText && !m_staticText->text().isEmpty()) @@ -962,7 +1080,7 @@ QString ApiTraceCall::searchText() const int ApiTraceCall::numChildren() const { - return 0; + return m_children.count(); } bool ApiTraceCall::contains(const QString &str, @@ -1025,22 +1143,17 @@ QStaticText ApiTraceFrame::staticText() const int ApiTraceFrame::numChildren() const { - return m_calls.count(); + return m_children.count(); } -ApiTrace * ApiTraceFrame::parentTrace() const +int ApiTraceFrame::numTotalCalls() const { - return m_parentTrace; + return m_calls.count(); } -void ApiTraceFrame::addCall(ApiTraceCall *call) +ApiTrace * ApiTraceFrame::parentTrace() const { - m_calls.append(call); - if (call->hasBinaryData()) { - QByteArray data = - call->arguments()[call->binaryDataIndex()].toByteArray(); - m_binaryDataSize += data.size(); - } + return m_parentTrace; } QVector ApiTraceFrame::calls() const @@ -1048,9 +1161,12 @@ QVector ApiTraceFrame::calls() const return m_calls; } -ApiTraceCall * ApiTraceFrame::call(int idx) const +ApiTraceEvent * ApiTraceFrame::eventAtRow(int row) const { - return m_calls.value(idx); + if (row < m_children.count()) + return m_children.value(row); + else + return NULL; } @@ -1067,7 +1183,7 @@ ApiTraceCall * ApiTraceFrame::callWithIndex(int index) const int ApiTraceFrame::callIndex(ApiTraceCall *call) const { - return m_calls.indexOf(call); + return m_children.indexOf(call); } bool ApiTraceFrame::isEmpty() const @@ -1084,9 +1200,11 @@ int ApiTraceFrame::binaryDataSize() const return m_binaryDataSize; } -void ApiTraceFrame::setCalls(const QVector &calls, +void ApiTraceFrame::setCalls(const QVector &children, + const QVector &calls, quint64 binaryDataSize) { + m_children = children; m_calls = calls; m_binaryDataSize = binaryDataSize; m_loaded = true; @@ -1099,11 +1217,6 @@ bool ApiTraceFrame::isLoaded() const return m_loaded; } -void ApiTraceFrame::setLoaded(bool l) -{ - m_loaded = l; -} - void ApiTraceFrame::setNumChildren(int num) { m_callsToLoad = num; @@ -1176,3 +1289,13 @@ unsigned ApiTraceFrame::lastCallIndex() const return m_lastCallIndex; } } + +void ApiTraceFrame::setThumbnail(const QImage & thumbnail) +{ + m_thumbnail = thumbnail; +} + +const QImage & ApiTraceFrame::thumbnail() const +{ + return m_thumbnail; +}