wirtz
/
OpenAudio_ArduinoLibrary
mirror of https://github.com/chipaudette/OpenAudio_ArduinoLibrary.git
1
0
Fork 0
Code Issues Releases Wiki Activity

Add AudioEffectCompressor2_F32

Browse Source
pull/11/head
boblark 3 years ago
parent 0e6fb86f77
commit c140ca25b9
6 changed files with 547 additions and 0 deletions
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Show Stats Download Patch File Download Diff File
  1. 148
      AudioEffectCompressor2_F32.cpp
  2. 225
      AudioEffectCompressor2_F32.h
  3. 1
      OpenAudio_ArduinoLibrary.h
  4. BIN
      examples/testCompressor2/OutInDefault.gif
  5. BIN
      examples/testCompressor2/OutInSquelch.gif
  6. 173
      examples/testCompressor2/testCompressor2.ino

148
AudioEffectCompressor2_F32.cpp
Unescape View File

@ -0,0 +1,148 @@
/* AudioEffectCompressor2_F32.cpp
*
* Bob Larkin W7PUA 22 January 2021
* See AudioEffectCompressor2_F32.h for details
*
* MIT License. Use at your own risk.
*/
#include "AudioEffectCompressor2_F32.h"
/* See https://github.com/Tympan/Tympan_Library/blob/master/src/AudioCalcGainWDRC_F32.h
* Dr Paul Beckmann
* https://community.arm.com/tools/f/discussions/4292/cmsis-dsp-new-functionality-proposal/22621#22621
* Fast approximation to the log2() function. It uses a two step
* process. First, it decomposes the floating-point number into
* a fractional component F and an exponent E. The fraction component
* is used in a polynomial approximation and then the exponent added
* to the result. A 3rd order polynomial is used and the result
* when computing db20() is accurate to 7.984884e-003 dB. Y is log2(X)
*/
float v2DB_Approx(float volts) {
float Y, F;
int E;
// This is the approximation to log2()
F = frexpf(volts, &E); // first separate power of 2;
// Y = C[0]*F*F*F + C[1]*F*F + C[2]*F + C[3] + E;
Y = 1.23149591; //C[0]
Y *= F;
Y += -4.11852516f; //C[1]
Y *= F;
Y += 6.02197014f; //C[2]
Y *= F;
Y += -3.13396450f; //C[3]
Y += E;
// Convert to dB = 20 Log10(volts)
return 6.020599f * Y; // (20.0f/log2(10.0))*Y;
}
// Accelerate the powf(10.0,x) function (from Chip's single slope compressor)
float pow10f(float x) {
//return powf(10.0f,x) //standard, but slower
return expf(2.30258509f*x); //faster: exp(log(10.0f)*x)
}
// begin()
void AudioEffectCompressor2_F32::begin(void) {
for(int kk =0; kk<5; kk++) // Keeps division out of update()
slope[kk] = 1.0f/curve0.compressionRatio[kk];
outKneeDB[0] = curve0.marginDB; // Start at top
for(int kk=1; kk<5; kk++) {
outKneeDB[kk] = outKneeDB[kk-1] - (curve0.kneeDB[kk-1] -
curve0.kneeDB[kk])/curve0.compressionRatio[kk-1];
}
firstIndex = 4; // Start at bottom
for(int kk=4; kk>0; kk--) {
if(curve0.kneeDB[kk] >= -500.0) {
firstIndex = kk;
break;
}
}
/* for(int kk=0; kk<5; kk++) {
Serial.print(kk);
Serial.print(" <--k outKneeDB[k]--> ");
Serial.println(outKneeDB[kk]);
}
Serial.print("firstIndex--> ");
Serial.println(firstIndex);
*/
}
// update()
void AudioEffectCompressor2_F32::update(void) {
float vAbs, vPeak;
float vInDB = 0.0f;
float vOutDB = 0.0f;
float targetGain;
// Receive the input audio data
audio_block_f32_t *block = AudioStream_F32::receiveWritable_f32();
if (!block) return;
// Allocate memory for the output
audio_block_f32_t *out_block = AudioStream_F32::allocate_f32();
if (!out_block) {
release(block);
return;
}
// Find the smoothed envelope, target gain and compressed output
vPeak = vPeakSave;
for (int k=0; k<block->length; k++) {
vAbs = (block->data[k] >= 0.0f) ? block->data[k] : -block->data[k];
if (vAbs >= vPeak) { // Attack (rising level)
vPeak = alpha * vPeak + (oneMinusAlpha) * vAbs;
} else { // Release (decay for falling level)
vPeak = beta * vPeak;
}
// Convert to dB
// At all levels and quite frequency flat, this under estimates by about 1.05 dB
vInDB = v2DB_Approx(vPeak) + 1.05f;
if(vInDB > vInMaxDB) vInMaxDB = vInDB; // For reporting back
// Find gain point. Don't look below first segment firstIndex.
for(int kk=firstIndex; kk>=0; kk--) {
if( vInDB<=curve0.kneeDB[kk] || kk==0 ) {
vOutDB = outKneeDB[kk] + slope[kk]*(vInDB - curve0.kneeDB[kk]);
break;
}
}
// Convert the needed gain back to a voltage ratio 10^(db/20)
targetGain = pow10f(0.05f*(vOutDB - vInDB));
// And apply target gain to signal stream from the delayed data. The
// delay buffer is circular because of delayBufferMask and length 2^m m<=8.
out_block->data[k] = targetGain * delayData[(k + in_index) & delayBufferMask];
if(printIO) {
Serial.print(block->data[k],6);
Serial.print("," );
Serial.print(delayData[(k + in_index) & delayBufferMask],6);
Serial.print("," );
Serial.println(targetGain);
}
// Put the new data into the delay line, delaySize positions ahead.
// If delaySize==256, this will be the same location as we just got data from.
delayData[(k + in_index + delaySize) & delayBufferMask] = block->data[k];
}
vPeakSave = vPeak; // save last vPeak for next time
sampleInputDB = vInDB; // Last values for get...() functions
sampleGainDB = vOutDB - vInDB;
// transmit the block and release memory
AudioStream_F32::release(block);
AudioStream_F32::transmit(out_block); // send the FIR output
AudioStream_F32::release(out_block);
// Update pointer in_index to delay line for next 128 update
in_index = (in_index + block->length) & delayBufferMask;
} // End update()
// Sets a new compression curve by transferring structure
void AudioEffectCompressor2_F32::setCompressionCurve(struct compressionCurve *_cCurve) {
curve0.marginDB = _cCurve->marginDB;
curve0.offsetDB = _cCurve->offsetDB;
for(int kk=0; kk<5; kk++) {
// Also, adjust the input levels for offsetDB value
curve0.kneeDB[kk] = _cCurve->kneeDB[kk] - curve0.offsetDB;
curve0.compressionRatio[kk] = _cCurve->compressionRatio[kk];
}
}

225
AudioEffectCompressor2_F32.h
Unescape View File

@ -0,0 +1,225 @@
/*
* AudioEffectCompressor2_F32.h
*
* Bob Larkin W7PUA 11 December 2020
*
* This is a general purpose audio compressor block (C++ class). It works by determining
* the average input of the input signal, and based on a pre-determined curve,
* changes the gain going through the block.
* A good discussion is the Wikipedia page:
* https://en.wikipedia.org/wiki/Dynamic_range_compression
* This compressor includes up to 5 dB/dB line segments allowing for most of the
* features listed. These include
* Multi segment compression curves, up to 5
* Limiting
* Approximation to "soft knees"
* Expansion for suppressing low-level artifacts
* Anticipation
* Scale offset for use such as hearing-aid audiology
* This is derived from the WDRC compressor. Chip Audette (OpenAudio) Feb 2017
* Which was derived From: WDRC_circuit from CHAPRO from BTNRC: https://github.com/BTNRH/chapro
* As of Feb 2017, CHAPRO license is listed as "Creative Commons?"
*
* MIT License. Use at your own risk.
*/
/* Compressor #2. Amplifies input signals by varying amoounts depending
* on the signal level. This is controlled by up to 5 line segments specified
* by a point at the highest input level for the line along with a compression ratio
* (1/slope) for the line segment. This can provide limiting at the highest inputs
* by setting compressionRatio[0]=1000.0 (i.e., some big value). Expansion at the
* lw levels provides a squelch action, using a very small compression
* ratio like 0.01.
*
* A special case is the [0] segment, that continues at the same slope for inputs up
* to any level. For this the kneeDB[0] can be the expected 0.0 or other values
* on that line. The output level for kneeDB[0] is the input variable, marginDB.
* This allows gain control near clipping but below. marginDB is typically 1 or 2 dB.
*
Vout dB
|
|
0.0 + kneeDB[0]
marg + kneeDB[1] @********************
| @************ 1:compressionRatio[0]
| ****
| ***
| ***
| *** 1:compressionRatio[1]
| kneeDB[2] ***
| @***
| *
| *
| *
| *
| * 1:compressionRatio[2]
| *
| * === Vout in dB vs. Vin in dB ===
|* Three segment example
* Knees (breakpoints) are shown with '@'
*| compressionRatio[] are ratio of: input change (in dB):output change in dB
* |
* |________|___________________|____________________________|________ vIn dB
k1 k2 0.0
* The graph shows the changes in gain on a log or dB scale. A compressionRatio
* of 1 represents a constant gain with level. When the compressionRatio is greater
* than 1, say 2.0, the voltage gain is decreasing as the input level increases.
*
* vInDB refers to the time averaged envelope voltage.
* The zero reference is the full ADC range output. This is ±1.0
* peak or 0.707 RMS in F32 terminology.
*
* The curve is for gainOffsetDB = 0.0. This parameter raises and lowers the
* input scale for the kneeDB[] parameter.
*
* Timing: For 44.1 kHz sample rate and 256 samples per update, the update( ) time
* runs 240 to 270 icroseconds using Teensy 3.6.
*/
#ifndef _AUDIO_EFFECT_COMPRESSOR2_F32_H
#define _AUDIO_EFFECT_COMPRESSOR2_F32_H
#include <Arduino.h>
#include <AudioStream_F32.h>
// The following 3 defines are simplified implementations for common uses.
// They replace the begin() function that is otherwise required.
// See testCompressor2.ino example for how to use these defines.
// None of these support offsetting the input scale as done in Tympan.
/* limiterBegin(pointerObject, float marDB, float linearInDB) has 2 segments.
* It is linear up to an input of linearInDB (typically -15.0f) and
* then virtually limits for higher input levels. The output level at
* this point is marDB, the margin to prevent clipping, like -2 dB.
* This is not a clipper with waveform distortion, but rather decreases
* the gain, dB for dB, as the input increases in the limiter region.
* pobject is a pointer to the INO AudioEffectCompressor2_F32 object.
* This function replaces begin() for the AudioEffectCompressor2_F32 object.
*/
#define limiterBegin(pobject, marDB, linearInDB) struct compressionCurve _curv={marDB,0.0f,{0.0,linearInDB,-1000.0f,-1000.0f,-1000.0f},{100.0,1.0f,1.0f,1.0f,1.0f}}; pobject->setCompressionCurve(&_curv); pobject->begin();
/* basicCompressorBegin has a 3 segments. It is linear up to an input linearInDB
* and then decreases gain according to compressionRatioDB up to an input -10 dB where it
* is almost limited, with an increase of output level of 1 dB for a 10 dB increase
* in input level. The output level at full input is 1 dB below full output.
* This function replaces begin() for the AudioEffectCompressor2_F32 object.
*/
#define basicCompressorBegin(pobject, linearInDB, compressionRatio) struct compressionCurve _curv={-1.0,0.0f,{0.0,-10.0f,linearInDB,-1000.0f,-1000.0f},{10.0f,compressionRatio,1.0f,1.0f,1.0f}}; pobject->setCompressionCurve(&_curv); pobject->begin();
/* squelchCompressorBegin is similar to basicCompression above, except that there is
* an expansion region for low levels. So, the call defines the four regions in
* terms of the input levels. squelchInDB sets the lowest input level
* before the squelching effect starts. */
#define squelchCompressorBegin(pobject, squelchInDB, linearInDB, compressionInDB, compressionRatio) struct compressionCurve _curv={-1.0,0.0f,{0.0,compressionInDB,linearInDB,squelchInDB,-1000.0f},{10.0,compressionRatio,1.0f,0.1f,1.0f}}; pobject->setCompressionCurve(&_curv); pobject->begin();
// Basic definition of compression curve:
struct compressionCurve {
float marginDB;
float offsetDB;
float kneeDB[5];
float compressionRatio[5];
};
// ---------------------------------------------------------------------------
class AudioEffectCompressor2_F32 : public AudioStream_F32
{
//GUI: inputs:1, outputs:1 //this line used for automatic generation of GUI node
//GUI: shortName: Compressor2
public:
AudioEffectCompressor2_F32(void): AudioStream_F32(1, inputQueueArray) {
setAttackReleaseSec(0.005f, 0.100f);
}
AudioEffectCompressor2_F32(const AudioSettings_F32 &settings): AudioStream_F32(1, inputQueueArray) {
//setSampleRate_Hz(settings.sample_rate_Hz);
setAttackReleaseSec(0.005f, 0.100f);
}
virtual void update(void);
void begin(void);
void setCompressionCurve(struct compressionCurve*);
// A delay of 256 samples is 256/44100 = 0.0058 sec = 5.8 mSec
void setDelayBufferSize(int16_t _delaySize) { // Any power of 2, i.e., 256, 128, 64, etc.
delaySize = _delaySize;
delayBufferMask = _delaySize - 1;
in_index = 0;
}
void printOn(bool _printIO) { printIO = _printIO; } // Diagnostics ONLY. Not for general INO
float getCurrentInputDB(void) { return sampleInputDB; }
float getCurrentGainDB(void) { return sampleGainDB; }
float getvInMaxDB(void) {
float vRet = vInMaxDB;
vInMaxDB = -1000.0f; // Reset for next max measure
return vRet;
}
//convert time constants from seconds to unitless parameters, from CHAPRO, agc_prepare.c
void setAttackReleaseSec(const float atk_sec, const float rel_sec) {
// convert ANSI attack & release times to filter time constants
float ansi_atk = atk_sec * sample_rate_Hz / 2.425f;
float ansi_rel = rel_sec * sample_rate_Hz / 1.782f;
alpha = (float) (ansi_atk / (1.0f + ansi_atk));
oneMinusAlpha = 1.0f - alpha;
beta = (float) (ansi_rel / (1.0f + ansi_rel));
}
private:
audio_block_f32_t *inputQueueArray[1];
float delayData[256]; // The circular delay line for the signal
uint16_t in_index = 0; // Pointer to next block update entry
// And a mask to make the circular buffer limit to a power of 2
uint16_t delayBufferMask = 0X00FF;
uint16_t delaySize = 256;
float sample_rate_Hz = 44100;
float attackSec = 0.005f; // Q: Can this be reduced with the delay line added to the signal path??
float releaseSec = 0.100f;
// This alpha, beta for 5 ms attack, 100ms release, about 0.07 dB max ripple at 1000 Hz
float alpha = 0.98912216f;
float oneMinusAlpha = 0.01087784f;
float beta = 0.9995961f;
/* Definition of the compression curve.
* Input and output are normally referenced to the full scale range (-1.0 to 1.0 in float).
* The full scale point is called 0 dB.
* There are 5 slopes, specified by the top input level for each line segment (kneeDB[])
* and the Compression Ratio (1/slope) of the segment (compressionRatio[]).
* These are numbered from the highest to the lowest allowing
* the number of segments to be adjusted, i.e., there is always a segment 0
* but there may not be a segment 3 and 4, for instance. This becomes very flexible,
* as there can be, say, compression for top levels and expansion for very low levels.
*
* A special case is segment 0. On a plot of output dB vs input db, an input
* level of kneeDB[0] produces an output of marginDB. A typical marginDB might
* be -1.0 or -2.0. This margin allows controlling the gain without clipping in the DAC.
*
* This structure can have multiple curve structures like cCurve that can be used by
* cmpr1.setCompressionCurve(&cCurve);
* cmpr1.begin();
*
* Unused segments can have knees like kneeDB[4] at, say -1000.0f.
* Values below -500 will slightly speed up the update() function. if the bottom
* two segments are not used, kneeDB[3] would also be set to -1000.0f amd so forth.
*
* Finally, there is a variable offsetDB that allows for a shift in the input scale.
* It simply shifts the definition input levels, in dB.
* This allows converting from DSP scales that have 0dB at full DSP scale
* to auditory scales such as are used in the Tympan library. An offsetDB=119.0
* would allow all inputs to be in "SPL" units with a maximum input value of 119.
*/
struct compressionCurve curve0 = { -2.0f, 0.0f, // margin, offset
{0.0f, -10.0f, -20.0f, -30.0f, -1000.0f}, // kneeDB[]
{ 100.0f, 2.0f, 1.5f, 1.0f, 1.0f} }; // compressionRatio
// VoutDB at each knee, needed to find gain; determined at begin():
float outKneeDB[5]={-2.0f, -3.0f, -8.0f -978.0f, -978.0f};
// slopes are 1/compressionRatio determined at begin() to save update{} time
float slope[5] = {0.01f, 0.5f, 0.666667f, 1.0f, 1.0f};
// Save time in update() by ignoring unused (low level) segments:
uint16_t firstIndex = 3;
float vPeakSave = 0.0f;
float vInMaxDB = -1000.0f; // Only for reporting
bool printIO = false; // Diagnostics Only
float sampleInputDB, sampleGainDB;
};
#endif

1
OpenAudio_ArduinoLibrary.h
Unescape View File

@ -8,6 +8,7 @@
#include "AudioControlTester.h"
#include "AudioConvert_F32.h"
#include "AudioEffectCompressor_F32.h"
#include "AudioEffectCompressor2_F32.h"
#include "AudioEffectCompWDRC_F32.h"
#include "AudioEffectEmpty_F32.h"
#include "AudioEffectGain_F32.h"

BIN
examples/testCompressor2/OutInDefault.gif
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 26 KiB

BIN
examples/testCompressor2/OutInSquelch.gif
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 26 KiB

173
examples/testCompressor2/testCompressor2.ino
Unescape View File

@ -0,0 +1,173 @@
/* TestCompressor2.ino Bob Larkin 23 January 2021
*
* Test of AudioEffectCompressor2_F32
* See AudioEffectCompressor2_F32.h for much detail and explanation.
* Choice of test signals is a single sine wave, a random sequence
* of sine waves of varying frequency and amplitude, a power
* sweep or a pulse of sine wave to see transient behavior.
*
* This version is for the Chip Audette OpenAudio_F32 Library. and
* thus has that interface structure.
*
* NOTE: As of 23 January 2021, the compressor AudioEffectWDRC2_F32.h
* was not finalized and could change in detail. Use here with
* this in mind.
*/
#include "Audio.h"
#include "OpenAudio_ArduinoLibrary.h"
#define RANDOM 1
#define POWER_SWEEP 2
#define PULSE 3
#define ALTERNATE 4
// Edit in one of the last four, here:
#define SIGNAL_SOURCE RANDOM
AudioSynthWaveformSine_F32 sine1; // Test signal
AudioEffectCompressor2_F32 compressor1; // Audio Compressor
AudioEffectGain_F32 gain0; // Sets volume sent to output
AudioEffectGain_F32 gain1; // Sets the same
AudioOutputI2S_F32 i2sOut;
AudioConnection_F32 patchCord1(sine1, 0, compressor1, 0);
AudioConnection_F32 patchCord2(compressor1, 0, gain0, 0);
AudioConnection_F32 patchCord3(compressor1, 0, gain1, 0);
AudioConnection_F32 patchCord4(gain0, 0, i2sOut, 0);
AudioConnection_F32 patchCord5(gain1, 0, i2sOut, 1);
AudioControlSGTL5000 sgtl5000_1;
uint16_t count17, count27;
float level = 0.05f;
void setup(void) {
AudioMemory(50);
AudioMemory_F32(100);
Serial.begin(300); delay(1000);
Serial.println("*** Test Compressor2 Gain Compressor **");
count17 = 0;
count27 = 0;
sine1.frequency(1000.0f);
sine1.amplitude(0.05f);
// CAUTION - If using ears on the output, adjust the following two carefully
gain0.setGain_dB(-25.0f); // Consider (-50.0f);
gain1.setGain_dB(-25.0f); // Consider (-50.0f);
sgtl5000_1.enable();
int16_t delaySize = 256; // Any power of 2, i.e., 256, 128, 64, etc.
compressor1.setDelayBufferSize(delaySize);
// *** Here are four sample compressor curves. ***
// Select by number here, and re-compile.
#define COMPRESSOR_CURVE 1
#if COMPRESSOR_CURVE == 1
// Specify arbitrary 5-segment compression curve. An example of specifying
// compressionCurve. See AudioEffectCompressor2_F32.h for more details.
struct compressionCurve crv = { -2.0f, 0.0f, // margin, offset
{0.0f, -10.0f, -20.0f, -30.0f, -1000.0f}, // kneeDB[]
{ 100.0f, 2.5f, 1.5f, 1.0f, 1.0f} }; // compressionRatio
compressor1.setCompressionCurve(&crv);
compressor1.begin();
#endif
AudioEffectCompressor2_F32 *pc1 = &compressor1; // Needed for any *macro* defined curve.
// Defines pointer to compressor1, called pc1
#if COMPRESSOR_CURVE == 2
// Sample of a limiter at -3 dB out for highest 15 dB, limiter macro
limiterBegin(pc1, -3.0f, -15.0f); // pc1 is a pointer to compressor1 object
#elif COMPRESSOR_CURVE == 3
// Another one, a basic compressor curve:
// (pobject, linearInDB, compressionRatioDB) <- macro parameters
basicCompressorBegin(pc1, -25.0f, 2.0);
#elif COMPRESSOR_CURVE == 4
// And one using a high gain region as a squelch (but no clicks or pops)
// (squelchIndB, linearInDB, compressionIndB, compressionRatioDB) <- macro parameters
squelchCompressorBegin(pc1, -40.0f, -25.0f, -10.0f, 1.5f);
#endif
}
void loop(void)
{
static uint16_t kk;
#if SIGNAL_SOURCE == RANDOM
/* To give an audio signal with interest, we alter the frequency
* every 17 blocks (49 msec) and alter the level every 27 b;ocks
* (78.4 msec) The pattern keeps changing to be more interesting
* Janet thinks it is aliens. */
delay(3);
// Serial.print(" CurInDB= "); Serial.print( compressor1.getCurrentInputDB(), 3);
// Serial.print(" CurrentGainDB= "); Serial.println( compressor1.getCurrentGainDB(), 3);
// Serial.print("Maximum Input = "); Serial.println(compressor1.getvInMaxDB());
if(count17++ == 17)
{
// Put a delay in, like between words
if(randUniform() < 0.03)
delay( (int)(1500.0*randUniform()) );
count17 = 0;
float ff = 350.0f + 700.0f*sqrtf( randUniform() );
sine1.frequency(ff); //Serial.println(ff);
}
if(count27++ == 27)
{
count27 = 0;
level = 1.0f*powf( randUniform(), 2 ); // 0 to 1, emphasizing 0 end
sine1.amplitude(level);
}
#elif SIGNAL_SOURCE == POWER_SWEEP
if(count17++ == 17)
{
count17 = 0;
level *= 1.0592537f; // 0.5 dB
delay(200);
if(level > 1.0f)
{
level=0.001f;
delay(500);
}
Serial.print( compressor1.getCurrentInputDB(), 3);
Serial.print(","); Serial.println( compressor1.getCurrentGainDB(), 3);
sine1.amplitude(level);
}
#elif SIGNAL_SOURCE == PULSE
// A pulse, repeats every 3 minutes or so
delay(3);
if(count17 == 5) sine1.amplitude(0.0f); // Settling
else if(count17 == 498) compressor1.printOn(true); //record it
else if(count17 == 500) sine1.amplitude(0.03f);
else if(count17 == 510) sine1.amplitude(0.0f);
else if(count17 == 700) compressor1.printOn(false);
// or build your own transient test pulse here
count17++;
#endif
}
/* randUniform() - Returns random number, uniform on (0, 1)
* The "Even Quicker" uniform random sample generator from D. E. Knuth and
* H. W. Lewis and described in Chapter 7 of "Numerical Receipes in C",
* 2nd ed, with the comment "this is about as good as any 32-bit linear
* congruential generator, entirely adequate for many uses."
*/
#define FL_ONE 0X3F800000
#define FL_MASK 0X007FFFFF
float randUniform(void)
{
static uint32_t idum = 12345;
union {
uint32_t i32;
float f32;
} uinf;
idum = (uint32_t)1664525 * idum + (uint32_t)1013904223;
// return (*(float *)&it); // Cute convert to float but gets compiler warning
uinf.i32 = FL_ONE | (FL_MASK & idum); // So do the same thing with a union
return uinf.f32 - 1.0f;
}
Write Preview
Loading…
Cancel
Save