clean up deviceVariant, clean up tests

Author: Dan-Flores

src/torchcodec/_core/Encoder.cpp

@@ -627,11 +627,7 @@ void VideoEncoder::initializeEncoder(
 
   // Try to find a hardware-accelerated encoder if not using CPU
   if (videoStreamOptions.device.type() != torch::kCPU) {
-    auto hardwareCodec =
-        deviceInterface_->findEncoder(avFormatContext_->oformat->video_codec);
-    if (hardwareCodec.has_value()) {
-      avCodec = hardwareCodec.value();
-    }
+    avCodec = deviceInterface_->findEncoder(avFormatContext_->oformat->video_codec).value_or(avCodec);
   }
 
   AVCodecContext* avCodecContext = avcodec_alloc_context3(avCodec);

src/torchcodec/_core/custom_ops.cpp

@@ -379,8 +379,6 @@ void _add_video_stream(
   validateDeviceInterface(std::string(device), std::string(device_variant));
 
   videoStreamOptions.device = torch::Device(std::string(device));
-  videoStreamOptions.deviceVariant = device_variant;
-
   std::vector<Transform*> transforms =
       makeTransforms(std::string(transform_specs));
 
@@ -609,7 +607,6 @@ void encode_video_to_file(
   videoStreamOptions.crf = crf;
 
   videoStreamOptions.device = torch::Device(std::string(device));
-  videoStreamOptions.deviceVariant = "ffmpeg";
   VideoEncoder(
       frames,
       validateInt64ToInt(frame_rate, "frame_rate"),
@@ -629,7 +626,6 @@ at::Tensor encode_video_to_tensor(
   videoStreamOptions.crf = crf;
 
   videoStreamOptions.device = torch::Device(std::string(device));
-  videoStreamOptions.deviceVariant = "ffmpeg";
   return VideoEncoder(
              frames,
              validateInt64ToInt(frame_rate, "frame_rate"),
@@ -654,9 +650,7 @@ void _encode_video_to_file_like(
 
   VideoStreamOptions videoStreamOptions;
   videoStreamOptions.crf = crf;
-
   videoStreamOptions.device = torch::Device(std::string(device));
-  videoStreamOptions.deviceVariant = "ffmpeg";
 
   VideoEncoder encoder(
       frames,

test/test_encoders.py

@@ -687,35 +687,3 @@ def encode_to_tensor(frames):
         torch.testing.assert_close(
             encoded_from_contiguous, encoded_from_non_contiguous, rtol=0, atol=0
         )
-
-    @pytest.mark.parametrize("method", ("to_file", "to_tensor", "to_file_like"))
-    @pytest.mark.parametrize(
-        "device", ("cpu", pytest.param("cuda", marks=pytest.mark.needs_cuda))
-    )
-    def test_device_video_encoder(self, method, device, tmp_path):
-        # Test that encoding works on CPU and CUDA devices
-        # num_frames, channels, height, width = 5, 3, 1024, 1024
-        # frames = (torch.rand(num_frames, channels, height, width) * 255).to(torch.uint8)
-
-        asset = TEST_SRC_2_720P
-        frames = self.decode(asset.path).data
-
-        encoder = VideoEncoder(frames, frame_rate=30, device=device)
-
-        if method == "to_file":
-            dest = str(tmp_path / "output.mp4")
-            encoder.to_file(dest=dest)
-            # Verify file was created
-            assert Path(dest).exists()
-        elif method == "to_tensor":
-            encoded = encoder.to_tensor(format="mp4")
-            assert encoded.dtype == torch.uint8
-            assert encoded.ndim == 1
-            assert encoded.numel() > 0
-        elif method == "to_file_like":
-            file_like = io.BytesIO()
-            encoder.to_file_like(file_like, format="mp4")
-            encoded_bytes = file_like.getvalue()
-            assert len(encoded_bytes) > 0
-        else:
-            raise ValueError(f"Unknown method: {method}")

test/test_ops.py

@@ -1409,20 +1409,13 @@ def get_encoded_data(self):
         decoded_samples = self.decode(file_like.get_encoded_data())
 
         if device == "cuda":
-            atol = 15
-            percentage = 98
-            assert_close = partial(
-                assert_tensor_close_on_at_least, percentage=percentage
-            )
+            assert_close = assert_frames_equal
         else:
-            assert_close = torch.testing.assert_close
-            atol = 2
+            assert_close = partial(torch.testing.assert_close, atol=2)
 
         assert_close(
             decoded_samples.data,
-            source_frames,
-            atol=atol,
-            rtol=0,
+            source_frames
         )
 
     @pytest.mark.parametrize(
@@ -1445,20 +1438,13 @@ def test_to_file_like_real_file(self, tmp_path, device):
         decoded_samples = self.decode(str(file_path))
 
         if device == "cuda":
-            atol = 15
-            percentage = 98
-            assert_close = partial(
-                assert_tensor_close_on_at_least, percentage=percentage
-            )
+            assert_close = assert_frames_equal
         else:
-            assert_close = torch.testing.assert_close
-            atol = 2
+            assert_close = partial(torch.testing.assert_close, atol=2)
 
         assert_close(
             decoded_samples.data,
-            source_frames,
-            atol=atol,
-            rtol=0,
+            source_frames
         )
 
     def test_to_file_like_bad_methods(self):