visqol-python 3.3.3__py3-none-any.whl

visqol/visqol_core.py

@@ -0,0 +1,240 @@
+"""
+Core ViSQOL algorithm: assembles all components into a similarity computation pipeline.
+
+Corresponds to C++ file: visqol.cc
+"""
+
+import math
+import numpy as np
+from typing import List
+from dataclasses import dataclass, field
+
+from visqol.audio_utils import AudioSignal, scale_to_match_sound_pressure_level
+from visqol.analysis_window import AnalysisWindow
+from visqol.gammatone import (
+    GammatoneSpectrogramBuilder, Spectrogram,
+    prepare_spectrograms_for_comparison,
+)
+from visqol.nsim import PatchSimilarityResult, measure_patch_similarity
+from visqol.patch_selector import (
+    find_most_optimal_deg_patches,
+    finely_align_and_recreate_patches,
+)
+from visqol.quality_mapper import SimilarityToQualityMapper
+
+
+@dataclass
+class SimilarityResult:
+    """Complete result of a ViSQOL similarity comparison."""
+    moslqo: float = 0.0
+    vnsim: float = 0.0
+    fvnsim: np.ndarray = field(default_factory=lambda: np.array([]))
+    fvnsim10: np.ndarray = field(default_factory=lambda: np.array([]))
+    fstdnsim: np.ndarray = field(default_factory=lambda: np.array([]))
+    fvdegenergy: np.ndarray = field(default_factory=lambda: np.array([]))
+    center_freq_bands: np.ndarray = field(default_factory=lambda: np.array([]))
+    patch_sims: List[PatchSimilarityResult] = field(default_factory=list)
+
+
+def calc_per_patch_mean_freq_band_means(
+    sim_results: List[PatchSimilarityResult]
+) -> np.ndarray:
+    """
+    Calculate mean of per-frequency-band means across all patches.
+    This is fvnsim.
+    Matches C++ Visqol::CalcPerPatchMeanFreqBandMeans.
+    """
+    all_means = np.array([r.freq_band_means for r in sim_results])
+    return np.mean(all_means, axis=0)
+
+
+def calc_per_patch_freq_band_quantile(
+    sim_results: List[PatchSimilarityResult],
+    quantile: float = 0.10,
+) -> np.ndarray:
+    """
+    Calculate quantile of per-frequency-band means across patches.
+    This is fvnsim10.
+    Matches C++ Visqol::CalcPerPatchFreqBandQuantile.
+    """
+    num_freq_bands = len(sim_results[0].freq_band_means)
+    result = np.zeros(num_freq_bands)
+
+    for band in range(num_freq_bands):
+        band_nsims = sorted([r.freq_band_means[band] for r in sim_results])
+        num_in_quantile = max(1, int(len(band_nsims) * quantile))
+        result[band] = np.mean(band_nsims[:num_in_quantile])
+
+    return result
+
+
+def calc_per_patch_mean_freq_band_deg_energy(
+    sim_results: List[PatchSimilarityResult]
+) -> np.ndarray:
+    """
+    Calculate mean of per-frequency-band degraded energy across patches.
+    This is fvdegenergy.
+    Matches C++ Visqol::CalcPerPatchMeanFreqBandDegradedEnergy.
+    """
+    all_energy = np.array([r.freq_band_deg_energy for r in sim_results])
+    return np.mean(all_energy, axis=0)
+
+
+def calc_per_patch_mean_freq_band_stddevs(
+    sim_results: List[PatchSimilarityResult],
+    frame_duration: float,
+) -> np.ndarray:
+    """
+    Calculate pooled standard deviation across patches.
+    This is fstdnsim.
+    Matches C++ Visqol::CalcPerPatchMeanFreqBandStdDevs.
+
+    Uses the pooled variance formula:
+    https://en.wikipedia.org/wiki/Pooled_variance
+    """
+    num_freq_bands = len(sim_results[0].freq_band_means)
+
+    # First compute fvnsim (global mean per band)
+    fvnsim = calc_per_patch_mean_freq_band_means(sim_results)
+
+    total_frame_count = 0
+    contribution = np.zeros(num_freq_bands)
+
+    for patch in sim_results:
+        secs_in_patch = patch.ref_patch_end_time - patch.ref_patch_start_time
+        frame_count = int(math.ceil(secs_in_patch / frame_duration))
+        total_frame_count += frame_count
+
+        for band in range(num_freq_bands):
+            stddev = patch.freq_band_stddevs[band]
+            mean = patch.freq_band_means[band]
+            contribution[band] += (frame_count - 1) * stddev * stddev
+            contribution[band] += frame_count * mean * mean
+
+    if total_frame_count <= 1:
+        return np.zeros(num_freq_bands)
+
+    variance = (contribution - fvnsim * fvnsim * total_frame_count) / (
+        total_frame_count - 1
+    )
+
+    # sqrt, filtering negative values due to precision
+    result = np.where(variance < 0, 0.0, np.sqrt(variance))
+    return result
+
+
+def alter_for_similarity_extremes(vnsim: float, moslqo: float) -> float:
+    """
+    Handle extreme similarity cases.
+    Matches C++ Visqol::AlterForSimilarityExtremes.
+    """
+    if vnsim < 0.15:
+        return 1.0
+    return moslqo
+
+
+def calc_frame_duration(frame_size: int, sample_rate: int) -> float:
+    """Calculate frame duration in seconds."""
+    return frame_size / float(sample_rate)
+
+
+class VisqolCore:
+    """
+    Core ViSQOL algorithm.
+    Orchestrates the complete similarity calculation pipeline.
+    """
+
+    def calculate_similarity(
+        self,
+        ref_signal: AudioSignal,
+        deg_signal: AudioSignal,
+        spect_builder: GammatoneSpectrogramBuilder,
+        window: AnalysisWindow,
+        patch_creator,
+        search_window: int,
+        quality_mapper: SimilarityToQualityMapper,
+        disable_realignment: bool = False,
+    ) -> SimilarityResult:
+        """
+        Calculate full similarity between reference and degraded signals.
+
+        Args:
+            ref_signal: Reference audio signal.
+            deg_signal: Degraded audio signal.
+            spect_builder: Gammatone spectrogram builder.
+            window: Analysis window.
+            patch_creator: Patch creator (ImagePatchCreator or VadPatchCreator).
+            search_window: Search window radius in patch units.
+            quality_mapper: Similarity-to-quality mapper.
+            disable_realignment: If True, skip fine realignment.
+
+        Returns:
+            SimilarityResult with MOS-LQO score and all intermediate data.
+        """
+        # Stage 1: Preprocessing - SPL matching
+        deg_signal = scale_to_match_sound_pressure_level(ref_signal, deg_signal)
+
+        # Build spectrograms
+        ref_spectrogram = spect_builder.build(ref_signal, window)
+        deg_spectrogram = spect_builder.build(deg_signal, window)
+
+        # Prepare spectrograms for comparison (dB conversion + noise floor)
+        ref_db, deg_db = prepare_spectrograms_for_comparison(
+            ref_spectrogram, deg_spectrogram
+        )
+
+        # Stage 2: Feature selection and similarity measure
+        ref_patch_indices = patch_creator.create_ref_patch_indices(
+            ref_db, ref_signal, window
+        )
+
+        frame_duration = calc_frame_duration(
+            int(window.size * window.overlap), ref_signal.sample_rate
+        )
+
+        ref_patches = patch_creator.create_patches_from_indices(
+            ref_db, ref_patch_indices
+        )
+
+        # DP patch matching
+        sim_match_info = find_most_optimal_deg_patches(
+            ref_patches, ref_patch_indices, deg_db,
+            frame_duration, search_window
+        )
+
+        # Fine realignment
+        if not disable_realignment:
+            sim_match_info = finely_align_and_recreate_patches(
+                sim_match_info, ref_signal, deg_signal,
+                spect_builder, window
+            )
+
+        # Aggregate statistics
+        fvnsim = calc_per_patch_mean_freq_band_means(sim_match_info)
+        fvnsim10 = calc_per_patch_freq_band_quantile(sim_match_info, 0.10)
+        fstdnsim = calc_per_patch_mean_freq_band_stddevs(
+            sim_match_info, frame_duration
+        )
+        fvdegenergy = calc_per_patch_mean_freq_band_deg_energy(sim_match_info)
+
+        # Predict MOS
+        moslqo = quality_mapper.predict_quality(
+            fvnsim, fvnsim10, fstdnsim, fvdegenergy
+        )
+
+        # Calculate vnsim (mean of fvnsim)
+        vnsim = float(np.mean(fvnsim))
+
+        # Handle extreme cases
+        moslqo = alter_for_similarity_extremes(vnsim, moslqo)
+
+        return SimilarityResult(
+            moslqo=moslqo,
+            vnsim=vnsim,
+            fvnsim=fvnsim,
+            fvnsim10=fvnsim10,
+            fstdnsim=fstdnsim,
+            fvdegenergy=fvdegenergy,
+            center_freq_bands=ref_spectrogram.center_freq_bands,
+            patch_sims=sim_match_info,
+        )

visqol/visqol_manager.py

@@ -0,0 +1,194 @@
+"""
+ViSQOL Manager: orchestrates the complete ViSQOL workflow.
+
+Corresponds to C++ file: visqol_manager.cc
+"""
+
+import os
+import logging
+from typing import Optional
+
+from visqol.audio_utils import AudioSignal, load_as_mono
+from visqol.analysis_window import AnalysisWindow
+from visqol.alignment import globally_align
+from visqol.gammatone import GammatoneSpectrogramBuilder
+from visqol.patch_creator import ImagePatchCreator, VadPatchCreator
+from visqol.quality_mapper import (
+    SvrSimilarityToQualityMapper,
+    SpeechSimilarityToQualityMapper,
+)
+from visqol.visqol_core import VisqolCore, SimilarityResult
+
+logger = logging.getLogger(__name__)
+
+# Default parameters (matching C++ VisqolManager constants)
+PATCH_SIZE_AUDIO = 30
+PATCH_SIZE_SPEECH = 20
+NUM_BANDS_AUDIO = 32
+NUM_BANDS_SPEECH = 21
+MINIMUM_FREQ = 50.0  # Hz (wideband)
+OVERLAP = 0.25  # 25% overlap
+DURATION_MISMATCH_TOLERANCE = 1.0  # seconds
+
+K_16K_SAMPLE_RATE = 16000
+K_48K_SAMPLE_RATE = 48000
+
+
+class VisqolManager:
+    """
+    Main manager class that configures and runs ViSQOL.
+    """
+
+    def __init__(self):
+        self.use_speech_mode = False
+        self.search_window = 60
+        self.disable_global_alignment = False
+        self.disable_realignment = False
+        self.is_initialized = False
+
+        self.spect_builder = None
+        self.patch_creator = None
+        self.quality_mapper = None
+        self.visqol_core = VisqolCore()
+
+    def init(self,
+             model_path: str = "",
+             use_speech_mode: bool = False,
+             use_unscaled_speech: bool = False,
+             search_window: int = 60,
+             disable_global_alignment: bool = False,
+             disable_realignment: bool = False):
+        """
+        Initialize the ViSQOL manager.
+
+        Args:
+            model_path: Path to SVR model file (Audio mode).
+            use_speech_mode: Use speech mode (16kHz, 21 bands).
+            use_unscaled_speech: Don't scale speech MOS to max 5.0.
+            search_window: Search window radius in patch units.
+            disable_global_alignment: Skip global alignment.
+            disable_realignment: Skip fine realignment.
+        """
+        self.use_speech_mode = use_speech_mode
+        self.search_window = search_window
+        self.disable_global_alignment = disable_global_alignment
+        self.disable_realignment = disable_realignment
+
+        # Initialize patch creator
+        if use_speech_mode:
+            self.patch_creator = VadPatchCreator(PATCH_SIZE_SPEECH)
+        else:
+            self.patch_creator = ImagePatchCreator(PATCH_SIZE_AUDIO)
+
+        # Initialize spectrogram builder
+        if use_speech_mode:
+            self.spect_builder = GammatoneSpectrogramBuilder(
+                NUM_BANDS_SPEECH, MINIMUM_FREQ, speech_mode=True
+            )
+        else:
+            self.spect_builder = GammatoneSpectrogramBuilder(
+                NUM_BANDS_AUDIO, MINIMUM_FREQ, speech_mode=False
+            )
+
+        # Initialize quality mapper
+        if use_speech_mode:
+            self.quality_mapper = SpeechSimilarityToQualityMapper(
+                scale_to_max_mos=not use_unscaled_speech
+            )
+        else:
+            self.quality_mapper = SvrSimilarityToQualityMapper(model_path)
+
+        self.quality_mapper.init()
+        self.is_initialized = True
+
+    def run(self, ref_path: str, deg_path: str) -> SimilarityResult:
+        """
+        Run ViSQOL on two audio files.
+
+        Args:
+            ref_path: Path to reference audio file.
+            deg_path: Path to degraded audio file.
+
+        Returns:
+            SimilarityResult with MOS-LQO score.
+        """
+        if not self.is_initialized:
+            raise RuntimeError("VisqolManager must be initialized before use.")
+
+        # Load audio
+        ref_signal = load_as_mono(ref_path)
+        deg_signal = load_as_mono(deg_path)
+
+        return self.run_from_signals(ref_signal, deg_signal)
+
+    def run_from_signals(self, ref_signal: AudioSignal,
+                         deg_signal: AudioSignal) -> SimilarityResult:
+        """
+        Run ViSQOL on two audio signals.
+
+        Args:
+            ref_signal: Reference audio signal.
+            deg_signal: Degraded audio signal.
+
+        Returns:
+            SimilarityResult with MOS-LQO score.
+        """
+        if not self.is_initialized:
+            raise RuntimeError("VisqolManager must be initialized before use.")
+
+        # Validate
+        self._validate_input(ref_signal, deg_signal)
+
+        # Global alignment
+        if not self.disable_global_alignment:
+            aligned_deg, lag = globally_align(ref_signal, deg_signal)
+            deg_signal = aligned_deg
+
+        # Create analysis window
+        window = AnalysisWindow(ref_signal.sample_rate, OVERLAP)
+
+        # Run core algorithm
+        return self.visqol_core.calculate_similarity(
+            ref_signal=ref_signal,
+            deg_signal=deg_signal,
+            spect_builder=self.spect_builder,
+            window=window,
+            patch_creator=self.patch_creator,
+            search_window=self.search_window,
+            quality_mapper=self.quality_mapper,
+            disable_realignment=self.disable_realignment,
+        )
+
+    def _validate_input(self, ref_signal: AudioSignal,
+                        deg_signal: AudioSignal):
+        """Validate input audio signals."""
+        # Check duration mismatch
+        ref_dur = ref_signal.duration
+        deg_dur = deg_signal.duration
+        if abs(ref_dur - deg_dur) > DURATION_MISMATCH_TOLERANCE:
+            logger.warning(
+                "Duration mismatch: reference=%.2fs, degraded=%.2fs",
+                ref_dur, deg_dur
+            )
+
+        # Check sample rate match
+        if ref_signal.sample_rate != deg_signal.sample_rate:
+            raise ValueError(
+                f"Sample rate mismatch: reference={ref_signal.sample_rate}, "
+                f"degraded={deg_signal.sample_rate}"
+            )
+
+        if self.use_speech_mode:
+            if ref_signal.sample_rate > K_16K_SAMPLE_RATE:
+                logger.warning(
+                    "Input sample rate (%d) is above 16kHz. "
+                    "Consider resampling for speech mode.",
+                    ref_signal.sample_rate
+                )
+        else:
+            if ref_signal.sample_rate != K_48K_SAMPLE_RATE:
+                logger.warning(
+                    "Input sample rate (%d) is not 48kHz. "
+                    "This may affect audio mode scoring.",
+                    ref_signal.sample_rate
+                )

visqol_python-3.3.3.dist-info/METADATA

@@ -0,0 +1,223 @@
+Metadata-Version: 2.4
+Name: visqol-python
+Version: 3.3.3
+Summary: ViSQOL - Virtual Speech Quality Objective Listener (Pure Python)
+Home-page: https://github.com/talker93/visqol-python
+Author: Shan Jiang
+License-Expression: Apache-2.0
+Project-URL: Homepage, https://github.com/talker93/visqol-python
+Project-URL: Bug Reports, https://github.com/talker93/visqol-python/issues
+Project-URL: Source, https://github.com/talker93/visqol-python
+Project-URL: Original C++, https://github.com/google/visqol
+Keywords: audio-quality,speech-quality,MOS,PESQ,POLQA,visqol,objective-metric,perceptual-quality
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Science/Research
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Multimedia :: Sound/Audio :: Analysis
+Classifier: Topic :: Scientific/Engineering
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy>=1.20
+Requires-Dist: scipy>=1.7
+Requires-Dist: soundfile>=0.10
+Requires-Dist: libsvm-official>=3.25
+Dynamic: home-page
+Dynamic: license-file
+Dynamic: requires-python
+
+# ViSQOL (Python)
+
+A pure Python implementation of [Google's ViSQOL](https://github.com/google/visqol) (Virtual Speech Quality Objective Listener) v3.3.3 for objective audio/speech quality assessment.
+
+ViSQOL compares a reference audio signal with a degraded version and outputs a **MOS-LQO** (Mean Opinion Score - Listening Quality Objective) score on a scale of **1.0 – 5.0**.
+
+## Features
+
+- **Two modes**: Audio mode (music/general audio at 48 kHz) and Speech mode (speech at 16 kHz)
+- **High accuracy**: 11/11 conformance tests pass against the official C++ implementation
+  - Audio mode: 9/10 tests produce **identical** MOS scores (diff = 0.000000), 1 test diff = 0.000117
+  - Speech mode: diff = 0.006715
+- **Pure Python**: no C/C++ compilation required
+- **Minimal dependencies**: only 4 pip packages (`numpy`, `scipy`, `soundfile`, `libsvm-official`)
+- **Faster than real-time**: Audio RTF ≈ 0.71x, Speech RTF ≈ 0.38x
+
+## Installation
+
+```bash
+pip install numpy scipy soundfile libsvm-official
+```
+
+Or install as a package:
+
+```bash
+git clone https://github.com/talker93/visqol-python.git
+cd visqol-python
+pip install -e .
+```
+
+## Quick Start
+
+### Python API
+
+```python
+from visqol import VisqolApi
+
+# Audio mode (default) - for music and general audio
+api = VisqolApi()
+api.create(mode="audio")
+result = api.measure("reference.wav", "degraded.wav")
+print(f"MOS-LQO: {result.moslqo:.4f}")
+
+# Speech mode - for speech signals
+api = VisqolApi()
+api.create(mode="speech")
+result = api.measure("ref_speech.wav", "deg_speech.wav")
+print(f"MOS-LQO: {result.moslqo:.4f}")
+```
+
+### Using NumPy Arrays
+
+```python
+import numpy as np
+import soundfile as sf
+from visqol import VisqolApi
+
+ref, sr = sf.read("reference.wav")
+deg, _  = sf.read("degraded.wav")
+
+api = VisqolApi()
+api.create(mode="audio")
+result = api.measure_from_arrays(ref, deg, sample_rate=sr)
+print(f"MOS-LQO: {result.moslqo:.4f}")
+```
+
+### Command Line
+
+```bash
+# Audio mode (default)
+python -m visqol -r reference.wav -d degraded.wav
+
+# Speech mode
+python -m visqol -r reference.wav -d degraded.wav --speech_mode
+
+# Verbose output (per-patch details)
+python -m visqol -r reference.wav -d degraded.wav -v
+```
+
+**CLI options:**
+
+| Flag | Description |
+|------|-------------|
+| `-r`, `--reference` | Path to reference WAV file (required) |
+| `-d`, `--degraded` | Path to degraded WAV file (required) |
+| `--speech_mode` | Use speech mode (16 kHz, polynomial mapping) |
+| `--model` | Custom SVR model file path (audio mode only) |
+| `--search_window` | Search window radius (default: 60) |
+| `--verbose`, `-v` | Show detailed per-patch results |
+
+## Output
+
+The `measure()` method returns a `SimilarityResult` object with:
+
+| Field | Description |
+|-------|-------------|
+| `moslqo` | MOS-LQO score (1.0 – 5.0) |
+| `vnsim` | Mean NSIM across all patches |
+| `fvnsim` | Per-frequency-band mean NSIM |
+| `fstdnsim` | Per-frequency-band std of NSIM |
+| `fvdegenergy` | Per-frequency-band degraded energy |
+| `patch_sims` | List of per-patch similarity details |
+
+## Modes
+
+### Audio Mode (default)
+- Target sample rate: **48 kHz**
+- 32 Gammatone frequency bands (50 Hz – 15 000 Hz)
+- Quality mapping: SVR (Support Vector Regression) model
+- Best for: music, environmental audio, codecs
+
+### Speech Mode
+- Target sample rate: **16 kHz**
+- 32 Gammatone frequency bands (50 Hz – 8 000 Hz)
+- Quality mapping: exponential polynomial fit
+- VAD (Voice Activity Detection) based patch selection
+- Best for: speech, VoIP, telephony
+
+## Performance
+
+Measured on Apple M-series, Python 3.13:
+
+| Mode | Avg RTF | Typical Time |
+|------|---------|-------------|
+| Audio (48 kHz) | **0.71x** | 7 – 12 s per file pair |
+| Speech (16 kHz) | **0.38x** | ~1 s per file pair |
+
+> RTF (Real-Time Factor) < 1.0 means faster than real-time.
+
+## Project Structure
+
+```
+visqol-python/
+├── visqol/                    # Main package
+│   ├── __init__.py            # Package exports
+│   ├── api.py                 # Public API
+│   ├── visqol_manager.py      # Pipeline orchestrator
+│   ├── visqol_core.py         # Core algorithm
+│   ├── audio_utils.py         # Audio I/O & SPL normalization
+│   ├── signal_utils.py        # Envelope, cross-correlation
+│   ├── analysis_window.py     # Hann window
+│   ├── gammatone.py           # ERB + Gammatone filterbank + spectrogram
+│   ├── patch_creator.py       # Patch creation (Image + VAD modes)
+│   ├── patch_selector.py      # DP-based optimal patch matching
+│   ├── alignment.py           # Global alignment via cross-correlation
+│   ├── nsim.py                # NSIM similarity metric
+│   ├── quality_mapper.py      # SVR & exponential quality mapping
+│   └── __main__.py            # CLI entry point
+├── model/                     # Bundled SVR model
+│   └── libsvm_nu_svr_model.txt
+├── tests/                     # Conformance tests
+│   ├── test_conformance.py
+│   └── test_quick.py
+├── setup.py
+├── requirements.txt
+├── LICENSE
+└── README.md
+```
+
+## Conformance Test Results
+
+Tested against the [official C++ ViSQOL v3.3.3](https://github.com/google/visqol) expected values:
+
+| Test Case | Mode | Expected MOS | Python MOS | Δ |
+|-----------|------|-------------|------------|---|
+| strauss_lp35 | Audio | 1.3889 | 1.3889 | 0.000000 |
+| steely_lp7 | Audio | 2.2502 | 2.2502 | 0.000000 |
+| sopr_256aac | Audio | 4.6823 | 4.6823 | 0.000000 |
+| ravel_128opus | Audio | 4.4651 | 4.4651 | 0.000000 |
+| moonlight_128aac | Audio | 4.6843 | 4.6843 | 0.000000 |
+| harpsichord_96mp3 | Audio | 4.2237 | 4.2237 | 0.000000 |
+| guitar_64aac | Audio | 4.3497 | 4.3497 | 0.000000 |
+| glock_48aac | Audio | 4.3325 | 4.3325 | 0.000000 |
+| contrabassoon_24aac | Audio | 2.3469 | 2.3468 | 0.000117 |
+| castanets_identity | Audio | 4.7321 | 4.7321 | 0.000000 |
+| speech_CA01 | Speech | 3.3745 | 3.3678 | 0.006715 |
+
+## References
+
+- [Google ViSQOL (C++)](https://github.com/google/visqol) — the original implementation this project is ported from
+- Hines, A., Gillen, E., Kelly, D., Skoglund, J., Kokaram, A., & Harte, N. (2015). *ViSQOLAudio: An Objective Audio Quality Metric for Low Bitrate Codecs.* The Journal of the Acoustical Society of America.
+- Chinen, M., Lim, F. S., Skoglund, J., Gureev, N., O'Gorman, F., & Hines, A. (2020). *ViSQOL v3: An Open Source Production Ready Objective Speech and Audio Metric.* 2020 Twelfth International Conference on Quality of Multimedia Experience (QoMEX).
+
+## License
+
+Apache License 2.0. See [LICENSE](LICENSE) for details.
+
+This project is a Python port of [Google's ViSQOL](https://github.com/google/visqol), which is also licensed under Apache 2.0.

visqol_python-3.3.3.dist-info/RECORD

@@ -0,0 +1,21 @@
+visqol/__init__.py,sha256=0yqtDr50SFgAI67HA6i83B97YPvMEsjhQcYbimV6YfM,539
+visqol/__main__.py,sha256=z3vXtZBKrQEnoUmvxxws58swBQuTY7CBHi5unHSSCCE,2776
+visqol/alignment.py,sha256=I78OZzQ4N-zlr60WYQlYNVPDe-hFYzWfXIZGw2yfx0s,2664
+visqol/analysis_window.py,sha256=j2P9ppg1PVDY5hY7c_mlLlbWn5-zePtsKO5NmQPHYuk,1659
+visqol/api.py,sha256=pLqpThyr0ndq-e3UARv8FBgPJ7kN_u8FAafpu5i_078,3828
+visqol/audio_utils.py,sha256=6iNrVJjKpxj7xd2LzbbLbvg0jdaSHuyhO4BJ7qR5kUY,2479
+visqol/gammatone.py,sha256=fuM0zdmW5DLPxBa-iF_RamlQpPt6yClquSND6PEuBoA,13228
+visqol/nsim.py,sha256=64qmZ6dHbSw1y_COJIcRK2YNcfJA4wNDopHcVLkEKHk,4789
+visqol/patch_creator.py,sha256=bu6bKmBtUWn6Co9XiHsnnfQPjNmwaFhkMRB46ZlWahI,7591
+visqol/patch_selector.py,sha256=p4YsV0qEaa54Eif3ENoUhtlmyEIOb5FixEdpT-rWXtw,12813
+visqol/quality_mapper.py,sha256=0qgdIzwnwIqhsTScz2_6EW9hFZpUa_0-IeQnLqnhw30,3831
+visqol/signal_utils.py,sha256=q3QfLb2Cy2uTYXMy9skgiASYKJe5klTrDDg8rWMalsI,2495
+visqol/visqol_core.py,sha256=I9Qp2fzVe6n203t3HHPIuXThIM2PVXg5XfrQUH74PZE,8034
+visqol/visqol_manager.py,sha256=roUk9hD5o613lUQ0kaxxQ3fwU4JOqqNz6OmfpN5vHfM,6527
+visqol/model/libsvm_nu_svr_model.txt,sha256=HoJG7TO_NtxchZNR9xEPLNMfmGYZiXFcD8-XTsSNPi4,138117
+visqol_python-3.3.3.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+visqol_python-3.3.3.dist-info/METADATA,sha256=V90XyFp1SnRj28t3BhYOVtXPe3IE7lnrzxKwGspcuvU,8217
+visqol_python-3.3.3.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+visqol_python-3.3.3.dist-info/entry_points.txt,sha256=Dl7miY_7U-116DDs7JJsrD_XhQZf5r9nfdm4N3ocpBQ,48
+visqol_python-3.3.3.dist-info/top_level.txt,sha256=JAzbSsJqgc6Ol-wc6r_xHonHsWVM-200RFAwuSMp0EY,7
+visqol_python-3.3.3.dist-info/RECORD,,

visqol_python-3.3.3.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (82.0.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

visqol_python-3.3.3.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+visqol = visqol.__main__:main