torchcodec 0.7.0__cp311-cp311-win_amd64.whl

torchcodec/samplers/_time_based.py

@@ -0,0 +1,350 @@
+from typing import Literal, Optional
+
+import torch
+
+from torchcodec import FrameBatch
+from torchcodec.samplers._common import (
+    _FRAMEBATCH_RETURN_DOCS,
+    _POLICY_FUNCTION_TYPE,
+    _POLICY_FUNCTIONS,
+    _reshape_4d_framebatch_into_5d,
+    _validate_common_params,
+)
+
+
+def _validate_params_time_based(
+    *,
+    decoder,
+    num_clips,
+    seconds_between_clip_starts,
+    seconds_between_frames,
+):
+
+    if (num_clips is None and seconds_between_clip_starts is None) or (
+        num_clips is not None and seconds_between_clip_starts is not None
+    ):
+        raise ValueError("This is internal only and should never happen.")
+
+    if seconds_between_clip_starts is not None and seconds_between_clip_starts <= 0:
+        raise ValueError(
+            f"seconds_between_clip_starts ({seconds_between_clip_starts}) must be > 0"
+        )
+
+    if num_clips is not None and num_clips <= 0:
+        raise ValueError(f"num_clips ({num_clips}) must be > 0")
+
+    if decoder.metadata.average_fps is None:
+        raise ValueError(
+            "Could not infer average fps from video metadata. "
+            "Try using an index-based sampler instead."
+        )
+
+    # Note that metadata.begin_stream_seconds is a property that will always yield a valid
+    # value; if it is not present in the actual metadata, the metadata object will return 0.
+    # Hence, we do not test for it here and only test metadata.end_stream_seconds.
+    if decoder.metadata.end_stream_seconds is None:
+        raise ValueError(
+            "Could not infer stream end from video metadata. "
+            "Try using an index-based sampler instead."
+        )
+
+    average_frame_duration_seconds = 1 / decoder.metadata.average_fps
+    if seconds_between_frames is None:
+        seconds_between_frames = average_frame_duration_seconds
+    elif seconds_between_frames <= 0:
+        raise ValueError(
+            f"seconds_between_clip_starts ({seconds_between_clip_starts}) must be > 0, got"
+        )
+
+    return seconds_between_frames
+
+
+def _validate_sampling_range_time_based(
+    *,
+    num_frames_per_clip,
+    seconds_between_frames,
+    sampling_range_start,
+    sampling_range_end,
+    begin_stream_seconds,
+    end_stream_seconds,
+):
+
+    if sampling_range_start is None:
+        sampling_range_start = begin_stream_seconds
+    else:
+        if sampling_range_start < begin_stream_seconds:
+            raise ValueError(
+                f"sampling_range_start ({sampling_range_start}) must be at least {begin_stream_seconds}"
+            )
+        if sampling_range_start >= end_stream_seconds:
+            raise ValueError(
+                f"sampling_range_start ({sampling_range_start}) must be smaller than {end_stream_seconds}"
+            )
+
+    if sampling_range_end is None:
+        # We allow a clip to start anywhere within
+        # [sampling_range_start, sampling_range_end)
+        # When sampling_range_end is None, we want to automatically set it to
+        # the largest possible value such that the sampled frames in any clip
+        # are within the bounds of the video duration (in other words, we don't
+        # want to have to resort to the `policy`).
+        # I.e. we want to guarantee that for all frames in any clip we have
+        # pts < end_stream_seconds.
+        #
+        # The frames of a clip will be sampled at the following pts:
+        # clip_timestamps = [
+        #  clip_start + 0 * seconds_between_frames,
+        #  clip_start + 1 * seconds_between_frames,
+        #  clip_start + 2 * seconds_between_frames,
+        #  ...
+        #  clip_start + (num_frames_per_clip - 1) * seconds_between_frames,
+        # ]
+        # To guarantee that any such value is < end_stream_seconds, we only need
+        # to guarantee that
+        # clip_start < end_stream_seconds - (num_frames_per_clip - 1) * seconds_between_frames
+        #
+        # So that's the value of sampling_range_end we want to use.
+        sampling_range_end = (
+            end_stream_seconds - (num_frames_per_clip - 1) * seconds_between_frames
+        )
+    elif sampling_range_end <= begin_stream_seconds:
+        raise ValueError(
+            f"sampling_range_end ({sampling_range_end}) must be at least {begin_stream_seconds}"
+        )
+
+    if sampling_range_start >= sampling_range_end:
+        raise ValueError(
+            f"sampling_range_start ({sampling_range_start}) must be smaller than sampling_range_end ({sampling_range_end})"
+        )
+
+    sampling_range_end = min(sampling_range_end, end_stream_seconds)
+
+    return sampling_range_start, sampling_range_end
+
+
+def _build_all_clips_timestamps(
+    *,
+    clip_start_seconds: torch.Tensor,  # 1D float tensor
+    num_frames_per_clip: int,
+    seconds_between_frames: float,
+    end_stream_seconds: float,
+    policy_fun: _POLICY_FUNCTION_TYPE,
+) -> list[float]:
+
+    all_clips_timestamps: list[float] = []
+    for start_seconds in clip_start_seconds:
+        clip_timestamps = [
+            timestamp
+            for i in range(num_frames_per_clip)
+            if (timestamp := start_seconds + i * seconds_between_frames)
+            < end_stream_seconds
+        ]
+
+        if len(clip_timestamps) < num_frames_per_clip:
+            clip_timestamps = policy_fun(clip_timestamps, num_frames_per_clip)
+        all_clips_timestamps += clip_timestamps
+
+    return all_clips_timestamps
+
+
+def _generic_time_based_sampler(
+    kind: Literal["random", "regular"],
+    decoder,
+    *,
+    num_clips: Optional[int],  # mutually exclusive with seconds_between_clip_starts
+    seconds_between_clip_starts: Optional[float],
+    num_frames_per_clip: int,
+    seconds_between_frames: Optional[float],
+    # None means "begining", which may not always be 0
+    sampling_range_start: Optional[float],
+    sampling_range_end: Optional[float],  # interval is [start, end).
+    policy: Literal["repeat_last", "wrap", "error"] = "repeat_last",
+) -> FrameBatch:
+    # Note: *everywhere*, sampling_range_end denotes the upper bound of where a
+    # clip can start. This is an *open* upper bound, i.e. we will make sure no
+    # clip starts exactly at (or above) sampling_range_end.
+
+    _validate_common_params(
+        decoder=decoder,
+        num_frames_per_clip=num_frames_per_clip,
+        policy=policy,
+    )
+
+    seconds_between_frames = _validate_params_time_based(
+        decoder=decoder,
+        num_clips=num_clips,
+        seconds_between_clip_starts=seconds_between_clip_starts,
+        seconds_between_frames=seconds_between_frames,
+    )
+
+    sampling_range_start, sampling_range_end = _validate_sampling_range_time_based(
+        num_frames_per_clip=num_frames_per_clip,
+        seconds_between_frames=seconds_between_frames,
+        sampling_range_start=sampling_range_start,
+        sampling_range_end=sampling_range_end,
+        begin_stream_seconds=decoder.metadata.begin_stream_seconds,
+        end_stream_seconds=decoder.metadata.end_stream_seconds,
+    )
+
+    if kind == "random":
+        assert num_clips is not None  # appease type-checker
+        sampling_range_width = sampling_range_end - sampling_range_start
+        # torch.rand() returns in [0, 1)
+        # which ensures all clip starts are < sampling_range_end
+        clip_start_seconds = (
+            torch.rand(num_clips) * sampling_range_width + sampling_range_start
+        )
+    else:
+        assert seconds_between_clip_starts is not None  # appease type-checker
+        clip_start_seconds = torch.arange(
+            sampling_range_start,
+            sampling_range_end,  # excluded
+            seconds_between_clip_starts,
+        )
+        num_clips = len(clip_start_seconds)
+
+    all_clips_timestamps = _build_all_clips_timestamps(
+        clip_start_seconds=clip_start_seconds,
+        num_frames_per_clip=num_frames_per_clip,
+        seconds_between_frames=seconds_between_frames,
+        end_stream_seconds=decoder.metadata.end_stream_seconds,
+        policy_fun=_POLICY_FUNCTIONS[policy],
+    )
+
+    frames = decoder.get_frames_played_at(seconds=all_clips_timestamps)
+    return _reshape_4d_framebatch_into_5d(
+        frames=frames,
+        num_clips=num_clips,
+        num_frames_per_clip=num_frames_per_clip,
+    )
+
+
+def clips_at_random_timestamps(
+    decoder,
+    *,
+    num_clips: int = 1,
+    num_frames_per_clip: int = 1,
+    seconds_between_frames: Optional[float] = None,
+    # None means "begining", which may not always be 0
+    sampling_range_start: Optional[float] = None,
+    sampling_range_end: Optional[float] = None,  # interval is [start, end).
+    policy: Literal["repeat_last", "wrap", "error"] = "repeat_last",
+) -> FrameBatch:
+    # See docstring below
+    torch._C._log_api_usage_once("torchcodec.samplers.clips_at_random_timestamps")
+    return _generic_time_based_sampler(
+        kind="random",
+        decoder=decoder,
+        num_clips=num_clips,
+        seconds_between_clip_starts=None,
+        num_frames_per_clip=num_frames_per_clip,
+        seconds_between_frames=seconds_between_frames,
+        sampling_range_start=sampling_range_start,
+        sampling_range_end=sampling_range_end,
+        policy=policy,
+    )
+
+
+def clips_at_regular_timestamps(
+    decoder,
+    *,
+    seconds_between_clip_starts: float,
+    num_frames_per_clip: int = 1,
+    seconds_between_frames: Optional[float] = None,
+    # None means "begining", which may not always be 0
+    sampling_range_start: Optional[float] = None,
+    sampling_range_end: Optional[float] = None,  # interval is [start, end).
+    policy: Literal["repeat_last", "wrap", "error"] = "repeat_last",
+) -> FrameBatch:
+    # See docstring below
+    torch._C._log_api_usage_once("torchcodec.samplers.clips_at_regular_timestamps")
+    return _generic_time_based_sampler(
+        kind="regular",
+        decoder=decoder,
+        num_clips=None,
+        seconds_between_clip_starts=seconds_between_clip_starts,
+        num_frames_per_clip=num_frames_per_clip,
+        seconds_between_frames=seconds_between_frames,
+        sampling_range_start=sampling_range_start,
+        sampling_range_end=sampling_range_end,
+        policy=policy,
+    )
+
+
+_COMMON_DOCS = """
+    {maybe_note}
+
+    Args:
+        decoder (VideoDecoder): The :class:`~torchcodec.decoders.VideoDecoder`
+            instance to sample clips from.
+        {num_clips_or_seconds_between_clip_starts}
+        num_frames_per_clip (int, optional): The number of frames per clips. Default: 1.
+        seconds_between_frames (float or None, optional): The time (in seconds)
+            between each frame within a clip. More accurately, this defines the
+            time between the *frame sampling point*, i.e. the timestamps at
+            which we sample the frames. Because frames span intervals in time ,
+            the resulting start of frames within a clip may not be exactly
+            spaced by ``seconds_between_frames`` - but on average, they will be.
+            Default is None, which is set to the average frame duration
+            (``1/average_fps``).
+        sampling_range_start (float or None, optional): The start of the
+            sampling range, which defines the first timestamp (in seconds) that
+            a clip may *start* at. Default: None, which corresponds to the start
+            of the video. (Note: some videos start at negative values, which is
+            why the default is not 0).
+        sampling_range_end (float or None, optional): The end of the sampling
+            range, which defines the last timestamp (in seconds) that a clip may
+            *start* at. This value is exclusive, i.e. a clip may only start within
+            [``sampling_range_start``, ``sampling_range_end``). If None
+            (default), the value is set automatically such that the clips never
+            span beyond the end of the video, i.e. it is set to
+            ``end_video_seconds - (num_frames_per_clip - 1) *
+            seconds_between_frames``. When a clip spans beyond the end of the
+            video, the ``policy`` parameter defines how to construct such clip.
+        policy (str, optional): Defines how to construct clips that span beyond
+            the end of the video. This is best described with an example:
+            assuming the last valid (seekable) timestamp in a video is 10.9, and
+            a clip was sampled to start at timestamp 10.5, with
+            ``num_frames_per_clip=5`` and ``seconds_between_frames=0.2``, the
+            sampling timestamps of the frames in the clip are supposed to be
+            [10.5, 10.7, 10.9, 11.1, 11.2]. But 11.1 and 11.2 are invalid
+            timestamps, so the ``policy`` parameter defines how to replace those
+            frames, with valid sampling timestamps:
+
+            - "repeat_last": repeats the last valid frame of the clip. We would
+              get frames sampled at timestamps [10.5, 10.7, 10.9, 10.9, 10.9].
+            - "wrap": wraps around to the beginning of the clip. We would get
+              frames sampled at timestamps [10.5, 10.7, 10.9, 10.5, 10.7].
+            - "error": raises an error.
+
+            Default is "repeat_last". Note that when ``sampling_range_end=None``
+            (default), this policy parameter is unlikely to be relevant.
+
+    {return_docs}
+"""
+
+
+_NUM_CLIPS_DOCS = """
+        num_clips (int, optional): The number of clips to return. Default: 1.
+"""
+clips_at_random_timestamps.__doc__ = f"""Sample :term:`clips` at random timestamps.
+{_COMMON_DOCS.format(maybe_note="", num_clips_or_seconds_between_clip_starts=_NUM_CLIPS_DOCS, return_docs=_FRAMEBATCH_RETURN_DOCS)}
+"""
+
+
+_SECONDS_BETWEEN_CLIP_STARTS = """
+        seconds_between_clip_starts (float): The space (in seconds) between each
+            clip start.
+"""
+
+_NOTE_DOCS = """
+    .. note::
+        For consistency with existing sampling APIs (such as torchvision), this
+        sampler takes a ``seconds_between_clip_starts`` parameter instead of
+        ``num_clips``. If you find that supporting ``num_clips`` would be
+        useful, please let us know by `opening a feature request
+        <https://github.com/pytorch/torchcodec/issues?q=is:open+is:issue>`_.
+"""
+clips_at_regular_timestamps.__doc__ = f"""Sample :term:`clips` at regular (equally-spaced) timestamps.
+{_COMMON_DOCS.format(maybe_note=_NOTE_DOCS, num_clips_or_seconds_between_clip_starts=_SECONDS_BETWEEN_CLIP_STARTS, return_docs=_FRAMEBATCH_RETURN_DOCS)}
+"""

torchcodec/version.py

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

torchcodec-0.7.0.dist-info/METADATA

@@ -0,0 +1,242 @@
+Metadata-Version: 2.4
+Name: torchcodec
+Version: 0.7.0
+Summary: A video decoder for PyTorch
+Author-email: PyTorch Team <packages@pytorch.org>
+Project-URL: GitHub, https://github.com/pytorch/torchcodec
+Project-URL: Documentation, https://pytorch.org/torchcodec/stable/index.html
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Provides-Extra: dev
+Requires-Dist: numpy; extra == "dev"
+Requires-Dist: pytest; extra == "dev"
+Requires-Dist: pillow; extra == "dev"
+Dynamic: license-file
+
+[**Installation**](#installing-torchcodec) | [**Simple Example**](#using-torchcodec) | [**Detailed Example**](https://pytorch.org/torchcodec/stable/generated_examples/) | [**Documentation**](https://pytorch.org/torchcodec) | [**Contributing**](CONTRIBUTING.md) | [**License**](#license)
+
+# TorchCodec
+
+TorchCodec is a Python library for decoding video and audio data into PyTorch
+tensors, on CPU and CUDA GPU. It also supports audio encoding, and video
+encoding will come soon!  It aims to be fast, easy to use, and well integrated
+into the PyTorch ecosystem.  If you want to use PyTorch to train ML models on
+videos and audio, TorchCodec is how you turn these into data.
+
+We achieve these capabilities through:
+
+* Pythonic APIs that mirror Python and PyTorch conventions.
+* Relying on [FFmpeg](https://www.ffmpeg.org/) to do the decoding and encoding.
+  TorchCodec uses the version of FFmpeg you already have installed. FFmpeg is a
+  mature library with broad coverage available on most systems. It is, however,
+  not easy to use. TorchCodec abstracts FFmpeg's complexity to ensure it is used
+  correctly and efficiently.
+* Returning data as PyTorch tensors, ready to be fed into PyTorch transforms
+  or used directly to train models.
+
+## Using TorchCodec
+
+Here's a condensed summary of what you can do with TorchCodec. For more detailed
+examples, [check out our
+documentation](https://pytorch.org/torchcodec/stable/generated_examples/)!
+
+#### Decoding
+
+```python
+from torchcodec.decoders import VideoDecoder
+
+device = "cpu"  # or e.g. "cuda" !
+decoder = VideoDecoder("path/to/video.mp4", device=device)
+
+decoder.metadata
+# VideoStreamMetadata:
+#   num_frames: 250
+#   duration_seconds: 10.0
+#   bit_rate: 31315.0
+#   codec: h264
+#   average_fps: 25.0
+#   ... (truncated output)
+
+# Simple Indexing API
+decoder[0]  # uint8 tensor of shape [C, H, W]
+decoder[0 : -1 : 20]  # uint8 stacked tensor of shape [N, C, H, W]
+
+# Indexing, with PTS and duration info:
+decoder.get_frames_at(indices=[2, 100])
+# FrameBatch:
+#   data (shape): torch.Size([2, 3, 270, 480])
+#   pts_seconds: tensor([0.0667, 3.3367], dtype=torch.float64)
+#   duration_seconds: tensor([0.0334, 0.0334], dtype=torch.float64)
+
+# Time-based indexing with PTS and duration info
+decoder.get_frames_played_at(seconds=[0.5, 10.4])
+# FrameBatch:
+#   data (shape): torch.Size([2, 3, 270, 480])
+#   pts_seconds: tensor([ 0.4671, 10.3770], dtype=torch.float64)
+#   duration_seconds: tensor([0.0334, 0.0334], dtype=torch.float64)
+```
+
+#### Clip sampling
+
+```python
+
+from torchcodec.samplers import clips_at_regular_timestamps
+
+clips_at_regular_timestamps(
+    decoder,
+    seconds_between_clip_starts=1.5,
+    num_frames_per_clip=4,
+    seconds_between_frames=0.1
+)
+# FrameBatch:
+#   data (shape): torch.Size([9, 4, 3, 270, 480])
+#   pts_seconds: tensor([[ 0.0000,  0.0667,  0.1668,  0.2669],
+#         [ 1.4681,  1.5682,  1.6683,  1.7684],
+#         [ 2.9696,  3.0697,  3.1698,  3.2699],
+#         ... (truncated), dtype=torch.float64)
+#   duration_seconds: tensor([[0.0334, 0.0334, 0.0334, 0.0334],
+#         [0.0334, 0.0334, 0.0334, 0.0334],
+#         [0.0334, 0.0334, 0.0334, 0.0334],
+#         ... (truncated), dtype=torch.float64)
+```
+
+You can use the following snippet to generate a video with FFmpeg and tryout
+TorchCodec:
+
+```bash
+fontfile=/usr/share/fonts/dejavu-sans-mono-fonts/DejaVuSansMono-Bold.ttf
+output_video_file=/tmp/output_video.mp4
+
+ffmpeg -f lavfi -i \
+    color=size=640x400:duration=10:rate=25:color=blue \
+    -vf "drawtext=fontfile=${fontfile}:fontsize=30:fontcolor=white:x=(w-text_w)/2:y=(h-text_h)/2:text='Frame %{frame_num}'" \
+    ${output_video_file}
+```
+
+## Installing TorchCodec
+### Installing CPU-only TorchCodec
+
+1. Install the latest stable version of PyTorch following the
+   [official instructions](https://pytorch.org/get-started/locally/). For other
+   versions, refer to the table below for compatibility between versions of
+   `torch` and `torchcodec`.
+
+2. Install FFmpeg, if it's not already installed. Linux distributions usually
+   come with FFmpeg pre-installed. TorchCodec supports all major FFmpeg versions
+   in [4, 7].
+
+   If FFmpeg is not already installed, or you need a more recent version, an
+   easy way to install it is to use `conda`:
+
+   ```bash
+   conda install "ffmpeg<8"
+   # or
+   conda install "ffmpeg<8" -c conda-forge
+   ```
+
+3. Install TorchCodec:
+
+   ```bash
+   pip install torchcodec
+   ```
+
+The following table indicates the compatibility between versions of
+`torchcodec`, `torch` and Python.
+
+| `torchcodec`       | `torch`            | Python              |
+| ------------------ | ------------------ | ------------------- |
+| `main` / `nightly` | `main` / `nightly` | `>=3.10`, `<=3.13`   |
+| `0.6`              | `2.8`              | `>=3.9`, `<=3.13`   |
+| `0.5`              | `2.7`              | `>=3.9`, `<=3.13`   |
+| `0.4`              | `2.7`              | `>=3.9`, `<=3.13`   |
+| `0.3`              | `2.7`              | `>=3.9`, `<=3.13`   |
+| `0.2`              | `2.6`              | `>=3.9`, `<=3.13`   |
+| `0.1`              | `2.5`              | `>=3.9`, `<=3.12`   |
+| `0.0.3`            | `2.4`              | `>=3.8`, `<=3.12`   |
+
+### Installing CUDA-enabled TorchCodec
+
+First, make sure you have a GPU that has NVDEC hardware that can decode the
+format you want. Refer to Nvidia's GPU support matrix for more details
+[here](https://developer.nvidia.com/video-encode-and-decode-gpu-support-matrix-new).
+
+1. Install Pytorch corresponding to your CUDA Toolkit using the
+   [official instructions](https://pytorch.org/get-started/locally/). You'll
+   need the `libnpp` and `libnvrtc` CUDA libraries, which are usually part of
+   the CUDA Toolkit.
+
+2. Install or compile FFmpeg with NVDEC support.
+   TorchCodec with CUDA should work with FFmpeg versions in [4, 7].
+
+   If FFmpeg is not already installed, or you need a more recent version, an
+   easy way to install it is to use `conda`:
+
+   ```bash
+   conda install "ffmpeg<8"
+   # or
+   conda install "ffmpeg<8" -c conda-forge
+   ```
+
+   If you are building FFmpeg from source you can follow Nvidia's guide to
+   configuring and installing FFmpeg with NVDEC support
+   [here](https://docs.nvidia.com/video-technologies/video-codec-sdk/12.0/ffmpeg-with-nvidia-gpu/index.html).
+
+   After installing FFmpeg make sure it has NVDEC support when you list the supported
+   decoders:
+
+   ```bash
+   ffmpeg -decoders | grep -i nvidia
+   # This should show a line like this:
+   # V..... h264_cuvid           Nvidia CUVID H264 decoder (codec h264)
+   ```
+
+   To check that FFmpeg libraries work with NVDEC correctly you can decode a sample video:
+
+   ```bash
+   ffmpeg -hwaccel cuda -hwaccel_output_format cuda -i test/resources/nasa_13013.mp4 -f null -
+   ```
+
+3. Install TorchCodec by passing in an `--index-url` parameter that corresponds
+   to your CUDA Toolkit version, example:
+
+   ```bash
+   # This corresponds to CUDA Toolkit version 12.6. It should be the same one
+   # you used when you installed PyTorch (If you installed PyTorch with pip).
+   pip install torchcodec --index-url=https://download.pytorch.org/whl/cu126
+   ```
+
+   Note that without passing in the `--index-url` parameter, `pip` installs
+   the CPU-only version of TorchCodec.
+
+## Benchmark Results
+
+The following was generated by running [our benchmark script](./benchmarks/decoders/generate_readme_data.py) on a lightly loaded 22-core machine with an Nvidia A100 with
+5 [NVDEC decoders](https://docs.nvidia.com/video-technologies/video-codec-sdk/12.1/nvdec-application-note/index.html#).
+
+![benchmark_results](./benchmarks/decoders/benchmark_readme_chart.png)
+
+The top row is a [Mandelbrot](https://ffmpeg.org/ffmpeg-filters.html#mandelbrot) video
+generated from FFmpeg that has a resolution of 1280x720 at 60 fps and is 120 seconds long.
+The bottom row is [promotional video from NASA](https://download.pytorch.org/torchaudio/tutorial-assets/stream-api/NASAs_Most_Scientifically_Complex_Space_Observatory_Requires_Precision-MP4_small.mp4)
+that has a resolution of 960x540 at 29.7 fps and is 206 seconds long. Both videos were
+encoded with libx264 and yuv420p pixel format. All decoders, except for TorchVision, used FFmpeg 6.1.2. TorchVision used FFmpeg 4.2.2.
+
+For TorchCodec, the "approx" label means that it was using [approximate mode](https://pytorch.org/torchcodec/stable/generated_examples/approximate_mode.html)
+for seeking.
+
+## Contributing
+
+We welcome contributions to TorchCodec! Please see our [contributing
+guide](CONTRIBUTING.md) for more details.
+
+## License
+
+TorchCodec is released under the [BSD 3 license](./LICENSE).
+
+However, TorchCodec may be used with code not written by Meta which may be
+distributed under different licenses.
+
+For example, if you build TorchCodec with ENABLE_CUDA=1 or use the CUDA-enabled
+release of torchcodec, please review CUDA's license here:
+[Nvidia licenses](https://docs.nvidia.com/cuda/eula/index.html).

torchcodec-0.7.0.dist-info/RECORD

@@ -0,0 +1,67 @@
+torchcodec/__init__.py,sha256=F9OpGp7psa4OKvSqaIsCL1FPGtBgqNyAd5Jn0_qUn9s,595
+torchcodec/_frame.py,sha256=_LIIorsNn0nbcInGC9Mwh3Dwc3AuPDhxK4YIBFsfOww,5350
+torchcodec/_internally_replaced_utils.py,sha256=5uYbY1l23FcfWSmLuwZb7j8mWXtMTTp--6sl9LQH28E,2422
+torchcodec/libtorchcodec_core4.dll,sha256=7MSt1zHzCicjD3V0FwOOCl2FKfnMsx3BEvbYXDeMnj0,310784
+torchcodec/libtorchcodec_core5.dll,sha256=_Yd4Nwu-uzLD9Bv-PxJCjsC1c1HG3shVCIPKyBL5vqc,310784
+torchcodec/libtorchcodec_core6.dll,sha256=iwno1JkW5Nd-kQG9nuDNvkSj8Mb9E3mhFz_AKNwe9Sc,310784
+torchcodec/libtorchcodec_core7.dll,sha256=NUUyMUsIHySzv5eLtzN4wYb5LAs7vK1q7QiJKcGy_Bs,310784
+torchcodec/libtorchcodec_custom_ops4.dll,sha256=ZbnPajBWs_gCMbTVUvhfZKIcuCKcem4pgIvabGbjYsk,564224
+torchcodec/libtorchcodec_custom_ops5.dll,sha256=m3HPCpWHOtCCt5XUGgwXkXVyvXmIaZyPgpGJ_0T98_k,564224
+torchcodec/libtorchcodec_custom_ops6.dll,sha256=RlBxQsu0Wr5Ti7r180R6HOcjcnqg3XsR6hv4giUumUI,564224
+torchcodec/libtorchcodec_custom_ops7.dll,sha256=SwtccchW6AECZEKZ87l-yY7MWmcrXlSxxHu46YZccXQ,564224
+torchcodec/libtorchcodec_pybind_ops4.pyd,sha256=VQ9zcpbMyk9t1IoKwA_f3fyDAJd_v-Lg0DoNbEmR77s,203264
+torchcodec/libtorchcodec_pybind_ops5.pyd,sha256=ZN4qH_rDgQ1ymyx1DYsB2L3TRj05mz5ehYTZUFoBaRc,203264
+torchcodec/libtorchcodec_pybind_ops6.pyd,sha256=DekXV_7gAvElb3lZeo1ylKjBHfjcgyEEXIlMm6q8Vyo,203264
+torchcodec/libtorchcodec_pybind_ops7.pyd,sha256=OT3Dcw8in1WXZe_AaIrJ-4DZ9A3SXuZTHMfBOI4ArV0,203264
+torchcodec/version.py,sha256=vUzeNMn0u4ZIrdugClyruOvja4DvMzg12beg1CQBNpI,75
+torchcodec/_core/AVIOContextHolder.cpp,sha256=ucOD1bGORgSzZfL5TxJtUVH2GAtXGVDylzWpvbJ2qJY,1628
+torchcodec/_core/AVIOContextHolder.h,sha256=iYRap1vDdvK_4wylu3Ds9Dkn1k_vAdkbVJDlVni9uNY,2697
+torchcodec/_core/AVIOFileLikeContext.cpp,sha256=bCMpEXhQPLWULWJRIPpNqzlio2eLE_EI7UoPuUgw70g,3450
+torchcodec/_core/AVIOFileLikeContext.h,sha256=oJM9q9X3i1leplaBsU1vMW0gMt1a-xANHhgk5FID3zA,2130
+torchcodec/_core/AVIOTensorContext.cpp,sha256=bNE33CeYuTsXbaZRo0Izs1pLJOQlYPtlX_ofgeBH9hM,4018
+torchcodec/_core/AVIOTensorContext.h,sha256=kYO93vn1hVINRHRoP2BWzEKUoPl1WeI62cgz5y0T6OA,1106
+torchcodec/_core/CMakeLists.txt,sha256=BOXfMdQxmo0WXIgFCXFYCnmYvrN7kYg2unGpAQvT7z0,10522
+torchcodec/_core/Cache.h,sha256=TG3kE1i86edBR9LXsEl4nToMOOi8wPJXFJYkTbBiJdk,5210
+torchcodec/_core/CpuDeviceInterface.cpp,sha256=I6aOFFaO_4hQc7EhjLAGQRWVyESUwc-J1armWlP11AU,10404
+torchcodec/_core/CpuDeviceInterface.h,sha256=9GVKS5D7Zz7ijJKzzHFwBJAi4h-VZFeHBkVa1miPlGM,2149
+torchcodec/_core/CudaDeviceInterface.cpp,sha256=mQvEeMI4EEzh0jDhMrEcKhUE2WLCpWGSVqZVH9awl4E,21782
+torchcodec/_core/CudaDeviceInterface.h,sha256=jtUC8la5pbBPnCoy6koOOVR9BDdWWQiPfb00bFbxQW0,1064
+torchcodec/_core/DeviceInterface.cpp,sha256=9tk2i_gwyxMWloQRB79qFaqbmntifU1en1Q-w9ltX3E,2310
+torchcodec/_core/DeviceInterface.h,sha256=6IEa_lO3f5VW8i4gAZWn4Jm3_TggqqzNQA3ha3sxrDU,2078
+torchcodec/_core/Encoder.cpp,sha256=VeWPOzzaD5Zlso1G7hc8AlqlS3khRsRoATgWPBElSQA,18555
+torchcodec/_core/Encoder.h,sha256=Sd0Oz48THSzJfS3xetglB4fKjuqdOXWqvzI3h1U0HKI,6494
+torchcodec/_core/FFMPEGCommon.cpp,sha256=W0ZLP-JjWs25fmAY1lTW64nfcOZvMqZ9LkUvGOXBv84,13526
+torchcodec/_core/FFMPEGCommon.h,sha256=6jyWfUmz9jA9ysqehLdKLp5p5sXAtWOuNlafI9EFXqI,7525
+torchcodec/_core/FilterGraph.cpp,sha256=khohAN1w4oWFlYsQTAqgBDtiwf6ygrI36jtdKACjue8,4857
+torchcodec/_core/FilterGraph.h,sha256=BIqHSpjyM99MtnULHh79HRuFgc8cHXouLWcioyknaI0,1223
+torchcodec/_core/Frame.cpp,sha256=xuPRBVL6yTAQqls-3xZ-YzjQXR0Z67Vnq3EQ-9okGF4,1130
+torchcodec/_core/Frame.h,sha256=TKlYFdObFBO0YK5sWs1KziovDwgnCaQixm71qB0MpEg,5022
+torchcodec/_core/Metadata.h,sha256=SFNyD4ey2rHmxbrjebHa6PUA-BoiytYrgi5nafNWlyI,2588
+torchcodec/_core/SingleStreamDecoder.cpp,sha256=BqSXEy0_LECdtegKFa-W8Qz_CnavSUOt9en-pl8C1eQ,66958
+torchcodec/_core/SingleStreamDecoder.h,sha256=Jn0i8mKppGd0y99e6Am2k5OeN2iqaWJD6-BvvEb-ub0,15594
+torchcodec/_core/StreamOptions.h,sha256=Xo0TTIQZy5bk5UBZ3NLQeCxoOiDLJGm-BM2NiU_CMeY,1638
+torchcodec/_core/ValidationUtils.cpp,sha256=PkBTLv_38eYG9ZUVbGijHSug3YewtD2FNiftfZ3q8S8,994
+torchcodec/_core/ValidationUtils.h,sha256=XWSUL441nPNYRGCnnpul0iuWtUNgZXC_fcsxeb-oB6E,579
+torchcodec/_core/__init__.py,sha256=pMKoJaSVKfOcUBM6UezF_GN0q2gUTaxQkDtFElDM_Qk,1070
+torchcodec/_core/_metadata.py,sha256=LWlCQmJwJ66TjK_4bwtMARzSDVlid62dpsOVpDHk8NQ,13117
+torchcodec/_core/custom_ops.cpp,sha256=4TpEaaVChJdbsyQN-hzCvsz8wr3o09VgYkwv2ZKO2ww,30231
+torchcodec/_core/fetch_and_expose_non_gpl_ffmpeg_libs.cmake,sha256=rrXg44VfrlOJBnHBxx5odozGE9W70EFC-JM-X4iTYQ4,6900
+torchcodec/_core/ops.py,sha256=9b56ImvKCwOjMKQRh6wrf7MgvsFhbnKDCkAoKFCqHTE,16623
+torchcodec/_core/pybind_ops.cpp,sha256=1D8siVAiQUqWyl-I785BBeZMQs3YGSbf6R07ZrMrpPg,3092
+torchcodec/_samplers/__init__.py,sha256=qWg69NiVSnMcYi68RTVFGvvp9bh1jkNha5u7q3VMRLw,258
+torchcodec/_samplers/video_clip_sampler.py,sha256=ChIbqJ461_8aZ37_hzkXDrweibjnQHpvYunv5GWdfFo,18975
+torchcodec/decoders/__init__.py,sha256=GeONirXzwswy5iJK61Yuj6oyfZ7GsEJp8EP1tACSWuE,414
+torchcodec/decoders/_audio_decoder.py,sha256=dWbtH7OLIgcbiFQIvP9qpATvIC7XeS67P9uGM4dmsRE,7580
+torchcodec/decoders/_decoder_utils.py,sha256=yM7izTYP72iY6mr3P30sAvd2wKZlWo-eopy3KVaZy8A,2089
+torchcodec/decoders/_video_decoder.py,sha256=jH4KzwkYNIBk0G0k-GlgdYBz_laVojf8VgC8TOlGZxU,19012
+torchcodec/encoders/__init__.py,sha256=Jw7dTzlTbzTaD_ZMrgSxUWEMs7Pn0cyxKm-_beuBIGo,50
+torchcodec/encoders/_audio_encoder.py,sha256=VMZs6VTQDIMcsBxWtQEUpwq_ruILrrvNVktkswajaiM,6312
+torchcodec/samplers/__init__.py,sha256=pijGrxa71UjRYHh1sRqLzwpsVXYAmHe24kMbC-rZW_M,159
+torchcodec/samplers/_common.py,sha256=okgK1nVKA6mE9Li1Jex1GbzN7m26S3LtaREeF1AX-dA,2823
+torchcodec/samplers/_index_based.py,sha256=8iwlYZrqTdP7CnnBbwd3PsJhQNkF-YHH802AHAEoG-g,11695
+torchcodec/samplers/_time_based.py,sha256=xMltTGyaSxyba44Q5CJvFD2nyYIZKul-1sV6D2p-p1w,14651
+torchcodec-0.7.0.dist-info/licenses/LICENSE,sha256=ry9-8rOEo-Fe1s7VhuGoMWcBx72CjMauQWTw26jlrI8,1502
+torchcodec-0.7.0.dist-info/METADATA,sha256=Mlio9SootCV0TIuRvRKcfKkXWUEc6px3pUlhO1T0nrQ,9677
+torchcodec-0.7.0.dist-info/WHEEL,sha256=pkI-s5KKCTCXRcuamRCpmUHK9lBRiVf1mC9_VUZSXgc,101
+torchcodec-0.7.0.dist-info/top_level.txt,sha256=S1IZq2_jNQE_RDGwxNunVF8S1RCMXmWdAAQjLXBdu2g,21
+torchcodec-0.7.0.dist-info/RECORD,,

torchcodec-0.7.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (78.1.1)
+Root-Is-Purelib: false
+Tag: cp311-cp311-win_amd64
+