HDC gblHDC;
HBITMAP gblHbm;
unsigned char *BitsConv;
PALETTEENTRY lapalette[256];
BITMAP                  bmConv;
HBITMAP                 hbmConv;
HDC                     hdcConv;

//Colle une image (très vieille fonction écrite par moi à l'époque ou je supportais encore
//l'anglais :|
int PasteImage(const char *fichier, int *dx, int *dy)	{
	hbmConv = (HBITMAP) LoadImage(NULL, fichier, IMAGE_BITMAP, 0, 0, LR_LOADFROMFILE|LR_CREATEDIBSECTION);
	if (!hbmConv)	{
		return 0;
	}
	GetObject(hbmConv, sizeof(bmConv), &bmConv);
	*dx=bmConv.bmWidth;
	*dy=bmConv.bmHeight;

	hdcConv = CreateCompatibleDC(GetDC(NULL));
	
	SelectObject(hdcConv, hbmConv);

	return 1;
}

//Crée une DIB de taille "cx" et "cy" pour pouvoir y dessiner en l'utilisant comme un
//bloc de mémoire de "ibitcount" bits par pixel. La sélectionne dans "hdc" et la stocke
//dans "hbm". Le pointeur sur les bits de cette bitmap sera écrit dans "bits".
int CreeDIB2(HDC hdc, int cx, int cy, int ibitcount, HBITMAP *hbm, void **bits, PALETTEENTRY* pPalEntries, int nCouleurs) 
{
   // Create a BITMAPINFOHEADER structure to describe the DIB.
   int iSize = sizeof(BITMAPINFOHEADER)+sizeof (PALETTEENTRY)*nCouleurs;
   int i;
   BITMAPINFO *bi;

   bi=(BITMAPINFO*)malloc(iSize);
   ASSERT((ibitcount == 8) || (ibitcount == 16) || (ibitcount == 24)) ;
   ASSERT(cx > 0);
   ASSERT(cy > 0);
   memset(&BIH, 0, sizeof(BITMAPINFOHEADER));

   // Fill in the header info. 
   BIH.biSize = sizeof(BITMAPINFOHEADER);
   BIH.biWidth = cx;
   BIH.biHeight = cy+1;
   BIH.biPlanes = 1;
   BIH.biBitCount = ibitcount;
   BIH.biCompression = BI_RGB;
   BIH.biClrUsed=nCouleurs;

   bi->bmiHeader=BIH;
//   memcpy(&bi->bmiColors,pPalEntries,sizeof (PALETTEENTRY)*nCouleurs);
   memset(&bi->bmiColors,0,sizeof (PALETTEENTRY)*nCouleurs);
   for (i=0;i<nCouleurs;i++)		{
	   bi->bmiColors[i].rgbRed=lapalette[i].peRed;
	   bi->bmiColors[i].rgbGreen=lapalette[i].peGreen;
	   bi->bmiColors[i].rgbBlue=lapalette[i].peBlue;
   }

   // Create a new device context.

   // Create the DIB section.
   *hbm = CreateDIBSection(hdc,
               (BITMAPINFO*) bi,
                             DIB_RGB_COLORS,
                             (void**)bits,
                             NULL,
                             0);
	
    ASSERT(*hbm);
    ASSERT(*bits);

    // Select the new bitmap into the buffer DC.
    if (*hbm && *bits)
    {
        SelectObject(hdc,*hbm);
		return 1;
    }
	else	{
		return 0;
	}
}

int tailleVoulueX, tailleVoulueY;

int ReductionHalftone(unsigned char *tableau, unsigned char *palette, int h, int l)		{
    HPALETTE hPalette;
	DIBSECTION ds;
	int i,cx,cy,x,y, nPad,nPad2, r,v,b, bas;
	unsigned char *ptr, *ptr2;


    hPalette = CreateHalftonePalette (GetDC(NULL));
	GetPaletteEntries(hPalette,0,256,lapalette);

	GetObject (hbmConv, sizeof (ds), &ds);
    nPad2 = ds.dsBm.bmWidthBytes - (((ds.dsBmih.biWidth *
        ds.dsBmih.biBitCount) + 7) / 8);

	lapalette[245].peBlue=255;
	lapalette[245].peGreen=255;
	lapalette[245].peRed=255;

	lapalette[255].peBlue=1;
	lapalette[255].peGreen=0;
	lapalette[255].peRed=0;

	gblHDC=CreateCompatibleDC(GetDC(NULL));
	cx=ds.dsBmih.biWidth;
	cy=ds.dsBmih.biHeight;
	CreeDIB2(gblHDC,cx,cy,8,&gblHbm,(void**)&BitsConv,lapalette,256);
	SelectObject(gblHDC,gblHbm);

	SetStretchBltMode(gblHDC,HALFTONE);
	StretchBlt(gblHDC,0,0,cx,cy,hdcConv,0,0,cx,cy,SRCCOPY);

	for (i=0;i<256;i++)		{
		palette[3*i]=lapalette[i].peBlue;
		palette[3*i+1]=lapalette[i].peGreen;
		palette[3*i+2]=lapalette[i].peRed;
	}

	nPad=(4-(cx&3))&3;

	ptr=BitsConv+cx+nPad;
	ptr2=(unsigned char *)ds.dsBm.bmBits;
	bas=tailleVoulueY-1-(tailleVoulueY-h);

	for (y=0;y<tailleVoulueY;y++)		{
		for (x=0;x<tailleVoulueX;x++)		{
			if (y>=h)
				tableau[y*tailleVoulueX+x]=0;
			else if (x>=l)
				tableau[(bas-y)*tailleVoulueX+x]=0;
			else	{
				b=*ptr2;
				v=*(ptr2+1);
				r=*(ptr2+2);
				ptr2+=3;
				if (r==255 && v==0 && b==254)
					tableau[(bas-y)*tailleVoulueX+x]=0;
				else
					tableau[(bas-y)*tailleVoulueX+x]=(*ptr)+1;
				ptr++;
			}
		}
		ptr+=nPad;
		ptr2+=nPad2;
	}

	DeleteObject(hPalette);
	DeleteObject(gblHbm);
	DeleteDC(gblHDC);
	DeleteDC(hdcConv);
	DeleteObject(hbmConv);

	return 255;
}

int ConvertitBmp(char *nom)			{
	ECRAN *ecr, ecrCourant;
	FILE *f;
	OBJET *obj;
	char dest[1000];
	int tX,tY, i,j;
	unsigned char *tableau;
	unsigned char *palette;
	unsigned short dim[2];

	strcpy(dest,nom);
	strcat(dest,".b8");
	strcat(nom,".bmp");

	obj=ChargeObjet(nom);

	if (!obj)			{
		Erreur("Fichier %s non trouvé!",nom);
		return 0;
	}

	PasteImage(nom,&tX,&tY);
	tailleVoulueX=tX, tailleVoulueY=tY;
	while(tailleVoulueX%4)
		tailleVoulueX++;
	tableau=(unsigned char*)malloc(tailleVoulueX*tY);
	palette=(unsigned char*)malloc(256*3);
	ReductionHalftone(tableau,palette,tY,tX);

	f=fopen(dest,"wb");
	dim[0]=tailleVoulueX;
	dim[1]=tY;
	fwrite(dim,sizeof(short),2,f);
	for (j=0;j<tY;j++)
		for (i=0;i<tailleVoulueX;i++)
			fputc(tableau[j*tailleVoulueX+i],f);

	fclose(f);

	free(tableau);
	free(palette);
	AffMsgChoix("Conversion terminée!");
	return 1;
}

