main.cpp

mpq文件查看器

	BLPHeader2 blph;
	long blphsize = sizeof(BLPHeader2);
	ZeroMemory(&blph, blphsize);
	unsigned long JPEGHeaderSize = 10L;
	unsigned long padsize = 0L;

	if(bpp!=32)			// only pictures with alpha channels
		return 0;		// for the moment, we will se later


	long nummipmapstocompute = 0, t=min(width, height);
	while(t%2==0)
	{
		t/=2;
		++nummipmapstocompute;
	}

	if(t!=1)			// only size power of 2
		return 0;		

	t=max(width, height);
	while(t%2==0)
		t/=2;

	if(t!=1)			// only size power of 2
		return 0;

	blph.compress = 0; // yes, compressed
	memcpy(blph.ident, "BLP1", 4);
	blph.nummipmaps = nummipmapstocompute;
	blph.picsubtype = 1;
	blph.pictype = 4;
	blph.sizex = width;
	blph.sizey = height;
	ZeroMemory(&blph.poffs, 16*4);
	ZeroMemory(&blph.psize, 16*4);
	blph.JPEGHeaderSize = JPEGHeaderSize;

	char * curpic, *resizedpic;
	unsigned long nn;
	int k=0;

	long curwidth=width, curheight=height;

	for(k=0; k<nummipmapstocompute+3; ++k)
	{
		nn = ResizePicture(srcBuf, width, height, bpp, NULL, curwidth, curheight);
		resizedpic=(char*)malloc_func(nn);
		ResizePicture(srcBuf, width, height, bpp, resizedpic, curwidth, curheight);

		nn = IJGWrite((unsigned char*)resizedpic, 10000+curwidth*curheight*bpp/8, NULL, 0, quality, curwidth, curheight, 4);

		if (nn<=JPEGHeaderSize)
			goto perilexit;

		curpic=(char*)malloc_func(nn);
		IJGWrite((unsigned char*)resizedpic, 10000+width*height*bpp/8, (unsigned char*)curpic, nn, quality, curwidth, curheight, 4);

		if(k==0)
		{
			blph.poffs[0]=blphsize+JPEGHeaderSize+padsize;
			blph.psize[0]=nn-JPEGHeaderSize;
		}
		else
		{
			blph.poffs[k]=blph.poffs[k-1]+blph.psize[k-1];
			blph.psize[k]=nn-JPEGHeaderSize;
		}		

		if(bSizeOnly==FALSE)
			memcpy(destBuf+blph.poffs[k], curpic+JPEGHeaderSize, nn-JPEGHeaderSize);
		
		if((k==0)&&(bSizeOnly==FALSE))
		{
			memcpy(destBuf+blphsize, curpic, JPEGHeaderSize);
			memset(destBuf+blphsize+JPEGHeaderSize, 0, padsize);
		}

		free_func(curpic);
		free_func(resizedpic);

		curwidth/=2; if(curwidth<1) curwidth=1;
		curheight/=2; if(curheight<1) curheight=1;
	}
 perilexit:

	if(bSizeOnly==FALSE)
		memcpy(destBuf, &blph, blphsize);

	return (blph.poffs[k-1]+blph.psize[k-1]);
}





DWORD MakeTGA(unsigned char* srcBuf, long width, long height, long bpp, unsigned char* destBuf)
{
	unsigned long curpos = 0;

	unsigned char byteSkip;
	short int shortSkip;
	unsigned char imageType;
	int colorMode;
//	int imageIdx;
	unsigned char bitDepth;
	long imageSize;

	imageType = 2;
	bitDepth = (unsigned char)bpp;
	colorMode = bpp/8;
	byteSkip = 0;
	shortSkip = 0;

	if (destBuf == NULL)
		return 18+width*height*colorMode;

	memcpy(destBuf+curpos, &byteSkip, 1);
	curpos++;

	memcpy(destBuf+curpos, &byteSkip, 1);
	curpos++;

	memcpy(destBuf+curpos, &imageType, 1);
	curpos++;

	memcpy(destBuf+curpos, &shortSkip, 2);
	curpos+=2;

	memcpy(destBuf+curpos, &shortSkip, 2);
	curpos+=2;

	memcpy(destBuf+curpos, &byteSkip, 1);
	curpos++;

	memcpy(destBuf+curpos, &shortSkip, 2);
	curpos+=2;

	memcpy(destBuf+curpos, &shortSkip, 2);
	curpos+=2;

	memcpy(destBuf+curpos, &width, 2);
	curpos+=2;

	memcpy(destBuf+curpos, &height, 2);
	curpos+=2;

	memcpy(destBuf+curpos, &bitDepth, 1);
	curpos++;

	if(bpp==24)
	{
		memcpy(destBuf+curpos, &byteSkip, 1);
		curpos++;
	}
	
	if(bpp==32)
	{
		byteSkip = 8;
		memcpy(destBuf+curpos, &byteSkip, 1);
		curpos++;
	}



	imageSize = width*height*colorMode;
/*
	for(imageIdx = 0; imageIdx<imageSize; imageIdx+= colorMode)
	{
		*(destBuf+curpos) = srcBuf[imageIdx];
		curpos++;

		*(destBuf+curpos) = srcBuf[imageIdx+1];
		curpos++;

		*(destBuf+curpos) = srcBuf[imageIdx+2];
		curpos++;

		if(colorMode==4)
		{
			*(destBuf+curpos) = srcBuf[imageIdx+3];
			curpos++;
		}
	}
*/
//	HorizFlip((char*)(destBuf+18), width*colorMode, height);

	memcpy(destBuf+curpos, srcBuf, width*height*colorMode);

	return 18+width*height*colorMode;
}



// loword = quality, hiword = bpp
int GetJPEGQuality(int defq = 85, int defbpp = 24)
{
	return MyDialogBoxParam(GetModuleHandle(NULL), MAKEINTRESOURCE(IDD_DIALOG5), dlg, (DLGPROC)DialogProcJPEGQuality, (LPARAM)MAKEWORD(defq, defbpp));
}



DWORD MakeBMP(char* srcBuf, long width, long height, long bpp, char* destBuf)
{								
	BITMAPFILEHEADER	file_header;		
	BITMAPINFOHEADER	info_header;
	long bytesbpp = bpp/8;

	if(srcBuf == NULL)
		return 0;

	if (destBuf == NULL)
		return (width*height*bytesbpp+sizeof(BITMAPFILEHEADER)+sizeof(BITMAPINFOHEADER));

	ZeroMemory(&file_header, sizeof(BITMAPFILEHEADER));
	file_header.bfType = BITMAP_ID;
	file_header.bfSize = width*height*bytesbpp+sizeof(BITMAPFILEHEADER)+sizeof(BITMAPINFOHEADER);
	file_header.bfReserved1 = file_header.bfReserved2 = 0;
	file_header.bfOffBits = sizeof(BITMAPFILEHEADER)+sizeof(BITMAPINFOHEADER);

	ZeroMemory(&info_header, sizeof(BITMAPINFOHEADER));
	info_header.biSize = sizeof(BITMAPINFOHEADER);
	info_header.biWidth = width;
	info_header.biHeight = height;
	info_header.biPlanes = 1L;
	info_header.biBitCount = (unsigned short)bpp;
	info_header.biCompression = BI_RGB;
	info_header.biSizeImage = width*height*bytesbpp;
	info_header.biXPelsPerMeter = 18;
	info_header.biYPelsPerMeter = 18;

	memcpy(destBuf, &file_header, sizeof(BITMAPFILEHEADER));
	destBuf+=sizeof(BITMAPFILEHEADER);

	memcpy(destBuf, &info_header, sizeof(BITMAPINFOHEADER));
	destBuf+=sizeof(BITMAPINFOHEADER);

	memcpy(destBuf, srcBuf, width*height*bytesbpp);
//	HorizFlip((char*)destBuf, width*bytesbpp, height);
	return (width*height*bytesbpp+sizeof(BITMAPFILEHEADER)+sizeof(BITMAPINFOHEADER));
}




BOOL ISBLP(char *s)
{
	char *stmp = (char*)malloc_func(lstrlen(s)+1);
	lstrcpy(stmp, s);
	stmp=strupr(stmp);
	BOOL b=ISBLPT(stmp);
	free_func(stmp);
	return b;
}


BOOL ISMODEL(char *s)
{
	char *stmp = (char*)malloc_func(lstrlen(s)+1);
	lstrcpy(stmp, s);
	stmp=strupr(stmp);
	BOOL b=ISMODELT(stmp);
	free_func(stmp);
	return b;
}


BOOL ISBMP(char *s)
{
	char *stmp = (char*)malloc_func(lstrlen(s)+1);
	lstrcpy(stmp, s);
	stmp=strupr(stmp);
	BOOL b=ISBMPT(stmp);
	free_func(stmp);
	return b;
}


BOOL ISTGA(char *s)
{
	char *stmp = (char*)malloc_func(lstrlen(s)+1);
	lstrcpy(stmp, s);
	stmp=strupr(stmp);
	BOOL b=ISTGAT(stmp);
	free_func(stmp);
	return b;
}


BOOL ISJPG(char *s)
{
	char *stmp = (char*)malloc_func(lstrlen(s)+1);
	lstrcpy(stmp, s);
	stmp=strupr(stmp);
	BOOL b=ISJPGT(stmp);
	free_func(stmp);
	return b;
}


BOOL BLP2Everything(char *srcbuf, DWORD srcbuflen, char *szFileDest)
{
	HANDLE hFile;
	char stmp[1024];

	DWORD r, dwsize = srcbuflen;
	
	if(ISBLP(szFileDest))
	{
		DeleteFile(szFileDest);
		hFile=CreateFile(szFileDest, GENERIC_WRITE, FILE_SHARE_READ, NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
		if(hFile==INVALID_HANDLE_VALUE)
		{
			switch(currentlanguage)
			{
				case LANG_FRENCH:
					sprintf(stmp, "Impossible de cr閑r %s", szFileDest);
					break;

				case LANG_ENGLISH:
					sprintf(stmp, "Cannot create %s", szFileDest);
					break;

				case LANG_PORTUGUESE:
					sprintf(stmp, "Impos韛el criar %s", szFileDest);
					break;

				case LANG_GERMAN:
					sprintf(stmp, "Kann %s nicht erstellen", szFileDest);
					break;

				default:
					sprintf(stmp, "Cannot create %s", szFileDest);
					break;
			}
			
			MessageBox(dlgtree, stmp, szAppName, MB_ICONEXCLAMATION);
			return FALSE;
		}

		WriteFile(hFile, srcbuf, dwsize, &r, NULL);
		CloseHandle(hFile);					
		return TRUE;
	}

	DWORD w,h;
	dwsize = ConvertBLP(srcbuf, NULL, &w, &h, NULL, NULL);
	char * rawbuf = (char*)malloc_func(dwsize);
	ConvertBLP(srcbuf, rawbuf, &w, &h, NULL, NULL);

	if(ISBMP(szFileDest))
	{
		int qinfo = GetJPEGQuality(0, 32);
		if(qinfo==0)
		{
			free_func(rawbuf);
			return FALSE;
		}
		int bpp = HIBYTE(qinfo);

		HorizFlip(rawbuf, w*4, h);

		if(bpp==24)
		{
			char *trawbuf = (char*)malloc_func(w*h*3);
			RGBA2RGB(rawbuf, dwsize, trawbuf, w*h*3);
			free_func(rawbuf);
			rawbuf=trawbuf;
		}

		dwsize = MakeBMP(rawbuf, w, h, bpp, NULL);
		char * bmpbuf = (char*)malloc_func(dwsize);
		MakeBMP(rawbuf, w, h, bpp, bmpbuf);
		free_func(rawbuf);

		DeleteFile(szFileDest);
		hFile=CreateFile(szFileDest, GENERIC_WRITE, FILE_SHARE_READ, NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
		if(hFile==INVALID_HANDLE_VALUE)
		{
			

			switch(currentlanguage)
			{
				case LANG_FRENCH:
					sprintf(stmp, "Impossible de cr閑r %s", szFileDest);
					break;

				case LANG_ENGLISH:
					sprintf(stmp, "Cannot create %s", szFileDest);
					break;

				case LANG_PORTUGUESE:
					sprintf(stmp, "Impos韛el criar %s", szFileDest);
					break;

				case LANG_GERMAN:
					sprintf(stmp, "Kann %s nicht erstellen", szFileDest);
					break;

				default:
					sprintf(stmp, "Cannot create %s", szFileDest);
					break;
			}

			MessageBox(dlgtree, stmp, szAppName, MB_ICONEXCLAMATION);
			return FALSE;
		}

		WriteFile(hFile, bmpbuf, dwsize, &r, NULL);
		CloseHandle(hFile);
		free_func(bmpbuf);
		return TRUE;
	}

	if(ISJPG(szFileDest))
	{
		int qinfo = GetJPEGQuality(glastqual);
		if(qinfo==0)
		{
			free_func(rawbuf);
			return FALSE;
		}

		int q = LOBYTE(qinfo), bpp = HIBYTE(qinfo);
		glastqual = q;

		DWORD jpgsize;
		char *jpgbuf;

		if(bpp==24)
		{
			char *rawbufb = (char*)malloc_func(w*h*3);
			RGBA2BGR(rawbuf, w*h*4, rawbufb, w*h*3);
			free_func(rawbuf);
			jpgsize = IJGWrite((unsigned char*)rawbufb, w*h*3, NULL, 0, q, w, h, 3);
			jpgbuf = (char*)malloc_func(jpgsize);
			IJGWrite((unsigned char*)rawbufb, w*h*3, (unsigned char*)jpgbuf, jpgsize, q, w, h, 3);
			free_func(rawbufb);
		}
		else
		{
			jpgsize = IJGWrite((unsigned char*)rawbuf, dwsize, NULL, 0, q, w, h, bpp/8);
			jpgbuf = (char*)malloc_func(jpgsize);
			IJGWrite((unsigned char*)rawbuf, dwsize, (unsigned char*)jpgbuf, jpgsize, q, w, h, bpp/8);
			free_func(rawbuf);
		}

		DeleteFile(szFileDest);
		hFile=CreateFile(szFileDest, GENERIC_WRITE, FILE_SHARE_READ, NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
		if(hFile==INVALID_HANDLE_VALUE)
		{
			switch(currentlanguage)
			{
				case LANG_FRENCH:
					sprintf(stmp, "Impossible de cr閑r %s", szFileDest);
					break;

				case LANG_ENGLISH:
					sprintf(stmp, "Cannot create %s", szFileDest);
					break;

				case LANG_PORTUGUESE:
					sprintf(stmp, "Impos韛el criar %s", szFileDest);
					break;

				case LANG_GERMAN:
					sprintf(stmp, "Kann %s nicht erstellen", szFileDest);
					break;

				default:
					sprintf(stmp, "Cannot create %s", szFileDest);
					break;
			}
			MessageBox(dlgtree, stmp, szAppName, MB_ICONEXCLAMATION);
			return FALSE;
		}

		WriteFile(hFile, jpgbuf, jpgsize, &r, NULL);
		CloseHandle(hFile);
		return TRUE;
	}

	if(ISTGA(szFileDest))
	{
		int qinfo = GetJPEGQuality(0, 32);
		if(qinfo==0)
		{
			free_func(rawbuf);
			return FALSE;
		}
		int bpp = HIBYTE(qinfo);

		HorizFlip(rawbuf, w*4, h);

		if(bpp==24)
		{
			char *trawbuf = (char*)malloc_func(w*h*3);
			RGBA2RGB(rawbuf, dwsize, trawbuf, w*h*3);
			free_func(rawbuf);
			rawbuf=trawbuf;
		}

		dwsize = MakeTGA((unsigned char*)rawbuf, w, h, bpp, NULL);
		char * bmpbuf = (char*)malloc_func(dwsize);
		MakeTGA((unsigned char*)rawbuf, w, h, bpp, (unsigned char*)bmpbuf);
		free_func(rawbuf);

		DeleteFile(szFileDest);
		hFile=CreateFile(szFileDest, GENERIC_WRITE, FILE_SHARE_READ, NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
		if(hFile==INVALID_HANDLE_VALUE)
		{
			switch(currentlanguage)
			{
				case LANG_FRENCH:
					sprintf(stmp, "Impossible de cr閑r %s", szFileDest);
					break;

				case LANG_ENGLISH:
					sprintf(stmp, "Cannot create %s", szFileDest);
					break;

				case