OLD | NEW |
(Empty) | |
| 1 /* |
| 2 * Copyright (c) 2013 The WebRTC project authors. All Rights Reserved. |
| 3 * |
| 4 * Use of this source code is governed by a BSD-style license |
| 5 * that can be found in the LICENSE file in the root of the source |
| 6 * tree. An additional intellectual property rights grant can be found |
| 7 * in the file PATENTS. All contributing project authors may |
| 8 * be found in the AUTHORS file in the root of the source tree. |
| 9 */ |
| 10 |
| 11 #include "dl/sp/src/test/compare.h" |
| 12 |
| 13 #include <math.h> |
| 14 #include <stdio.h> |
| 15 |
| 16 extern int verbose; |
| 17 |
| 18 // Convert to dB |
| 19 static double Db(double x) { |
| 20 return (x <= 0) ? -1000.0 : 10 * log(x) / log(10); |
| 21 } |
| 22 |
| 23 static double CalculateSNR(double signal_power, double noise_power) { |
| 24 return (noise_power == 0) ? 1000 : Db(signal_power / noise_power); |
| 25 } |
| 26 |
| 27 /* |
| 28 * Compute the SNR of the actual signal, returning the SNR of the real |
| 29 * and imaginary parts separately, and also the overall (complex SNR) |
| 30 */ |
| 31 |
| 32 void CompareComplex32(struct SnrResult* snr, OMX_SC32* actual, |
| 33 OMX_SC32* expected, int size) { |
| 34 double real_signal_power = 0; |
| 35 double imag_signal_power = 0; |
| 36 double complex_signal_power = 0; |
| 37 double real_noise_power = 0; |
| 38 double imag_noise_power = 0; |
| 39 double complex_noise_power = 0; |
| 40 int k; |
| 41 |
| 42 for (k = 0; k < size; ++k) { |
| 43 double x2; |
| 44 double y2; |
| 45 double z2; |
| 46 |
| 47 if (verbose > 255) { |
| 48 printf("%4d: (%10d, %10d) (%10d, %10d)\n", k, |
| 49 actual[k].Re, actual[k].Im, |
| 50 expected[k].Re, expected[k].Im); |
| 51 } |
| 52 |
| 53 x2 = pow((double) expected[k].Re, 2); |
| 54 y2 = pow((double) expected[k].Im, 2); |
| 55 real_signal_power += x2; |
| 56 imag_signal_power += y2; |
| 57 complex_signal_power += x2 + y2; |
| 58 |
| 59 x2 = pow((double) actual[k].Re - expected[k].Re, 2); |
| 60 y2 = pow((double) actual[k].Im - expected[k].Im, 2); |
| 61 |
| 62 real_noise_power += x2; |
| 63 imag_noise_power += y2; |
| 64 complex_noise_power += x2 + y2; |
| 65 } |
| 66 |
| 67 snr->real_snr_ = CalculateSNR(real_signal_power, real_noise_power); |
| 68 snr->imag_snr_ = CalculateSNR(imag_signal_power, imag_noise_power); |
| 69 snr->complex_snr_ = CalculateSNR(complex_signal_power, complex_noise_power); |
| 70 } |
| 71 |
| 72 void CompareComplex16(struct SnrResult* snr, OMX_SC16* actual, |
| 73 OMX_SC16* expected, int size) { |
| 74 double realSignalPower = 0; |
| 75 double imagSignalPower = 0; |
| 76 double complexSignalPower = 0; |
| 77 double realNoisePower = 0; |
| 78 double imagNoisePower = 0; |
| 79 double complexNoisePower = 0; |
| 80 int k; |
| 81 for (k = 0; k < size; ++k) { |
| 82 double x2; |
| 83 double y2; |
| 84 double z2; |
| 85 |
| 86 if (verbose > 255) { |
| 87 printf("%4d: (%10d, %10d) (%10d, %10d)\n", k, |
| 88 actual[k].Re, actual[k].Im, |
| 89 expected[k].Re, expected[k].Im); |
| 90 } |
| 91 |
| 92 x2 = pow((double) expected[k].Re, 2); |
| 93 y2 = pow((double) expected[k].Im, 2); |
| 94 realSignalPower += x2; |
| 95 imagSignalPower += y2; |
| 96 complexSignalPower += x2 + y2; |
| 97 |
| 98 x2 = pow((double) actual[k].Re - expected[k].Re, 2); |
| 99 y2 = pow((double) actual[k].Im - expected[k].Im, 2); |
| 100 |
| 101 realNoisePower += x2; |
| 102 imagNoisePower += y2; |
| 103 complexNoisePower += x2 + y2; |
| 104 } |
| 105 |
| 106 snr->real_snr_ = CalculateSNR(realSignalPower, realNoisePower); |
| 107 snr->imag_snr_ = CalculateSNR(imagSignalPower, imagNoisePower); |
| 108 snr->complex_snr_ = CalculateSNR(complexSignalPower, complexNoisePower); |
| 109 } |
| 110 |
| 111 /* |
| 112 * Compute the SNR of the actual real signal, returning the SNR. |
| 113 */ |
| 114 |
| 115 void CompareReal32(struct SnrResult* snr, OMX_S32* actual, |
| 116 OMX_S32* expected, int size) { |
| 117 double real_signal_power = 0; |
| 118 double real_noise_power = 0; |
| 119 |
| 120 int k; |
| 121 for (k = 0; k < size; ++k) { |
| 122 double x2; |
| 123 |
| 124 x2 = pow((double) expected[k], 2); |
| 125 |
| 126 real_signal_power += x2; |
| 127 |
| 128 x2 = pow((double) actual[k] - expected[k], 2); |
| 129 |
| 130 real_noise_power += x2; |
| 131 } |
| 132 |
| 133 snr->real_snr_ = CalculateSNR(real_signal_power, real_noise_power); |
| 134 snr->imag_snr_ = -10000; |
| 135 snr->complex_snr_ = -10000; |
| 136 } |
| 137 |
| 138 void CompareReal16(struct SnrResult* snr, OMX_S16* actual, |
| 139 OMX_S16* expected, int size) { |
| 140 double real_signal_power = 0; |
| 141 double real_noise_power = 0; |
| 142 |
| 143 int k; |
| 144 for (k = 0; k < size; ++k) { |
| 145 double x2; |
| 146 |
| 147 x2 = pow((double) expected[k], 2); |
| 148 |
| 149 real_signal_power += x2; |
| 150 |
| 151 x2 = pow((double) actual[k] - expected[k], 2); |
| 152 |
| 153 real_noise_power += x2; |
| 154 } |
| 155 |
| 156 snr->real_snr_ = CalculateSNR(real_signal_power, real_noise_power); |
| 157 snr->imag_snr_ = -10000; |
| 158 snr->complex_snr_ = -10000; |
| 159 } |
| 160 |
| 161 void CompareComplexFloat(struct SnrResult* snr, OMX_FC32* actual, |
| 162 OMX_FC32* expected, int size) { |
| 163 double real_signal_power = 0; |
| 164 double imag_signal_power = 0; |
| 165 double complex_signal_power = 0; |
| 166 double real_noise_power = 0; |
| 167 double imag_noise_power = 0; |
| 168 double complex_noise_power = 0; |
| 169 int k; |
| 170 |
| 171 for (k = 0; k < size; ++k) { |
| 172 double x2; |
| 173 double y2; |
| 174 double z2; |
| 175 |
| 176 if (verbose > 255) { |
| 177 printf("%4d: (%10g, %10g) (%10g, %10g)\n", k, |
| 178 actual[k].Re, actual[k].Im, |
| 179 expected[k].Re, expected[k].Im); |
| 180 } |
| 181 |
| 182 x2 = pow((double) expected[k].Re, 2); |
| 183 y2 = pow((double) expected[k].Im, 2); |
| 184 real_signal_power += x2; |
| 185 imag_signal_power += y2; |
| 186 complex_signal_power += x2 + y2; |
| 187 |
| 188 x2 = pow((double) actual[k].Re - expected[k].Re, 2); |
| 189 y2 = pow((double) actual[k].Im - expected[k].Im, 2); |
| 190 |
| 191 real_noise_power += x2; |
| 192 imag_noise_power += y2; |
| 193 complex_noise_power += x2 + y2; |
| 194 } |
| 195 |
| 196 snr->real_snr_ = CalculateSNR(real_signal_power, real_noise_power); |
| 197 snr->imag_snr_ = CalculateSNR(imag_signal_power, imag_noise_power); |
| 198 snr->complex_snr_ = CalculateSNR(complex_signal_power, complex_noise_power); |
| 199 } |
| 200 |
| 201 void CompareFloat(struct SnrResult* snr, OMX_F32* actual, |
| 202 OMX_F32* expected, int size) { |
| 203 double signal_power = 0; |
| 204 double noise_power = 0; |
| 205 |
| 206 int k; |
| 207 for (k = 0; k < size; ++k) { |
| 208 double x2; |
| 209 |
| 210 x2 = pow((double) expected[k], 2); |
| 211 |
| 212 signal_power += x2; |
| 213 |
| 214 x2 = pow((double) actual[k] - expected[k], 2); |
| 215 |
| 216 noise_power += x2; |
| 217 } |
| 218 |
| 219 snr->real_snr_ = CalculateSNR(signal_power, noise_power); |
| 220 snr->imag_snr_ = -10000; |
| 221 snr->complex_snr_ = snr->real_snr_; |
| 222 } |
OLD | NEW |