release performed different from debug

BOOL FrameParser::Parse(char *Filename,void **Data)
{

LPD3DXFILE pDXFile = NULL;
LPD3DXFILEENUMOBJECT pDXEnum = NULL;
LPD3DXFILEDATA pDXData = NULL;
HRESULT hr;
SIZE_T cChildren;

if(Filename == NULL)
{
return FALSE;
}

//
if(FAILED(D3DXFileCreate(&pDXFile)))
{
return FALSE;
}

//
if(FAILED(pDXFile->RegisterTemplates((LPVOID)D3DRM_XTEMPLATES,D3DRM_XTEMPLATE_BYTES)))
{
pDXFile->Release();
return FALSE;
}

//
if(FAILED(pDXFile->CreateEnumObject((LPVOID)Filename,
D3DXF_FILELOAD_FROMFILE,&pDXEnum)))
{
pDXFile->Release();
return FALSE;
}

//
//
//
pDXEnum->GetChildren(&cChildren);
for (UINT iChild = 0; iChild < cChildren; iChild++)
{
hr = pDXEnum->GetChild(iChild, &pDXData);
if (FAILED(hr))
{
return FALSE;
}

m_bReference = pDXData->IsReference();
hr = LoadFrame( pDXData,NULL,NULL,m_bReference);

SAFE_RELEASE( pDXData);
if( FAILED(hr) )
{
SAFE_RELEASE( pDXEnum);
SAFE_RELEASE( pDXFile);
return FALSE;
}
}

//
SAFE_RELEASE(pDXEnum);
SAFE_RELEASE(pDXFile);

return TRUE;
}

HRESULT FrameParser::LoadFrame(LPD3DXFILEDATA pFileData,LPD3DXFILEDATA pParentDataObj, void **Data,BOOL Reference)
{
LPD3DXFILEDATA pChildData = NULL;
GUID Guid;
SIZE_T cbSize = 0;
SIZE_T cChildren = 0;
D3DXFRAME_DERIVED* p_CurrentFrame;
// D3DXMESHCONTAINER_DERIVED* p_CurrentMesh;
HRESULT hr;

// Get the type of the object
if( FAILED( hr = pFileData->GetType( &Guid ) ) )
{
return hr;
}

if( Guid == TID_D3DRMFrameTransformMatrix && Reference == FALSE && Data)
{
D3DXFRAME_DERIVED *Frame = (D3DXFRAME_DERIVED*)(*Data);

D3DXMATRIX* pmatMatrix;

if(Frame)
{
hr = pFileData->Lock(&cbSize, (LPCVOID*)&pmatMatrix );
if( FAILED(hr) )
{
return hr;
}

// Update the parent's matrix with the new one
Frame->TransformationMatrix = *pmatMatrix;
pFileData->Unlock();
Frame->matOriginal = Frame->TransformationMatrix;
}

}

if( Guid == TID_D3DRMMesh && Reference == FALSE )
{

// Load the mesh using the data object load method
D3DXMESHCONTAINER_DERIVED *pMesh = NULL;
//mesh
LoadMesh(&pMesh,pFileData,m_texPath);
// Link mesh to head of list of meshes
if(pMesh)
{
pMesh->pNextMeshContainer = m_pRootMesh;
m_pRootMesh = pMesh;
pMesh = NULL;

// Link mesh to frame if needed
if(Data)
{
D3DXFRAME_DERIVED *pFrame = (D3DXFRAME_DERIVED*)*Data;
if(pFrame)
{
pFrame->pMeshContainer = m_pRootMesh;
}
}
}
}

if( Guid == TID_D3DRMMesh && Reference == TRUE )
{
// If referenced, then check if wanting to link to frame
if(Data)
{
D3DXFRAME_DERIVED *pFrame = (D3DXFRAME_DERIVED*)*Data;
if( m_pRootMesh && pFrame)
{
char strAnsiName[512] = "";
SIZE_T dwNameLength = 512;

if( FAILED( hr = pFileData->GetName( strAnsiName, &dwNameLength ) ) )
{
return hr;
}

if(strAnsiName)
{
pFrame->pMeshContainer = m_pRootMesh->FindMesh(strAnsiName);
}

}
}
}

if( Guid == TID_D3DRMFrame && Reference == FALSE)
{
//
char* strAnsiName = new char[100];
SIZE_T dwNameLength = 100;
SIZE_T cChildren;

if( FAILED( hr = pFileData->GetName( strAnsiName, &dwNameLength ) ) )
{
return hr;
}
p_CurrentFrame = new D3DXFRAME_DERIVED();

if(p_CurrentFrame == NULL )
{
return E_OUTOFMEMORY;
}
p_CurrentFrame->Name = strAnsiName;

//
if(Data == NULL)
{
// Link as sibling of root
p_CurrentFrame->pFrameSibling = m_pRootFrame;
m_pRootFrame = p_CurrentFrame;
p_CurrentFrame = NULL;
Data = (void**)&m_pRootFrame;
}
else
{
// Link as child of supplied frame
D3DXFRAME_DERIVED *pFramePtr = (D3DXFRAME_DERIVED*)*Data;
p_CurrentFrame->pFrameSibling = pFramePtr->pFrameFirstChild;
pFramePtr->pFrameFirstChild = p_CurrentFrame;
p_CurrentFrame = NULL;
Data = (void**)&pFramePtr->pFrameFirstChild;
}

cChildren = 0;
pFileData->GetChildren(&cChildren);
for (UINT iChild = 0; iChild < cChildren; iChild++)
{
hr = pFileData->GetChild(iChild, &pChildData);
if (FAILED(hr))
{
return hr;
}

m_bReference = pChildData->IsReference();
hr = LoadFrame( pChildData,pFileData, Data,m_bReference);

SAFE_RELEASE( pChildData);
}
}
return S_OK;
}

HRESULT FrameParser::LoadMesh(D3DXMESHCONTAINER_DERIVED** m_pMesh, LPD3DXFILEDATA pDataObj, char *TexturePath, DWORD NewFVF,DWORD LoadFlags)
{
LPD3DXMESH pLoadMesh = NULL;
LPD3DXSKININFO pSkin = NULL;
HRESULT hr;

if( !pDataObj || !TexturePath)
{
return E_FAIL;
}
DWORD TempLoadFlags = LoadFlags;
if(NewFVF)
{
TempLoadFlags = D3DXMESH_SYSTEMMEM;
}
// Load the mesh using the D3DX skinned mesh interface
LPD3DXBUFFER MaterialBuffer = NULL;
LPD3DXBUFFER AdjacencyBuffer = NULL;
DWORD NumMaterials;

if(FAILED(hr = D3DXLoadSkinMeshFromXof((LPD3DXFILEDATA)pDataObj,
TempLoadFlags,
m_pD3DDevice,
&AdjacencyBuffer,
&MaterialBuffer,
NULL,
&NumMaterials,
&pSkin,
&pLoadMesh)))
{
return hr;
}

// Free skin info if no bones
if(pSkin && !pSkin->GetNumBones())
{
SAFE_RELEASE(pSkin);
}
// Convert to new FVF first as needed (not w/skinned models)
if(NewFVF)
{
LPD3DXMESH pTempMesh = NULL;

// Use CloneMeshFVF to convert mesh
if(FAILED(hr =pLoadMesh->CloneMeshFVF(LoadFlags, NewFVF, m_pD3DDevice, &pTempMesh)))
{
SAFE_RELEASE(pLoadMesh);
SAFE_RELEASE(pSkin);
SAFE_RELEASE(MaterialBuffer);
SAFE_RELEASE(AdjacencyBuffer);
return hr;
}

// Free prior mesh and store new pointer
SAFE_RELEASE(pLoadMesh);
pLoadMesh = pTempMesh;
pTempMesh = NULL;
}

// Allocate a D3DXMESHCONTAINER_EX structure
D3DXMESHCONTAINER_DERIVED *pMesh = new D3DXMESHCONTAINER_DERIVED();
*m_pMesh = pMesh;

// Store mesh template name, type, and mesh pointers
DWORD Size;
pDataObj->GetName(NULL, &Size);
if(Size)
{
pMesh->Name = new char[Size];
pDataObj->GetName(pMesh->Name, &Size);
}
pMesh->MeshData.Type = D3DXMESHTYPE_MESH;
pMesh->MeshData.pMesh = pLoadMesh;
pLoadMesh = NULL;
pMesh->pSkinInfo = pSkin;
pSkin = NULL;

// Store adjacency buffer
DWORD AdjSize = AdjacencyBuffer->GetBufferSize();
if(AdjSize)
{
pMesh->pAdjacency = (DWORD*)new char[AdjSize];
memcpy(pMesh->pAdjacency, AdjacencyBuffer->GetBufferPointer(), AdjSize);
}

SAFE_RELEASE(AdjacencyBuffer);

// Create a duplicate mesh in case skinning is used
if(pMesh->pSkinInfo)
{
pMesh->MeshData.pMesh->CloneMeshFVF(D3DXMESH_SYSTEMMEM/*0*/, //D3DXMESH_MANAGED,
pMesh->MeshData.pMesh->GetFVF(),
m_pD3DDevice,
&pMesh->pSkinMesh);
}

// Build material list
if(!(pMesh->NumMaterials = NumMaterials)) {

// Create a default material
pMesh->NumMaterials = 1;
pMesh->pMaterials = new D3DXMATERIAL[1];
pMesh->pTextures = new IDirect3DTexture9*[1];

ZeroMemory(&pMesh->pMaterials[0], sizeof(D3DXMATERIAL));
pMesh->pMaterials[0].MatD3D.Diffuse.r = 1.0f;
pMesh->pMaterials[0].MatD3D.Diffuse.g = 1.0f;
pMesh->pMaterials[0].MatD3D.Diffuse.b = 1.0f;
pMesh->pMaterials[0].MatD3D.Diffuse.a = 1.0f;
pMesh->pMaterials[0].MatD3D.Ambient = pMesh->pMaterials[0].MatD3D.Diffuse;
pMesh->pMaterials[0].MatD3D.Specular = pMesh->pMaterials[0].MatD3D.Diffuse;
pMesh->pMaterials[0].pTextureFilename = NULL;
pMesh->pTextures[0] = NULL;

}
else
{

// Load the materials
D3DXMATERIAL *Materials = (D3DXMATERIAL*)MaterialBuffer->GetBufferPointer();
pMesh->pMaterials = new D3DXMATERIAL[pMesh->NumMaterials];
pMesh->pTextures = new IDirect3DTexture9*[pMesh->NumMaterials];

for(DWORD i=0;i<pMesh->NumMaterials;i++) {
pMesh->pMaterials[i].MatD3D = Materials[i].MatD3D;
pMesh->pMaterials[i].MatD3D.Ambient = pMesh->pMaterials[i].MatD3D.Diffuse;

// Load the texture if one exists
pMesh->pTextures[i] = NULL;
if(Materials[i].pTextureFilename)
{
char TextureFile[MAX_PATH];
sprintf_s(TextureFile,MAX_PATH, "%s%s", TexturePath, Materials[i].pTextureFilename);
D3DXCreateTextureFromFileA( m_pD3DDevice, TextureFile,
&pMesh->pTextures[i]);
}
}
}
SAFE_RELEASE(MaterialBuffer);

// Optimize the mesh for better attribute access
pMesh->MeshData.pMesh->OptimizeInplace(D3DXMESHOPT_ATTRSORT, NULL, NULL, NULL, NULL);

// Clear pMesh pointer just in case
pMesh = NULL;

return S_OK;
}