2025-11-19 nightly release (1ea235a)

Author: pytorchbot

src/torchcodec/_core/Encoder.cpp

@@ -607,7 +607,7 @@ void tryToValidateCodecOption(
           "] for this codec. For more details, run 'ffmpeg -h encoder=",
           avCodec.name,
           "'");
-    } catch (const std::invalid_argument& e) {
+    } catch (const std::invalid_argument&) {
       TORCH_CHECK(
           false,
           "Option ",

src/torchcodec/_core/custom_ops.cpp

@@ -613,14 +613,14 @@ void encode_video_to_file(
     const at::Tensor& frames,
     int64_t frame_rate,
     std::string_view file_name,
-    std::optional<std::string> codec = std::nullopt,
+    std::optional<std::string_view> codec = std::nullopt,
     std::optional<std::string_view> pixel_format = std::nullopt,
     std::optional<double> crf = std::nullopt,
     std::optional<std::string_view> preset = std::nullopt,
     std::optional<std::vector<std::string>> extra_options = std::nullopt) {
   VideoStreamOptions videoStreamOptions;
-  videoStreamOptions.codec = codec;
-  videoStreamOptions.pixelFormat = pixel_format;
+  videoStreamOptions.codec = std::move(codec);
+  videoStreamOptions.pixelFormat = std::move(pixel_format);
   videoStreamOptions.crf = crf;
   videoStreamOptions.preset = preset;
 
@@ -641,15 +641,15 @@ at::Tensor encode_video_to_tensor(
     const at::Tensor& frames,
     int64_t frame_rate,
     std::string_view format,
-    std::optional<std::string> codec = std::nullopt,
+    std::optional<std::string_view> codec = std::nullopt,
     std::optional<std::string_view> pixel_format = std::nullopt,
     std::optional<double> crf = std::nullopt,
     std::optional<std::string_view> preset = std::nullopt,
     std::optional<std::vector<std::string>> extra_options = std::nullopt) {
   auto avioContextHolder = std::make_unique<AVIOToTensorContext>();
   VideoStreamOptions videoStreamOptions;
-  videoStreamOptions.codec = codec;
-  videoStreamOptions.pixelFormat = pixel_format;
+  videoStreamOptions.codec = std::move(codec);
+  videoStreamOptions.pixelFormat = std::move(pixel_format);
   videoStreamOptions.crf = crf;
   videoStreamOptions.preset = preset;
 
@@ -672,7 +672,7 @@ void _encode_video_to_file_like(
     int64_t frame_rate,
     std::string_view format,
     int64_t file_like_context,
-    std::optional<std::string> codec = std::nullopt,
+    std::optional<std::string_view> codec = std::nullopt,
     std::optional<std::string_view> pixel_format = std::nullopt,
     std::optional<double> crf = std::nullopt,
     std::optional<std::string_view> preset = std::nullopt,
@@ -684,8 +684,8 @@ void _encode_video_to_file_like(
   std::unique_ptr<AVIOFileLikeContext> avioContextHolder(fileLikeContext);
 
   VideoStreamOptions videoStreamOptions;
-  videoStreamOptions.codec = codec;
-  videoStreamOptions.pixelFormat = pixel_format;
+  videoStreamOptions.codec = std::move(codec);
+  videoStreamOptions.pixelFormat = std::move(pixel_format);
   videoStreamOptions.crf = crf;
   videoStreamOptions.preset = preset;
 

src/torchcodec/_core/ops.py

@@ -331,7 +331,7 @@ def encode_video_to_file_abstract(
     frames: torch.Tensor,
     frame_rate: int,
     filename: str,
-    codec: Optional[str],
+    codec: Optional[str] = None,
     pixel_format: Optional[str] = None,
     preset: Optional[str] = None,
     crf: Optional[Union[int, float]] = None,
@@ -345,7 +345,7 @@ def encode_video_to_tensor_abstract(
     frames: torch.Tensor,
     frame_rate: int,
     format: str,
-    codec: Optional[str],
+    codec: Optional[str] = None,
     pixel_format: Optional[str] = None,
     preset: Optional[str] = None,
     crf: Optional[Union[int, float]] = None,
@@ -360,7 +360,7 @@ def _encode_video_to_file_like_abstract(
     frame_rate: int,
     format: str,
     file_like_context: int,
-    codec: Optional[str],
+    codec: Optional[str] = None,
     pixel_format: Optional[str] = None,
     preset: Optional[str] = None,
     crf: Optional[Union[int, float]] = None,

src/torchcodec/encoders/_video_encoder.py

@@ -35,12 +35,12 @@ def __init__(self, frames: Tensor, *, frame_rate: int):
     def to_file(
         self,
         dest: Union[str, Path],
-        extra_options: Optional[Dict[str, Any]] = None,
         *,
         codec: Optional[str] = None,
         pixel_format: Optional[str] = None,
         crf: Optional[Union[int, float]] = None,
         preset: Optional[Union[str, int]] = None,
+        extra_options: Optional[Dict[str, Any]] = None,
     ) -> None:
         """Encode frames into a file.
 

test/test_encoders.py

@@ -919,7 +919,10 @@ def test_against_to_file(self, tmp_path, format, method):
             {"pixel_format": "yuv420p", "crf": None, "preset": None},
         ],
     )
-    def test_video_encoder_against_ffmpeg_cli(self, tmp_path, format, encode_params):
+    @pytest.mark.parametrize("method", ("to_file", "to_tensor", "to_file_like"))
+    def test_video_encoder_against_ffmpeg_cli(
+        self, tmp_path, format, encode_params, method
+    ):
         ffmpeg_version = get_ffmpeg_major_version()
         if format == "webm" and (
             ffmpeg_version == 4 or (IS_WINDOWS and ffmpeg_version in (6, 7))
@@ -967,26 +970,45 @@ def test_video_encoder_against_ffmpeg_cli(self, tmp_path, format, encode_params)
         # Output path must be last
         ffmpeg_cmd.append(ffmpeg_encoded_path)
         subprocess.run(ffmpeg_cmd, check=True)
+        ffmpeg_frames = self.decode(ffmpeg_encoded_path).data
 
         # Encode with our video encoder
-        encoder_output_path = str(tmp_path / f"encoder_output.{format}")
         encoder = VideoEncoder(frames=source_frames, frame_rate=frame_rate)
-        encoder.to_file(
-            dest=encoder_output_path,
-            pixel_format=pixel_format,
-            crf=crf,
-            preset=preset,
-        )
+        encoder_output_path = str(tmp_path / f"encoder_output.{format}")
 
-        ffmpeg_frames = self.decode(ffmpeg_encoded_path).data
-        encoder_frames = self.decode(encoder_output_path).data
+        if method == "to_file":
+            encoder.to_file(
+                dest=encoder_output_path,
+                pixel_format=pixel_format,
+                crf=crf,
+                preset=preset,
+            )
+            encoder_frames = self.decode(encoder_output_path).data
+        elif method == "to_tensor":
+            encoded_output = encoder.to_tensor(
+                format=format,
+                pixel_format=pixel_format,
+                crf=crf,
+                preset=preset,
+            )
+            encoder_frames = self.decode(encoded_output).data
+        elif method == "to_file_like":
+            file_like = io.BytesIO()
+            encoder.to_file_like(
+                file_like=file_like,
+                format=format,
+                pixel_format=pixel_format,
+                crf=crf,
+                preset=preset,
+            )
+            encoder_frames = self.decode(file_like.getvalue()).data
+        else:
+            raise ValueError(f"Unknown method: {method}")
 
         assert ffmpeg_frames.shape[0] == encoder_frames.shape[0]
 
-        # If FFmpeg selects a codec or pixel format that uses qscale (not crf),
-        # the VideoEncoder outputs *slightly* different frames.
-        # There may be additional subtle differences in the encoder.
-        percentage = 94 if ffmpeg_version == 6 or format == "avi" else 99
+        # MPEG codec used for avi format does not accept CRF
+        percentage = 94 if format == "avi" else 99
 
         # Check that PSNR between both encoded versions is high
         for ff_frame, enc_frame in zip(ffmpeg_frames, encoder_frames):
@@ -996,6 +1018,19 @@ def test_video_encoder_against_ffmpeg_cli(self, tmp_path, format, encode_params)
                 ff_frame, enc_frame, percentage=percentage, atol=2
             )
 
+        # Check that video metadata is the same
+        if method == "to_file":
+            fields = ["duration", "duration_ts", "r_frame_rate", "nb_frames"]
+            ffmpeg_metadata = self._get_video_metadata(
+                ffmpeg_encoded_path,
+                fields=fields,
+            )
+            encoder_metadata = self._get_video_metadata(
+                encoder_output_path,
+                fields=fields,
+            )
+            assert ffmpeg_metadata == encoder_metadata
+
     def test_to_file_like_custom_file_object(self):
         """Test to_file_like with a custom file-like object that implements write and seek."""