test cleanup, qp, failing on ffmpeg4/cuda12.6

Author: Dan-Flores

src/torchcodec/_core/Encoder.cpp

@@ -677,9 +677,11 @@ void VideoEncoder::initializeEncoder(
   // Apply videoStreamOptions
   AVDictionary* options = nullptr;
   if (videoStreamOptions.crf.has_value()) {
+    // nvenc encoders use qp, others use crf (for C++ tests)
+    std::string_view quality_param = (strstr(avCodec->name, "nvenc") == nullptr) ? "crf" : "qp";
     av_dict_set(
         &options,
-        "crf",
+        quality_param.data(),
         std::to_string(videoStreamOptions.crf.value()).c_str(),
         0);
   }

test/test_encoders.py

@@ -645,11 +645,9 @@ def test_contiguity(self, method, tmp_path, device):
         # frame tensors, one is contiguous while the other is non-contiguous.
 
         num_frames, channels, height, width = 5, 3, 256, 256
-        contiguous_frames = (
-            (torch.rand(num_frames, channels, height, width) * 255)
-            .to(torch.uint8)
-            .contiguous()
-        )
+        contiguous_frames = torch.randint(
+            0, 256, size=(num_frames, channels, height, width), dtype=torch.uint8
+        ).contiguous()
         assert contiguous_frames.is_contiguous()
 
         # Permute NCHW to NHWC, then update the memory layout, then permute back

test/test_ops.py

@@ -1212,20 +1212,15 @@ def test_video_encoder_round_trip(self, tmp_path, format, method, device):
         assert source_frames.shape == round_trip_frames.shape
         assert source_frames.dtype == round_trip_frames.dtype
 
-        # If FFmpeg selects a codec or pixel format that does lossy encoding, assert 99% of pixels
-        # are within a higher tolerance.
-        if ffmpeg_version == 6 or device == "cuda":
-            atol = 15
-            percentage = 98 if device == "cuda" else 99
+        # If encoding on GPU, assert 99% of pixels are within a strict tolerance.
+        if device == "cuda":
+            assert_close = partial(assert_tensor_close_on_at_least, atol=3, percentage=99)
+        else:
             assert_close = partial(
-                assert_tensor_close_on_at_least, percentage=percentage
+                torch.testing.assert_close, atol=2, rtol=0
             )
-        else:
-            assert_close = torch.testing.assert_close
-            atol = 2
         for s_frame, rt_frame in zip(source_frames, round_trip_frames):
-            assert psnr(s_frame, rt_frame) > 30
-            assert_close(s_frame, rt_frame, atol=atol, rtol=0)
+            assert_close(s_frame, rt_frame)
 
     @pytest.mark.parametrize(
         "format",
@@ -1340,14 +1335,10 @@ def test_video_encoder_against_ffmpeg_cli(self, tmp_path, format, device):
 
         if codec_str:
             ffmpeg_cmd.extend(codec_str.split())
+        quality_param = "qp" if device == "cuda" else "crf"
 
-        ffmpeg_cmd.extend(
-            [
-                "-crf",
-                str(crf),
-                ffmpeg_encoded_path,
-            ]
-        )
+        ffmpeg_cmd.extend([f"-{quality_param}", str(crf)])
+        ffmpeg_cmd.extend([ffmpeg_encoded_path])
         subprocess.run(ffmpeg_cmd, check=True)
 
         # Encode with our video encoder
@@ -1372,8 +1363,7 @@ def test_video_encoder_against_ffmpeg_cli(self, tmp_path, format, device):
 
         # Check that PSNR between both encoded versions is high
         for ff_frame, enc_frame in zip(ffmpeg_frames, encoder_frames):
-            res = psnr(ff_frame, enc_frame)
-            assert res > 30
+            assert psnr(ff_frame, enc_frame) > 30
             assert_tensor_close_on_at_least(
                 ff_frame, enc_frame, percentage=percentage, atol=2
             )