torchrir 0.1.4__py3-none-any.whl → 0.2.0__py3-none-any.whl

torchrir/__init__.py

@@ -18,6 +18,11 @@ from .datasets import (
     CmuArcticDataset,
     CmuArcticSentence,
     choose_speakers,
+    CollateBatch,
+    collate_dataset_items,
+    DatasetItem,
+    LibriSpeechDataset,
+    LibriSpeechSentence,
     list_cmu_arctic_speakers,
     SentenceLike,
     load_dataset_sources,
@@ -61,6 +66,11 @@ __all__ = [
     "CmuArcticDataset",
     "CmuArcticSentence",
     "choose_speakers",
+    "CollateBatch",
+    "collate_dataset_items",
+    "DatasetItem",
+    "LibriSpeechDataset",
+    "LibriSpeechSentence",
     "DynamicConvolver",
     "estimate_beta_from_t60",
     "estimate_t60_from_beta",

torchrir/core.py

@@ -262,6 +262,11 @@ def simulate_dynamic_rir(
 
     src_traj = as_tensor(src_traj, device=device, dtype=dtype)
     mic_traj = as_tensor(mic_traj, device=device, dtype=dtype)
+    device, dtype = infer_device_dtype(
+        src_traj, mic_traj, room.size, device=device, dtype=dtype
+    )
+    src_traj = as_tensor(src_traj, device=device, dtype=dtype)
+    mic_traj = as_tensor(mic_traj, device=device, dtype=dtype)
 
     if src_traj.ndim == 2:
         src_traj = src_traj.unsqueeze(1)
@@ -274,24 +279,95 @@ def simulate_dynamic_rir(
     if src_traj.shape[0] != mic_traj.shape[0]:
         raise ValueError("src_traj and mic_traj must have the same time length")
 
-    t_steps = src_traj.shape[0]
-    rirs = []
-    for t_idx in range(t_steps):
-        rir = simulate_rir(
-            room=room,
-            sources=src_traj[t_idx],
-            mics=mic_traj[t_idx],
-            max_order=max_order,
-            nsample=nsample,
-            tmax=tmax,
-            directivity=directivity,
-            orientation=orientation,
-            config=config,
-            device=device,
-            dtype=dtype,
+    if not isinstance(room, Room):
+        raise TypeError("room must be a Room instance")
+    if nsample is None:
+        if tmax is None:
+            raise ValueError("nsample or tmax must be provided")
+        nsample = int(math.ceil(tmax * room.fs))
+    if nsample <= 0:
+        raise ValueError("nsample must be positive")
+    if max_order < 0:
+        raise ValueError("max_order must be non-negative")
+
+    room_size = as_tensor(room.size, device=device, dtype=dtype)
+    room_size = ensure_dim(room_size)
+    dim = room_size.numel()
+    if src_traj.shape[2] != dim:
+        raise ValueError("src_traj must match room dimension")
+    if mic_traj.shape[2] != dim:
+        raise ValueError("mic_traj must match room dimension")
+
+    src_ori = None
+    mic_ori = None
+    if orientation is not None:
+        if isinstance(orientation, (list, tuple)):
+            if len(orientation) != 2:
+                raise ValueError("orientation tuple must have length 2")
+            src_ori, mic_ori = orientation
+        else:
+            src_ori = orientation
+            mic_ori = orientation
+    if src_ori is not None:
+        src_ori = as_tensor(src_ori, device=device, dtype=dtype)
+    if mic_ori is not None:
+        mic_ori = as_tensor(mic_ori, device=device, dtype=dtype)
+
+    beta = _resolve_beta(room, room_size, device=device, dtype=dtype)
+    beta = _validate_beta(beta, dim)
+    n_vec = _image_source_indices(max_order, dim, device=device, nb_img=None)
+    refl = _reflection_coefficients(n_vec, beta)
+
+    src_pattern, mic_pattern = split_directivity(directivity)
+    mic_dir = None
+    if mic_pattern != "omni":
+        if mic_ori is None:
+            raise ValueError("mic orientation required for non-omni directivity")
+        mic_dir = orientation_to_unit(mic_ori, dim)
+
+    n_src = src_traj.shape[1]
+    n_mic = mic_traj.shape[1]
+    rirs = torch.zeros((src_traj.shape[0], n_src, n_mic, nsample), device=device, dtype=dtype)
+    fdl = cfg.frac_delay_length
+    fdl2 = (fdl - 1) // 2
+    img_chunk = cfg.image_chunk_size
+    if img_chunk <= 0:
+        img_chunk = n_vec.shape[0]
+
+    src_dirs = None
+    if src_pattern != "omni":
+        if src_ori is None:
+            raise ValueError("source orientation required for non-omni directivity")
+        src_dirs = orientation_to_unit(src_ori, dim)
+        if src_dirs.ndim == 1:
+            src_dirs = src_dirs.unsqueeze(0).repeat(n_src, 1)
+        if src_dirs.ndim != 2 or src_dirs.shape[0] != n_src:
+            raise ValueError("source orientation must match number of sources")
+
+    for start in range(0, n_vec.shape[0], img_chunk):
+        end = min(start + img_chunk, n_vec.shape[0])
+        n_vec_chunk = n_vec[start:end]
+        refl_chunk = refl[start:end]
+        sample_chunk, attenuation_chunk = _compute_image_contributions_time_batch(
+            src_traj,
+            mic_traj,
+            room_size,
+            n_vec_chunk,
+            refl_chunk,
+            room,
+            fdl2,
+            src_pattern=src_pattern,
+            mic_pattern=mic_pattern,
+            src_dirs=src_dirs,
+            mic_dir=mic_dir,
         )
-        rirs.append(rir)
-    return torch.stack(rirs, dim=0)
+        t_steps = src_traj.shape[0]
+        sample_flat = sample_chunk.reshape(t_steps * n_src, n_mic, -1)
+        attenuation_flat = attenuation_chunk.reshape(t_steps * n_src, n_mic, -1)
+        rir_flat = rirs.view(t_steps * n_src, n_mic, nsample)
+        _accumulate_rir_batch(rir_flat, sample_flat, attenuation_flat, cfg)
+
+    return rirs
 
 
 def _prepare_entities(
@@ -508,6 +584,54 @@ def _compute_image_contributions_batch(
     return sample, attenuation
 
 
+def _compute_image_contributions_time_batch(
+    src_traj: Tensor,
+    mic_traj: Tensor,
+    room_size: Tensor,
+    n_vec: Tensor,
+    refl: Tensor,
+    room: Room,
+    fdl2: int,
+    *,
+    src_pattern: str,
+    mic_pattern: str,
+    src_dirs: Optional[Tensor],
+    mic_dir: Optional[Tensor],
+) -> Tuple[Tensor, Tensor]:
+    """Compute samples/attenuation for all time steps in batch."""
+    sign = torch.where((n_vec % 2) == 0, 1.0, -1.0).to(dtype=src_traj.dtype)
+    n = torch.floor_divide(n_vec + 1, 2).to(dtype=src_traj.dtype)
+    base = 2.0 * room_size * n
+    img = base[None, None, :, :] + sign[None, None, :, :] * src_traj[:, :, None, :]
+    vec = mic_traj[:, None, :, None, :] - img[:, :, None, :, :]
+    dist = torch.linalg.norm(vec, dim=-1)
+    dist = torch.clamp(dist, min=1e-6)
+    time = dist / room.c
+    time = time + (fdl2 / room.fs)
+    sample = time * room.fs
+
+    gain = refl.view(1, 1, 1, -1)
+    if src_pattern != "omni":
+        if src_dirs is None:
+            raise ValueError("source orientation required for non-omni directivity")
+        src_dirs_b = src_dirs[None, :, None, None, :]
+        cos_theta = _cos_between(vec, src_dirs_b)
+        gain = gain * directivity_gain(src_pattern, cos_theta)
+    if mic_pattern != "omni":
+        if mic_dir is None:
+            raise ValueError("mic orientation required for non-omni directivity")
+        mic_dir_b = (
+            mic_dir[None, None, :, None, :]
+            if mic_dir.ndim == 2
+            else mic_dir.view(1, 1, 1, 1, -1)
+        )
+        cos_theta = _cos_between(-vec, mic_dir_b)
+        gain = gain * directivity_gain(mic_pattern, cos_theta)
+
+    attenuation = gain / dist
+    return sample, attenuation
+
+
 def _select_orientation(orientation: Tensor, idx: int, count: int, dim: int) -> Tensor:
     """Pick the correct orientation vector for a given entity index."""
     if orientation.ndim == 0:

torchrir/datasets/__init__.py

@@ -1,14 +1,15 @@
 """Dataset helpers for torchrir."""
 
-from .base import BaseDataset, SentenceLike
-from .utils import choose_speakers, load_dataset_sources
+from .base import BaseDataset, DatasetItem, SentenceLike
+from .utils import choose_speakers, load_dataset_sources, load_wav_mono
+from .collate import CollateBatch, collate_dataset_items
 from .template import TemplateDataset, TemplateSentence
+from .librispeech import LibriSpeechDataset, LibriSpeechSentence
 
 from .cmu_arctic import (
     CmuArcticDataset,
     CmuArcticSentence,
     list_cmu_arctic_speakers,
-    load_wav_mono,
     save_wav,
 )
 
@@ -17,6 +18,9 @@ __all__ = [
     "CmuArcticDataset",
     "CmuArcticSentence",
     "choose_speakers",
+    "DatasetItem",
+    "CollateBatch",
+    "collate_dataset_items",
     "list_cmu_arctic_speakers",
     "SentenceLike",
     "load_dataset_sources",
@@ -24,4 +28,6 @@ __all__ = [
     "save_wav",
     "TemplateDataset",
     "TemplateSentence",
+    "LibriSpeechDataset",
+    "LibriSpeechSentence",
 ]

torchrir/datasets/base.py

@@ -2,9 +2,11 @@ from __future__ import annotations
 
 """Dataset protocol definitions."""
 
-from typing import Protocol, Sequence, Tuple
+from dataclasses import dataclass
+from typing import Optional, Protocol, Sequence, Tuple
 
 import torch
+from torch.utils.data import Dataset
 
 
 class SentenceLike(Protocol):
@@ -14,14 +16,52 @@ class SentenceLike(Protocol):
     text: str
 
 
-class BaseDataset(Protocol):
-    """Protocol for datasets used in torchrir examples and tools."""
+@dataclass(frozen=True)
+class DatasetItem:
+    """Dataset item for DataLoader consumption."""
+
+    audio: torch.Tensor
+    sample_rate: int
+    utterance_id: str
+    text: Optional[str] = None
+    speaker: Optional[str] = None
+
+
+class BaseDataset(Dataset[DatasetItem]):
+    """Base dataset class compatible with torch.utils.data.Dataset."""
+
+    _sentences_cache: Optional[list[SentenceLike]] = None
 
     def list_speakers(self) -> list[str]:
         """Return available speaker IDs."""
+        raise NotImplementedError
 
     def available_sentences(self) -> Sequence[SentenceLike]:
         """Return sentence entries that have audio available."""
+        raise NotImplementedError
 
     def load_wav(self, utterance_id: str) -> Tuple[torch.Tensor, int]:
         """Load audio for an utterance and return (audio, sample_rate)."""
+        raise NotImplementedError
+
+    def __len__(self) -> int:
+        return len(self._get_sentences())
+
+    def __getitem__(self, idx: int) -> DatasetItem:
+        sentences = self._get_sentences()
+        sentence = sentences[idx]
+        audio, sample_rate = self.load_wav(sentence.utterance_id)
+        speaker = getattr(self, "speaker", None)
+        text = getattr(sentence, "text", None)
+        return DatasetItem(
+            audio=audio,
+            sample_rate=sample_rate,
+            utterance_id=sentence.utterance_id,
+            text=text,
+            speaker=speaker,
+        )
+
+    def _get_sentences(self) -> list[SentenceLike]:
+        if self._sentences_cache is None:
+            self._sentences_cache = list(self.available_sentences())
+        return self._sentences_cache

torchrir/datasets/cmu_arctic.py

@@ -2,6 +2,7 @@ from __future__ import annotations
 
 """CMU ARCTIC dataset helpers."""
 
+import logging
 import tarfile
 import urllib.request
 from dataclasses import dataclass
@@ -9,7 +10,9 @@ from pathlib import Path
 from typing import List, Tuple
 
 import torch
-import logging
+
+from .base import BaseDataset
+from .utils import load_wav_mono
 
 BASE_URL = "http://www.festvox.org/cmu_arctic/packed"
 VALID_SPEAKERS = {
@@ -49,7 +52,7 @@ class CmuArcticSentence:
     text: str
 
 
-class CmuArcticDataset:
+class CmuArcticDataset(BaseDataset):
     """CMU ARCTIC dataset loader.
 
     Example:
@@ -191,23 +194,6 @@ def _parse_text_line(line: str) -> Tuple[str, str]:
     return utterance, text
 
 
-def load_wav_mono(path: Path) -> Tuple[torch.Tensor, int]:
-    """Load a wav file and return mono audio and sample rate.
-
-    Example:
-        >>> audio, fs = load_wav_mono(Path("datasets/cmu_arctic/ARCTIC/.../wav/arctic_a0001.wav"))
-    """
-    import soundfile as sf
-
-    audio, sample_rate = sf.read(str(path), dtype="float32", always_2d=True)
-    audio_t = torch.from_numpy(audio)
-    if audio_t.shape[1] > 1:
-        audio_t = audio_t.mean(dim=1)
-    else:
-        audio_t = audio_t.squeeze(1)
-    return audio_t, sample_rate
-
-
 def save_wav(path: Path, audio: torch.Tensor, sample_rate: int) -> None:
     """Save a mono or multi-channel wav to disk.
 

torchrir/datasets/collate.py

@@ -0,0 +1,90 @@
+from __future__ import annotations
+
+"""Collate helpers for DataLoader usage."""
+
+from dataclasses import dataclass
+from typing import Any, Iterable, List, Optional
+
+import torch
+from torch import Tensor
+
+from .base import DatasetItem
+
+
+@dataclass(frozen=True)
+class CollateBatch:
+    """Collated batch of dataset items.
+
+    Attributes:
+        audio: Padded audio tensor of shape (batch, max_len).
+        lengths: Original lengths for each item.
+        sample_rate: Sample rate shared across the batch.
+        utterance_ids: Utterance IDs per item.
+        texts: Optional text per item.
+        speakers: Optional speaker IDs per item.
+        metadata: Optional per-item metadata (pass-through).
+    """
+
+    audio: Tensor
+    lengths: Tensor
+    sample_rate: int
+    utterance_ids: list[str]
+    texts: list[Optional[str]]
+    speakers: list[Optional[str]]
+    metadata: Optional[list[Any]] = None
+
+
+def collate_dataset_items(
+    items: Iterable[DatasetItem],
+    *,
+    pad_value: float = 0.0,
+    keep_metadata: bool = False,
+) -> CollateBatch:
+    """Collate DatasetItem entries into a padded batch.
+
+    Args:
+        items: Iterable of DatasetItem.
+        pad_value: Value used for padding.
+        keep_metadata: Preserve item-level metadata field if present.
+
+    Returns:
+        CollateBatch with padded audio and metadata lists.
+    """
+    batch = list(items)
+    if not batch:
+        raise ValueError("collate_dataset_items received an empty batch")
+
+    sample_rate = batch[0].sample_rate
+    for item in batch[1:]:
+        if item.sample_rate != sample_rate:
+            raise ValueError("sample_rate must be consistent within a batch")
+
+    lengths = torch.tensor([item.audio.numel() for item in batch], dtype=torch.long)
+    max_len = int(lengths.max().item())
+    audio = torch.full(
+        (len(batch), max_len),
+        pad_value,
+        dtype=batch[0].audio.dtype,
+        device=batch[0].audio.device,
+    )
+
+    for idx, item in enumerate(batch):
+        audio[idx, : item.audio.numel()] = item.audio
+
+    utterance_ids = [item.utterance_id for item in batch]
+    texts = [item.text for item in batch]
+    speakers = [item.speaker for item in batch]
+
+    metadata: Optional[list[Any]] = None
+    if keep_metadata:
+        metadata = [getattr(item, "metadata", None) for item in batch]
+
+    return CollateBatch(
+        audio=audio,
+        lengths=lengths,
+        sample_rate=sample_rate,
+        utterance_ids=utterance_ids,
+        texts=texts,
+        speakers=speakers,
+        metadata=metadata,
+    )

torchrir/datasets/librispeech.py

@@ -0,0 +1,175 @@
+from __future__ import annotations
+
+"""LibriSpeech dataset helpers."""
+
+import logging
+import tarfile
+import urllib.request
+from dataclasses import dataclass
+from pathlib import Path
+from typing import List, Tuple
+
+import torch
+
+from .base import BaseDataset
+from .utils import load_wav_mono
+
+BASE_URL = "https://www.openslr.org/resources/12"
+VALID_SUBSETS = {
+    "dev-clean",
+    "dev-other",
+    "test-clean",
+    "test-other",
+    "train-clean-100",
+    "train-clean-360",
+    "train-other-500",
+}
+
+logger = logging.getLogger(__name__)
+
+
+@dataclass
+class LibriSpeechSentence:
+    """Sentence metadata from LibriSpeech."""
+
+    utterance_id: str
+    text: str
+    speaker_id: str
+    chapter_id: str
+
+
+class LibriSpeechDataset(BaseDataset):
+    """LibriSpeech dataset loader.
+
+    Example:
+        >>> dataset = LibriSpeechDataset(Path("datasets/librispeech"), subset="train-clean-100", download=True)
+        >>> audio, fs = dataset.load_wav("103-1240-0000")
+    """
+
+    def __init__(
+        self, root: Path, subset: str = "train-clean-100", download: bool = False
+    ) -> None:
+        """Initialize a LibriSpeech dataset handle.
+
+        Args:
+            root: Root directory where the dataset is stored.
+            subset: LibriSpeech subset name (e.g., "train-clean-100").
+            download: Download and extract if missing.
+        """
+        if subset not in VALID_SUBSETS:
+            raise ValueError(f"unsupported subset: {subset}")
+        self.root = Path(root)
+        self.subset = subset
+        self._archive_name = f"{subset}.tar.gz"
+        self._base_dir = self.root / "LibriSpeech"
+        self._subset_dir = self._base_dir / subset
+
+        if download:
+            self._download_and_extract()
+
+        if not self._subset_dir.exists():
+            raise FileNotFoundError(
+                "dataset not found; run with download=True or place the archive under "
+                f"{self.root}"
+            )
+
+    def list_speakers(self) -> List[str]:
+        """Return available speaker IDs."""
+        if not self._subset_dir.exists():
+            return []
+        return sorted([p.name for p in self._subset_dir.iterdir() if p.is_dir()])
+
+    def available_sentences(self) -> List[LibriSpeechSentence]:
+        """Return sentences that have a corresponding audio file."""
+        sentences: List[LibriSpeechSentence] = []
+        for trans_path in self._subset_dir.rglob("*.trans.txt"):
+            chapter_dir = trans_path.parent
+            speaker_id = chapter_dir.parent.name
+            chapter_id = chapter_dir.name
+            with trans_path.open("r", encoding="utf-8") as f:
+                for line in f:
+                    line = line.strip()
+                    if not line:
+                        continue
+                    utt_id, text = _parse_text_line(line)
+                    wav_path = chapter_dir / f"{utt_id}.flac"
+                    if wav_path.exists():
+                        sentences.append(
+                            LibriSpeechSentence(
+                                utterance_id=utt_id,
+                                text=text,
+                                speaker_id=speaker_id,
+                                chapter_id=chapter_id,
+                            )
+                        )
+        return sentences
+
+    def load_wav(self, utterance_id: str) -> Tuple[torch.Tensor, int]:
+        """Load a mono wav for the given utterance ID."""
+        speaker_id, chapter_id, _ = utterance_id.split("-", 2)
+        path = self._subset_dir / speaker_id / chapter_id / f"{utterance_id}.flac"
+        return load_wav_mono(path)
+
+    def _download_and_extract(self) -> None:
+        """Download and extract the subset archive if needed."""
+        self.root.mkdir(parents=True, exist_ok=True)
+        archive_path = self.root / self._archive_name
+        url = f"{BASE_URL}/{self._archive_name}"
+
+        if not archive_path.exists():
+            logger.info("Downloading %s", url)
+            _download(url, archive_path)
+        if not self._subset_dir.exists():
+            logger.info("Extracting %s", archive_path)
+            try:
+                with tarfile.open(archive_path, "r:gz") as tar:
+                    tar.extractall(self.root)
+            except (tarfile.ReadError, EOFError, OSError) as exc:
+                logger.warning("Extraction failed (%s); re-downloading.", exc)
+                if archive_path.exists():
+                    archive_path.unlink()
+                _download(url, archive_path)
+                with tarfile.open(archive_path, "r:gz") as tar:
+                    tar.extractall(self.root)
+
+
+def _download(url: str, dest: Path, retries: int = 1) -> None:
+    """Download a file with retry and resume-safe temp file."""
+    for attempt in range(retries + 1):
+        try:
+            _stream_download(url, dest)
+            return
+        except Exception as exc:
+            if dest.exists():
+                dest.unlink()
+            if attempt >= retries:
+                raise
+            logger.warning("Download failed (%s); retrying...", exc)
+
+
+def _stream_download(url: str, dest: Path) -> None:
+    """Stream a URL to disk with a progress indicator."""
+    tmp_path = dest.with_suffix(dest.suffix + ".part")
+    if tmp_path.exists():
+        tmp_path.unlink()
+
+    with urllib.request.urlopen(url) as response:
+        total = response.length or 0
+        downloaded = 0
+        chunk_size = 1024 * 1024
+        with tmp_path.open("wb") as f:
+            while True:
+                chunk = response.read(chunk_size)
+                if not chunk:
+                    break
+                f.write(chunk)
+                downloaded += len(chunk)
+    if total > 0 and downloaded != total:
+        raise IOError(f"incomplete download: {downloaded} of {total} bytes")
+    tmp_path.replace(dest)
+
+
+def _parse_text_line(line: str) -> Tuple[str, str]:
+    """Parse a LibriSpeech transcript line into (utterance_id, text)."""
+    left, _, right = line.partition(" ")
+    return left, right.strip()

torchrir/datasets/utils.py

@@ -3,6 +3,7 @@ from __future__ import annotations
 """Dataset-agnostic utilities."""
 
 import random
+from pathlib import Path
 from typing import Callable, List, Optional, Sequence, Tuple
 
 import torch
@@ -94,3 +95,20 @@ def load_dataset_sources(
     if fs is None:
         raise RuntimeError("no audio loaded from dataset sources")
     return stacked, int(fs), info
+
+
+def load_wav_mono(path: Path) -> Tuple[torch.Tensor, int]:
+    """Load a wav/flac file and return mono audio and sample rate.
+
+    Example:
+        >>> audio, fs = load_wav_mono(Path("datasets/cmu_arctic/ARCTIC/.../wav/arctic_a0001.wav"))
+    """
+    import soundfile as sf
+
+    audio, sample_rate = sf.read(str(path), dtype="float32", always_2d=True)
+    audio_t = torch.from_numpy(audio)
+    if audio_t.shape[1] > 1:
+        audio_t = audio_t.mean(dim=1)
+    else:
+        audio_t = audio_t.squeeze(1)
+    return audio_t, sample_rate

{torchrir-0.1.4.dist-info → torchrir-0.2.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: torchrir
-Version: 0.1.4
+Version: 0.2.0
 Summary: PyTorch-based room impulse response (RIR) simulation toolkit for static and dynamic scenes.
 Project-URL: Repository, https://github.com/taishi-n/torchrir
 Requires-Python: >=3.10
@@ -59,7 +59,7 @@ For detailed documentation, see the docs under `docs/` and Read the Docs.
 ## Future Work
 - Ray tracing backend: implement `RayTracingSimulator` with frequency-dependent absorption/scattering.
 - CUDA-native acceleration: introduce dedicated CUDA kernels for large-scale RIR generation.
-- Dataset expansion: add additional dataset integrations beyond CMU ARCTIC (see `TemplateDataset`).
+- Dataset expansion: add additional dataset integrations beyond CMU ARCTIC (see `TemplateDataset`), including torchaudio datasets (e.g., LibriSpeech, VCTK, LibriTTS, SpeechCommands, CommonVoice, GTZAN, MUSDB-HQ).
 - Add regression tests comparing generated RIRs against gpuRIR outputs.
 
 ## Related Libraries

{torchrir-0.1.4.dist-info → torchrir-0.2.0.dist-info}/RECORD

@@ -1,7 +1,7 @@
-torchrir/__init__.py,sha256=urydbUWuUHPBqmy-9QBaQg8eFGznRamkSjLmPiNvBo0,2383
+torchrir/__init__.py,sha256=MTlouAErvB7IyM4pcmhEN1U0KQsZBglWxUoHxnZDa5U,2615
 torchrir/animation.py,sha256=x3Y-BLz3J6DQNmoDIjbMEgGfng2yavJFLyQEmRCSpQU,6391
 torchrir/config.py,sha256=PsZdDIS3p4jepeNSHyd69aSD9QlOEdpG9v1SAXlZ_Fg,2295
-torchrir/core.py,sha256=VdljYoCoQoZqD8aYJRnuHEb7uORQjyQysVc8K3RGuao,26826
+torchrir/core.py,sha256=Ug5thts1rXvCpdq9twVHz72oWygmk5J6gliloozHKL4,31704
 torchrir/directivity.py,sha256=v_t37YgeXF_IYzbnrk0TCs1npb_0yKR7zHiG8XV3V4w,1259
 torchrir/dynamic.py,sha256=01JHMxhORdcz93J-YaMIeSLo7k2tHrZke8llPHHXwZg,2153
 torchrir/logging_utils.py,sha256=s4jDSSDoHT0HKeplDUpGMsdeBij4eibLSpaaAPzkB68,2146
@@ -15,14 +15,16 @@ torchrir/scene_utils.py,sha256=2La5dtjxYdINX315VXRRJMJK9oaR2rY0xHmDLjZma8M,2140
 torchrir/signal.py,sha256=M0BpKDBqrfOmCHIJ_dvl-C3uKdFpXLDqtSIU115jsME,8383
 torchrir/simulators.py,sha256=NCl8Ptv2TGdBpNLwAb3nigT77On-BLIANtc2ivgKasw,3131
 torchrir/utils.py,sha256=2oE-JzAtkW5qdRds2Y5R5lbSyNZl_9piFXd6xOLzjxM,10680
-torchrir/datasets/__init__.py,sha256=3T55F3fjjRR3j618ubRkMlZnQTxvXaxioFMhygxm7oQ,601
-torchrir/datasets/base.py,sha256=mCHLtGOOaD1II1alJpP6ipzkz87l-rh19NgfeLnJbDU,720
-torchrir/datasets/cmu_arctic.py,sha256=DrOcawHvOEUnFJRw4qZgwuK1jbL2oQ-Vz_zNodYtpjE,7049
+torchrir/datasets/__init__.py,sha256=NS4zQas9YdsuDv8KQtTKmIJmS6mxMRxQk2xGzglbgUw,853
+torchrir/datasets/base.py,sha256=LfdXO-NGCBtzaAqAeVxo8XuV5ieU6Vl91woqAHymsT8,1970
+torchrir/datasets/cmu_arctic.py,sha256=7IFv33RBBu044kTMO6nKUmziml2gjILUgnpL262rAU8,6593
+torchrir/datasets/collate.py,sha256=gZfaHog0gtb8Avg6qsDZ1m4yoKkYkcuwmty1RtLYhhI,2542
+torchrir/datasets/librispeech.py,sha256=XKlAm0Z0coipKuqR9Z8X8l9puXVYz7zb6yE3PCuMUrI,6019
 torchrir/datasets/template.py,sha256=pHAKj5E7Gehfk9pqdTsFQjiDV1OK3hSZJIbYutd-E4c,2090
-torchrir/datasets/utils.py,sha256=TUfdt_XSB71ztCfzq_gCNrbvPh0Y-O5gkyxUnHWYID0,3227
-torchrir-0.1.4.dist-info/licenses/LICENSE,sha256=5vS_7WTsMEw_QQHEPQ_WCwovJXEgmxoEwcwOI-9VbXI,10766
-torchrir-0.1.4.dist-info/licenses/NOTICE,sha256=SRs_q-ZqoVF9_YuuedZOvVBk01jV7YQAeF8rRvlRg0s,118
-torchrir-0.1.4.dist-info/METADATA,sha256=HNSQV3uXeRYfX9eDb7ZllGAMvWCdtzq9Rn-q0kokkL4,2964
-torchrir-0.1.4.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
-torchrir-0.1.4.dist-info/top_level.txt,sha256=aIFwntowJjvm7rZk480HymC3ipDo1g-9hEbNY1wF-Oo,9
-torchrir-0.1.4.dist-info/RECORD,,
+torchrir/datasets/utils.py,sha256=OCYd7Dbr2hsqBbiHE1LHPMYdqwe2YfDw0tpRMfND0Og,3790
+torchrir-0.2.0.dist-info/licenses/LICENSE,sha256=5vS_7WTsMEw_QQHEPQ_WCwovJXEgmxoEwcwOI-9VbXI,10766
+torchrir-0.2.0.dist-info/licenses/NOTICE,sha256=SRs_q-ZqoVF9_YuuedZOvVBk01jV7YQAeF8rRvlRg0s,118
+torchrir-0.2.0.dist-info/METADATA,sha256=0f5EhK2SWmP_RxZ2O8y7AIDP_dFaKaf9X_n0mt7045k,3077
+torchrir-0.2.0.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+torchrir-0.2.0.dist-info/top_level.txt,sha256=aIFwntowJjvm7rZk480HymC3ipDo1g-9hEbNY1wF-Oo,9
+torchrir-0.2.0.dist-info/RECORD,,