wip: test timestamping for h264

Author: DatCaptainHorse

src/encoder/h264/api.rs

@@ -93,12 +93,15 @@ impl H264Encoder {
             self.sps_written = true;
         }
 
+        let cpu_start = std::time::Instant::now();
         encoded_data.extend_from_slice(&self.encode_frame_internal(
             gop_position,
             frame_num,
             pic_order_cnt,
             is_idr,
         )?);
+        let cpu_elapsed = cpu_start.elapsed();
+        debug!("CPU encode wall time: {:.2} µs", cpu_elapsed.as_micros());
 
         self.encode_frame_num += 1;
         if is_reference && !is_b_frame {

src/encoder/h264/encode.rs

@@ -61,6 +61,22 @@ impl H264Encoder {
             )?;
         }
 
+        // Reset and write start timestamp
+        unsafe {
+            self.context.device().cmd_reset_query_pool(
+                self.encode_command_buffer,
+                self.timestamp_query_pool,
+                0,
+                2,
+            );
+            self.context.device().cmd_write_timestamp(
+                self.encode_command_buffer,
+                vk::PipelineStageFlags::TOP_OF_PIPE,
+                self.timestamp_query_pool,
+                0, // query index 0 = start
+            );
+        }
+
         // Transition DPB images for encode.
         let ref_dpb_slots: Vec<u8> = self.l0_references.iter().map(|r| r.dpb_slot).collect();
         unsafe {
@@ -584,6 +600,16 @@ impl H264Encoder {
             );
         }
 
+        // Write end timestamp
+        unsafe {
+            self.context.device().cmd_write_timestamp(
+                self.encode_command_buffer,
+                vk::PipelineStageFlags::BOTTOM_OF_PIPE,
+                self.timestamp_query_pool,
+                1, // query index 1 = end
+            );
+        }
+
         // End query.
         unsafe {
             self.context
@@ -624,6 +650,25 @@ impl H264Encoder {
             )?
         };
 
+        // Read GPU timestamps (fence already signaled from submit)
+        unsafe {
+            let result = self.context.device().get_query_pool_results(
+                self.timestamp_query_pool,
+                0,                        // first_query
+                &mut self.gpu_timestamps, // data slice (length 2)
+                vk::QueryResultFlags::WAIT | vk::QueryResultFlags::TYPE_64,
+            );
+            if result.is_ok() {
+                let encode_time_ns = (self.gpu_timestamps[1] - self.gpu_timestamps[0]) as f32
+                    * self.timestamp_period;
+                debug!(
+                    "GPU encode time: {:.2} µs ({:.2} ms)",
+                    encode_time_ns / 1000.0,
+                    encode_time_ns / 1_000_000.0
+                );
+            }
+        }
+
         // Mark DPB slot as active.
         self.dpb_slot_active[self.current_dpb_slot as usize] = true;
 

src/encoder/h264/init.rs

@@ -524,6 +524,26 @@ impl H264Encoder {
         }
         .map_err(|e| PixelForgeError::QueryPool(e.to_string()))?;
 
+        // Create timestamping query pool and resources
+        let timestamp_query_pool_create_info = vk::QueryPoolCreateInfo::default()
+            .query_type(vk::QueryType::TIMESTAMP)
+            .query_count(2); // start and end
+
+        let timestamp_query_pool = unsafe {
+            context
+                .device()
+                .create_query_pool(&timestamp_query_pool_create_info, None)
+        }
+        .map_err(|e| PixelForgeError::QueryPool(e.to_string()))?;
+
+        let timestamp_period = unsafe {
+            context
+                .instance()
+                .get_physical_device_properties(context.physical_device())
+                .limits
+                .timestamp_period
+        };
+
         // Create DPB and GOP structure.
         // The DPB size should match the actual number of allocated DPB slots.
         let mut dpb = DecodedPictureBuffer::new();
@@ -591,6 +611,9 @@ impl H264Encoder {
             encode_command_buffer,
             encode_fence,
             query_pool,
+            timestamp_query_pool,
+            gpu_timestamps: [0; 2],
+            timestamp_period,
             sps_written: false,
             // has_reference: false, // removed
             // reference_frame_num: 0, // removed

src/encoder/h264/mod.rs

@@ -85,6 +85,11 @@ pub struct H264Encoder {
     encode_fence: vk::Fence,
     query_pool: vk::QueryPool,
 
+    // Timestamping resources
+    timestamp_query_pool: vk::QueryPool,
+    gpu_timestamps: [u64; 2], // start and end timestamps
+    timestamp_period: f32,    // nanoseconds per timestamp unit
+
     // SPS/PPS written flag.
     sps_written: bool,
 
@@ -159,6 +164,10 @@ impl Drop for H264Encoder {
             if let Some(q) = self.context.video_encode_queue() {
                 let _ = self.context.device().queue_wait_idle(q);
             }
+            // TODO(dathorse): Move into destroy_encoder_resources as EncoderResources field..
+            self.context
+                .device()
+                .destroy_query_pool(self.timestamp_query_pool, None);
             destroy_encoder_resources(
                 self.context.device(),
                 &self.video_queue_fn,