diff --git a/CMakeLists.txt b/CMakeLists.txt index f123600..c845a43 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -87,6 +87,8 @@ add_library(zimtohrli_base STATIC cpp/zimt/loudness.h cpp/zimt/masking.cc cpp/zimt/masking.h + cpp/zimt/mos.cc + cpp/zimt/mos.h cpp/zimt/zimtohrli.cc cpp/zimt/zimtohrli.h ) @@ -175,6 +177,7 @@ add_executable(zimtohrli_test cpp/zimt/filterbank_test.cc cpp/zimt/loudness_test.cc cpp/zimt/masking_test.cc + cpp/zimt/mos_test.cc cpp/zimt/zimtohrli_test.cc cpp/zimt/test_file_paths.cc ) diff --git a/cpp/zimt/compare.cc b/cpp/zimt/compare.cc index c3eb08d..7a29973 100644 --- a/cpp/zimt/compare.cc +++ b/cpp/zimt/compare.cc @@ -55,6 +55,7 @@ #include "sndfile.h" #include "zimt/audio.h" #include "zimt/cam.h" +#include "zimt/mos.h" #include "zimt/ux.h" #include "zimt/zimtohrli.h" @@ -79,6 +80,12 @@ ABSL_FLAG(float, time_norm_order, zimtohrli::Zimtohrli{}.time_norm_order, ABSL_FLAG(bool, normalize_amplitude, true, "whether to normalize the amplitude of all B sounds to the same max " "amplitude as the A sound"); +ABSL_FLAG(bool, output_zimtohrli_distance, false, + "Whether to output the raw Zimtohrli distance instead of a mapped " + "mean opinion score."); +ABSL_FLAG(bool, per_channel, false, + "Whether to output the produced metric per channel instead of a " + "single value for all channels."); namespace zimtohrli { @@ -172,6 +179,13 @@ std::ostream& operator<<(std::ostream& outs, const DistanceData& data) { return outs; } +float GetMetric(float zimtohrli_score) { + if (absl::GetFlag(FLAGS_output_zimtohrli_distance)) { + return zimtohrli_score; + } + return MOSFromZimtohrli(zimtohrli_score); +} + int Main(int argc, char* argv[]) { absl::ParseCommandLine(argc, argv); const std::string path_a = absl::GetFlag(FLAGS_path_a); @@ -291,6 +305,7 @@ int Main(int argc, char* argv[]) { } const bool ux = absl::GetFlag(FLAGS_ux); + const bool per_channel = absl::GetFlag(FLAGS_per_channel); if (!ux && !verbose) { const size_t num_downscaled_samples_a = static_cast( std::ceil(static_cast(file_a->Frames().shape()[1]) * @@ -301,32 +316,53 @@ int Main(int argc, char* argv[]) { {num_downscaled_samples_a, z.cam_filterbank->filter.Size()}); hwy::AlignedNDArray partial_energy_channels_db_a( {num_downscaled_samples_a, z.cam_filterbank->filter.Size()}); - hwy::AlignedNDArray spectrogram_a( - {num_downscaled_samples_a, z.cam_filterbank->filter.Size()}); + std::vector> file_a_spectrograms; for (size_t channel_index = 0; channel_index < file_a->Info().channels; ++channel_index) { + hwy::AlignedNDArray spectrogram( + {num_downscaled_samples_a, z.cam_filterbank->filter.Size()}); z.Spectrogram(file_a->Frames()[{channel_index}], channels_a, energy_channels_db_a, partial_energy_channels_db_a, - spectrogram_a); - for (const AudioFile& file_b : file_b_vector) { - const size_t num_downscaled_samples_b = static_cast(std::ceil( - static_cast(file_b.Frames().shape()[1]) * - time_resolution_frequency / z.cam_filterbank->sample_rate)); - hwy::AlignedNDArray channels_b( - {file_b.Frames().shape()[1], z.cam_filterbank->filter.Size()}); - hwy::AlignedNDArray energy_channels_db_b( - {num_downscaled_samples_b, z.cam_filterbank->filter.Size()}); - hwy::AlignedNDArray partial_energy_channels_db_b( - {num_downscaled_samples_b, z.cam_filterbank->filter.Size()}); - hwy::AlignedNDArray spectrogram_b( - {num_downscaled_samples_b, z.cam_filterbank->filter.Size()}); + spectrogram); + file_a_spectrograms.push_back(std::move(spectrogram)); + } + for (int file_b_index = 0; file_b_index < file_b_vector.size(); + ++file_b_index) { + const AudioFile& file_b = file_b_vector[file_b_index]; + const size_t num_downscaled_samples_b = static_cast( + std::ceil(static_cast(file_b.Frames().shape()[1]) * + time_resolution_frequency / z.cam_filterbank->sample_rate)); + hwy::AlignedNDArray channels_b( + {file_b.Frames().shape()[1], z.cam_filterbank->filter.Size()}); + hwy::AlignedNDArray energy_channels_db_b( + {num_downscaled_samples_b, z.cam_filterbank->filter.Size()}); + hwy::AlignedNDArray partial_energy_channels_db_b( + {num_downscaled_samples_b, z.cam_filterbank->filter.Size()}); + hwy::AlignedNDArray spectrogram_b( + {num_downscaled_samples_b, z.cam_filterbank->filter.Size()}); + float sum_of_squares = 0; + for (size_t channel_index = 0; channel_index < file_a->Info().channels; + ++channel_index) { z.Spectrogram(file_b.Frames()[{channel_index}], channels_b, energy_channels_db_b, partial_energy_channels_db_b, spectrogram_b); - std::cout << z.Distance(false, spectrogram_a, spectrogram_b, - unwarp_window_samples) - .value - << std::endl; + const float distance = + z.Distance(false, file_a_spectrograms[channel_index], spectrogram_b, + unwarp_window_samples) + .value; + if (per_channel) { + std::cout << GetMetric(distance) << std::endl; + } else { + sum_of_squares += distance * distance; + } + } + if (!per_channel) { + for (int file_b_index = 0; file_b_index < file_b_vector.size(); + ++file_b_index) { + std::cout << GetMetric(std::sqrt(sum_of_squares / + float(file_a->Info().channels))) + << std::endl; + } } } return 0; @@ -358,6 +394,7 @@ int Main(int argc, char* argv[]) { const AudioFile& file_b = file_b_vector[b_index]; std::cout << "A (" << file_a->Path() << ") vs B (" << file_b.Path() << ")" << std::endl; + float sum_of_squares = 0; for (size_t channel_index = 0; channel_index < comparison.analysis_a.size(); ++channel_index) { std::cout << " Channel " << channel_index << std::endl; @@ -385,7 +422,18 @@ int Main(int argc, char* argv[]) { time_resolution_frequency, unwarp_window_samples); std::cout << " Phons channel distance: " << phons_channel_distance << std::endl; + + const float distance = phons_channel_distance.distance.value; + sum_of_squares += distance * distance; + + std::cout << " Channel MOS: " << MOSFromZimtohrli(distance) + << std::endl; } + const float zimtohrli_file_distance = + std::sqrt(sum_of_squares / float(comparison.analysis_a.size())); + std::cout << " File distance: " << zimtohrli_file_distance << std::endl; + std::cout << " File MOS: " << MOSFromZimtohrli(zimtohrli_file_distance) + << std::endl; } return 0; } diff --git a/cpp/zimt/goohrli.cc b/cpp/zimt/goohrli.cc index d796f36..20c430e 100644 --- a/cpp/zimt/goohrli.cc +++ b/cpp/zimt/goohrli.cc @@ -21,6 +21,7 @@ #include "hwy/aligned_allocator.h" #include "hwy/base.h" #include "zimt/cam.h" +#include "zimt/mos.h" #include "zimt/zimtohrli.h" EnergyAndMaxAbsAmplitude Measure(const float* signal, int size) { @@ -33,17 +34,22 @@ EnergyAndMaxAbsAmplitude Measure(const float* signal, int size) { .MaxAbsAmplitude = measurements.max_abs_amplitude}; } -EnergyAndMaxAbsAmplitude NormalizeAmplitudes(float max_abs_amplitude, - float* signal, int size) { +EnergyAndMaxAbsAmplitude NormalizeAmplitude(float max_abs_amplitude, + float* signal, int size) { hwy::AlignedNDArray signal_array({static_cast(size)}); hwy::CopyBytes(signal, signal_array.data(), size * sizeof(float)); const zimtohrli::EnergyAndMaxAbsAmplitude measurements = zimtohrli::NormalizeAmplitude(max_abs_amplitude, signal_array[{}]); + hwy::CopyBytes(signal_array.data(), signal, size * sizeof(float)); return EnergyAndMaxAbsAmplitude{ .EnergyDBFS = measurements.energy_db_fs, .MaxAbsAmplitude = measurements.max_abs_amplitude}; } +float MOSFromZimtohrli(float zimtohrli_distance) { + return zimtohrli::MOSFromZimtohrli(zimtohrli_distance); +} + Zimtohrli CreateZimtohrli(float sample_rate, float frequency_resolution) { zimtohrli::Cam cam{.minimum_bandwidth_hz = frequency_resolution}; cam.high_threshold_hz = std::min(cam.high_threshold_hz, sample_rate); diff --git a/cpp/zimt/mos.cc b/cpp/zimt/mos.cc new file mode 100644 index 0000000..9097eb7 --- /dev/null +++ b/cpp/zimt/mos.cc @@ -0,0 +1,37 @@ +// Copyright 2024 The Zimtohrli Authors. All Rights Reserved. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +#include "zimt/mos.h" + +#include +#include + +namespace zimtohrli { + +const std::array params = {3.439e+00, -4.138e-02, 3.008e+00, + -1.354e-01}; + +namespace { + +float sigmoid(float x) { return 1 / (1 + std::exp(-x)); } + +} // namespace + +// Optimized using `mos_mapping.ipynb`. +float MOSFromZimtohrli(float zimtohrli_distance) { + return 1 + 2 * (sigmoid(params[0] + params[1] * zimtohrli_distance) + + sigmoid(params[2] + params[3] * zimtohrli_distance)); +} + +} // namespace zimtohrli \ No newline at end of file diff --git a/cpp/zimt/mos.h b/cpp/zimt/mos.h new file mode 100644 index 0000000..24bcb26 --- /dev/null +++ b/cpp/zimt/mos.h @@ -0,0 +1,30 @@ +// Copyright 2024 The Zimtohrli Authors. All Rights Reserved. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +#ifndef CPP_ZIMT_MOS_H_ +#define CPP_ZIMT_MOS_H_ + +namespace zimtohrli { + +// Returns a _very_approximate_ mean opinion score based on the +// provided Zimtohrli distance. +// This is calibrated using default settings of v0.1.5, with a +// minimum channel bandwidth (zimtohrli::Cam.minimum_bandwidth_hz) +// of 5Hz and perceptual sample rate +// (zimtohrli::Distance(..., perceptual_sample_rate, ...) of 100Hz. +float MOSFromZimtohrli(float zimtohrli_distance); + +} // namespace zimtohrli + +#endif // CPP_ZIMT_MOS_H_ \ No newline at end of file diff --git a/cpp/zimt/mos_test.cc b/cpp/zimt/mos_test.cc new file mode 100644 index 0000000..8ca8217 --- /dev/null +++ b/cpp/zimt/mos_test.cc @@ -0,0 +1,34 @@ +// Copyright 2024 The Zimtohrli Authors. All Rights Reserved. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +#include "zimt/mos.h" + +#include "gtest/gtest.h" + +namespace zimtohrli { + +namespace { + +TEST(MOS, MOSFromZimtohrli) { + const std::vector zimt_scores = {5, 20, 40, 80}; + const std::vector mos = {4.746790024702545, 4.01181593706087, + 2.8773086764995064, 2.0648331964917945}; + for (size_t index = 0; index < zimt_scores.size(); ++index) { + ASSERT_NEAR(MOSFromZimtohrli(zimt_scores[index]), mos[index], 1e-2); + } +} + +} // namespace + +} // namespace zimtohrli \ No newline at end of file diff --git a/go/bin/compare/compare.go b/go/bin/compare/compare.go index e373784..a1d0957 100644 --- a/go/bin/compare/compare.go +++ b/go/bin/compare/compare.go @@ -28,6 +28,8 @@ import ( func main() { pathA := flag.String("path_a", "", "Path to ffmpeg-decodable file with signal A.") pathB := flag.String("path_b", "", "Path to ffmpeg-decodable file with signal B.") + outputZimtohrliDistance := flag.Bool("output_zimtohrli_distance", false, "Whether to output the raw Zimtohrli distance instead of a mapped mean opinion score.") + perChannel := flag.Bool("per_channel", false, "Whether to output the produced metric per channel instead of a single value for all channels.") frequencyResolution := flag.Float64("frequency_resolution", 5.0, "Band width of smallest filter, i.e. expected frequency resolution of human hearing.") flag.Parse() @@ -53,10 +55,25 @@ func main() { log.Panic(fmt.Errorf("%q has %v channels, and %q has %v channels", *pathA, len(signalA.Samples), *pathB, len(signalB.Samples))) } + getMetric := func(f float32) float32 { + if *outputZimtohrliDistance { + return f + } + return goohrli.MOSFromZimtohrli(f) + } + g := goohrli.New(signalA.Rate, *frequencyResolution) - for channelIndex := range signalA.Samples { - measurement := goohrli.Measure(signalA.Samples[channelIndex]) - goohrli.NormalizeAmplitude(measurement.MaxAbsAmplitude, signalB.Samples[channelIndex]) - fmt.Println(g.Distance(signalA.Samples[channelIndex], signalB.Samples[channelIndex])) + if *perChannel { + for channelIndex := range signalA.Samples { + measurement := goohrli.Measure(signalA.Samples[channelIndex]) + goohrli.NormalizeAmplitude(measurement.MaxAbsAmplitude, signalB.Samples[channelIndex]) + fmt.Println(getMetric(g.Distance(signalA.Samples[channelIndex], signalB.Samples[channelIndex]))) + } + } else { + dist, err := g.NormalizedAudioDistance(signalA, signalB) + if err != nil { + log.Panic(err) + } + fmt.Println(getMetric(float32(dist))) } } diff --git a/go/goohrli/goohrli.a b/go/goohrli/goohrli.a index 4773bca..08486db 100644 Binary files a/go/goohrli/goohrli.a and b/go/goohrli/goohrli.a differ diff --git a/go/goohrli/goohrli.go b/go/goohrli/goohrli.go index a1c4474..1af6832 100644 --- a/go/goohrli/goohrli.go +++ b/go/goohrli/goohrli.go @@ -48,13 +48,18 @@ func Measure(signal []float32) EnergyAndMaxAbsAmplitude { // NormalizeAmplitude normalizes the amplitudes of the signal so that it has the provided max // amplitude, and returns the new energ in dB FS, and the new maximum absolute amplitude. func NormalizeAmplitude(maxAbsAmplitude float32, signal []float32) EnergyAndMaxAbsAmplitude { - measurements := C.NormalizeAmplitudes(C.float(maxAbsAmplitude), (*C.float)(&signal[0]), C.int(len(signal))) + measurements := C.NormalizeAmplitude(C.float(maxAbsAmplitude), (*C.float)(&signal[0]), C.int(len(signal))) return EnergyAndMaxAbsAmplitude{ EnergyDBFS: float32(measurements.EnergyDBFS), MaxAbsAmplitude: float32(measurements.MaxAbsAmplitude), } } +// MOSFromZimtohrli returns an approximate mean opinion score for a given zimtohrli distance. +func MOSFromZimtohrli(zimtohrliDistance float32) float32 { + return float32(C.MOSFromZimtohrli(C.float(zimtohrliDistance))) +} + // Goohrli is a Go wrapper around zimtohrli::Zimtohrli. type Goohrli struct { zimtohrli C.Zimtohrli diff --git a/go/goohrli/goohrli.h b/go/goohrli/goohrli.h index 2a1f2c1..ce914af 100644 --- a/go/goohrli/goohrli.h +++ b/go/goohrli/goohrli.h @@ -56,8 +56,11 @@ EnergyAndMaxAbsAmplitude Measure(const float* signal, int size); // Normalizes the amplitudes of the signal so that it has the provided max // amplitude, and returns the new energ in dB FS, and the new maximum absolute // amplitude. -EnergyAndMaxAbsAmplitude NormalizeAmplitudes(float max_abs_amplitude, - float* signal_data, int size); +EnergyAndMaxAbsAmplitude NormalizeAmplitude(float max_abs_amplitude, + float* signal_data, int size); + +// Returns an approximate MOS score for a given Zimtohrli distance. +float MOSFromZimtohrli(float zimtohrli_distance); // Deletes a zimtohrli::Analysis. void FreeAnalysis(Analysis a); diff --git a/go/goohrli/goohrli_test.go b/go/goohrli/goohrli_test.go index d27c8a3..a5bc5c3 100644 --- a/go/goohrli/goohrli_test.go +++ b/go/goohrli/goohrli_test.go @@ -16,9 +16,55 @@ package goohrli import ( "math" + "reflect" "testing" ) +func TestMeasureAndNormalize(t *testing.T) { + signal := []float32{1, 2, -1, -2} + measurements := Measure(signal) + if measurements.MaxAbsAmplitude != 2 { + t.Errorf("MaxAbsAmplitude = %v, want %v", measurements.MaxAbsAmplitude, 2) + } + wantEnergyDBFS := float32(20 * math.Log10(2.5)) + if math.Abs(float64(measurements.EnergyDBFS-float32(wantEnergyDBFS))) > 1e-4 { + t.Errorf("EnergyDBFS = %v, want %v", measurements.EnergyDBFS, wantEnergyDBFS) + } + NormalizeAmplitude(1, signal) + wantNormalizedSignal := []float32{0.5, 1, -0.5, -1} + if !reflect.DeepEqual(signal, wantNormalizedSignal) { + t.Errorf("NormalizeAmplitude produced %+v, want %+v", signal, wantNormalizedSignal) + } +} + +func TestMOSFromZimtohrli(t *testing.T) { + for _, tc := range []struct { + zimtDistance float32 + wantMOS float32 + }{ + { + zimtDistance: 5, + wantMOS: 4.746790024702545, + }, + { + zimtDistance: 20, + wantMOS: 4.01181593706087, + }, + { + zimtDistance: 40, + wantMOS: 2.8773086764995064, + }, + { + zimtDistance: 80, + wantMOS: 2.0648331964917945, + }, + } { + if mos := MOSFromZimtohrli(tc.zimtDistance); math.Abs(float64(mos-tc.wantMOS)) > 1e-2 { + t.Errorf("MOSFromZimtohrli(%v) = %v, want %v", tc.zimtDistance, mos, tc.wantMOS) + } + } +} + func TestGettersSetters(t *testing.T) { g := New(48000.0, 4.0) diff --git a/python/mos_mapping.ipynb b/python/mos_mapping.ipynb new file mode 100644 index 0000000..922bec3 --- /dev/null +++ b/python/mos_mapping.ipynb @@ -0,0 +1,122 @@ +{ + "nbformat": 4, + "nbformat_minor": 0, + "metadata": { + "colab": { + "provenance": [] + }, + "kernelspec": { + "name": "python3", + "display_name": "Python 3" + }, + "language_info": { + "name": "python" + } + }, + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": { + "id": "gsCcH5KtJ2x9" + }, + "outputs": [], + "source": [ + "import json\n", + "import numpy as np\n", + "import scipy\n", + "import matplotlib.pyplot as plt" + ] + }, + { + "cell_type": "code", + "source": [ + "coresvnet_json = json.load(open('coresvnet.json'))\n", + "furball_json = json.load(open('furball.json'))\n", + "minimodal_json = json.load(open('minimodal.json'))\n", + "\n", + "def append_scores(js_file, z_scoes, mos_scores, scale, offset):\n", + " for ref in js_file:\n", + " for dist in ref['Distortions']:\n", + " z_scores.append(dist['Scores']['Zimtohrli'])\n", + " mos_scores.append(dist['Scores']['MOS'] * scale + offset)\n", + "\n", + "z_scores = []\n", + "mos_scores = []\n", + "append_scores(coresvnet_json, z_scores, mos_scores, 1, 0)\n", + "append_scores(furball_json, z_scores, mos_scores, 0.04, 1)\n", + "append_scores(minimodal_json, z_scores, mos_scores, 1, 0)\n", + "\n", + "z_scores = np.asarray(z_scores)\n", + "mos_scores = np.asarray(mos_scores)\n", + "mos_extremes = np.asarray([1, 5])\n", + "z_extremes = np.asarray([np.max(z_scores), 0])\n", + "\n", + "print(f'{z_scores.shape=}')\n", + "print(f'{mos_scores.shape=}')\n", + "print(f'{mos_extremes=}')\n", + "print(f'{z_extremes=}')\n", + "\n", + "def sigmoid(x):\n", + " return 1 / (1 + np.exp(-x))\n", + "\n", + "def predict(z_score, params):\n", + " return 1 + 2 * (sigmoid(params[0] + params[1] * z_score) + sigmoid(params[2] + params[3] * z_score))\n", + "\n", + "def loss(params):\n", + " return np.linalg.norm(mos_scores - predict(z_scores, params)) + mos_scores.shape[0] * 0.0005 * (np.linalg.norm(5 - predict(0, params)) + np.linalg.norm(1 - predict(200, params)))\n", + "\n", + "res = scipy.optimize.minimize(loss, -np.ones((4,)), method='BFGS')\n", + "print(f'{res=}')\n", + "plt.scatter(z_scores, mos_scores)\n", + "x = np.linspace(0, z_extremes[0], 1000)\n", + "plt.plot(x, predict(x, res.x), 'r')\n", + "plt.show()\n" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 725 + }, + "id": "E8p0kxlNKer7", + "outputId": "fdf9f268-6430-47d2-f7ef-2b0054cf66e0" + }, + "execution_count": 123, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "z_scores.shape=(3116,)\n", + "mos_scores.shape=(3116,)\n", + "mos_extremes=array([1, 5])\n", + "z_extremes=array([111.11403656, 0. ])\n", + "res= message: Desired error not necessarily achieved due to precision loss.\n", + " success: False\n", + " status: 2\n", + " fun: 44.2629411710931\n", + " x: [ 3.439e+00 -4.138e-02 3.008e+00 -1.354e-01]\n", + " nit: 27\n", + " jac: [-1.431e-06 -4.387e-05 -1.431e-06 -2.766e-05]\n", + " hess_inv: [[ 2.251e+01 -2.873e-01 9.278e-02 -2.031e-01]\n", + " [-2.873e-01 3.763e-03 -1.318e-03 2.550e-03]\n", + " [ 9.278e-02 -1.318e-03 3.662e-03 -7.035e-04]\n", + " [-2.031e-01 2.550e-03 -7.035e-04 2.035e-03]]\n", + " nfev: 300\n", + " njev: 60\n" + ] + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": {} + } + ] + } + ] +} \ No newline at end of file