Commit 32fecd7b authored by henryjandrew's avatar henryjandrew
Browse files

progress on yulewalk -not finished

parent 3d611fbb
......@@ -43,6 +43,14 @@ namespace ITADSP
ITA_DSP_API float InnerProduct(const float *x, const float *y, const int length);
ITA_DSP_API void numf();
ITA_DSP_API void denf( float *A, const ITASampleBuffer& R, int na );
ITA_DSP_API void toeplitz(float **out, const ITASampleBuffer &row, const ITASampleBuffer &column);
ITA_DSP_API void toeplitz(float **out, const ITASampleBuffer &in, int na);
}
}
......
......@@ -62,7 +62,7 @@ public:
void SetDumpFilename( const std::string& sFilename );
// Filter erzeugen
void GenerateFilter( const ITABase::CThirdOctaveGainMagnitudeSpectrum& oTOMagnitudes, float* pfFilterCoeffs );
void GenerateFilter( const ITABase::CThirdOctaveGainMagnitudeSpectrum& oTOMagnitudes, float* pfFilterCoeffs, bool bMinimumPhase = false);
private:
double m_dSamplerate; // Abtastrate der Ausgabefilter [Hz]
......
#include <ITAIIRFilterGenerator.h>
#include <ITAException.h>
#include <ITAConstants.h>
#include <algorithm>
#include <iostream>
void ITADSP::IIRFilterGenerator::Yulewalk( const ITABase::CFiniteImpulseResponse& oIR, CIIRCoefficients& oCoeffs )
{
// a bit inefficient ...
//oCoeffs.InitializeOrder( oCoeffs.uiOrder );
ITA_EXCEPT_NOT_IMPLEMENTED;
int na = oCoeffs.vfDenominator.size();
int n = oIR.GetLength();
int n2 = floor((n + 1) / 2);
int nb = na;
int nr = 4 * na;
//nt = 0:nr-1
//pick nr coefficients
ITASampleBuffer R(nr, false);
for (int i = 0; i < nr; i++)
R.GetData()[i] = oIR.GetData()[i] * (0.54 + 0.46*cos(ITAConstants::PI_F*i/(nr-1)));
//window used t extract right wing of two sided covaianc sequence
ITASampleBuffer Rwindow(n, true);
Rwindow[0] = 0.5f;
for (int i = 1; i <= n2; i++ )
Rwindow[i] = 1.0f;
//find roots of
float *A = new float(oCoeffs.vfDenominator.size());
denf( A, R, na );
}
void ITADSP::IIRFilterGenerator::denf(float *A, const ITASampleBuffer& R, int na) {
//output coefficients A of length na + 1, input vector R, and order na
float **out;
out = new float*[R.GetLength() - na - 1];
for (int i = 0; i < R.GetLength() - na - 1; i++) {
out[i] = new float[na];
}
toeplitz( out, R, na);
for (int i = 0; i < R.GetLength() - na - 1; i++) {
for (int j = 0; j < na; j++) {
std::cout << out[i][j] << '\t';
}
std::cout << '\n';
}
}
void ITADSP::IIRFilterGenerator::toeplitz(float **out, const ITASampleBuffer &row, const ITASampleBuffer &column) {
//return a toeplitz matrix out constructed from input vectors row and column
//initialise 2d array out to size [column][row]
out = new float*[column.GetLength()];
for (int i = 0; i < column.GetLength(); i++) {
out[i] = new float[row.GetLength()];
}
int test = std::min(row.GetLength(), column.GetLength());
//set the upper diagonal (excluding leading edge)
for (int i = 1; i < row.GetLength(); i++) {
for( int j=0; j<test-i; j++ )
out[j][j+i] = row[i];
}
//set lower diagonal (including leading edge)
for (int i = 0; i < column.GetLength(); i++) {
for (int j = 0; j < test-i; j++)
out[j+i][j] = column[i];
}
return;
}
void ITADSP::IIRFilterGenerator::toeplitz(float **out, const ITASampleBuffer &in, int na) {
//return a toeplitz matrix out constructed from input vectors row and column
/*
//initialise 2d array out to size [in.GetLength()-na-1][na]
out = new float*[in.GetLength() - na - 1];
for (int i = 0; i < in.GetLength() - na - 1; i++) {
out[i] = new float[na];
}
*/
//set the upper diagonal (excluding leading edge)
for (int i = 1; i < na; i++) {
for (int j = 0; j < na - i; j++)
out[j][j + i] = in[na-i];
}
//set lower diagonal (including leading edge)
for (int i = 0; i < in.GetLength()-na-1; i++) {
for (int j = 0; j < na - i; j++)
out[j + i][j] = in[na+i-1];
}
return;
}
void ITADSP::IIRFilterGenerator::Burg(const ITABase::CFiniteImpulseResponse& oIR, CIIRCoefficients& oCoeffs) {
//oIR -> targe impulse response -> x, filter order = oCoeffs.uiOrder -> p
......
......@@ -80,62 +80,80 @@ void CITAThirdOctaveFIRFilterGenerator::SetDumpFilename( const std::string& sFil
m_sDumpFilename = sFilename;
}
void CITAThirdOctaveFIRFilterGenerator::GenerateFilter( const ITABase::CThirdOctaveGainMagnitudeSpectrum& oTOGainMagnitudes, float* pfFilterCoeffs )
void CITAThirdOctaveFIRFilterGenerator::GenerateFilter(const ITABase::CThirdOctaveGainMagnitudeSpectrum& oTOGainMagnitudes, float* pfFilterCoeffs, bool bMinimumPhase /*=false*/)
{
m_sw.start();
if( oTOGainMagnitudes.IsZero() )
if (oTOGainMagnitudes.IsZero())
{
for( int i = 0; i < m_iFilterLength; i++ )
pfFilterCoeffs[ i ] = 0.0f;
for (int i = 0; i < m_iFilterLength; i++)
pfFilterCoeffs[i] = 0.0f;
return;
}
if( oTOGainMagnitudes.IsIdentity() )
if (oTOGainMagnitudes.IsIdentity())
{
for( int i = 0; i < m_iFilterLength; i++ )
pfFilterCoeffs[ i ] = 0.0f;
pfFilterCoeffs[ int( m_iFilterLength / 2 ) ] = 1.0f;
for (int i = 0; i < m_iFilterLength; i++)
pfFilterCoeffs[i] = 0.0f;
pfFilterCoeffs[int(m_iFilterLength / 2)] = 1.0f;
return;
}
// 1st step: Interpolate the magnitudes
m_pfInputData[ 0 ] = 1.0f;
for( int i = 0; i < CThirdOctaveGainMagnitudeSpectrum::GetNumBands(); i++ )
m_pfInputData[ 1 + i ] = float( oTOGainMagnitudes[ i ] );
m_pfInputData[ m_iInputFreqs - 1 ] = 0.0f; // @todo jst: check if this is good
m_pfInputData[0] = 1.0f;
for (int i = 0; i < CThirdOctaveGainMagnitudeSpectrum::GetNumBands(); i++)
m_pfInputData[1 + i] = float(oTOGainMagnitudes[i]);
m_pfInputData[m_iInputFreqs - 1] = 0.0f; // @todo jst: check if this is good
// Initialize cubic spline interpolation
m_ypp = spline_cubic_set( m_iInputFreqs,
m_ypp = spline_cubic_set(m_iInputFreqs,
m_pfInputFreqs,
m_pfInputData,
1, // Left boundary condition => 1st derivative m=0
0,
1, // Right boundary condition => 1st derivative m=0
0 );
0);
float fDummy;
const float fScale = 1 / ( float ) m_iFilterLength;
const float fScale = 1 / (float)m_iFilterLength;
// No DC offset, ever!
m_pfBuf1[ 0 ] = 0;
m_pfBuf1[ 1 ] = 0;
for( int i = 1; i < m_iDFTCoeffs; i++ )
{
float x = spline_cubic_val( m_iInputFreqs,
m_pfInputFreqs,
i*m_fDeltaF,
m_pfInputData,
m_ypp,
&fDummy,
&fDummy );
// Phase-shift by half the FFT-period: Negate all odd DFT coefficients
m_pfBuf1[ 2 * i ] = ( ( i % 2 ) == 0 ) ? x*fScale : -x*fScale;
m_pfBuf1[ 2 * i + 1 ] = 0;
m_pfBuf1[0] = 0;
m_pfBuf1[1] = 0;
if (bMinimumPhase) {
for (int i = 1; i < m_iDFTCoeffs; i++)
{
float x = spline_cubic_val(m_iInputFreqs,
m_pfInputFreqs,
i*m_fDeltaF,
m_pfInputData,
m_ypp,
&fDummy,
&fDummy);
// Phase-shift by half the FFT-period
m_pfBuf1[2 * i] = pow( x * fScale, 2 ) * m_iFilterLength; //minimum phase
m_pfBuf1[2 * i + 1] = 0;
}
}
else {
for (int i = 1; i < m_iDFTCoeffs; i++)
{
float x = spline_cubic_val(m_iInputFreqs,
m_pfInputFreqs,
i*m_fDeltaF,
m_pfInputData,
m_ypp,
&fDummy,
&fDummy);
// Phase-shift by half the FFT-period: Negate all odd DFT coefficients
m_pfBuf1[2 * i] = ((i % 2) == 0) ? x * fScale : -x * fScale;
m_pfBuf1[2 * i + 1] = 0;
}
}
// 2nd step: Convert into time-domain (out-of-place C2R-IFFT)
m_ifft.execute();
......
......@@ -16,11 +16,19 @@
*
*/
#include <ITAStringUtils.h>
#include <ITAStreamFunctionGenerator.h>
#include <ITAFileDataSource.h>
#include <ITAStreamInfo.h>
#include <math.h>
#include <vector>
#include <ITAIIRFilterGenerator.h>
#include <ITAIIRCoefficients.h>
#include <ITAIIRUtils.h>
#include <ITAIIRFilterEngine.h>
#include <ITASIMOVariableDelayLine.h>
#include <ITAAudiofileWriter.h>
#include <ITAStringUtils.h>
......@@ -38,8 +46,24 @@ using namespace std;
const float g_fSampleRate = 44100;
void VDLIIRTest();
//absorption filter
vector<float> abs_Magnitudes = { 0.02f,0.02f,0.02f,0.0233333f,0.0266667f,0.03f,0.03f,0.03f,0.03f,0.03f,0.03f,0.03f,0.03f,0.03f,0.03f,0.0333333f,0.0366667f,0.04f,0.0433333f,0.0466667f,0.05f,0.0566667f,0.0633333f,0.07f,0.07f,0.07f,0.07f,0.0733333f,0.0766667f,0.08f,0.08f };
//trumpet directivity
vector<float> trump_Magnitudes = { 0.860280990600586f, 0.860280632972717f, 0.860280632972717f, 0.860280632972717f, 0.860280632972717f, 0.860280632972717f, 0.860280632972717f, 0.860280692577362f, 0.860280692577362f, 0.863133668899536f, 0.752475023269653f, 0.674751520156860f, 0.499466955661774f, 0.738280415534973f, 0.653443872928619f, 0.507191777229309f, 0.533296763896942f, 0.503476321697235f, 0.376767426729202f, 0.353374809026718f, 0.269741356372833f, 0.207140043377876f, 0.153062343597412f, 0.112099960446358f, 0.127615734934807f, 0.0946486070752144f, 0.0785422623157501f, 0.0600289255380631f, 0.0488252453505993f, 0.0387985333800316f, 0.0315645076334477f };
//diffracion filter
vector<float> diff_Magnitudes = {0.111934553579764f, 0.106460935614618f, 0.100699704548526f, 0.0947001721104573f, 0.0890866491204974f, 0.0835569704783756f, 0.0775507540050590f, 0.0722382340567499f, 0.0670519961369095f, 0.0621838133597414f, 0.0565935658858452f, 0.0519303873398500f, 0.0473436952392266f, 0.0428843783633814f, 0.0389753239378729f, 0.0351914143864374f, 0.0315689677042525f, 0.0284535398945892f, 0.0255957249048243f, 0.0227266136854582f, 0.0203857703689526f, 0.0182702796747406f, 0.0162996829305633f, 0.0144787461518097f, 0.0129580533457382f, 0.0115033291355433f, 0.0102513560003608f, 0.00917063160436257f, 0.00820336236165088f, 0.00725137721071123f, 0.00648611579946720f };
int main(int, char**)
{
VDLIIRTest();
return 255;
//Load an target impulse response from file (oIR)
ITABase::CFiniteImpulseResponse oIR;
float fSampleRate;
......@@ -53,14 +77,11 @@ int main(int, char**)
CITAThirdOctaveFIRFilterGenerator oIRGenerator(oIR2.GetSampleRate(), oIR2.GetLength());
ITABase::CThirdOctaveGainMagnitudeSpectrum oMags;
oMags.SetMagnitudes(abs_Magnitudes);
//oMags.SetIdentity();
vector<float> Magnitudes = { 0.02f,0.02f,0.02f,0.0233333f,0.0266667f,0.03f,0.03f,0.03f,0.03f,0.03f,0.03f,0.03f,0.03f,0.03f,0.03f,0.0333333f,0.0366667f,0.04f,0.0433333f,0.0466667f,0.05f,0.0566667f,0.0633333f,0.07f,0.07f,0.07f,0.07f,0.0733333f,0.0766667f,0.08f,0.08f };
//vector<float> Magnitudes = {0.111934553579764f, 0.106460935614618f, 0.100699704548526f, 0.0947001721104573f, 0.0890866491204974f, 0.0835569704783756f, 0.0775507540050590f, 0.0722382340567499f, 0.0670519961369095f, 0.0621838133597414f, 0.0565935658858452f, 0.0519303873398500f, 0.0473436952392266f, 0.0428843783633814f, 0.0389753239378729f, 0.0351914143864374f, 0.0315689677042525f, 0.0284535398945892f, 0.0255957249048243f, 0.0227266136854582f, 0.0203857703689526f, 0.0182702796747406f, 0.0162996829305633f, 0.0144787461518097f, 0.0129580533457382f, 0.0115033291355433f, 0.0102513560003608f, 0.00917063160436257f, 0.00820336236165088f, 0.00725137721071123f, 0.00648611579946720f };
oMags.SetMagnitudes(Magnitudes);
//oMags.SetIdentity();
//oMags.SetZero();
oIRGenerator.GenerateFilter( oMags, oIR2.GetData() );
oIRGenerator.GenerateFilter( oMags, oIR2.GetData(), true );
/*
//Generate filter from magnitude response using yule-walker method
......@@ -68,30 +89,44 @@ int main(int, char**)
ITADSP::IIRFilterGenerator::Yulewalk( oIR, oYulewalkCoeffs );
*/
CITAIIRFilterEngine oIIRFilterEngine(filter_order); //create an IIR filter
//ITASampleBuffer pfIn;
//pfIn.Load("WelcomeToVA.wav", fSampleRate);
ITASampleBuffer pfIn(1024, true);
pfIn.GetData()[0] = 1.0f; //impulse
ITASampleBuffer pfOut(pfIn.GetLength());
/*
//Generate filter using the Burg method
ITADSP::CIIRCoefficients oBurgCoeffs( filter_order, false );
ITAStopWatch sw;
sw.start();
sw.start(); //start timing
ITADSP::IIRFilterGenerator::Burg( oIR2, oBurgCoeffs );
cout << timeToString( sw.stop() ) << endl << endl;
//cout << timeToString( sw.stop() ) << endl << endl;
CITAIIRFilterEngine oIIRFilterEngine(filter_order); //create an IIR filter
oIIRFilterEngine.SetCoefficients(oBurgCoeffs); //set filter coefficients to those calculated with Burg
ITASampleBuffer pfIn;
pfIn.Load("WelcomeToVA.wav", fSampleRate);
ITASampleBuffer pfOut(pfIn.GetLength());
oIIRFilterEngine.Process(pfIn.GetData(), pfOut.GetData(), pfIn.GetLength()); //apply the filter to an input signal
writeAudiofile("WelcomeToVA_filtered_burg_filter.wav", &pfOut, fSampleRate);
cout << timeToString(sw.stop()) << endl << endl; //stop timing
*/
ITADSP::CIIRCoefficients oYuleCoeffs;
ITADSP::IIRFilterGenerator::Yulewalk(oIR2, oYuleCoeffs);
//writeAudiofile("WelcomeToVA_filtered_burg_trumpet.wav", &pfOut, fSampleRate);
//--------------------------------------------------------Output data------------------------------------------------------------------
/*
//Display output data in console
cout << "Gain: " << oBurgCoeffs.vfNumerator[0] << endl << endl << "Denominators:" << endl;
//writeAudiofile("Generated_IR_out_utd.wav", &oIR2, fSampleRate);
//writeAudiofile("Generated_IR_out_absorption_minphase.wav", &oIR2, fSampleRate);
for( int i=0; i<= oBurgCoeffs.uiOrder; i++ )
cout << oBurgCoeffs.vfDenominator[i] << endl;
......@@ -99,6 +134,171 @@ int main(int, char**)
#ifdef WITH_JSON_SUPPORT //export generated coefficients as json file
ITADSP::ExportIIRCoefficientsToJSON( "ITADSPIIRFilterGeneratorTest_burg_coeffs.json", oBurgCoeffs );
#endif
*/
return 255;
}
void VDLIIRTest()
{
//input parameters
const unsigned int iBlockLength = 128;
const double dSampleRate = 44.1e3;
const float fMaxReservedDelaySamples = 5 * iBlockLength;
const float fSimulateSeconds = 10;
const string sInFilePath = "IIR_SIMOVDL_in.wav"; //file where the input stream to the VDL is written
const string sOutFilePath = "IIR_SIMOVDL_out.wav"; //file where the data read by the output cursors of the VDL is written
//-----
ITAStreamFunctionGenerator sinesignal(1, dSampleRate, iBlockLength, ITAStreamFunctionGenerator::SINE, 500.0f, 0.9f, true);
//ITAFileDatasource filesignal( "cl-mod-bb-piece-32.wav", iBlockLength, true );
ITADatasource* pIntputStream = &sinesignal;
CITASIMOVariableDelayLine* pSIMOVDL = new CITASIMOVariableDelayLine(dSampleRate, iBlockLength, fMaxReservedDelaySamples, CITASIMOVariableDelayLine::CUBIC_SPLINE_INTERPOLATION);
double dSamplerate = dSampleRate;
unsigned int uiBlocklength = iBlockLength;
unsigned int uiNumberOfFrames = (unsigned int)std::ceil(dSamplerate * fSimulateSeconds / (float)uiBlocklength);
int iCursor0 = pSIMOVDL->AddCursor(); //create read cursors for the vdl
pSIMOVDL->SetDelaySamples(iCursor0, .0f); //set how many samples the cursor is delayed by from the write cursor
int iCursor1 = pSIMOVDL->AddCursor();
pSIMOVDL->SetDelaySamples(iCursor1, 11.0f);
int iCursor2 = pSIMOVDL->AddCursor();
pSIMOVDL->SetDelaySamples(iCursor2, float(uiBlocklength * 2));
int iCursor3 = pSIMOVDL->AddCursor();
pSIMOVDL->SetDelaySamples(iCursor3, float(uiBlocklength * 3));
ITAAudiofileProperties props_in;
props_in.iChannels = 1;
props_in.dSampleRate = dSamplerate;
props_in.eQuantization = ITAQuantization::ITA_FLOAT;
props_in.eDomain = ITADomain::ITA_TIME_DOMAIN;
props_in.iLength = uiNumberOfFrames * uiBlocklength;
ITAAudiofileWriter* writer_in = ITAAudiofileWriter::create(sInFilePath, props_in);
ITAAudiofileProperties props_out(props_in);
props_out.iChannels = pSIMOVDL->GetNumCursors(); //set number of channels for output data to 4 (number of read cursors on VDL)
ITAAudiofileWriter* writer_out = ITAAudiofileWriter::create(sOutFilePath, props_out);
ITAStreamInfo oState;
ITASampleBuffer* psbInput = new ITASampleBuffer(uiBlocklength, true);
ITASampleFrame* psfOutput = new ITASampleFrame(pSIMOVDL->GetNumCursors(), uiBlocklength, true);
ITASampleFrame* psfOut_IIR = new ITASampleFrame(pSIMOVDL->GetNumCursors(), uiBlocklength, true);
//-----------------set up filters---------------------------
int filter_order = 4;
int filter_length = 1024;
ITABase::CThirdOctaveGainMagnitudeSpectrum oMags1; //set magnitude responses
oMags1.SetMagnitudes(abs_Magnitudes);
ITABase::CThirdOctaveGainMagnitudeSpectrum oMags2;
oMags2.SetMagnitudes(trump_Magnitudes);
ITABase::CThirdOctaveGainMagnitudeSpectrum oMags3;
oMags3.SetMagnitudes(diff_Magnitudes);
ITABase::CThirdOctaveGainMagnitudeSpectrum oMags4;
oMags4.SetIdentity();
CITAThirdOctaveFIRFilterGenerator oIRGenerator(g_fSampleRate, filter_length); //create FIR filter generator, used to transform freq response to IR
ITABase::CFiniteImpulseResponse oIR1(filter_length, g_fSampleRate); //create empty IR
oIRGenerator.GenerateFilter(oMags1, oIR1.GetData(), false); //generate IR from magnitude response
ITABase::CFiniteImpulseResponse oIR2(filter_length, g_fSampleRate);
oIRGenerator.GenerateFilter(oMags2, oIR2.GetData(), false);
ITABase::CFiniteImpulseResponse oIR3(filter_length, g_fSampleRate);
oIRGenerator.GenerateFilter(oMags3, oIR3.GetData(), false);
ITABase::CFiniteImpulseResponse oIR4(filter_length, g_fSampleRate);
oIRGenerator.GenerateFilter(oMags4, oIR4.GetData(), false);
CITAIIRFilterEngine oIIRFilterEngine1(filter_order); //create an IIR filter
ITADSP::CIIRCoefficients oFilterCoeffs1(filter_order, false);
ITADSP::IIRFilterGenerator::Burg(oIR1, oFilterCoeffs1);
oIIRFilterEngine1.SetCoefficients(oFilterCoeffs1); //set filter coefficients to those calculated with Burg
CITAIIRFilterEngine oIIRFilterEngine2(filter_order); //create an IIR filter
ITADSP::CIIRCoefficients oFilterCoeffs2(filter_order, false);
ITADSP::IIRFilterGenerator::Burg(oIR2, oFilterCoeffs2);
oIIRFilterEngine2.SetCoefficients(oFilterCoeffs2); //set filter coefficients to those calculated with Burg
CITAIIRFilterEngine oIIRFilterEngine3(filter_order); //create an IIR filter
ITADSP::CIIRCoefficients oFilterCoeffs3(filter_order, false);
ITADSP::IIRFilterGenerator::Burg(oIR3, oFilterCoeffs3);
oIIRFilterEngine3.SetCoefficients(oFilterCoeffs3); //set filter coefficients to those calculated with Burg
CITAIIRFilterEngine oIIRFilterEngine4(filter_order); //create an IIR filter
ITADSP::CIIRCoefficients oFilterCoeffs4(filter_order, false);
ITADSP::IIRFilterGenerator::Burg(oIR4, oFilterCoeffs4);
oIIRFilterEngine4.SetCoefficients(oFilterCoeffs4); //set filter coefficients to those calculated with Burg
//-----------begin
cout << "Input file: " << sInFilePath << endl;
cout << "Processing ";
unsigned int n = 0;
while (n < uiNumberOfFrames)
{
// Add new samples
psbInput->write(pIntputStream->GetBlockPointer(0, &oState), uiBlocklength); //set the data for a samplebuffer = the next bit of a sine wave
pSIMOVDL->WriteBlock(psbInput); //write the samplebuffer length blocksize to the VDL
pSIMOVDL->ReadBlockAndIncrement(psfOutput); //read VDL and increment cursor positions
//--------------------------apply filters
oIIRFilterEngine1.Process((*psfOutput)[0].GetData(), (*psfOut_IIR)[0].GetData(), uiBlocklength); //apply the filter to an input signal
oIIRFilterEngine2.Process((*psfOutput)[1].GetData(), (*psfOut_IIR)[1].GetData(), uiBlocklength); //apply the filter to an input signal
oIIRFilterEngine3.Process((*psfOutput)[2].GetData(), (*psfOut_IIR)[2].GetData(), uiBlocklength); //apply the filter to an input signal
oIIRFilterEngine4.Process((*psfOutput)[3].GetData(), (*psfOut_IIR)[3].GetData(), uiBlocklength); //apply the filter to an input signal
//ITASampleBuffer &test = (*psfOutput)[0];
//--------------------------------------
std::vector< float* > pIn;
pIn.push_back(psbInput->data()); //adds the data written on the VDL to the end of pIn
writer_in->write(uiBlocklength, pIn); //write pIn
//writer_out->write(psfOutput, uiBlocklength); //write the outputs of the VDL
writer_out->write(psfOut_IIR, uiBlocklength); //write the outputs of the VDL
n++;
pIntputStream->IncrementBlockPointer(); //increment the input stream to the VDL
if (n % (uiNumberOfFrames / 40) == 0) //show progress
cout << ".";
}
cout << " done." << endl;
cout << "Output file: " << sOutFilePath << endl;
delete writer_in;
delete writer_out;
delete psbInput;
delete psfOutput;
return;
}
Markdown is supported
0% or .
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment