Stack overflow?

      
HRESULT LoadPcx(LPCTSTR FileName, IDirect3DDevice9 *pd3ddev, BOOL MipMap, _D3DFORMAT Format, IDirect3DTexture9 **ppTex)
{
	CFileHandle hFile = CreateFile(FileName, GENERIC_READ, FILE_SHARE_READ, 0, OPEN_EXISTING, 0, 0);
	if (hFile == INVALID_HANDLE_VALUE) {
		ATLTRACE(_T("LS_PCXLDR: Cannot open file: %s\n"), FileName);
		return HRESULT_FROM_WIN32(GetLastError());
	}

	CKernelHandle hFileMapping = CreateFileMapping(hFile, 0, PAGE_READONLY, 0, 0, 0);
	if (!hFileMapping) {
		ATLTRACE(_T("LS_PCXLDR: Cannot create file mapping for: %s\n"), FileName);
		return HRESULT_FROM_WIN32(GetLastError());
	}

	CViewOfFilePointer pFileView = MapViewOfFile(hFileMapping, FILE_MAP_READ, 0, 0, 0);
	if (!pFileView) {
		ATLTRACE(_T("LS_PCXLDR: Cannot map view of file for: %s\n"), FileName);
		return HRESULT_FROM_WIN32(GetLastError());
	}

	PCX_HEADER *pHeader = (PCX_HEADER *) (PVOID) pFileView;
	if (pHeader->Manufacturer != 10) {
		ATLTRACE(_T("LS_PCXLDR: Wrong manufacturer: %s\n"), FileName);
		return HRESULT_FROM_WIN32(ERROR_BAD_FORMAT);
	}

	if (pHeader->Encoding != 1) {
		ATLTRACE(_T("LS_PCXLDR: %s: Only RLE encoding is supported\n"), FileName);
		return HRESULT_FROM_WIN32(ERROR_BAD_FORMAT);
	}

	if (pHeader->Bpp != 8) {
		ATLTRACE(_T("LS_PCXLDR: %s: Only 8-bpp PCXs are supported\n"), FileName);
		return HRESULT_FROM_WIN32(ERROR_BAD_FORMAT);
	}

	if (pHeader->NPlanes != 1 && pHeader->NPlanes != 3) {
		ATLTRACE(_T("LS_PCXLDR: %s: Only 1-plane 8-bit and 3-plane 24-bit pcxs are supported\n"), FileName);
		return HRESULT_FROM_WIN32(ERROR_BAD_FORMAT);
	}

	UINT Width = pHeader->WindowXmax-pHeader->WindowXmin+1;
	UINT Height = pHeader->WindowYmax-pHeader->WindowYmin+1;

	HRESULT hr = D3DXCreateTexture(pd3ddev, Width, Height, MipMap ? 0 : 1, 0, Format, D3DPOOL_MANAGED, ppTex);
	if (FAILED(hr)) {
		ATLTRACE(_T("LS_PCXLDR: %s: Cannot create texture\n"));
		return hr;
	}


	D3DSURFACE_DESC desc;
	(*ppTex)->GetLevelDesc(0, &desc);
//	if (desc.Width != Width || desc.Height != Height) {

//		ATLTRACE(_T("LS_PCXLDR: %s: Texture was created with improper dimensions\n"));

//		return D3DERR_NOTAVAILABLE;

//	}


	FILL_TEXTURE_DATA ftd = {
		Width, Height, new DWORD[Width*Height],
	};

	if (pHeader->NPlanes == 1) {
		// Read palette

		DWORD FileSize = GetFileSize(hFile, 0);
		BYTE *PaletteMagic = AdvanceCastPtr<BYTE>((PVOID) pFileView, FileSize-769);

		if (*PaletteMagic != 12) {
			ATLTRACE(_T("LS_PCXLDR: %s: Bad palette information in 8-bit pcx file\n"));
			delete ftd.pLoadedData;
			return HRESULT_FROM_WIN32(ERROR_BAD_FORMAT);
		}

		RGBTRIPLE *pSourcePalette = (RGBTRIPLE *) (PaletteMagic+1);
		RGBQUAD *pPalette = new RGBQUAD[256];
		RGBQUAD *pDestPalette = pPalette;

		for (int i = 0; i < 256; ++i) {
			pDestPalette->rgbBlue = pSourcePalette->rgbtRed;
			pDestPalette->rgbGreen = pSourcePalette->rgbtGreen;
			pDestPalette->rgbRed = pSourcePalette->rgbtBlue;
			pDestPalette->rgbReserved = 0;
			++pDestPalette;
			++pSourcePalette;
		}

		Decode8bitPcx(pHeader, Width, Height, (RGBQUAD *) ftd.pLoadedData, pPalette);
		
		delete pPalette;
	} else {
		Decode24bitPcx(pHeader, Width, Height, ftd.pLoadedData);
	}

#if 0
	ATLASSERT(Format == D3DFMT_X8R8G8B8 || Format == D3DFMT_A8R8G8B8);
	D3DLOCKED_RECT lr;
	pTex->LockRect(0, &lr, 0, 0);

	for (UINT i = 0; i < Height; ++i)
	{
		memcpy(AdvancePtr(lr.pBits, i*lr.Pitch), ftd.pLoadedData+i*Width, Width*4);
	}

	(*ppTex)->UnlockRect(0);
#else
	
	D3DXFillTexture((*ppTex), (LPD3DXFILL2D) FillTextureProc, &ftd);
	
#endif

	delete ftd.pLoadedData;
	return S_OK;
}      

  
void __cdecl FillTextureProc(D3DXVECTOR4 *pOut, D3DXVECTOR2 *pTexCoord, D3DXVECTOR2 *pTexelSize, FILL_TEXTURE_DATA *pftd) {
	ATLASSERT(pTexCoord->x < 0.9999 && pTexCoord->y < 0.9999);
	UINT x = UINT(pTexCoord->x*pftd->Width); // Problem line

	UINT y = UINT(pTexCoord->y*pftd->Height);
	DWORD *pSourceImage = pftd->pLoadedData+x+y*pftd->Width;
	RGBQUAD *prgbq = (RGBQUAD *) (pSourceImage);
	if (*pSourceImage) {
		int x = 2;
	}
	pOut->x = prgbq->rgbRed/255.f;
	pOut->y = prgbq->rgbGreen/255.f;
	pOut->z = prgbq->rgbBlue/255.f;
	pOut->w = 0;
}