torchcodec 0.10.0__cp312-cp312-manylinux_2_28_x86_64.whl

torchcodec/share/cmake/TorchCodec/TorchCodecConfig.cmake

@@ -0,0 +1,76 @@
+# FindTorchCodec
+# --------------
+#
+# Finds the TorchCodec library
+#
+# This will define the following variables:
+#
+#   TORCHCODEC_FOUND: True if the system has the TorchCodec library
+#   TORCHCODEC_VARIANTS: list of TorchCodec variants. A variant is a supported
+#   FFmpeg major version.
+#
+# and the following imported targets:
+#
+#   torchcodec::ffmpeg${N}
+#   torchcodec::core${N}
+#
+# where N is a TorchCodec variant (FFmpeg major version) from
+# TORCHCODEC_VARIANTS list.
+
+include(FindPackageHandleStandardArgs)
+include("${CMAKE_CURRENT_LIST_DIR}/ffmpeg_versions.cmake")
+
+# Assume we are in <install-prefix>/share/cmake/TorchCodec/TorchCodecConfig.cmake
+get_filename_component(CMAKE_CURRENT_LIST_DIR "${CMAKE_CURRENT_LIST_FILE}" PATH)
+get_filename_component(TORCHCODEC_INSTALL_PREFIX "${CMAKE_CURRENT_LIST_DIR}/../../../" ABSOLUTE)
+
+# Include directories.
+set(TORCHCODEC_INCLUDE_DIRS ${TORCHCODEC_INSTALL_PREFIX}/_core)
+set(TORCHCODEC_VARIANTS "")
+
+function(add_torchcodec_target ffmpeg_major_version)
+    set(target torchcodec::core${ffmpeg_major_version})
+
+    if (NOT TARGET torchcodec::ffmpeg${ffmpeg_major_version})
+        message(FATAL_ERROR "torchcodec::ffmpeg${ffmpeg_major_version} target is not defined")
+    endif()
+
+    find_library(lib_path torchcodec_core${ffmpeg_major_version}
+        PATHS "${TORCHCODEC_INSTALL_PREFIX}" NO_CACHE NO_DEFAULT_PATH)
+    if (NOT lib_path)
+        message(FATAL_ERROR "torchcodec_core${ffmpeg_major_version} shared library is missing")
+    endif()
+
+    message("Adding ${target} target")
+    add_library(${target} SHARED IMPORTED)
+    add_dependencies(${target} torchcodec::ffmpeg${ffmpeg_major_version})
+    set_target_properties(${target} PROPERTIES
+      INTERFACE_INCLUDE_DIRECTORIES ${TORCHCODEC_INCLUDE_DIRS}
+      IMPORTED_LOCATION ${lib_path}
+    )
+
+    list(APPEND TORCHCODEC_VARIANTS "${ffmpeg_major_version}")
+    set(TORCHCODEC_VARIANTS "${TORCHCODEC_VARIANTS}" PARENT_SCOPE)
+endfunction()
+
+# If any of the TORCHCODEC_FFMPEG${N}_INSTALL_PREFIX environment variables
+# are defined, use them to locate the corresponding FFmpeg and TorchCodec targets.
+# Otherwise, fall back to pkg-config to find FFmpeg.
+set(use_pkg_config TRUE)
+foreach(ffmpeg_major_version IN LISTS TORCHCODEC_SUPPORTED_FFMPEG_VERSIONS)
+    if (DEFINED ENV{TORCHCODEC_FFMPEG${ffmpeg_major_version}_INSTALL_PREFIX})
+        add_ffmpeg_target(
+            "${ffmpeg_major_version}"
+            "$ENV{TORCHCODEC_FFMPEG${ffmpeg_major_version}_INSTALL_PREFIX}"
+        )
+        add_torchcodec_target(${ffmpeg_major_version})
+        set(use_pkg_config FALSE)
+    endif()
+endforeach()
+
+if (use_pkg_config)
+    add_ffmpeg_target_with_pkg_config(ffmpeg_major_version)
+    add_torchcodec_target(${ffmpeg_major_version})
+endif()
+
+find_package_handle_standard_args(TorchCodec DEFAULT_MSG TORCHCODEC_VARIANTS)

torchcodec/share/cmake/TorchCodec/ffmpeg_versions.cmake

@@ -0,0 +1,122 @@
+# This file exposes helpers to create and expose FFmpeg targets as torchcodec::ffmpeg${N}
+# where N is the FFmpeg major version.
+
+# List of FFmpeg versions that TorchCodec can support - that's not a list of
+# FFmpeg versions available on the current system!
+set(TORCHCODEC_SUPPORTED_FFMPEG_VERSIONS "4;5;6;7;8")
+
+# Create and expose torchcodec::ffmpeg${ffmpeg_major_version} target which can
+# then be used as a dependency in other targets.
+# prefix is the path to the FFmpeg installation containing the usual `include`
+# and `lib` directories.
+function(add_ffmpeg_target ffmpeg_major_version prefix)
+    # Check that given ffmpeg major version is something we support and error out if
+    # it's not.
+    list(FIND TORCHCODEC_SUPPORTED_FFMPEG_VERSIONS "${ffmpeg_major_version}" _index)
+    if (_index LESS 0)
+        message(FATAL_ERROR "FFmpeg version ${ffmpeg_major_version} is not supported")
+    endif()
+    if (NOT DEFINED prefix)
+        message(FATAL_ERROR "No prefix defined calling add_ffmpeg_target()")
+    endif()
+
+    # Define library names based on platform and FFmpeg version
+    if (LINUX)
+        if (ffmpeg_major_version EQUAL 4)
+            set(library_file_names libavutil.so.56 libavcodec.so.58 libavformat.so.58 libavdevice.so.58 libavfilter.so.7 libswscale.so.5 libswresample.so.3)
+        elseif (ffmpeg_major_version EQUAL 5)
+            set(library_file_names libavutil.so.57 libavcodec.so.59 libavformat.so.59 libavdevice.so.59 libavfilter.so.8 libswscale.so.6 libswresample.so.4)
+        elseif (ffmpeg_major_version EQUAL 6)
+            set(library_file_names libavutil.so.58 libavcodec.so.60 libavformat.so.60 libavdevice.so.60 libavfilter.so.9 libswscale.so.7 libswresample.so.4)
+        elseif (ffmpeg_major_version EQUAL 7)
+            set(library_file_names libavutil.so.59 libavcodec.so.61 libavformat.so.61 libavdevice.so.61 libavfilter.so.10 libswscale.so.8 libswresample.so.5)
+        elseif (ffmpeg_major_version EQUAL 8)
+            set(library_file_names libavutil.so.60 libavcodec.so.62 libavformat.so.62 libavdevice.so.62 libavfilter.so.11 libswscale.so.9 libswresample.so.6)
+        endif()
+    elseif (APPLE)
+        if (ffmpeg_major_version EQUAL 4)
+            set(library_file_names libavutil.56.dylib libavcodec.58.dylib libavformat.58.dylib libavdevice.58.dylib libavfilter.7.dylib libswscale.5.dylib libswresample.3.dylib)
+        elseif (ffmpeg_major_version EQUAL 5)
+            set(library_file_names libavutil.57.dylib libavcodec.59.dylib libavformat.59.dylib libavdevice.59.dylib libavfilter.8.dylib libswscale.6.dylib libswresample.4.dylib)
+        elseif (ffmpeg_major_version EQUAL 6)
+            set(library_file_names libavutil.58.dylib libavcodec.60.dylib libavformat.60.dylib libavdevice.60.dylib libavfilter.9.dylib libswscale.7.dylib libswresample.4.dylib)
+        elseif (ffmpeg_major_version EQUAL 7)
+            set(library_file_names libavutil.59.dylib libavcodec.61.dylib libavformat.61.dylib libavdevice.61.dylib libavfilter.10.dylib libswscale.8.dylib libswresample.5.dylib)
+        elseif (ffmpeg_major_version EQUAL 8)
+            set(library_file_names libavutil.60.dylib libavcodec.62.dylib libavformat.62.dylib libavdevice.62.dylib libavfilter.11.dylib libswscale.9.dylib libswresample.6.dylib)
+        endif()
+    elseif (WIN32)
+        set(library_file_names avutil.lib avcodec.lib avformat.lib avdevice.lib avfilter.lib swscale.lib swresample.lib)
+    else()
+        message(FATAL_ERROR "Unsupported operating system: ${CMAKE_SYSTEM_NAME}")
+    endif()
+
+    set(target "torchcodec::ffmpeg${ffmpeg_major_version}")
+    set(include_dir "${prefix}/include")
+    if (LINUX OR APPLE)
+        set(lib_dir "${prefix}/lib")
+    elseif (WIN32)
+        set(lib_dir "${prefix}/bin")
+    else()
+        message(FATAL_ERROR "Unsupported operating system: ${CMAKE_SYSTEM_NAME}")
+    endif()
+
+    list(
+        TRANSFORM library_file_names
+        PREPEND ${lib_dir}/
+        OUTPUT_VARIABLE lib_paths
+    )
+
+    message("Adding ${target} target")
+    # Verify that ffmpeg includes and libraries actually exist.
+    foreach (path IN LISTS include_dir lib_paths)
+        if (NOT EXISTS "${path}")
+            message(FATAL_ERROR "${path} does not exist")
+        endif()
+    endforeach()
+
+    # Actually define the target
+    add_library(${target} INTERFACE IMPORTED)
+    target_include_directories(${target} INTERFACE ${include_dir})
+    target_link_libraries(${target} INTERFACE ${lib_paths})
+endfunction()
+
+# Create and expose torchcodec::ffmpeg${ffmpeg_major_version} target which can
+# then be used as a dependency in other targets.
+# The FFmpeg installation is found by pkg-config.
+function(add_ffmpeg_target_with_pkg_config ret_ffmpeg_major_version_var)
+    find_package(PkgConfig REQUIRED)
+    pkg_check_modules(TORCHCODEC_LIBAV REQUIRED IMPORTED_TARGET
+        libavdevice
+        libavfilter
+        libavformat
+        libavcodec
+        libavutil
+        libswresample
+        libswscale
+    )
+
+    # Split libavcodec's version string by '.' and convert it to a list
+    # The TORCHCODEC_LIBAV_libavcodec_VERSION is made available by pkg-config.
+    string(REPLACE "." ";" libavcodec_version_list ${TORCHCODEC_LIBAV_libavcodec_VERSION})
+    # Get the first element of the list, which is the major version
+    list(GET libavcodec_version_list 0 libavcodec_major_version)
+
+    if (${libavcodec_major_version} STREQUAL "58")
+        set(ffmpeg_major_version "4")
+    elseif (${libavcodec_major_version} STREQUAL "59")
+        set(ffmpeg_major_version "5")
+    elseif (${libavcodec_major_version} STREQUAL "60")
+        set(ffmpeg_major_version "6")
+    elseif (${libavcodec_major_version} STREQUAL "61")
+        set(ffmpeg_major_version "7")
+    elseif (${libavcodec_major_version} STREQUAL "62")
+        set(ffmpeg_major_version "8")
+    else()
+        message(FATAL_ERROR "Unsupported libavcodec version: ${libavcodec_major_version}")
+    endif()
+
+    message("Adding torchcodec::ffmpeg${ffmpeg_major_version} target")
+    add_library(torchcodec::ffmpeg${ffmpeg_major_version} ALIAS PkgConfig::TORCHCODEC_LIBAV)
+    set(${ret_ffmpeg_major_version_var} ${ffmpeg_major_version} PARENT_SCOPE)
+endfunction()

torchcodec/transforms/__init__.py

@@ -0,0 +1,12 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+# All rights reserved.
+#
+# This source code is licensed under the BSD-style license found in the
+# LICENSE file in the root directory of this source tree.
+
+from ._decoder_transforms import (  # noqa
+    CenterCrop,
+    DecoderTransform,
+    RandomCrop,
+    Resize,
+)

torchcodec/transforms/_decoder_transforms.py

@@ -0,0 +1,375 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+# All rights reserved.
+#
+# This source code is licensed under the BSD-style license found in the
+# LICENSE file in the root directory of this source tree.
+
+
+from abc import ABC, abstractmethod
+from collections.abc import Sequence
+from types import ModuleType
+
+import torch
+from torch import nn
+
+
+class DecoderTransform(ABC):
+    """Base class for all decoder transforms.
+
+    A *decoder transform* is a transform that is applied by the decoder before
+    returning the decoded frame.  Applying decoder transforms to frames
+    should be both faster and more memory efficient than receiving normally
+    decoded frames and applying the same kind of transform.
+
+    Most ``DecoderTransform`` objects have a complementary transform in TorchVision,
+    specificially in `torchvision.transforms.v2 <https://docs.pytorch.org/vision/stable/transforms.html>`_.
+    For such transforms, we ensure that:
+
+      1. The names are the same.
+      2. Default behaviors are the same.
+      3. The parameters for the ``DecoderTransform`` object are a subset of the
+         TorchVision :class:`~torchvision.transforms.v2.Transform` object.
+      4. Parameters with the same name control the same behavior and accept a
+         subset of the same types.
+      5. The difference between the frames returned by a decoder transform and
+         the complementary TorchVision transform are such that a model should
+         not be able to tell the difference.
+    """
+
+    @abstractmethod
+    def _make_transform_spec(self, input_dims: tuple[int | None, int | None]) -> str:
+        """Makes the transform spec that is used by the `VideoDecoder`.
+
+        Args:
+            input_dims (tuple[int | None, int | None]): The dimensions of
+                the input frame in the form (height, width). We cannot know the
+                dimensions at object construction time because it's dependent on
+                the video being decoded and upstream transforms in the same
+                transform pipeline. Not all transforms need to know this; those
+                that don't will ignore it. The individual values in the tuple are
+                optional because the original values come from file metadata which
+                may be missing. We maintain the optionality throughout the APIs so
+                that we can decide as late as possible that it's necessary for the
+                values to exist. That is, if the values are missing from the
+                metadata and we have transforms which ignore the input dimensions,
+                we want that to still work.
+
+                Note: This method is the moral equivalent of TorchVision's
+                `Transform.make_params()`.
+
+        Returns:
+            str: A string which contains the spec for the transform that the
+                `VideoDecoder` knows what to do with.
+        """
+        pass
+
+    def _get_output_dims(self) -> tuple[int | None, int | None] | None:
+        """Get the dimensions of the output frame.
+
+        Transforms that change the frame dimensions need to override this
+        method. Transforms that don't change the frame dimensions can rely on
+        this default implementation.
+
+        Returns:
+            tuple[int | None, int | None] | None: The output dimensions.
+                - None: The output dimensions are the same as the input dimensions.
+                - (int, int): The (height, width) of the output frame.
+        """
+        return None
+
+
+def import_torchvision_transforms_v2() -> ModuleType:
+    try:
+        from torchvision.transforms import v2
+    except ImportError as e:
+        raise RuntimeError(
+            "Cannot import TorchVision; this should never happen, please report a bug."
+        ) from e
+    return v2
+
+
+class Resize(DecoderTransform):
+    """Resize the decoded frame to a given size.
+
+    Complementary TorchVision transform: :class:`~torchvision.transforms.v2.Resize`.
+    Interpolation is always bilinear. Anti-aliasing is always on.
+
+    Args:
+        size (Sequence[int]): Desired output size. Must be a sequence of
+            the form (height, width).
+    """
+
+    def __init__(self, size: Sequence[int]):
+        if len(size) != 2:
+            raise ValueError(
+                "Resize transform must have a (height, width) "
+                f"pair for the size, got {size}."
+            )
+        self.size = size
+
+    def _make_transform_spec(self, input_dims: tuple[int | None, int | None]) -> str:
+        return f"resize, {self.size[0]}, {self.size[1]}"
+
+    def _get_output_dims(self) -> tuple[int | None, int | None] | None:
+        return (self.size[0], self.size[1])
+
+    @classmethod
+    def _from_torchvision(cls, tv_resize: nn.Module):
+        v2 = import_torchvision_transforms_v2()
+
+        assert isinstance(tv_resize, v2.Resize)
+
+        if tv_resize.interpolation is not v2.InterpolationMode.BILINEAR:
+            raise ValueError(
+                "TorchVision Resize transform must use bilinear interpolation."
+            )
+        if tv_resize.antialias is False:
+            raise ValueError(
+                "TorchVision Resize transform must have antialias enabled."
+            )
+        if tv_resize.size is None:
+            raise ValueError("TorchVision Resize transform must have a size specified.")
+        if len(tv_resize.size) != 2:
+            raise ValueError(
+                "TorchVision Resize transform must have a (height, width) "
+                f"pair for the size, got {tv_resize.size}."
+            )
+        return cls(size=tv_resize.size)
+
+
+class CenterCrop(DecoderTransform):
+    """Crop the decoded frame to a given size in the center of the frame.
+
+    Complementary TorchVision transform: :class:`~torchvision.transforms.v2.CenterCrop`.
+
+    Args:
+        size (Sequence[int]): Desired output size. Must be a sequence of
+            the form (height, width).
+    """
+
+    def __init__(self, size: Sequence[int]):
+        if len(size) != 2:
+            raise ValueError(
+                "CenterCrop transform must have a (height, width) "
+                f"pair for the size, got {size}."
+            )
+        self.size = size
+
+    def _make_transform_spec(self, input_dims: tuple[int | None, int | None]) -> str:
+        return f"center_crop, {self.size[0]}, {self.size[1]}"
+
+    def _get_output_dims(self) -> tuple[int | None, int | None] | None:
+        return (self.size[0], self.size[1])
+
+    @classmethod
+    def _from_torchvision(
+        cls,
+        tv_center_crop: nn.Module,
+    ):
+        v2 = import_torchvision_transforms_v2()
+
+        if not isinstance(tv_center_crop, v2.CenterCrop):
+            raise ValueError(
+                "Transform must be TorchVision's CenterCrop, "
+                f"it is instead {type(tv_center_crop).__name__}. "
+                "This should never happen, please report a bug."
+            )
+
+        if len(tv_center_crop.size) != 2:
+            raise ValueError(
+                "TorchVision CenterCrop transform must have a (height, width) "
+                f"pair for the size, got {tv_center_crop.size}."
+            )
+
+        return cls(size=tv_center_crop.size)
+
+
+class RandomCrop(DecoderTransform):
+    """Crop the decoded frame to a given size at a random location in the frame.
+
+    Complementary TorchVision transform: :class:`~torchvision.transforms.v2.RandomCrop`.
+    Padding of all kinds is disabled. The random location within the frame is
+    determined during the initialization of the
+    :class:`~torchcodec.decoders.VideoDecoder` object that owns this transform.
+    As a consequence, each decoded frame in the video will be cropped at the
+    same location. Videos with variable resolution may result in undefined
+    behavior.
+
+    Args:
+        size (Sequence[int]): Desired output size. Must be a sequence of
+            the form (height, width).
+    """
+
+    def __init__(self, size: Sequence[int]):
+        if len(size) != 2:
+            raise ValueError(
+                "RandomCrop transform must have a (height, width) "
+                f"pair for the size, got {size}."
+            )
+        self.size = size
+
+    def _make_transform_spec(self, input_dims: tuple[int | None, int | None]) -> str:
+        height, width = input_dims
+        if height is None:
+            raise ValueError(
+                "Video metadata has no height. "
+                "RandomCrop can only be used when input frame dimensions are known."
+            )
+        if width is None:
+            raise ValueError(
+                "Video metadata has no width. "
+                "RandomCrop can only be used when input frame dimensions are known."
+            )
+
+        # Note: This logic below must match the logic in
+        #       torchvision.transforms.v2.RandomCrop.make_params(). Given
+        #       the same seed, they should get the same result. This is an
+        #       API guarantee with our users.
+        if height < self.size[0] or width < self.size[1]:
+            raise ValueError(
+                f"Input dimensions {input_dims} are smaller than the crop size {self.size}."
+            )
+
+        top = int(torch.randint(0, height - self.size[0] + 1, size=()).item())
+        left = int(torch.randint(0, width - self.size[1] + 1, size=()).item())
+
+        return f"crop, {self.size[0]}, {self.size[1]}, {left}, {top}"
+
+    def _get_output_dims(self) -> tuple[int | None, int | None] | None:
+        return (self.size[0], self.size[1])
+
+    @classmethod
+    def _from_torchvision(
+        cls,
+        tv_random_crop: nn.Module,
+    ):
+        v2 = import_torchvision_transforms_v2()
+
+        if not isinstance(tv_random_crop, v2.RandomCrop):
+            raise ValueError(
+                "Transform must be TorchVision's RandomCrop, "
+                f"it is instead {type(tv_random_crop).__name__}. "
+                "This should never happen, please report a bug."
+            )
+
+        if tv_random_crop.padding is not None:
+            raise ValueError(
+                "TorchVision RandomCrop transform must not specify padding."
+            )
+
+        if tv_random_crop.pad_if_needed is True:
+            raise ValueError(
+                "TorchVision RandomCrop transform must not specify pad_if_needed."
+            )
+
+        if tv_random_crop.fill != 0:
+            raise ValueError("TorchVision RandomCrop fill must be 0.")
+
+        if tv_random_crop.padding_mode != "constant":
+            raise ValueError("TorchVision RandomCrop padding_mode must be constant.")
+
+        if len(tv_random_crop.size) != 2:
+            raise ValueError(
+                "TorchVision RandcomCrop transform must have a (height, width) "
+                f"pair for the size, got {tv_random_crop.size}."
+            )
+
+        return cls(size=tv_random_crop.size)
+
+
+def _make_transform_specs(
+    transforms: Sequence[DecoderTransform | nn.Module] | None,
+    input_dims: tuple[int | None, int | None],
+) -> str:
+    """Given a sequence of transforms, turn those into the specification string
+       the core API expects.
+
+    Args:
+        transforms: Optional sequence of transform objects. The objects can be
+            one of two types:
+                1. torchcodec.transforms.DecoderTransform
+                2. torchvision.transforms.v2.Transform, but our type annotation
+                   only mentions its base, nn.Module. We don't want to take a
+                   hard dependency on TorchVision.
+        input_dims: Optional (height, width) pair. Note that only some
+            transforms need to know the dimensions. If the user provides
+            transforms that don't need to know the dimensions, and that metadata
+            is missing, everything should still work. That means we assert their
+            existence as late as possible.
+
+    Returns:
+        String of transforms in the format the core API expects: transform
+        specifications separate by semicolons.
+    """
+    if transforms is None:
+        return ""
+
+    try:
+        from torchvision.transforms import v2
+
+        tv_available = True
+    except ImportError:
+        tv_available = False
+
+    # The following loop accomplishes two tasks:
+    #
+    #     1. Converts the transform to a DecoderTransform, if necessary. We
+    #        accept TorchVision transform objects and they must be converted
+    #        to their matching DecoderTransform.
+    #     2. Calculates what the input dimensions are to each transform.
+    #
+    # The order in our transforms list is semantically meaningful, as we
+    # actually have a pipeline where the output of one transform is the input to
+    # the next. For example, if we have the transforms list [A, B, C, D], then
+    # we should understand that as:
+    #
+    #     A -> B -> C -> D
+    #
+    # Where the frame produced by A is the input to B, the frame produced by B
+    # is the input to C, etc. This particularly matters for frame dimensions.
+    # Transforms can both:
+    #
+    #     1. Produce frames with arbitrary dimensions.
+    #     2. Rely on their input frame's dimensions to calculate ahead-of-time
+    #        what their runtime behavior will be.
+    #
+    # The consequence of the above facts is that we need to statically track
+    # frame dimensions in the pipeline while we pre-process it. The input
+    # frame's dimensions to A, our first transform, is always what we know from
+    # our metadata. For each transform, we always calculate its output
+    # dimensions from its input dimensions. We store these with the converted
+    # transform, to be all used together when we generate the specs.
+    converted_transforms: list[
+        tuple[
+            DecoderTransform,
+            # A (height, width) pair where the values may be missing.
+            tuple[int | None, int | None],
+        ]
+    ] = []
+    curr_input_dims = input_dims
+    for transform in transforms:
+        if not isinstance(transform, DecoderTransform):
+            if not tv_available:
+                raise ValueError(
+                    f"The supplied transform, {transform}, is not a TorchCodec "
+                    " DecoderTransform. TorchCodec also accepts TorchVision "
+                    "v2 transforms, but TorchVision is not installed."
+                )
+            elif isinstance(transform, v2.Resize):
+                transform = Resize._from_torchvision(transform)
+            elif isinstance(transform, v2.CenterCrop):
+                transform = CenterCrop._from_torchvision(transform)
+            elif isinstance(transform, v2.RandomCrop):
+                transform = RandomCrop._from_torchvision(transform)
+            else:
+                raise ValueError(
+                    f"Unsupported transform: {transform}. Transforms must be "
+                    "either a TorchCodec DecoderTransform or a TorchVision "
+                    "v2 transform."
+                )
+
+        converted_transforms.append((transform, curr_input_dims))
+        output_dims = transform._get_output_dims()
+        curr_input_dims = output_dims if output_dims is not None else curr_input_dims
+
+    return ";".join([t._make_transform_spec(dims) for t, dims in converted_transforms])

torchcodec/version.py

@@ -0,0 +1,2 @@
+# Note that this file is generated during install.
+__version__ = '0.10.0'