main.cpp

mpq文件查看器

		else
			return hprev;
	}
	return hprev;
}


DWORD AddItems(HWND htree, HTREEITEM hit)
{
	WIN32_FIND_DATA w;
	char tmp[1024], itp[1024];
	long k=0,i=0;
	BOOL b = TRUE;
	GetItemPathWithoutRoot(htree, hit, itp);
	sprintf(tmp, "%s\\*.*", itp);
	HANDLE hf = FindFirstFile(tmp, &w);
	while((hf != INVALID_HANDLE_VALUE)&&(b==TRUE))
	{
		if(ISBLP(w.cFileName)||ISMODEL(w.cFileName)||(w.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY))
		{
			if((lstrcmp(w.cFileName, ".")!=0)&&(lstrcmp(w.cFileName, "..")!=0))
			{
				++i;
				TVINSERTSTRUCT is;
				is.hParent = hit;
				is.item.mask = TVIF_TEXT + TVIF_CHILDREN + TVIF_IMAGE + TVIF_SELECTEDIMAGE + TVIF_PARAM;				
				if(w.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)
				{	
					is.hInsertAfter = InsertWhere(htree, hit, 1, w.cFileName);
					is.item.iImage = 0;
					is.item.iSelectedImage = 1;
					is.item.lParam = 1;
				}
				else
				{
					is.hInsertAfter = InsertWhere(htree, hit, 0, w.cFileName);
					is.item.iImage = 6;
					is.item.iSelectedImage = 6;
					is.item.lParam = 0;
				}
				
				is.item.pszText = w.cFileName;
				sprintf(tmp, "%s\\%s", itp, w.cFileName);
				is.item.cChildren = GetValidFilesCount(tmp);
				TreeView_InsertItem(htree, &is);
			}
		}
		b = FindNextFile(hf, &w);
	}
	return i;
}


DWORD AddDrives(HWND htree, HTREEITEM hit)
{
	char tmp[5];
	ZeroMemory(&tmp, 5);
	lstrcpy(tmp, "A:");
	int k=0, i=0, j=0;
	for(k='A'; k<'Z'+1; ++k)
	{
		tmp[0]=k;
		j = GetDriveType(tmp);
		if (/*(j != DRIVE_UNKNOWN)&&(j != DRIVE_NO_ROOT_DIR)*/1)
		{
			++i;
			TVINSERTSTRUCT is;
			is.hParent = hit;
			is.item.mask = TVIF_TEXT + TVIF_CHILDREN + TVIF_IMAGE + TVIF_SELECTEDIMAGE + TVIF_PARAM;
			is.item.pszText = tmp;
			is.item.cChildren = GetValidFilesCount(tmp);
			is.item.lParam = 1;
			switch(j)
			{
				case DRIVE_REMOVABLE:
					is.item.iImage = 2;
					is.item.iSelectedImage = 2;
					break;

				case DRIVE_FIXED:
				case DRIVE_RAMDISK:
				case DRIVE_REMOTE:
					is.item.iImage = 3;
					is.item.iSelectedImage = 3;
					break;

				case DRIVE_CDROM:
					is.item.iImage = 4;
					is.item.iSelectedImage = 4;
					break;

				default:
					is.item.iImage = 3;
					is.item.iSelectedImage = 3;
					break;
			}
			TreeView_InsertItem(htree, &is);
		}
	}
	return i;
}




DWORD GetNextSnapshotName(char *destbuf)
{
	char tmp[1024];
	int k = 0;

	sprintf(tmp, "%sss%04u.jpg", gInitialDir, k);
	while(utilFileExists(tmp)==TRUE)
		sprintf(tmp, "%sss%04u.jpg", gInitialDir, ++k);

	if (destbuf!=NULL)
		lstrcpy(destbuf, tmp);
	
	return lstrlen(tmp)+1;
}



#define BITMAP_ID	0x4D42


DWORD LoadBMP(char *srcbuf, long *w, long *h, long *bp, char *destbuf)
{
	DWORD curpos = 0;
	long width, height, bpp; 
	BITMAPFILEHEADER	file_header;			//The bitmap file header
	BITMAPINFOHEADER	info_header;
	int					imageIdx = 0;			//Image index counter
//	unsigned char		tempRGB;				//Swap variable
	int b_align = 0;


	//Read the bitmap file header
	memcpy(&file_header, srcbuf+curpos, sizeof(BITMAPFILEHEADER));
	curpos+=sizeof(BITMAPFILEHEADER);

	//Confirm that this is a bitmap by checking for the universal bitmap id
	if(file_header.bfType != BITMAP_ID)
	{
		if(w!=NULL) *w=0;
		if(h!=NULL) *h=0;
		if(bp!=NULL) *bp=0;

		return 0;
	}

	//Read the bitmap information header in
	memcpy(&info_header, srcbuf+curpos, sizeof(BITMAPINFOHEADER));
	curpos+=sizeof(BITMAPINFOHEADER);
/*
	if (info_header.biBitCount != 32)
	{
		if(w!=NULL) *w=0;
		if(h!=NULL) *h=0;
		if(bp!=NULL) *bp=info_header.biBitCount;

		return 0;		
	}
*/
	//Advance the file pointer to the beginning of the bitmap data
	curpos = file_header.bfOffBits;

	width = info_header.biWidth;
	height= info_header.biHeight;
	bpp	  = info_header.biBitCount;

	if(w!=NULL) *w = width;
	if(h!=NULL) *h = height;
	if(bp!=NULL) *bp = bpp;

	if(info_header.biSizeImage==0) info_header.biSizeImage=(width*height*bpp/8);

	//Allocate the bitmap image data
//	unsigned char *data = (unsigned char*)malloc_func(info_header.biSizeImage);
//	unsigned char *tdata= (unsigned char*)malloc_func(info_header.biSizeImage);

	if(destbuf==NULL)
		return info_header.biSizeImage;

	//Read in the bitmap image data
	memcpy(destbuf, srcbuf+curpos, info_header.biSizeImage);
	curpos=+info_header.biSizeImage;

//	b_align=4;


	//Swap the R and B values to get RGB since the bitmap color format is in BGR
/*	if(bpp==32)
		for(imageIdx = 0; imageIdx<(int)info_header.biSizeImage; imageIdx+=4)
			{
			tempRGB			= data[imageIdx];
			data[imageIdx]  = data[imageIdx + 2];
			data[imageIdx+2]= tempRGB;
			}
	else if(bpp==24)
		for(imageIdx = 0; imageIdx<(int)info_header.biSizeImage; imageIdx+=3)
			{
			tempRGB			= data[imageIdx];
			data[imageIdx]  = data[imageIdx + 2];
			data[imageIdx+2]= tempRGB;
			}
*/

	//bitmaps are upside-down
/*
	for(unsigned long k=0; k<height; ++k)
	{
		memcpy(tdata+k*width*b_align, data+(height*width*b_align-k*width*b_align), width*b_align);
	}
	memcpy(data, tdata, width*height*b_align);
*/
//	free_func(tdata);

	return info_header.biSizeImage;
}


unsigned long LoadTGA(char *srcbuf, long *w, long *h, long *bp, char *destbuf, long *type)
{    
	TGAHeader		header;
    
    unsigned long	bytesPerPixel;
	unsigned long	imageSize;

	unsigned long curpos = 0;
	long width, height, bpp;
    
	memcpy((char *)&header, srcbuf, sizeof(TGAHeader));

    curpos+=sizeof(TGAHeader);
    
    if( header.colorMapType != 0 ||
        (header.imageType != 2 && header.imageType != 10) ||
        header.width == 0 ||
        header.height == 0 ||
        (header.bpp != 32 && header.bpp != 24))
	{
	   if(w!=NULL) *w=0;
	   if(h!=NULL) *h=0;
	   if(bp!=NULL) *bp=0;
           if(type!=NULL) *type = 0;
	   return 0;
	}
    
    width = header.width;
    height = header.height;
    bpp = header.bpp;
    
    if(w != NULL) *w = width;
    if(h != NULL) *h = height;
    if(bp != NULL) *bp = header.bpp; // if we have 24, we'll add an 8 bit alpha channel to each pixel
    if(type!=NULL) *type = header.imageType;

    bytesPerPixel = bpp/8;
    imageSize = width*height*bytesPerPixel; // if we have 24, we'll add an 8 bit alpha channel to each pixel

    if(destbuf == NULL)
            return imageSize;

    // Increment curpos to skip the image ID field if it's there
    curpos += header.imageIDLength;
    
    if(header.imageType == 2)
    {
        memcpy(destbuf, srcbuf+curpos, imageSize);
        curpos+=imageSize;
    }
    else if(header.imageType == 10)
    {
        // RLE compressed
        
        char *sourcePtr = srcbuf+curpos;
        char *destPtr = destbuf;
        RGBAPix onePixel = {0, 0, 0, 0xFF}; // 4 bytes, fully opaque alpha
        unsigned long i = 0;
        unsigned char rlCount = 0;
        
        while((unsigned long)(destPtr - destbuf) < imageSize)
        {
            if(*sourcePtr & 0x80)
            {
                // Run-length packet
                rlCount = (*sourcePtr & 0x7F) + 1;
                memcpy(&onePixel, ++sourcePtr, bytesPerPixel);
                for(i=0;i<rlCount;i++)
                {
                    memcpy(destPtr, &onePixel, bytesPerPixel);
                    destPtr += bytesPerPixel;
                }
                
                sourcePtr += bytesPerPixel;
            }
            else
            {
                // Raw packet
                rlCount = (*sourcePtr & 0x7F) + 1;
                sourcePtr++;

                memcpy(destPtr, sourcePtr, rlCount * bytesPerPixel);
                sourcePtr += rlCount * bytesPerPixel;
                destPtr += rlCount * bytesPerPixel;
            }
        }
    }
    
	if(header.imageOrigin == 0)
		HorizFlip(destbuf, bytesPerPixel*width, height);
	
	return imageSize;
}



DWORD ResizePicture(char* srcBuf, long width, long height, long bpp, char* destBuf, long newwidth, long newheight)
{
	if (destBuf==NULL)
		return (newwidth*newheight*bpp/8);

	if(bpp==24)
	{
		int r = gluScaleImage(GL_RGB, width, height, GL_UNSIGNED_BYTE, srcBuf, newwidth, newheight, GL_UNSIGNED_BYTE, destBuf);
		return (r==0 ? (newwidth*newheight*bpp/8) : 0);
	}

	if(bpp==32)
	{
		int r = gluScaleImage(GL_RGBA, width, height, GL_UNSIGNED_BYTE, srcBuf, newwidth, newheight, GL_UNSIGNED_BYTE, destBuf);
		return (r==0 ? (newwidth*newheight*bpp/8) : 0);
	}

	return (0);
}


/*
DWORD IJLWriteWrap(unsigned char *buf, unsigned long buflen, unsigned char *destbuf, unsigned long destbuflen, int quality, long image_width, long image_height, long image_planes)
{
  JPEG_CORE_PROPERTIES jcprops;
  BOOL bNoWrite = FALSE;

  if((destbuf==NULL)||(destbuflen == 0))
	  bNoWrite = TRUE;

  if ( ijlInit(&jcprops) != IJL_OK )
  {
    ijlFree(&jcprops);
    return 0;
  }

  jcprops.DIBWidth    = image_width;
  jcprops.DIBHeight   = image_height;
  jcprops.JPGWidth    = image_width;
  jcprops.JPGHeight   = image_height;
  jcprops.DIBBytes    = (unsigned char *) buf;
  jcprops.DIBPadBytes = 0;
  jcprops.DIBChannels = image_planes ;
  jcprops.JPGChannels = image_planes;

  if ( image_planes == 3 )
  {
    jcprops.DIBColor = IJL_RGB;
    jcprops.JPGColor = IJL_YCBCR;
    jcprops.JPGSubsampling = IJL_411;
    jcprops.DIBSubsampling = (IJL_DIBSUBSAMPLING) 0;
  }
  else
  {
    jcprops.DIBColor = IJL_OTHER;
    jcprops.JPGColor = IJL_OTHER;
    jcprops.JPGSubsampling = (IJL_JPGSUBSAMPLING) 0;
    jcprops.DIBSubsampling = (IJL_DIBSUBSAMPLING) 0;
	jcprops.cconversion_reqd = FALSE;
	jcprops.upsampling_reqd = FALSE;
  }

  int size = (image_width*image_height*image_planes<10000 ? 10000 : image_width*image_height*image_planes);

  unsigned char * buffer = (unsigned char*)malloc_func(size);

  jcprops.JPGSizeBytes = size;
  jcprops.JPGBytes     = buffer;

  jcprops.jquality = quality;


  if ( ijlWrite(&jcprops,IJL_JBUFF_WRITEWHOLEIMAGE) != IJL_OK )
  {
    ijlFree(&jcprops);
	if (bNoWrite == TRUE) free_func(buffer);
    return 0;
  }


  if ( ijlFree(&jcprops) != IJL_OK )
  {
	if (bNoWrite == TRUE) free_func(buffer);
    return 0;
  }

  if (bNoWrite == FALSE)
  {
	 memcpy(destbuf, buffer, jcprops.JPGSizeBytes);
  }
	free_func(buffer);

  return jcprops.JPGSizeBytes;
}
*/



/*
DWORD BuildBLP2(char *srcBuf, long width, long height, long bpp, char *destBuf, int quality)
{
	BOOL bSizeOnly = FALSE;
	if(destBuf==NULL)
		bSizeOnly=TRUE;

	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 = IJLWriteWrap((unsigned char*)resizedpic, curwidth*curheight*bpp/8, NULL, 0, quality, curwidth, curheight, 4);
		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);
		//IJLWriteWrap((unsigned char*)resizedpic, width*height*bpp/8, (unsigned char*)curpic, nn, quality, curwidth, curheight, 4);
		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;
		curheight/=2;
	}
 perilexit:

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

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



DWORD BuildBLP(char *srcBuf, long width, long height, long bpp, char *destBuf, int quality)
{
	BOOL bSizeOnly = FALSE;
	if(destBuf==NULL)
		bSizeOnly=TRUE;