UI: vogleditor_tracereplayer now outputs messages regarding success of replaying...

* NOTE: GL errors / warnings that vogl detects during the replay are not yet redirected back to vogleditor
* The tracereplayer now has better return values to indicate the difference between an error, the user closing the replay window, a successful snapshot, and a successful replay.

diff --git a/src/vogleditor/vogleditor.cpp b/src/vogleditor/vogleditor.cpp
index 14da0b21bb299dfc72045a939d0257c173001c9f..c609a5f4e474b9b83a1d67daf4f1d568bd0317ba 100644 (file)
--- a/src/vogleditor/vogleditor.cpp
+++ b/src/vogleditor/vogleditor.cpp
@@ -323,16 +323,10 @@ void VoglEditor::playCurrentTraceFile()
     m_pPlayButton->setEnabled(false);
     m_pTrimButton->setEnabled(false);
 
-    if (m_traceReplayer.replay(m_pTraceReader, m_pApiCallTreeModel->root(), NULL, 0, true))
-    {
-        // replay was successful
-        m_pPlayButton->setEnabled(true);
-        m_pTrimButton->setEnabled(true);
-    }
-    else
-    {
-        vogleditor_output_error("Failed to replay the trace.");
-    }
+    m_traceReplayer.replay(m_pTraceReader, m_pApiCallTreeModel->root(), NULL, 0, true);
+
+    m_pPlayButton->setEnabled(true);
+    m_pTrimButton->setEnabled(true);
 
     setCursor(origCursor);
 }
@@ -1522,6 +1516,7 @@ void VoglEditor::update_ui_for_snapshot(vogleditor_gl_state_snapshot* pStateSnap
                GLuint cur2DBinding = pContext->get_general_state().get_value<GLuint>(GL_TEXTURE_2D_BINDING_EXT, curActiveTextureUnit - GL_TEXTURE0);
                displayTexture(cur2DBinding, false);
            }
+           if (textureObjects.size() > 0) { VOGLEDITOR_ENABLE_STATE_TAB(ui->textureTab); }
 
            // renderbuffers
            vogl_gl_object_state_ptr_vec renderbufferObjects;
@@ -1535,6 +1530,7 @@ void VoglEditor::update_ui_for_snapshot(vogleditor_gl_state_snapshot* pStateSnap
            m_pFramebufferExplorer->set_framebuffer_objects(framebufferObjects, *pContext, pStateSnapshot->get_default_framebuffer());
            GLuint64 curDrawFramebuffer = pContext->get_general_state().get_value<GLuint64>(GL_DRAW_FRAMEBUFFER_BINDING);
            displayFramebuffer(curDrawFramebuffer, false);
+           if (framebufferObjects.size() > 0) { VOGLEDITOR_ENABLE_STATE_TAB(ui->framebufferTab); }
 
            // programs
            vogl_gl_object_state_ptr_vec programObjects;

diff --git a/src/vogleditor/vogleditor_tracereplayer.cpp b/src/vogleditor/vogleditor_tracereplayer.cpp
index c7d826bd4cc65661c5f6d7c0c03dc501bd6cc8f0..bb3ba4329f6b0fb4d47e7649c7e097fedccd8f05 100644 (file)
--- a/src/vogleditor/vogleditor_tracereplayer.cpp
+++ b/src/vogleditor/vogleditor_tracereplayer.cpp
@@ -6,7 +6,7 @@
 #include "vogl_find_files.h"
 #include "vogl_file_utils.h"
 #include "vogl_gl_replayer.h"
-
+#include "vogleditor_output.h"
 
 vogleditor_traceReplayer::vogleditor_traceReplayer()
     : m_pTraceReplayer(vogl_new(vogl_gl_replayer))
@@ -107,7 +107,7 @@ bool vogleditor_traceReplayer::applying_snapshot_and_process_resize(const vogl_g
     bool bStatus = true;
     while (status == vogl_gl_replayer::cStatusResizeWindow)
     {
-        vogl_warning_printf("%s: Waiting for window to resize\n", VOGL_METHOD_NAME);
+        vogleditor_output_message("Waiting for replay window to resize.");
 
         // Pump X events in case the window is resizing
         if (process_x_events())
@@ -123,17 +123,16 @@ bool vogleditor_traceReplayer::applying_snapshot_and_process_resize(const vogl_g
 
     if (bStatus && status != vogl_gl_replayer::cStatusOK)
     {
-        vogl_error_printf("%s: Replay unable to apply snapshot\n", VOGL_FUNCTION_NAME);
+        vogleditor_output_error("Replay unable to apply snapshot");
         bStatus = false;
     }
 
     return bStatus;
 }
 
-bool vogleditor_traceReplayer::recursive_replay_apicallTreeItem(vogleditor_apiCallTreeItem* pItem, vogleditor_gl_state_snapshot** ppNewSnapshot, uint64_t apiCallNumber)
+vogleditor_tracereplayer_result vogleditor_traceReplayer::recursive_replay_apicallTreeItem(vogleditor_apiCallTreeItem* pItem, vogleditor_gl_state_snapshot** ppNewSnapshot, uint64_t apiCallNumber)
 {
-    bool bStatus = true;
-
+    vogleditor_tracereplayer_result result = VOGLEDITOR_TRR_SUCCESS;
     vogleditor_apiCallItem* pApiCall = pItem->apiCallItem();
     if (pApiCall != NULL)
     {
@@ -145,8 +144,7 @@ bool vogleditor_traceReplayer::recursive_replay_apicallTreeItem(vogleditor_apiCa
         while (m_pTraceReplayer->get_has_pending_window_resize() || m_pTraceReplayer->get_pending_apply_snapshot())
         {
             // Pump X events in case the window is resizing
-            bStatus = process_x_events();
-            if (bStatus)
+            if (process_x_events())
             {
                 status = m_pTraceReplayer->process_pending_window_resize();
                 if (status != vogl_gl_replayer::cStatusResizeWindow)
@@ -155,7 +153,7 @@ bool vogleditor_traceReplayer::recursive_replay_apicallTreeItem(vogleditor_apiCa
             else
             {
                 // most likely the window wants to close, so let's return
-                return false;
+                return VOGLEDITOR_TRR_USER_EXIT;
             }
         }
 
@@ -171,56 +169,69 @@ bool vogleditor_traceReplayer::recursive_replay_apicallTreeItem(vogleditor_apiCa
                // get the snapshot after the selected api call
                if ((!*ppNewSnapshot) && (m_pTraceReplayer->get_last_processed_call_counter() == static_cast<int64_t>(apiCallNumber)))
                {
-                  vogl_printf("Taking snapshot on API call # %" PRIu64 "\n", apiCallNumber);
+                  dynamic_string info;
+                  vogleditor_output_message(info.format("Taking snapshot on API call # %" PRIu64 "...", apiCallNumber).c_str());
 
                   vogl_gl_state_snapshot* pNewSnapshot = m_pTraceReplayer->snapshot_state();
                   if (pNewSnapshot == NULL)
                   {
-                      vogl_error_printf("Taking new snapshot failed!\n");
+                      result = VOGLEDITOR_TRR_ERROR;
+                      vogleditor_output_error("... snapshot failed!");
                   }
                   else
                   {
-                      vogl_printf("Taking snapshot succeeded\n");
+                      result = VOGLEDITOR_TRR_SNAPSHOT_SUCCESS;
+                      vogleditor_output_message("... snapshot succeeded!\n");
                       *ppNewSnapshot = vogl_new(vogleditor_gl_state_snapshot, pNewSnapshot);
                       if (*ppNewSnapshot == NULL)
                       {
-                         vogl_error_printf("Allocating memory for snapshot container failed!\n");
+                         result = VOGLEDITOR_TRR_ERROR;
+                         vogleditor_output_error("Allocating memory for snapshot container failed!");
                          vogl_delete(pNewSnapshot);
                       }
                   }
-
-                  bStatus = false;
                }
             }
         }
         else
         {
             // replaying the trace packet failed, set as error
-            vogl_error_printf("%s: unable to replay gl entrypoint at call %" PRIu64 "\n", VOGL_FUNCTION_NAME, pTrace_packet->get_call_counter());
-            bStatus = false;
+            result = VOGLEDITOR_TRR_ERROR;
+            dynamic_string info;
+            vogleditor_output_error(info.format("Unable to replay gl entrypoint at call %" PRIu64, pTrace_packet->get_call_counter()).c_str());
         }
     }
 
-    if (bStatus && pItem->has_snapshot() && pItem->get_snapshot()->is_edited() && pItem->get_snapshot()->is_valid())
+    if (result == VOGLEDITOR_TRR_SUCCESS && pItem->has_snapshot() && pItem->get_snapshot()->is_edited() && pItem->get_snapshot()->is_valid())
     {
-        bStatus = applying_snapshot_and_process_resize(pItem->get_snapshot()->get_snapshot());
+        if(applying_snapshot_and_process_resize(pItem->get_snapshot()->get_snapshot()))
+        {
+            result = VOGLEDITOR_TRR_SUCCESS;
+        }
     }
 
-    if (bStatus)
+    if (result == VOGLEDITOR_TRR_SUCCESS)
     {
         for (int i = 0; i < pItem->childCount(); i++)
         {
-            bStatus = recursive_replay_apicallTreeItem(pItem->child(i), ppNewSnapshot, apiCallNumber);
+            result = recursive_replay_apicallTreeItem(pItem->child(i), ppNewSnapshot, apiCallNumber);
 
-            if (!bStatus)
+            if (result != VOGLEDITOR_TRR_SUCCESS)
                 break;
+
+            // Pump X events in case the window is resizing
+            if (process_x_events() == false)
+            {
+                // most likely the window wants to close, so let's return
+                return VOGLEDITOR_TRR_USER_EXIT;
+            }
         }
     }
 
-    return bStatus;
+    return result;
 }
 
-bool vogleditor_traceReplayer::replay(vogl_trace_file_reader* m_pTraceReader, vogleditor_apiCallTreeItem* pRootItem, vogleditor_gl_state_snapshot** ppNewSnapshot, uint64_t apiCallNumber, bool endlessMode)
+vogleditor_tracereplayer_result vogleditor_traceReplayer::replay(vogl_trace_file_reader* m_pTraceReader, vogleditor_apiCallTreeItem* pRootItem, vogleditor_gl_state_snapshot** ppNewSnapshot, uint64_t apiCallNumber, bool endlessMode)
 {
    // reset to beginnning of trace file.
    m_pTraceReader->seek_to_frame(0);
@@ -230,16 +241,16 @@ bool vogleditor_traceReplayer::replay(vogl_trace_file_reader* m_pTraceReader, vo
 
    if (!m_window.open(initial_window_width, initial_window_height))
    {
-      vogl_error_printf("%s: Failed opening GL replayer window!\n", VOGL_FUNCTION_NAME);
-      return false;
+      vogleditor_output_error("Failed opening GL replayer window!");
+      return VOGLEDITOR_TRR_ERROR;
    }
 
    uint replayer_flags = cGLReplayerForceDebugContexts;
    if (!m_pTraceReplayer->init(replayer_flags, &m_window, m_pTraceReader->get_sof_packet(), m_pTraceReader->get_multi_blob_manager()))
    {
-      vogl_error_printf("%s: Failed initializing GL replayer\n", VOGL_FUNCTION_NAME);
+      vogleditor_output_error("Failed initializing GL replayer!");
       m_window.close();
-      return false;
+      return VOGLEDITOR_TRR_ERROR;
    }
 
    XSelectInput(m_window.get_display(), m_window.get_xwindow(),
@@ -251,12 +262,13 @@ bool vogleditor_traceReplayer::replay(vogl_trace_file_reader* m_pTraceReader, vo
    timer tm;
    tm.start();
 
-   bool bStatus = true;
+   vogleditor_tracereplayer_result result = VOGLEDITOR_TRR_SUCCESS;
 
    for ( ; ; )
    {
       if (process_x_events() == false)
       {
+          result = VOGLEDITOR_TRR_USER_EXIT;
           break;
       }
 
@@ -264,6 +276,7 @@ bool vogleditor_traceReplayer::replay(vogl_trace_file_reader* m_pTraceReader, vo
       {
           vogleditor_apiCallTreeItem* pFirstFrame = pRootItem->child(0);
 
+          bool bStatus = true;
           // if the first snapshot has not been edited, then restore it here, otherwise it will get restored in the recursive call below.
           if (pFirstFrame->has_snapshot() && !pFirstFrame->get_snapshot()->is_edited())
           {
@@ -273,20 +286,31 @@ bool vogleditor_traceReplayer::replay(vogl_trace_file_reader* m_pTraceReader, vo
           if (bStatus)
           {
               // replay each API call.
-              bStatus = recursive_replay_apicallTreeItem(pRootItem, ppNewSnapshot, apiCallNumber);
+              result = recursive_replay_apicallTreeItem(pRootItem, ppNewSnapshot, apiCallNumber);
 
-              if (bStatus == false)
+              if (result == VOGLEDITOR_TRR_ERROR)
+              {
+                  QString msg = QString("Replay ending abruptly at frame index %1, global api call %2").arg(m_pTraceReplayer->get_frame_index()).arg(m_pTraceReplayer->get_last_processed_call_counter());
+                  vogleditor_output_error(msg.toStdString().c_str());
+                  break;
+              }
+              else if (result == VOGLEDITOR_TRR_SNAPSHOT_SUCCESS)
+              {
+                  break;
+              }
+              else if (result == VOGLEDITOR_TRR_USER_EXIT)
               {
-                 vogl_error_printf("%s: Replay ending abruptly at frame index %u, global api call %" PRIu64 "\n", VOGL_FUNCTION_NAME, m_pTraceReplayer->get_frame_index(), m_pTraceReplayer->get_last_processed_call_counter());
-                 break;
+                  vogleditor_output_message("Replay stopped");
+                  break;
               }
               else
               {
-                 vogl_message_printf("%s: At trace EOF, frame index %u\n", VOGL_FUNCTION_NAME, m_pTraceReplayer->get_frame_index());
-                 if (!endlessMode)
-                 {
-                     break;
-                 }
+                  QString msg = QString("At trace EOF, frame index %1").arg(m_pTraceReplayer->get_frame_index());
+                  vogleditor_output_message(msg.toStdString().c_str());
+                  if (!endlessMode)
+                  {
+                      break;
+                  }
               }
           }
           else
@@ -298,7 +322,7 @@ bool vogleditor_traceReplayer::replay(vogl_trace_file_reader* m_pTraceReader, vo
 
    m_pTraceReplayer->deinit();
    m_window.close();
-   return bStatus;
+   return result;
 }
 
 bool vogleditor_traceReplayer::pause()

diff --git a/src/vogleditor/vogleditor_tracereplayer.h b/src/vogleditor/vogleditor_tracereplayer.h
index 176b22a41d8f26e01da47d168818bcf1e4bb5eb9..129011040997b146dba9421a407d6778923e11aa 100644 (file)
--- a/src/vogleditor/vogleditor_tracereplayer.h
+++ b/src/vogleditor/vogleditor_tracereplayer.h
@@ -10,13 +10,21 @@ class vogl_gl_state_snapshot;
 class vogleditor_apiCallTreeItem;
 class vogl_trace_file_reader;
 
+enum vogleditor_tracereplayer_result
+{
+    VOGLEDITOR_TRR_SUCCESS = 0,
+    VOGLEDITOR_TRR_SNAPSHOT_SUCCESS,
+    VOGLEDITOR_TRR_USER_EXIT,
+    VOGLEDITOR_TRR_ERROR
+};
+
 class vogleditor_traceReplayer
 {
 public:
     vogleditor_traceReplayer();
     virtual ~vogleditor_traceReplayer();
 
-    bool replay(vogl_trace_file_reader* m_pTraceReader, vogleditor_apiCallTreeItem* pRootItem, vogleditor_gl_state_snapshot** ppNewSnapshot, uint64_t apiCallNumber, bool endlessMode);
+    vogleditor_tracereplayer_result replay(vogl_trace_file_reader* m_pTraceReader, vogleditor_apiCallTreeItem* pRootItem, vogleditor_gl_state_snapshot** ppNewSnapshot, uint64_t apiCallNumber, bool endlessMode);
     bool pause();
     bool restart();
     bool trim();
@@ -26,7 +34,7 @@ private:
 
     bool applying_snapshot_and_process_resize(const vogl_gl_state_snapshot* pSnapshot);
 
-    bool recursive_replay_apicallTreeItem(vogleditor_apiCallTreeItem* pItem, vogleditor_gl_state_snapshot** ppNewSnapshot, uint64_t apiCallNumber);
+    vogleditor_tracereplayer_result recursive_replay_apicallTreeItem(vogleditor_apiCallTreeItem* pItem, vogleditor_gl_state_snapshot** ppNewSnapshot, uint64_t apiCallNumber);
     bool process_x_events();
     vogl_gl_replayer* m_pTraceReplayer;
     vogl_replay_window m_window;