diff --git a/src/encoder/nvidia_encoder.cpp b/src/encoder/nvidia_encoder.cpp
index ad91eb47f617fa167e68da48398204f3984d7d11..0823eaf8c958f3ea4ed00da107162e7d1b9217d8 100644
--- a/src/encoder/nvidia_encoder.cpp
+++ b/src/encoder/nvidia_encoder.cpp
@@ -10,6 +10,8 @@
     #error "Not implemented for this platform!"
 #endif
 
+#define NVIDIA_ENDODER_ENABLE_SUBFRAMES 0
+
 typedef NVENCSTATUS (NVENCAPI* NvEncodeAPICreateInstance_Type)(NV_ENCODE_API_FUNCTION_LIST*);
 typedef NVENCSTATUS (NVENCAPI* NvEncodeAPIGetMaxSupportedVersion_Type)(uint32_t* version);
 
@@ -335,7 +337,11 @@ void NvidiaEncoder::read_frame(NvidiaEncoderFrame::Ptr frame)
         NV_ENC_LOCK_BITSTREAM lock_stream;
         memset(&lock_stream, 0, sizeof(lock_stream));
         lock_stream.version = NV_ENC_LOCK_BITSTREAM_VER;
+#if NVIDIA_ENDODER_ENABLE_SUBFRAMES
         lock_stream.doNotWait = 1;
+#else
+        lock_stream.doNotWait = 0;
+#endif
         lock_stream.getRCStats = 0;
         lock_stream.reservedBitFields = 0;
         lock_stream.outputBitstream = frame->nvenc_output_buffer;
@@ -375,10 +381,14 @@ void NvidiaEncoder::read_frame(NvidiaEncoderFrame::Ptr frame)
             return;
         }
 
+#if NVIDIA_ENDODER_ENABLE_SUBFRAMES
         if (lock_stream.hwEncodeStatus == 2)
         {
             break;
         }
+#else
+        break;
+#endif
     }
 
     if (nvenc_functions.nvEncUnmapInputResource(this->nvenc_session, frame->nvenc_mapped_buffer) != NV_ENC_SUCCESS)
@@ -722,7 +732,11 @@ bool NvidiaEncoder::create_session(const glm::uvec2& size)
     this->nvenc_session_config.enableEncodeAsync = 0;
     this->nvenc_session_config.enablePTD = 1;
     this->nvenc_session_config.reportSliceOffsets = 0;
+#if NVIDIA_ENDODER_ENABLE_SUBFRAMES
     this->nvenc_session_config.enableSubFrameWrite = 1;
+#else
+    this->nvenc_session_config.enableSubFrameWrite = 0;
+#endif
     this->nvenc_session_config.enableExternalMEHints = 0;
     this->nvenc_session_config.enableMEOnlyMode = 0;
     this->nvenc_session_config.enableWeightedPrediction = 0;
diff --git a/src/transport/transport.hpp b/src/transport/transport.hpp
index 850208a5984772c7f66eab95d231af1ac715ae9e..6a25f8cad917509c64c2cc513da50694a412d669 100644
--- a/src/transport/transport.hpp
+++ b/src/transport/transport.hpp
@@ -4,7 +4,7 @@
   The communication between hedaset and host applications starts with the sending of a setup packet from the headset to the host.
   Due to unreliable protocolls such as UDP for example it could be the case that packages get reordered during transmission.
   The transport class however has to allways make sure that the callback for the setup is called before any other callbacks during the startup of the connection.
-  With the help of the function wait_connection() it should be possible to wait for the arrival of the setup packet.
+  With the help of the function wait_connect() it should be possible to wait for the arrival of the setup packet.
   After the setup packet has been received, the host-system should responde with a setup-complete packet which maks the end of the handshake that is used to initialize the connection between the two devices.
   After the handshake phase the host-system can send images in form of encoded nal packets and the headset can send transformation information or controller events.
   It is strongly advised to use a single worker thread that waits for packets and sends packets.
@@ -33,9 +33,9 @@
 enum TransportState
 {
     TRANSPORT_STATE_UNINITIALIZED, // Initial state of the transport class
-    TRANSPORT_STATE_WAITING,       // State after calling create(...) and before wait_connect(...) returns
-    TRANSPORT_STATE_CONNECTED,     // State after wait_connect(...) returns successfully
-    TRANSPORT_STATE_ERROR          // State after any error during the communication or if an disconnect was detected. By calling destroy(...) the transport should return to the uninitalized state
+    TRANSPORT_STATE_WAITING,       // State after calling create(...) and before wait_connect() returns
+    TRANSPORT_STATE_CONNECTED,     // State after wait_connect() returns successfully
+    TRANSPORT_STATE_ERROR          // State after any error during the communication or if an disconnect was detected. By calling destroy() the transport should return to the uninitalized state
 };
 
 // When adding or removing a transport method, the function make_transport(...) as well as
diff --git a/src/utility/pass_timer.cpp b/src/utility/pass_timer.cpp
index ad154c2a257cdefbdf7c3118737edf612014edda..c13b0f3ca5c2bfeb74e108c632c499bbded4766d 100644
--- a/src/utility/pass_timer.cpp
+++ b/src/utility/pass_timer.cpp
@@ -182,7 +182,15 @@ bool PassTimer::evaluate_wating_passes(lava::device_ptr device, lava::index fram
             }
 
             std::array<uint64_t, 2> timestamps;
-            if (vkGetQueryPoolResults(device->get(), current_pool, wait_info.timestamp_index, 2, sizeof(uint64_t) * timestamps.size(), timestamps.data(), 0, flags) != VK_SUCCESS)
+
+            if (vkGetQueryPoolResults(device->get(), current_pool, wait_info.timestamp_index, 1, sizeof(uint64_t), &timestamps[0], 0, flags) != VK_SUCCESS)
+            {
+                lava::log()->error("can't get the timestamp results for the pass timer");
+
+                return false;
+            }
+
+            if (vkGetQueryPoolResults(device->get(), current_pool, wait_info.timestamp_index + 1, 1, sizeof(uint64_t), &timestamps[1], 0, flags) != VK_SUCCESS)
             {
                 lava::log()->error("can't get the timestamp results for the pass timer");