// PCMVolumeMaximizer.cpp: implementation of the PCMVolumeMaximizer class.
|
//
|
//////////////////////////////////////////////////////////////////////
|
|
#include <math.h>
|
|
#include "PCMVolumeMaximizer.h"
|
#include "AudioSample.h"
|
#include "Exception.h"
|
|
//////////////////////////////////////////////////////////////////////
|
// Construction/Destruction
|
//////////////////////////////////////////////////////////////////////
|
|
PCMVolumeMaximizer::PCMVolumeMaximizer() : averageVolumeCalculator(&tracer)
|
{
|
char subFacilityName[100];
|
sprintf(subFacilityName, "PCMVolumeMaximizer:%x", this);
|
tracer.SetSubFacilityName(subFacilityName);
|
SetTraceLevel();
|
maximizePercentile = 100.0;
|
maximumAmplification = 100;
|
averageVolumeCalculator.SetCalculationInterval(100);
|
}
|
|
PCMVolumeMaximizer::~PCMVolumeMaximizer()
|
{
|
|
}
|
|
int
|
PCMVolumeMaximizer::TransformStarted()
|
{
|
averageVolumeCalculator.Reset();
|
return 0;
|
}
|
|
int
|
PCMVolumeMaximizer::SetTraceLevel()
|
{
|
long SystemMask = 0;
|
if ((SystemMask = GetRegKeyLong(HKEY_CURRENT_USER, "Software\\Cisco Systems\\MTC\\Tracing", "AllComponents", 0x0)) == 0)
|
{
|
SystemMask = GetRegKeyLong(HKEY_CURRENT_USER, "Software\\Cisco Systems\\MTC\\Tracing", "PCMVolumeMaximizer", 0x100000);
|
}
|
tracer.SetSystemMask(SystemMask);
|
return 0;
|
}
|
|
int
|
PCMVolumeMaximizer::SetMaximizePercentile(double percentile)
|
{
|
if (percentile < 0.0)
|
{
|
percentile = 0.0;
|
}
|
if (percentile > 100.0)
|
{
|
percentile = 100.0;
|
}
|
maximizePercentile = percentile;
|
return 0;
|
}
|
|
int
|
PCMVolumeMaximizer::SetMaximumAmplification(unsigned int amplification)
|
{
|
if (amplification < 100)
|
{
|
amplification = 100;
|
}
|
maximumAmplification = amplification;
|
return 0;
|
}
|
|
int
|
PCMVolumeMaximizer::TransformAudioSamples(std::vector<std::pair<AudioSample *, AudioSource *> > &data, AudioSample **ppAudioSample)
|
{
|
int result = 0;
|
AudioSample *inSample = NULL;
|
if (data.size() > 0)
|
{
|
inSample = data[0].first;
|
}
|
try
|
{
|
if (!inSample)
|
{
|
throw Exception(-10, "inSample = NULL");
|
}
|
if (inSample->DataSize() <= 0)
|
{
|
throw Exception(-20, "inSample->DataSize is %d\n", inSample->DataSize());
|
}
|
if (maximumAmplification <= 100)
|
{
|
throw Exception(0, "maximumAmplification is %d\n", maximumAmplification);
|
}
|
|
WAVEFORMATEX wfx;
|
inSample->GetFormat(&wfx);
|
|
int bytesPerSample(0);
|
int numSamples(0);
|
int numBytes = inSample->DataSize();
|
double maxValue(0.0);
|
|
switch(wfx.wBitsPerSample)
|
{
|
case 8:
|
bytesPerSample = 1;
|
maxValue = 127;
|
break;
|
case 16:
|
bytesPerSample = 2;
|
maxValue = 32767;
|
break;
|
case 32:
|
bytesPerSample = 4;
|
maxValue = pow(2.0, 31) - 1;
|
break;
|
default:
|
throw Exception(-30, "sample audioformat wBitsPerSample = %d", wfx.wBitsPerSample);
|
break;
|
}
|
|
numSamples = numBytes/bytesPerSample;
|
|
// make a histogram of the volume values
|
memset(bins, 0, sizeof(unsigned int) * NUM_BINS);
|
|
char *dataPtr = (char *)(inSample->Data());
|
for (int i=0; i<numSamples; i++)
|
{
|
double sampleValue(0.0);
|
switch(bytesPerSample)
|
{
|
case 1:
|
sampleValue = abs((double)(*((char *)(dataPtr + (bytesPerSample * i)))));
|
break;
|
case 2:
|
sampleValue = abs((double)(*((short *)(dataPtr + (bytesPerSample * i)))));
|
break;
|
case 4:
|
sampleValue = abs((double)(*((long *)(dataPtr + (bytesPerSample * i)))));
|
break;
|
}
|
int binNumber = 256 * (sampleValue / maxValue);
|
(bins[binNumber])++;
|
}
|
|
// now find how many bins are to be amplified
|
int total(0);
|
int numBinsToAmplify(0);
|
for (i=NUM_BINS-1; i>=0; i--)
|
{
|
total += bins[i];
|
double percentile = (double)(numSamples - total) / (double)numSamples * 100;
|
if (percentile >= maximizePercentile)
|
{
|
continue;
|
}
|
numBinsToAmplify = i+1;
|
break;
|
}
|
|
// find out maximum amplification possible
|
double amplification = (double)NUM_BINS / (double)numBinsToAmplify;
|
if (amplification > (maximumAmplification / 100.0))
|
{
|
amplification = maximumAmplification / 100.0;
|
}
|
|
averageVolumeCalculator.TakeNextValue(amplification);
|
|
tracer.tracef(DET, "TransformAudioSamples : amplifying by %.2f\n", amplification);
|
// now amplify the sample
|
for (i=0; i<numSamples; i++)
|
{
|
double sampleValue(0.0);
|
double newValue(0.0);
|
switch(bytesPerSample)
|
{
|
case 1:
|
sampleValue = (double)(*((char *)(dataPtr + (bytesPerSample * i))));
|
newValue = sampleValue * amplification;
|
if (newValue > maxValue)
|
{
|
newValue = maxValue;
|
}
|
if (newValue < -maxValue)
|
{
|
newValue = -maxValue;
|
}
|
*((char *)(dataPtr + (bytesPerSample * i))) = newValue;
|
break;
|
case 2:
|
sampleValue = (double)(*((short *)(dataPtr + (bytesPerSample * i))));
|
newValue = sampleValue * amplification;
|
if (newValue > maxValue)
|
{
|
newValue = maxValue;
|
}
|
if (newValue < -maxValue)
|
{
|
newValue = -maxValue;
|
}
|
*((short *)(dataPtr + (bytesPerSample * i))) = newValue;
|
break;
|
case 4:
|
sampleValue = (double)(*((long *)(dataPtr + (bytesPerSample * i))));
|
newValue = sampleValue * amplification;
|
if (newValue > maxValue)
|
{
|
newValue = maxValue;
|
}
|
if (newValue < -maxValue)
|
{
|
newValue = -maxValue;
|
}
|
*((long *)(dataPtr + (bytesPerSample * i))) = newValue;
|
break;
|
}
|
}
|
}
|
catch (Exception ex)
|
{
|
if (result < 0)
|
{
|
tracer.tracef(ERR, "TransformAudioSamples : error %d. %s\n", ex.ErrorCode(), ex.ErrorMessage());
|
}
|
else
|
{
|
tracer.tracef(DET, "TransformAudioSamples : error %d. %s\n", ex.ErrorCode(), ex.ErrorMessage());
|
}
|
result = ex.ErrorCode();
|
}
|
if (result == 0)
|
{
|
*ppAudioSample = inSample;
|
if (inSample)
|
{
|
inSample->AddRef(this);
|
}
|
}
|
return result;
|
}
|
