DynamicAudioNormalizerWA5/src/DynamicAudioNormalizerWA5.cpp

   1 //////////////////////////////////////////////////////////////////////////////////
   2 // Dynamic Audio Normalizer - Winamp DSP Wrapper
   3 // Copyright (c) 2014-2019 LoRd_MuldeR <mulder2@gmx.de>. Some rights reserved.
   4 //
   5 // Permission is hereby granted, free of charge, to any person obtaining a copy
   6 // of this software and associated documentation files (the "Software"), to deal
   7 // in the Software without restriction, including without limitation the rights
   8 // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
   9 // copies of the Software, and to permit persons to whom the Software is
  10 // furnished to do so, subject to the following conditions:
  11 //
  12 // The above copyright notice and this permission notice shall be included in
  13 // all copies or substantial portions of the Software.
  14 //
  15 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  16 // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  17 // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
  18 // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  19 // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  20 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
  21 // THE SOFTWARE.
  22 //
  23 // http://opensource.org/licenses/MIT
  24 //////////////////////////////////////////////////////////////////////////////////
  25
  26 //Stdlib
  27 #include <cstdlib>
  28 #include <cstdio>
  29 #include <stdint.h>
  30 #include <algorithm>
  31
  32 //Win32
  33 #define NOMINMAX 1
  34 #define WIN32_LEAN_AND_MEAN 1
  35 #include <Windows.h>
  36
  37 //Winamp
  38 #include <winamp_dsp.h>
  39 #include <winamp_ipc.h>
  40
  41 //Internal
  42 #include <Common.h>
  43 #include <Threads.h>
  44
  45 //Dynamic Audio Normalizer API
  46 #include <DynamicAudioNormalizer.h>
  47
  48 //DLL exports
  49 #define DLL_EXPORT __declspec(dllexport)
  50
  51 //Reg key
  52 static const wchar_t *REGISTRY_BASEPATH = L"Software\\MuldeR\\DynAudNorm\\WA5";
  53 static const wchar_t *REGISTRY_VERSION  = L"Version";
  54 static const wchar_t *REGISTRY_FRAMELEN = L"FrameLenMsec";
  55 static const wchar_t *REGISTRY_FLTRSIZE = L"FilterSize";
  56
  57 //Defaults
  58 static const DWORD FRAMELEN_DEFAULT = 500;
  59 static const DWORD FLTRSIZE_DEFAULT = 31;
  60
  61 //Critical Section
  62 static char g_loggingBuffer[1024];
  63 static MY_CRITSEC_INIT(g_loggingMutex);
  64
  65 //Forward declarations
  66 static void config(struct winampDSPModule*);
  67 static int init(struct winampDSPModule*);
  68 static void quit(struct winampDSPModule*);
  69 static int modify_samples(struct winampDSPModule*, short int*, int, int, int, int);
  70 static winampDSPModule *getModule(int);
  71 static int sf(int);
  72 static bool showAboutScreen(const uint32_t&, const uint32_t&, const uint32_t&, const char *const, const char *const, const char *const, const char *const, const bool&, const bool &config);
  73
  74 //Const
  75 static const size_t MAX_CHANNELS = 12;
  76
  77 ///////////////////////////////////////////////////////////////////////////////
  78 // Global Data
  79 ///////////////////////////////////////////////////////////////////////////////
  80
  81 static char g_description[256] = { '\0' };
  82
  83 static winampDSPHeader g_header =
  84 {
  85         DSP_HDRVER + 1,
  86         "Dynamic Audio Normalizer [" __DATE__ "]",
  87         getModule,
  88         sf
  89 };
  90
  91 static winampDSPModule g_module =
  92 {
  93         g_description,
  94         NULL,   // hwndParent
  95         NULL,   // hDllInstance
  96         config,
  97         init,
  98         modify_samples,
  99         quit
 100 };
 101
 102 static struct
 103 {
 104         uint32_t sampleRate;
 105         uint32_t bitsPerSample;
 106         uint32_t channels;
 107 }
 108 g_properties =
 109 {
 110         44100, 16, 2
 111 };
 112
 113 static volatile WNDPROC g_oldWndProc = NULL;
 114 static volatile LONG g_forceReset = 0;
 115 static volatile DWORD g_lastResetTick = 0;
 116
 117 ///////////////////////////////////////////////////////////////////////////////
 118 // Helper functions
 119 ///////////////////////////////////////////////////////////////////////////////
 120
 121 static void outputMessage(const char *const format, ...)
 122 {
 123         MY_CRITSEC_ENTER(g_loggingMutex);
 124
 125         va_list argList;
 126         va_start(argList, format);
 127         vsnprintf_s(g_loggingBuffer, 1024, _TRUNCATE, format, argList);
 128         va_end(argList);
 129         OutputDebugStringA(g_loggingBuffer);
 130
 131         MY_CRITSEC_LEAVE(g_loggingMutex);
 132 }
 133
 134 static void logFunction(const int logLevel, const char *const message)
 135 {
 136         switch (logLevel)
 137         {
 138         case MDynamicAudioNormalizer::LOG_LEVEL_DBG:
 139                 outputMessage("[DynAudNorm_WA5] NFO: %s\n", message);
 140                 break;
 141         case MDynamicAudioNormalizer::LOG_LEVEL_WRN:
 142                 outputMessage("[DynAudNorm_WA5] WRN: %s\n", message);
 143                 break;
 144         case MDynamicAudioNormalizer::LOG_LEVEL_ERR:
 145                 outputMessage("[DynAudNorm_WA5] ERR: %s\n", message);
 146                 break;
 147         default:
 148                 outputMessage("[DynAudNorm_WA5] DBG: %s\n", message);
 149                 break;
 150         }
 151 }
 152
 153 static void showErrorMsg(const char *const text)
 154 {
 155         MessageBoxA(NULL, text, "Dynamic Audio Normalizer", MB_ICONSTOP | MB_TOPMOST | MB_TASKMODAL);
 156 }
 157
 158 static DWORD regValueGet(const wchar_t *const name)
 159 {
 160         DWORD result = 0; HKEY hKey = NULL;
 161         if(RegCreateKeyExW(HKEY_CURRENT_USER, REGISTRY_BASEPATH, 0, NULL, 0, KEY_READ, NULL, &hKey, NULL) == ERROR_SUCCESS)
 162         {
 163                 DWORD type = 0, value = 0, size = sizeof(DWORD);
 164                 if(RegQueryValueExW(hKey, name, 0, &type, ((LPBYTE) &value), &size) == ERROR_SUCCESS)
 165                 {
 166                         if((type == REG_DWORD) && (size == sizeof(DWORD)))
 167                         {
 168                                 result = value;
 169                         }
 170                 }
 171                 RegCloseKey(hKey);
 172         }
 173         return result;
 174 }
 175
 176 static bool regValueSet(const wchar_t *const name, const DWORD &value)
 177 {
 178         bool result = false; HKEY hKey = NULL;
 179         if(RegCreateKeyExW(HKEY_CURRENT_USER, REGISTRY_BASEPATH, 0, NULL, 0, KEY_WRITE, NULL, &hKey, NULL) == ERROR_SUCCESS)
 180         {
 181                 if(RegSetValueExW(hKey, name, 0, REG_DWORD, ((LPBYTE) &value), sizeof(DWORD)) == ERROR_SUCCESS)
 182                 {
 183                         result = true;
 184                 }
 185                 RegCloseKey(hKey);
 186         }
 187         return result;
 188 }
 189
 190 static double *allocBuffer(size_t size)
 191 {
 192         double *buffer = NULL;
 193         try
 194         {
 195                 buffer = new double[size];
 196         }
 197         catch(...)
 198         {
 199                 outputMessage("[DynAudNorm_WA5] ERR: Allocation of size %u failed!", static_cast<unsigned int>(sizeof(double) * size));
 200                 showErrorMsg("Memory allocation has failed: Out of memory!");
 201                 _exit(0xC0000017);
 202         }
 203         return buffer;
 204 }
 205
 206 ///////////////////////////////////////////////////////////////////////////////
 207 // Internal Functions
 208 ///////////////////////////////////////////////////////////////////////////////
 209
 210 static MDynamicAudioNormalizer *g_instance = NULL;
 211 static size_t g_sampleBufferSize = 0;
 212 static double *g_sampleBuffer[MAX_CHANNELS];
 213
 214 static void updateBufferSize(const int &numsamples)
 215 {
 216         if(size_t(numsamples) > g_sampleBufferSize)
 217         {
 218                 if(g_sampleBufferSize > 0)
 219                 {
 220                         for(int c = 0; c < MAX_CHANNELS; c++)
 221                         {
 222                                 delete [] (g_sampleBuffer[c]);
 223                                 g_sampleBuffer[c] = NULL;
 224                         }
 225                 }
 226                 for(int c = 0; c < MAX_CHANNELS; c++)
 227                 {
 228                         g_sampleBuffer[c] = allocBuffer(numsamples);
 229                 }
 230                 g_sampleBufferSize = numsamples;
 231         }
 232 }
 233
 234 static void deinterleave(const short int *const input, const int &numsamples, const int &bps, const int &nch)
 235 {
 236         updateBufferSize(numsamples);
 237
 238         if(bps == 16)
 239         {
 240                 const short int *ptr = input;
 241                 for(int i = 0; i < numsamples; i++)
 242                 {
 243                         for(int c = 0; c < nch; c++)
 244                         {
 245                                 g_sampleBuffer[c][i] = std::min(1.0, std::max(-1.0, (double(*(ptr++)) / double(SHRT_MAX))));
 246                         }
 247                 }
 248         }
 249         else if(bps == 8)
 250         {
 251                 const int8_t *ptr = reinterpret_cast<const int8_t*>(input);
 252                 for(int i = 0; i < numsamples; i++)
 253                 {
 254                         for(int c = 0; c < nch; c++)
 255                         {
 256                                 g_sampleBuffer[c][i] = std::min(1.0, std::max(-1.0, (double(*(ptr++)) / double(INT8_MAX))));
 257                         }
 258                 }
 259         }
 260         else
 261         {
 262                 showErrorMsg("Unsupported bit-depth detected!");
 263         }
 264 }
 265
 266 static void interleave(short int *const output, const int &numsamples, const int &bps, const int &nch)
 267 {
 268         updateBufferSize(numsamples);
 269
 270         if(bps == 16)
 271         {
 272                 short int *ptr = output;
 273                 for(int i = 0; i < numsamples; i++)
 274                 {
 275                         for(int c = 0; c < nch; c++)
 276                         {
 277                                 *(ptr++) = static_cast<short int>(std::max(double(SHRT_MIN), std::min(double(SHRT_MAX), round(g_sampleBuffer[c][i] * double(SHRT_MAX)))));
 278                         }
 279                 }
 280         }
 281         else if(bps == 8)
 282         {
 283                 int8_t *ptr = reinterpret_cast<int8_t*>(output);
 284                 for(int i = 0; i < numsamples; i++)
 285                 {
 286                         for(int c = 0; c < nch; c++)
 287                         {
 288                                 *(ptr++) = static_cast<int8_t>(std::max(double(INT8_MIN), std::min(double(INT8_MAX), round(g_sampleBuffer[c][i] * double(INT8_MAX)))));
 289                         }
 290                 }
 291         }
 292         else
 293         {
 294                 showErrorMsg("Unsupported bit-depth detected!");
 295         }
 296 }
 297
 298 static bool createNewInstance(const uint32_t sampleRate, const uint32_t channelCount)
 299 {
 300         if(g_instance)
 301         {
 302                 delete g_instance;
 303                 g_instance = NULL;
 304         }
 305
 306         const DWORD optionFrameLen = regValueGet(REGISTRY_FRAMELEN);
 307         const DWORD optionFltrSize = regValueGet(REGISTRY_FLTRSIZE);
 308
 309         try
 310         {
 311                 g_instance = new MDynamicAudioNormalizer
 312                 (
 313                         channelCount,
 314                         sampleRate,
 315                         optionFrameLen ? optionFrameLen : FRAMELEN_DEFAULT,
 316                         optionFltrSize ? optionFltrSize : FLTRSIZE_DEFAULT
 317                 );
 318         }
 319         catch(...)
 320         {
 321                 showErrorMsg("Failed to create Dynamic Audio Normalizer instance!");
 322                 return false;
 323         }
 324
 325         if(!g_instance->initialize())
 326         {
 327                 showErrorMsg("Dynamic Audio Normalizer initialization has failed!");
 328                 return false;
 329         }
 330
 331         return true;
 332 }
 333
 334 static bool detectWinampVersion(const HWND &hwndParent)
 335 {
 336         unsigned long winampVersion      = 0;
 337         unsigned long winampVersionMajor = 0;
 338         unsigned long winampVersionMinor = 0;
 339
 340         if(SendMessageTimeout(hwndParent, WM_WA_IPC, 0, IPC_GETVERSION, SMTO_ABORTIFHUNG, 5000, &winampVersion))
 341         {
 342                 if((winampVersion >= 0x5000) && (winampVersion <= 0xFFFFF))
 343                 {
 344                         winampVersionMajor = (winampVersion >> 0xC);
 345                         winampVersionMinor = (winampVersion & 0xFF);
 346                 }
 347         }
 348         else
 349         {
 350                 winampVersion = 0xFFFFFFFF;
 351         }
 352
 353         outputMessage("[DynAudNorm_WA5] Winamp version is: 0x%X (v%X.%02X)", winampVersion, winampVersionMajor, winampVersionMinor);
 354
 355         if(winampVersionMajor < 1)
 356         {
 357                 showErrorMsg("Failed to detect Winamp version. Please use Winamp 5.0 or newer!");
 358                 return false;
 359         }
 360
 361         if(winampVersionMajor < 5)
 362         {
 363                 showErrorMsg("Your Winamp version is too old. Please use Winamp 5.0 or newer!");
 364                 return false;
 365         }
 366
 367         return true;
 368 }
 369
 370 static LRESULT CALLBACK winampWindowHook(const HWND hwnd, const UINT uMsg, const WPARAM wParam, const LPARAM lParam)
 371 {
 372         if ((lParam == IPC_CB_MISC) && ((wParam == IPC_CB_MISC_STATUS) || (wParam == IPC_CB_MISC_TITLE)))
 373         {
 374                 InterlockedIncrement(&g_forceReset);
 375         }
 376
 377         if (g_oldWndProc)
 378         {
 379                 return g_oldWndProc(hwnd, uMsg, wParam, lParam);
 380         }
 381
 382         return 0L;
 383 }
 384
 385 ///////////////////////////////////////////////////////////////////////////////
 386 // Public Functions
 387 ///////////////////////////////////////////////////////////////////////////////
 388
 389 static void config(struct winampDSPModule *this_mod)
 390 {
 391         outputMessage("[DynAudNorm_WA5] WinampDSP::config(%p)", this_mod);
 392
 393         uint32_t major, minor, patch;
 394         MDynamicAudioNormalizer::getVersionInfo(major, minor, patch);
 395
 396         const char *date, *time, *compiler, *arch; bool debug;
 397         MDynamicAudioNormalizer::getBuildInfo(&date, &time, &compiler, &arch, debug);
 398
 399         showAboutScreen(major, minor, patch, date, time, compiler, arch, debug, true);
 400 }
 401
 402 static int init(struct winampDSPModule *this_mod)
 403 {
 404         outputMessage("[DynAudNorm_WA5] WinampDSP::init(%p)", this_mod);
 405         detectWinampVersion(this_mod->hwndParent);
 406
 407         if(g_sampleBufferSize == 0)
 408         {
 409                 for(int c = 0; c < MAX_CHANNELS; c++)
 410                 {
 411                         g_sampleBuffer[c] = allocBuffer(1024);
 412                 }
 413                 g_sampleBufferSize = 1024;
 414         }
 415
 416         if(!createNewInstance(g_properties.sampleRate, g_properties.channels))
 417         {
 418                 return 1;
 419         }
 420
 421         if (!(g_oldWndProc = (WNDPROC)SetWindowLong(this_mod->hwndParent, GWL_WNDPROC, (LONG_PTR)winampWindowHook)))
 422         {
 423                 outputMessage("[DynAudNorm_WA5] WARNING: Failed to hook Winamp window!");
 424         }
 425
 426         return 0;
 427 }
 428
 429 static void quit(struct winampDSPModule *this_mod)
 430 {
 431         outputMessage("[DynAudNorm_WA5] WinampDSP::quit(%p)", this_mod);
 432
 433         if (g_oldWndProc)
 434         {
 435                 if (SetWindowLong(this_mod->hwndParent, GWL_WNDPROC, (LONG_PTR)g_oldWndProc))
 436                 {
 437                         g_oldWndProc = NULL;
 438                 }
 439         }
 440
 441         if(g_sampleBufferSize > 0)
 442         {
 443                 for(int c = 0; c < MAX_CHANNELS; c++)
 444                 {
 445                         delete [] (g_sampleBuffer[c]);
 446                         g_sampleBuffer[c] = NULL;
 447                 }
 448                 g_sampleBufferSize = 0;
 449         }
 450 }
 451
 452 static int modify_samples(struct winampDSPModule *this_mod, short int *samples, int numsamples, int bps, int nch, int srate)
 453 {
 454         if(numsamples < 1)
 455         {
 456                 outputMessage("[DynAudNorm_WA5] Sample count is zero or negative -> nothing to do!");
 457                 return 0;
 458         }
 459
 460         if(nch > MAX_CHANNELS)
 461         {
 462                 showErrorMsg("Maximum channel count has been exceeded!");
 463                 return 0;
 464         }
 465
 466         if((!g_instance) || (g_properties.bitsPerSample != bps) || (g_properties.channels != nch) || (g_properties.sampleRate != srate))
 467         {
 468                 outputMessage("[DynAudNorm_WA5] WinampDSP::modify_samples(mod=%p, num=%d, bps=%d, nch=%d, srate=%d)", this_mod, numsamples, bps, nch, srate);
 469
 470                 g_properties.bitsPerSample = bps;
 471                 g_properties.channels = nch;
 472                 g_properties.sampleRate = srate;
 473
 474                 if(!createNewInstance(g_properties.sampleRate, g_properties.channels))
 475                 {
 476                         return 0; /*creating instance failed!*/
 477                 }
 478         }
 479         else if (InterlockedExchange(&g_forceReset, 0L) > 0L)
 480         {
 481                 const DWORD tickCount = GetTickCount();
 482                 if ((tickCount < g_lastResetTick) || ((tickCount - g_lastResetTick) > 250L))
 483                 {
 484                         if (g_lastResetTick)
 485                         {
 486                                 outputMessage("[DynAudNorm_WA5] Reset has been triggered!");
 487                                 g_instance->reset();
 488                         }
 489                         g_lastResetTick = tickCount;
 490                 }
 491         }
 492
 493         deinterleave(samples, numsamples, bps, nch);
 494
 495         int64_t outputSize;
 496         g_instance->processInplace(g_sampleBuffer, numsamples, outputSize);
 497
 498         interleave(samples, static_cast<int>(outputSize), bps, nch);
 499         return static_cast<int>(outputSize);
 500 }
 501
 502 ///////////////////////////////////////////////////////////////////////////////
 503 // Winamp DSP API
 504 ///////////////////////////////////////////////////////////////////////////////
 505
 506 static int8_t g_initialized = -1;
 507 static MY_CRITSEC_INIT(g_createEffMutex);
 508
 509 static void appendStr(wchar_t *buffer, const size_t &size, const wchar_t *const text, ...)
 510 {
 511         wchar_t temp[128];
 512         va_list argList;
 513         va_start(argList, text);
 514         _vsnwprintf_s(temp, 128, _TRUNCATE, text, argList);
 515         va_end(argList);
 516         wcsncat_s(buffer, size, temp, _TRUNCATE);
 517 }
 518
 519 static bool showAboutScreen(const uint32_t &major, const uint32_t &minor, const uint32_t &patch, const char *const date, const char *const time, const char *const compiler, const char *const arch, const bool &debug, const bool &config)
 520 {
 521         wchar_t text[1024] = { '\0' };
 522         appendStr(text, 1024, L"Dynamic Audio Normalizer, Winamp Wrapper, Version %u.%02u-%u, %s\n", major, minor, patch, (debug ? L"DEBGU" : L"Release"));
 523         appendStr(text, 1024, L"Copyright (c) 2014-2019 LoRd_MuldeR <mulder2@gmx.de>. Some rights reserved.\n");
 524         appendStr(text, 1024, L"Built on %S at %S with %S for %S.\n\n", date, time, compiler, arch);
 525         appendStr(text, 1024, L"This library is free software; you can redistribute it and/or\n");
 526         appendStr(text, 1024, L"modify it under the terms of the GNU Lesser General Public\n");
 527         appendStr(text, 1024, L"License as published by the Free Software Foundation; either\n");
 528         appendStr(text, 1024, L"version 2.1 of the License, or (at your option) any later version.\n\n");
 529         appendStr(text, 1024, L"This library is distributed in the hope that it will be useful,\n");
 530         appendStr(text, 1024, L"but WITHOUT ANY WARRANTY; without even the implied warranty of\n");
 531         appendStr(text, 1024, L"MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU\n");
 532         appendStr(text, 1024, L"Lesser General Public License for more details.\n");
 533
 534         if(config)
 535         {
 536                 MessageBoxW(NULL, text, L"Dynamic Audio Normalizer", MB_TOPMOST | MB_TASKMODAL | MB_OK);
 537                 return true;
 538         }
 539         else
 540         {
 541                 appendStr(text, 1024, L"\nPlease click 'OK' if you agree to the above notice or 'Cancel' otherwise...\n");
 542                 const int ret = MessageBoxW(NULL, text, L"Dynamic Audio Normalizer", MB_TOPMOST | MB_TASKMODAL | MB_OKCANCEL | MB_DEFBUTTON2);
 543                 return (ret == IDOK);
 544         }
 545 }
 546
 547 static bool initializeCoreLibrary(void)
 548 {
 549         MDynamicAudioNormalizer::setLogFunction(logFunction);
 550
 551         uint32_t major, minor, patch;
 552         MDynamicAudioNormalizer::getVersionInfo(major, minor, patch);
 553
 554         outputMessage("[DynAudNorm_WA5] Dynamic Audio Normalizer Winamp-Wrapper (v%u.%02u-%u)", major, minor, patch);
 555         _snprintf_s(g_description, 256, _TRUNCATE, "Dynamic Audio Normalizer v%u.%02u-%u [by LoRd_MuldeR]", major, minor, patch);
 556
 557         const DWORD version = (1000u * major) + (10u * minor) + patch;
 558         if(regValueGet(REGISTRY_VERSION) != version)
 559         {
 560                 const char *date, *time, *compiler, *arch; bool debug;
 561                 MDynamicAudioNormalizer::getBuildInfo(&date, &time, &compiler, &arch, debug);
 562
 563                 if(!showAboutScreen(major, minor, patch, date, time, compiler, arch, debug, false))
 564                 {
 565                         return false;
 566                 }
 567                 regValueSet(REGISTRY_VERSION, version);
 568                 regValueSet(REGISTRY_FRAMELEN, FRAMELEN_DEFAULT);
 569                 regValueSet(REGISTRY_FLTRSIZE, FLTRSIZE_DEFAULT);
 570         }
 571
 572         return true;
 573 }
 574
 575 static winampDSPModule *getModule(int which)
 576 {
 577         outputMessage("[DynAudNorm_WA5] WinampDSP::getModule(%d)", which);
 578
 579         winampDSPModule *module = NULL;
 580         MY_CRITSEC_ENTER(g_createEffMutex);
 581
 582         if(which == 0)
 583         {
 584                 if(g_initialized < 0)
 585                 {
 586                         g_initialized = initializeCoreLibrary() ? 1 : 0;
 587                 }
 588                 if(g_initialized > 0)
 589                 {
 590                         module = &g_module;
 591                 }
 592         }
 593
 594         MY_CRITSEC_LEAVE(g_createEffMutex);
 595         return module;
 596 }
 597
 598 static int sf(int v)    /*Note: The "sf" function was copied 1:1 from the example code, I have NO clue what it does!*/
 599 {
 600         int res;
 601         res = v * (unsigned long)1103515245;
 602         res += (unsigned long)13293;
 603         res &= (unsigned long)0x7FFFFFFF;
 604         res ^= v;
 605         return res;
 606 }
 607
 608 extern "C" DLL_EXPORT winampDSPHeader *winampDSPGetHeader2()
 609 {
 610         outputMessage("[DynAudNorm_WA5] WinampDSP::winampDSPGetHeader2()");
 611         return &g_header;
 612 }