instrumentation error fixes (12a463d1) · Commits · IVAS Codec Public Collaboration / IVAS Codec

Workspace_msvc/lib_rend.vcxproj

+3 −3

Original line number	Diff line number	Diff line
		@@ -89,7 +89,7 @@
		</Midl>
		<ClCompile>
		<Optimization>Disabled</Optimization>
		<AdditionalIncludeDirectories>ivas_cldfb_trans_codec;..\lib_com;..\lib_debug;..\lib_dec;..\lib_enc;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
		<AdditionalIncludeDirectories>ivas_cldfb_trans_codec;..\lib_com;..\lib_debug;..\lib_dec;..\lib_enc;..\lib_util;..\lib_rend;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
		<PreprocessorDefinitions>_CRT_SECURE_NO_WARNINGS;$(Macros);WIN32;%(PreprocessorDefinitions)</PreprocessorDefinitions>
		<ExceptionHandling />
		<BasicRuntimeChecks>EnableFastChecks</BasicRuntimeChecks>
		@@ -126,7 +126,7 @@
		</Midl>
		<ClCompile>
		<Optimization>Disabled</Optimization>
		<AdditionalIncludeDirectories>ivas_cldfb_trans_codec;..\lib_com;..\lib_debug;..\lib_dec;..\lib_enc;..\lib_util;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
		<AdditionalIncludeDirectories>ivas_cldfb_trans_codec;..\lib_com;..\lib_debug;..\lib_dec;..\lib_enc;..\lib_util;..\lib_rend;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
		<PreprocessorDefinitions>_CRT_SECURE_NO_WARNINGS;$(Macros);WIN32;%(PreprocessorDefinitions)</PreprocessorDefinitions>
		<ExceptionHandling>
		</ExceptionHandling>
		@@ -169,7 +169,7 @@
		<FavorSizeOrSpeed>Neither</FavorSizeOrSpeed>
		<OmitFramePointers>false</OmitFramePointers>
		<EnableFiberSafeOptimizations>false</EnableFiberSafeOptimizations>
		<AdditionalIncludeDirectories>ivas_cldfb_trans_codec;..\lib_com;..\lib_debug;..\lib_dec;..\lib_enc;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
		<AdditionalIncludeDirectories>ivas_cldfb_trans_codec;..\lib_com;..\lib_debug;..\lib_dec;..\lib_enc;..\lib_util;..\lib_rend;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
		<PreprocessorDefinitions>_CRT_SECURE_NO_WARNINGS;$(Macros);WIN32;%(PreprocessorDefinitions)</PreprocessorDefinitions>
		<StringPooling>true</StringPooling>
		<ExceptionHandling />

lib_rend/ivas_cldfb_trans_codec/CQMFDecoder.c

+61 −59

Original line number	Diff line number	Diff line
		@@ -5,6 +5,8 @@
		#include <stdlib.h>
		#include <assert.h>
		#include "Tables.h"
		#include "options.h"
		#include "prot.h"
		#include "wmops.h"
		#include "PerceptualModel.h"
		#include "RMSEnvDeltaHuff.h"
		@@ -54,7 +56,7 @@ CQMFDecoder* CreateCQMFDecoder(const int iSampleRate,

		assert(iSampleRate == 48000); //Fix

		psCQMFDecoder = (CQMFDecoder*)malloc(sizeof(CQMFDecoder));
		psCQMFDecoder = (CQMFDecoder*)count_malloc(sizeof(CQMFDecoder));
		psCQMFDecoder->iSampleRate = iSampleRate;
		psCQMFDecoder->iChannels = iChannels;
		psCQMFDecoder->iNumBlocks = CQMF_BLOCKS_PER_FRAME;
		@@ -64,42 +66,42 @@ CQMFDecoder* CreateCQMFDecoder(const int iSampleRate,
		psCQMFDecoder->piBandwidths = c_aiBandwidths48; //Fix

		psCQMFDecoder->iMSMode = 0;
		psCQMFDecoder->piMSFlags = (int)malloc(MAX_BANDS sizeof(int));
		psCQMFDecoder->piMSFlags = (int)count_malloc(MAX_BANDS sizeof(int));

		psCQMFDecoder->iCommonGrouping = 1; // Common grouping always on only impacts stereo
		psCQMFDecoder->piNumGroups = (int)malloc(psCQMFDecoder->iChannels sizeof(int));
		psCQMFDecoder->ppiGroupLengths = (int*)malloc(psCQMFDecoder->iChannels sizeof(int*));
		psCQMFDecoder->pppiRMSEnvelope = (int**)malloc(psCQMFDecoder->iChannels sizeof(int**));
		psCQMFDecoder->pppiSMR = (int**)malloc(psCQMFDecoder->iChannels sizeof(int**));
		psCQMFDecoder->pppiExcitation = (int**)malloc(psCQMFDecoder->iChannels sizeof(int**));
		psCQMFDecoder->pppiAlloc = (int**)malloc(psCQMFDecoder->iChannels sizeof(int**));

		psCQMFDecoder->pppiCQMFSignReal = (int**)malloc(psCQMFDecoder->iChannels sizeof(int**));
		psCQMFDecoder->pppiCQMFSignImag = (int**)malloc(psCQMFDecoder->iChannels sizeof(int**));
		psCQMFDecoder->pppiQCQMFReal = (int**)malloc(psCQMFDecoder->iChannels sizeof(int**));
		psCQMFDecoder->pppiQCQMFImag = (int**)malloc(psCQMFDecoder->iChannels sizeof(int**));
		psCQMFDecoder->piNumGroups = (int)count_malloc(psCQMFDecoder->iChannels sizeof(int));
		psCQMFDecoder->ppiGroupLengths = (int*)count_malloc(psCQMFDecoder->iChannels sizeof(int*));
		psCQMFDecoder->pppiRMSEnvelope = (int**)count_malloc(psCQMFDecoder->iChannels sizeof(int**));
		psCQMFDecoder->pppiSMR = (int**)count_malloc(psCQMFDecoder->iChannels sizeof(int**));
		psCQMFDecoder->pppiExcitation = (int**)count_malloc(psCQMFDecoder->iChannels sizeof(int**));
		psCQMFDecoder->pppiAlloc = (int**)count_malloc(psCQMFDecoder->iChannels sizeof(int**));

		psCQMFDecoder->pppiCQMFSignReal = (int**)count_malloc(psCQMFDecoder->iChannels sizeof(int**));
		psCQMFDecoder->pppiCQMFSignImag = (int**)count_malloc(psCQMFDecoder->iChannels sizeof(int**));
		psCQMFDecoder->pppiQCQMFReal = (int**)count_malloc(psCQMFDecoder->iChannels sizeof(int**));
		psCQMFDecoder->pppiQCQMFImag = (int**)count_malloc(psCQMFDecoder->iChannels sizeof(int**));
		for(n = 0; n < iChannels ; n ++){
		int k;
		psCQMFDecoder->ppiGroupLengths[n] = (int)malloc(CQMF_BLOCKS_PER_FRAME sizeof(int));
		psCQMFDecoder->pppiRMSEnvelope[n] = (int*)malloc(CQMF_BLOCKS_PER_FRAME sizeof(int*));
		psCQMFDecoder->pppiSMR[n] = (int*)malloc(CQMF_BLOCKS_PER_FRAME sizeof(int*));
		psCQMFDecoder->pppiExcitation[n] = (int*)malloc(CQMF_BLOCKS_PER_FRAME sizeof(int*));
		psCQMFDecoder->pppiAlloc[n] = (int*)malloc(CQMF_BLOCKS_PER_FRAME sizeof(int*));

		psCQMFDecoder->pppiCQMFSignReal[n] = (int*)malloc(CQMF_BLOCKS_PER_FRAME sizeof(int*));
		psCQMFDecoder->pppiCQMFSignImag[n] = (int*)malloc(CQMF_BLOCKS_PER_FRAME sizeof(int*));
		psCQMFDecoder->pppiQCQMFReal[n] = (int*)malloc(CQMF_BLOCKS_PER_FRAME sizeof(int*));
		psCQMFDecoder->pppiQCQMFImag[n] = (int*)malloc(CQMF_BLOCKS_PER_FRAME sizeof(int*));
		psCQMFDecoder->ppiGroupLengths[n] = (int)count_malloc(CQMF_BLOCKS_PER_FRAME sizeof(int));
		psCQMFDecoder->pppiRMSEnvelope[n] = (int*)count_malloc(CQMF_BLOCKS_PER_FRAME sizeof(int*));
		psCQMFDecoder->pppiSMR[n] = (int*)count_malloc(CQMF_BLOCKS_PER_FRAME sizeof(int*));
		psCQMFDecoder->pppiExcitation[n] = (int*)count_malloc(CQMF_BLOCKS_PER_FRAME sizeof(int*));
		psCQMFDecoder->pppiAlloc[n] = (int*)count_malloc(CQMF_BLOCKS_PER_FRAME sizeof(int*));

		psCQMFDecoder->pppiCQMFSignReal[n] = (int*)count_malloc(CQMF_BLOCKS_PER_FRAME sizeof(int*));
		psCQMFDecoder->pppiCQMFSignImag[n] = (int*)count_malloc(CQMF_BLOCKS_PER_FRAME sizeof(int*));
		psCQMFDecoder->pppiQCQMFReal[n] = (int*)count_malloc(CQMF_BLOCKS_PER_FRAME sizeof(int*));
		psCQMFDecoder->pppiQCQMFImag[n] = (int*)count_malloc(CQMF_BLOCKS_PER_FRAME sizeof(int*));
		for(k = 0; k < CQMF_BLOCKS_PER_FRAME; k ++){
		psCQMFDecoder->pppiRMSEnvelope[n][k] = (int)malloc(MAX_BANDS sizeof(int));
		psCQMFDecoder->pppiSMR[n][k] = (int)malloc(MAX_BANDS sizeof(int));
		psCQMFDecoder->pppiExcitation[n][k] = (int)malloc(MAX_BANDS sizeof(int));
		psCQMFDecoder->pppiAlloc[n][k] = (int)malloc(MAX_BANDS sizeof(int));
		psCQMFDecoder->pppiRMSEnvelope[n][k] = (int)count_malloc(MAX_BANDS sizeof(int));
		psCQMFDecoder->pppiSMR[n][k] = (int)count_malloc(MAX_BANDS sizeof(int));
		psCQMFDecoder->pppiExcitation[n][k] = (int)count_malloc(MAX_BANDS sizeof(int));
		psCQMFDecoder->pppiAlloc[n][k] = (int)count_malloc(MAX_BANDS sizeof(int));

		psCQMFDecoder->pppiCQMFSignReal[n][k] = (int)malloc(CQMF_BANDS sizeof(int));
		psCQMFDecoder->pppiCQMFSignImag[n][k] = (int)malloc(CQMF_BANDS sizeof(int));
		psCQMFDecoder->pppiQCQMFReal[n][k] = (int)malloc(CQMF_BANDS sizeof(int));
		psCQMFDecoder->pppiQCQMFImag[n][k] = (int)malloc(CQMF_BANDS sizeof(int));
		psCQMFDecoder->pppiCQMFSignReal[n][k] = (int)count_malloc(CQMF_BANDS sizeof(int));
		psCQMFDecoder->pppiCQMFSignImag[n][k] = (int)count_malloc(CQMF_BANDS sizeof(int));
		psCQMFDecoder->pppiQCQMFReal[n][k] = (int)count_malloc(CQMF_BANDS sizeof(int));
		psCQMFDecoder->pppiQCQMFImag[n][k] = (int)count_malloc(CQMF_BANDS sizeof(int));
		}
		}

		@@ -117,19 +119,19 @@ void DeleteCQMFDecoder(CQMFDecoder *psCQMFDecoder)
		if(psCQMFDecoder != NULL){

		if(psCQMFDecoder->piMSFlags != NULL){
		free(psCQMFDecoder->piMSFlags);
		count_free(psCQMFDecoder->piMSFlags);
		}

		if(psCQMFDecoder->piNumGroups != NULL){
		free(psCQMFDecoder->piNumGroups);
		count_free(psCQMFDecoder->piNumGroups);
		}

		if(psCQMFDecoder->ppiGroupLengths != NULL){
		int n;
		for(n = 0; n < psCQMFDecoder->iChannels; n ++){
		free(psCQMFDecoder->ppiGroupLengths[n]);
		count_free(psCQMFDecoder->ppiGroupLengths[n]);
		}
		free(psCQMFDecoder->ppiGroupLengths);
		count_free(psCQMFDecoder->ppiGroupLengths);
		}

		if(psCQMFDecoder->pppiRMSEnvelope != NULL){
		@@ -137,11 +139,11 @@ void DeleteCQMFDecoder(CQMFDecoder *psCQMFDecoder)
		for(n = 0; n < psCQMFDecoder->iChannels; n ++){
		int k;
		for(k = 0; k < CQMF_BLOCKS_PER_FRAME; k ++){
		free(psCQMFDecoder->pppiRMSEnvelope[n][k]);
		count_free(psCQMFDecoder->pppiRMSEnvelope[n][k]);
		}
		free(psCQMFDecoder->pppiRMSEnvelope[n]);
		count_free(psCQMFDecoder->pppiRMSEnvelope[n]);
		}
		free(psCQMFDecoder->pppiRMSEnvelope);
		count_free(psCQMFDecoder->pppiRMSEnvelope);
		}

		if(psCQMFDecoder->pppiSMR != NULL){
		@@ -149,11 +151,11 @@ void DeleteCQMFDecoder(CQMFDecoder *psCQMFDecoder)
		for(n = 0; n < psCQMFDecoder->iChannels; n ++){
		int k;
		for(k = 0; k < CQMF_BLOCKS_PER_FRAME; k ++){
		free(psCQMFDecoder->pppiSMR[n][k]);
		count_free(psCQMFDecoder->pppiSMR[n][k]);
		}
		free(psCQMFDecoder->pppiSMR[n]);
		count_free(psCQMFDecoder->pppiSMR[n]);
		}
		free(psCQMFDecoder->pppiSMR);
		count_free(psCQMFDecoder->pppiSMR);
		}

		if(psCQMFDecoder->pppiExcitation != NULL){
		@@ -161,11 +163,11 @@ void DeleteCQMFDecoder(CQMFDecoder *psCQMFDecoder)
		for(n = 0; n < psCQMFDecoder->iChannels; n ++){
		int k;
		for(k = 0; k < CQMF_BLOCKS_PER_FRAME; k ++){
		free(psCQMFDecoder->pppiExcitation[n][k]);
		count_free(psCQMFDecoder->pppiExcitation[n][k]);
		}
		free(psCQMFDecoder->pppiExcitation[n]);
		count_free(psCQMFDecoder->pppiExcitation[n]);
		}
		free(psCQMFDecoder->pppiExcitation);
		count_free(psCQMFDecoder->pppiExcitation);
		}

		if(psCQMFDecoder->pppiAlloc != NULL){
		@@ -173,11 +175,11 @@ void DeleteCQMFDecoder(CQMFDecoder *psCQMFDecoder)
		for(n = 0; n < psCQMFDecoder->iChannels; n ++){
		int k;
		for(k = 0; k < CQMF_BLOCKS_PER_FRAME; k ++){
		free(psCQMFDecoder->pppiAlloc[n][k]);
		count_free(psCQMFDecoder->pppiAlloc[n][k]);
		}
		free(psCQMFDecoder->pppiAlloc[n]);
		count_free(psCQMFDecoder->pppiAlloc[n]);
		}
		free(psCQMFDecoder->pppiAlloc);
		count_free(psCQMFDecoder->pppiAlloc);
		}

		if(psCQMFDecoder->pppiCQMFSignReal != NULL){
		@@ -185,11 +187,11 @@ void DeleteCQMFDecoder(CQMFDecoder *psCQMFDecoder)
		for(n = 0; n < psCQMFDecoder->iChannels; n ++){
		int k;
		for(k = 0; k < CQMF_BLOCKS_PER_FRAME; k ++){
		free(psCQMFDecoder->pppiCQMFSignReal[n][k]);
		count_free(psCQMFDecoder->pppiCQMFSignReal[n][k]);
		}
		free(psCQMFDecoder->pppiCQMFSignReal[n]);
		count_free(psCQMFDecoder->pppiCQMFSignReal[n]);
		}
		free(psCQMFDecoder->pppiCQMFSignReal);
		count_free(psCQMFDecoder->pppiCQMFSignReal);
		}

		if(psCQMFDecoder->pppiCQMFSignImag != NULL){
		@@ -197,11 +199,11 @@ void DeleteCQMFDecoder(CQMFDecoder *psCQMFDecoder)
		for(n = 0; n < psCQMFDecoder->iChannels; n ++){
		int k;
		for(k = 0; k < CQMF_BLOCKS_PER_FRAME; k ++){
		free(psCQMFDecoder->pppiCQMFSignImag[n][k]);
		count_free(psCQMFDecoder->pppiCQMFSignImag[n][k]);
		}
		free(psCQMFDecoder->pppiCQMFSignImag[n]);
		count_free(psCQMFDecoder->pppiCQMFSignImag[n]);
		}
		free(psCQMFDecoder->pppiCQMFSignImag);
		count_free(psCQMFDecoder->pppiCQMFSignImag);
		}

		if(psCQMFDecoder->pppiQCQMFReal != NULL){
		@@ -209,11 +211,11 @@ void DeleteCQMFDecoder(CQMFDecoder *psCQMFDecoder)
		for(n = 0; n < psCQMFDecoder->iChannels; n ++){
		int k;
		for(k = 0; k < CQMF_BLOCKS_PER_FRAME; k ++){
		free(psCQMFDecoder->pppiQCQMFReal[n][k]);
		count_free(psCQMFDecoder->pppiQCQMFReal[n][k]);
		}
		free(psCQMFDecoder->pppiQCQMFReal[n]);
		count_free(psCQMFDecoder->pppiQCQMFReal[n]);
		}
		free(psCQMFDecoder->pppiQCQMFReal);
		count_free(psCQMFDecoder->pppiQCQMFReal);
		}

		if(psCQMFDecoder->pppiQCQMFImag != NULL){
		@@ -221,11 +223,11 @@ void DeleteCQMFDecoder(CQMFDecoder *psCQMFDecoder)
		for(n = 0; n < psCQMFDecoder->iChannels; n ++){
		int k;
		for(k = 0; k < CQMF_BLOCKS_PER_FRAME; k ++){
		free(psCQMFDecoder->pppiQCQMFImag[n][k]);
		count_free(psCQMFDecoder->pppiQCQMFImag[n][k]);
		}
		free(psCQMFDecoder->pppiQCQMFImag[n]);
		count_free(psCQMFDecoder->pppiQCQMFImag[n]);
		}
		free(psCQMFDecoder->pppiQCQMFImag);
		count_free(psCQMFDecoder->pppiQCQMFImag);
		}

		if(psCQMFDecoder->psBSRead != NULL){
		@@ -236,7 +238,7 @@ void DeleteCQMFDecoder(CQMFDecoder *psCQMFDecoder)
		DeleteNoiseGen(psCQMFDecoder->psNoiseGen);
		}

		free(psCQMFDecoder);
		count_free(psCQMFDecoder);
		}
		}

lib_rend/ivas_cldfb_trans_codec/CQMFEncoder.c

+894 −773

File changed.

Preview size limit exceeded, changes collapsed.

lib_rend/ivas_cldfb_trans_codec/NoiseGen.c

+6 −4

Original line number	Diff line number	Diff line
		@@ -2,6 +2,8 @@
		#include <stdio.h>
		#include <stdlib.h>
		#include <math.h>
		#include "options.h"
		#include "prot.h"
		#include "wmops.h"

		NoiseGen* CreateNoiseGen()
		@@ -10,12 +12,12 @@ NoiseGen* CreateNoiseGen()

		NoiseGen *psNoiseGen = NULL;

		psNoiseGen = (NoiseGen*)malloc(sizeof(NoiseGen));
		psNoiseGen = (NoiseGen*)count_malloc(sizeof(NoiseGen));
		psNoiseGen->iNoiseBufferLength = 2048;
		psNoiseGen->iNoiseBufferMask = 2047;
		psNoiseGen->iNoiseBufferIndex = 0;

		psNoiseGen->pfNoiseBuffer = (float)malloc(psNoiseGen->iNoiseBufferLength sizeof(float));
		psNoiseGen->pfNoiseBuffer = (float)count_malloc(psNoiseGen->iNoiseBufferLength sizeof(float));

		/* Generate Laplacian distributed noise */
		for(n = 0; n < psNoiseGen->iNoiseBufferLength; n ++){
		@@ -38,8 +40,8 @@ NoiseGen* CreateNoiseGen()

		void DeleteNoiseGen(NoiseGen *psNoiseGen)
		{
		free(psNoiseGen->pfNoiseBuffer);
		free(psNoiseGen);
		count_free(psNoiseGen->pfNoiseBuffer);
		count_free(psNoiseGen);
		}

		extern float GetNoise(NoiseGen *psNoiseGen);

lib_rend/ivas_cldfb_trans_codec/RMSEnvGrouping.c

+21 −19

Original line number	Diff line number	Diff line
		@@ -6,6 +6,8 @@
		#include <math.h>
		#include <stdlib.h>
		#include <assert.h>
		#include "options.h"
		#include "prot.h"
		#include "wmops.h"
		#include "Tables.h"

		@@ -29,26 +31,26 @@ typedef struct RMS_ENVELOPE_GROUPING
		RMSEnvelopeGrouping* CreateRMSEnvelopeGrouping(int iNumBlocks)
		{
		int n;
		assert((iNumBlocks & 0x1) == 0); // remove this
		//assert((iNumBlocks & 0x1) == 0); // remove this

		RMSEnvelopeGrouping *psRMSEnvelopeGrouping;

		psRMSEnvelopeGrouping = (RMSEnvelopeGrouping*)malloc(sizeof(RMSEnvelopeGrouping));
		psRMSEnvelopeGrouping = (RMSEnvelopeGrouping*)count_malloc(sizeof(RMSEnvelopeGrouping));
		psRMSEnvelopeGrouping->iNumBlocks = iNumBlocks;
		psRMSEnvelopeGrouping->iMaxGroups = iNumBlocks >> 1; // Change this

		psRMSEnvelopeGrouping->ppfBandEnergy = (float*)malloc(psRMSEnvelopeGrouping->iNumBlocks sizeof(float*));
		psRMSEnvelopeGrouping->ppfBandEnergydB = (float*)malloc(psRMSEnvelopeGrouping->iNumBlocks sizeof(float*));
		psRMSEnvelopeGrouping->ppfWeight = (float*)malloc(psRMSEnvelopeGrouping->iNumBlocks sizeof(float*));
		psRMSEnvelopeGrouping->ppfBandEnergy = (float*)count_malloc(psRMSEnvelopeGrouping->iNumBlocks sizeof(float*));
		psRMSEnvelopeGrouping->ppfBandEnergydB = (float*)count_malloc(psRMSEnvelopeGrouping->iNumBlocks sizeof(float*));
		psRMSEnvelopeGrouping->ppfWeight = (float*)count_malloc(psRMSEnvelopeGrouping->iNumBlocks sizeof(float*));
		for(n = 0; n < psRMSEnvelopeGrouping->iNumBlocks; n ++){
		psRMSEnvelopeGrouping->ppfBandEnergy[n] = (float)malloc(MAX_BANDS 2 * sizeof(float)); /* 2 for stereo joint group calc */
		psRMSEnvelopeGrouping->ppfBandEnergydB[n] = (float)malloc(MAX_BANDS 2 * sizeof(float));
		psRMSEnvelopeGrouping->ppfWeight[n] = (float)malloc(MAX_BANDS 2 * sizeof(float));
		psRMSEnvelopeGrouping->ppfBandEnergy[n] = (float)count_malloc(MAX_BANDS 2 * sizeof(float)); /* 2 for stereo joint group calc */
		psRMSEnvelopeGrouping->ppfBandEnergydB[n] = (float)count_malloc(MAX_BANDS 2 * sizeof(float));
		psRMSEnvelopeGrouping->ppfWeight[n] = (float)count_malloc(MAX_BANDS 2 * sizeof(float));
		}

		psRMSEnvelopeGrouping->psGMNodes = (GMNode)malloc(psRMSEnvelopeGrouping->iNumBlocks sizeof(GMNode));
		psRMSEnvelopeGrouping->psGMNodes = (GMNode)count_malloc(psRMSEnvelopeGrouping->iNumBlocks sizeof(GMNode));
		for(n = 0; n < psRMSEnvelopeGrouping->iNumBlocks; n ++){
		psRMSEnvelopeGrouping->psGMNodes[n].pfMergedEnergydB = (float)malloc(MAX_BANDS 2 * sizeof(float));
		psRMSEnvelopeGrouping->psGMNodes[n].pfMergedEnergydB = (float)count_malloc(MAX_BANDS 2 * sizeof(float));
		}

		return psRMSEnvelopeGrouping;
		@@ -59,20 +61,20 @@ void DeleteRMSEnvelopeGrouping(RMSEnvelopeGrouping *psRMSEnvelopeGrouping)
		int n;

		for(n = 0; n < psRMSEnvelopeGrouping->iNumBlocks; n ++){
		free(psRMSEnvelopeGrouping->ppfBandEnergy[n]);
		free(psRMSEnvelopeGrouping->ppfBandEnergydB[n]);
		free(psRMSEnvelopeGrouping->ppfWeight[n]);
		count_free(psRMSEnvelopeGrouping->ppfBandEnergy[n]);
		count_free(psRMSEnvelopeGrouping->ppfBandEnergydB[n]);
		count_free(psRMSEnvelopeGrouping->ppfWeight[n]);
		}
		free(psRMSEnvelopeGrouping->ppfBandEnergy);
		free(psRMSEnvelopeGrouping->ppfBandEnergydB);
		free(psRMSEnvelopeGrouping->ppfWeight);
		count_free(psRMSEnvelopeGrouping->ppfBandEnergy);
		count_free(psRMSEnvelopeGrouping->ppfBandEnergydB);
		count_free(psRMSEnvelopeGrouping->ppfWeight);

		for(n = 0; n < psRMSEnvelopeGrouping->iNumBlocks; n ++){
		free(psRMSEnvelopeGrouping->psGMNodes[n].pfMergedEnergydB);
		count_free(psRMSEnvelopeGrouping->psGMNodes[n].pfMergedEnergydB);
		}
		free(psRMSEnvelopeGrouping->psGMNodes);
		count_free(psRMSEnvelopeGrouping->psGMNodes);

		free(psRMSEnvelopeGrouping);
		count_free(psRMSEnvelopeGrouping);
		}