| 1 | /* $Id: cvtbitmap.cpp,v 1.3 2000-02-16 14:25:36 sandervl Exp $ */
|
|---|
| 2 |
|
|---|
| 3 | /*
|
|---|
| 4 | * PE2LX bitmap conversion code
|
|---|
| 5 | *
|
|---|
| 6 | * Copyright 1998 Sander van Leeuwen (sandervl@xs4all.nl)
|
|---|
| 7 | * Copyright 1998 Knut St. Osmundsen
|
|---|
| 8 | *
|
|---|
| 9 | *
|
|---|
| 10 | * Project Odin Software License can be found in LICENSE.TXT
|
|---|
| 11 | *
|
|---|
| 12 | */
|
|---|
| 13 | #define INCL_GPIBITMAPS
|
|---|
| 14 | #define INCL_BITMAPFILEFORMAT
|
|---|
| 15 | #define INCL_DOSFILEMGR /* File Manager values */
|
|---|
| 16 | #define INCL_DOSERRORS /* DOS Error values */
|
|---|
| 17 | #define INCL_DOSPROCESS /* DOS Process values */
|
|---|
| 18 | #define INCL_DOSMISC /* DOS Miscellanous values */
|
|---|
| 19 | #define INCL_WIN
|
|---|
| 20 | #include <os2wrap.h>
|
|---|
| 21 | #include <stdio.h>
|
|---|
| 22 | #include <string.h>
|
|---|
| 23 | #include <stdlib.h>
|
|---|
| 24 | #include <string.h>
|
|---|
| 25 | #include <assert.h>
|
|---|
| 26 | #include <win32type.h>
|
|---|
| 27 | #include <winicon.h>
|
|---|
| 28 | #include <misc.h>
|
|---|
| 29 | #include "cvtresource.h"
|
|---|
| 30 |
|
|---|
| 31 | #define DBG_LOCALLOG DBG_cvtbitmap
|
|---|
| 32 | #include "dbglocal.h"
|
|---|
| 33 |
|
|---|
| 34 | #define __StackToFlat(a) a
|
|---|
| 35 | #define ltassert(a)
|
|---|
| 36 | #define MAXPTR
|
|---|
| 37 | #define MINPTR
|
|---|
| 38 |
|
|---|
| 39 | /**********/
|
|---|
| 40 | /* Macros */
|
|---|
| 41 | /**********/
|
|---|
| 42 | #define Need1BitTo4BitConvertWIN(pBHdr) \
|
|---|
| 43 | ( \
|
|---|
| 44 | pBHdr->biBitCount == 1 \
|
|---|
| 45 | && !( \
|
|---|
| 46 | (((PULONG)pBHdr)[10] == 0x00000000 && (pBHdr->biClrUsed == 1 || ((PULONG)pBHdr)[11] == 0x00ffffff)) /*black and white*/ \
|
|---|
| 47 | || (((PULONG)pBHdr)[10] == 0x00ffffff && (pBHdr->biClrUsed == 1 || ((PULONG)pBHdr)[11] == 0x00000000)) /*white and black*/ \
|
|---|
| 48 | ) \
|
|---|
| 49 | )
|
|---|
| 50 |
|
|---|
| 51 | #define Need1BitTo4BitConvertOS2(pBIH) \
|
|---|
| 52 | ( \
|
|---|
| 53 | pBIH->cBitCount == 1 \
|
|---|
| 54 | && !( \
|
|---|
| 55 | (((PULONG)pBIH)[3] == 0x0ff00000 && ((PUSHORT)pBIH)[8] == 0xffff) /*black and white*/ \
|
|---|
| 56 | || (((PULONG)pBIH)[3] == 0x00ffffff && ((PUSHORT)pBIH)[8] == 0x0000) /*white and black*/ \
|
|---|
| 57 | ) \
|
|---|
| 58 | )
|
|---|
| 59 |
|
|---|
| 60 | static ULONG Convert1BitTo4Bit(void *pNewData, PBYTE pbOldData, LONG cx, LONG cy);
|
|---|
| 61 | static ULONG QueryPaletteSize(WINBITMAPINFOHEADER *pBHdr);
|
|---|
| 62 | static ULONG QueryPaletteSize(BITMAPINFOHEADER *pBHdr);
|
|---|
| 63 | static ULONG QueryPaletteSize(BITMAPINFOHEADER2 *pBHdr);
|
|---|
| 64 | static ULONG CalcBitmapSize(ULONG cBits, LONG cx, LONG cy);
|
|---|
| 65 |
|
|---|
| 66 | //******************************************************************************
|
|---|
| 67 | //******************************************************************************
|
|---|
| 68 | void *ConvertBitmap(WINBITMAPINFOHEADER *pBHdr, ULONG ulSize, PULONG pulSize)
|
|---|
| 69 | {
|
|---|
| 70 | ltassert((ULONG)pBHdr > MINPTR && (ULONG)pBHdr+ulSize < MAXPTR);
|
|---|
| 71 |
|
|---|
| 72 | switch (pBHdr->biSize)
|
|---|
| 73 | {
|
|---|
| 74 | /**************************************/
|
|---|
| 75 | /* Windows v3.0 bitmap */
|
|---|
| 76 | /**************************************/
|
|---|
| 77 | case sizeof(WINBITMAPINFOHEADER):
|
|---|
| 78 | {//convert to OS/2 v2.0 bitmap
|
|---|
| 79 | PBITMAPFILEHEADER2 pBFH;
|
|---|
| 80 | ULONG cbPalette;
|
|---|
| 81 | ULONG cbImage;
|
|---|
| 82 | BOOL fConvert1Bit = FALSE;
|
|---|
| 83 |
|
|---|
| 84 | dprintf(("Windows v3.0 bitmap"));
|
|---|
| 85 | dprintf((" Size: %d", pBHdr->biSizeImage));
|
|---|
| 86 | dprintf((" Width: %d", pBHdr->biWidth));
|
|---|
| 87 | dprintf((" Height: %d", pBHdr->biHeight));
|
|---|
| 88 | dprintf((" Bitcount: %d", pBHdr->biBitCount));
|
|---|
| 89 | dprintf((" Compress: %d", pBHdr->biCompression));
|
|---|
| 90 |
|
|---|
| 91 | fConvert1Bit = Need1BitTo4BitConvertWIN(pBHdr);
|
|---|
| 92 |
|
|---|
| 93 | cbPalette = QueryPaletteSize(pBHdr);
|
|---|
| 94 | ltassert(cbPalette != -1);
|
|---|
| 95 | dprintf((" PaletteSize: %d", cbPalette));
|
|---|
| 96 |
|
|---|
| 97 | /* calc bitmap size and allocate */
|
|---|
| 98 | #ifdef BITFIELDS
|
|---|
| 99 | if (pBHdr->biCompression == BI_RGB || pBHdr->biCompression == BI_BITFIELDS)
|
|---|
| 100 | #else
|
|---|
| 101 | if (pBHdr->biCompression == BI_RGB)
|
|---|
| 102 | #endif
|
|---|
| 103 | {
|
|---|
| 104 | /* recalc for non-compressed images */
|
|---|
| 105 | if (fConvert1Bit)
|
|---|
| 106 | cbImage = CalcBitmapSize(4, pBHdr->biWidth, pBHdr->biHeight);
|
|---|
| 107 | else cbImage = CalcBitmapSize(pBHdr->biBitCount, pBHdr->biWidth, pBHdr->biHeight);
|
|---|
| 108 | }
|
|---|
| 109 | else
|
|---|
| 110 | {
|
|---|
| 111 | ltassert(!fConvert1Bit);
|
|---|
| 112 | cbImage = pBHdr->biSizeImage;
|
|---|
| 113 | if (cbImage == 0)
|
|---|
| 114 | cbImage = ulSize - sizeof(WINBITMAPINFOHEADER) + sizeof(BITMAPFILEHEADER2);
|
|---|
| 115 | }
|
|---|
| 116 | ltassert(cbImage != 0);
|
|---|
| 117 |
|
|---|
| 118 | //bounds checking
|
|---|
| 119 | if (!fConvert1Bit)
|
|---|
| 120 | { /* brackets must not be removed! */
|
|---|
| 121 | ltassert(cbImage <= ulSize - sizeof(WINBITMAPINFOHEADER) - cbPalette);
|
|---|
| 122 | }
|
|---|
| 123 | else ltassert(CalcBitmapSize(pBHdr->biBitCount, pBHdr->biWidth, pBHdr->biHeight) <= ulSize - sizeof(WINBITMAPINFOHEADER) - cbPalette);
|
|---|
| 124 |
|
|---|
| 125 | *pulSize = sizeof(BITMAPFILEHEADER2) + cbPalette + cbImage;
|
|---|
| 126 |
|
|---|
| 127 | dprintf((" Debug: Size(recalced): %d", cbImage));
|
|---|
| 128 | dprintf((" Debug: Size in : %d", ulSize));
|
|---|
| 129 | dprintf((" Debug: Size out : %D", *pulSize));
|
|---|
| 130 |
|
|---|
| 131 | pBFH = (PBITMAPFILEHEADER2)malloc(*pulSize + 0x10);//allocate more than we need!
|
|---|
| 132 | ltassert(pBFH);
|
|---|
| 133 |
|
|---|
| 134 | /* file header */
|
|---|
| 135 | pBFH->usType = BFT_BMAP;
|
|---|
| 136 | pBFH->cbSize = sizeof(BITMAPFILEHEADER2);
|
|---|
| 137 | pBFH->xHotspot = 0;
|
|---|
| 138 | pBFH->yHotspot = 0;
|
|---|
| 139 | pBFH->offBits = sizeof(BITMAPFILEHEADER2) + cbPalette;
|
|---|
| 140 |
|
|---|
| 141 | /* info header*/
|
|---|
| 142 | memset((void*)&pBFH->bmp2, 0, sizeof(BITMAPINFOHEADER2));
|
|---|
| 143 | memcpy((void*)&pBFH->bmp2, (void*)pBHdr, sizeof(WINBITMAPINFOHEADER));
|
|---|
| 144 | pBFH->bmp2.cbFix = sizeof(BITMAPINFOHEADER2);
|
|---|
| 145 |
|
|---|
| 146 | /* bitfields */
|
|---|
| 147 | if (pBFH->bmp2.ulCompression == BI_BITFIELDS)
|
|---|
| 148 | {//TODO: Identical except for BI_BITFIELDS (3L) type! - cast a warning note
|
|---|
| 149 | /* KSO: I need files to test it on */
|
|---|
| 150 | #ifndef BITFIELDS
|
|---|
| 151 | dprintf(("Warning: ulCompression = BI_BITFIELDS"));
|
|---|
| 152 | pBFH->bmp2.ulCompression = BCA_UNCOMP; //since BI_BITFIELDS == BCA_RLE24
|
|---|
| 153 | #else
|
|---|
| 154 | #error("Sorry, BITFIELDS are not implmented yet.")
|
|---|
| 155 | /* generate new palette */
|
|---|
| 156 | /* convert bitmap data */
|
|---|
| 157 | /* update fileheader */
|
|---|
| 158 | #endif //#ifdef BITFIELDS
|
|---|
| 159 | }
|
|---|
| 160 |
|
|---|
| 161 | /* palette */
|
|---|
| 162 | if (cbPalette > 0)
|
|---|
| 163 | memcpy((void*)((ULONG)pBFH + sizeof(BITMAPFILEHEADER2)), (void*)((ULONG)pBHdr + sizeof(WINBITMAPINFOHEADER)), cbPalette);
|
|---|
| 164 |
|
|---|
| 165 | /* bitmap data */
|
|---|
| 166 | if (fConvert1Bit)
|
|---|
| 167 | {
|
|---|
| 168 | /* convert */
|
|---|
| 169 | Convert1BitTo4Bit(
|
|---|
| 170 | (PVOID)((ULONG)pBFH + sizeof(BITMAPFILEHEADER2) + cbPalette),
|
|---|
| 171 | (PBYTE)((ULONG)pBHdr + sizeof(WINBITMAPINFOHEADER)+ cbPalette),
|
|---|
| 172 | pBFH->bmp2.cx,
|
|---|
| 173 | pBFH->bmp2.cy
|
|---|
| 174 | );
|
|---|
| 175 |
|
|---|
| 176 | /* update some infoheader fields */
|
|---|
| 177 | pBFH->bmp2.cBitCount = 4;
|
|---|
| 178 | if (pBFH->bmp2.cclrUsed == 0)
|
|---|
| 179 | pBFH->bmp2.cclrUsed = 2;
|
|---|
| 180 | if (pBFH->bmp2.cbImage != 0)
|
|---|
| 181 | pBFH->bmp2.cbImage = cbImage;
|
|---|
| 182 | }
|
|---|
| 183 | else memcpy((void*)((ULONG)pBFH + sizeof(BITMAPFILEHEADER2) + cbPalette), (void*)((ULONG)pBHdr + sizeof(WINBITMAPINFOHEADER) + cbPalette), cbImage);
|
|---|
| 184 |
|
|---|
| 185 | return pBFH;
|
|---|
| 186 | }
|
|---|
| 187 |
|
|---|
| 188 | /**************************************/
|
|---|
| 189 | /* Windows v4.0 bitmap */
|
|---|
| 190 | /**************************************/
|
|---|
| 191 | case sizeof(BITMAPV4HEADER):
|
|---|
| 192 | {//convert to OS/2 v2.0 bitmap - some other day when I find the specs.
|
|---|
| 193 | dprintf(("Windows v4.0 bitmap"));
|
|---|
| 194 | dprintf((" Not supported yet!"));
|
|---|
| 195 | ltassert(FALSE && "Windows v4.0 bitmap");
|
|---|
| 196 | break;
|
|---|
| 197 | }
|
|---|
| 198 |
|
|---|
| 199 | /**************************************/
|
|---|
| 200 | /* OS/2 v1.x bitmap */
|
|---|
| 201 | /**************************************/
|
|---|
| 202 | case sizeof(BITMAPINFOHEADER):
|
|---|
| 203 | {//no conversion needed - only build fileheader
|
|---|
| 204 | PBITMAPINFOHEADER pBIH = (PBITMAPINFOHEADER)pBHdr;
|
|---|
| 205 | PBITMAPFILEHEADER pBFH ;
|
|---|
| 206 | BOOL fConvert1Bit;
|
|---|
| 207 | ULONG cbPalette;
|
|---|
| 208 |
|
|---|
| 209 | cbPalette = QueryPaletteSize(pBIH);
|
|---|
| 210 | ltassert(cbPalette != -1);
|
|---|
| 211 | *pulSize = ulSize + sizeof(BITMAPFILEHEADER) - sizeof(BITMAPINFOHEADER);
|
|---|
| 212 |
|
|---|
| 213 | fConvert1Bit = Need1BitTo4BitConvertOS2(pBIH);
|
|---|
| 214 | if (fConvert1Bit)
|
|---|
| 215 | *pulSize += (ulSize - cbPalette - sizeof(BITMAPINFOHEADER))*3 + 14 * sizeof(RGB);
|
|---|
| 216 |
|
|---|
| 217 | pBFH = (PBITMAPFILEHEADER)malloc(*pulSize);
|
|---|
| 218 | ltassert(pBFH != NULL);
|
|---|
| 219 |
|
|---|
| 220 | if (fConvert1Bit)
|
|---|
| 221 | {
|
|---|
| 222 | /* copy infoheader */
|
|---|
| 223 | memcpy(&pBFH->bmp, pBIH, sizeof(pBFH->bmp));
|
|---|
| 224 | memset((void*)((ULONG)pBFH + sizeof(*pBFH)), 0, 16*sizeof(RGB));
|
|---|
| 225 | memcpy((void*)((ULONG)pBFH + sizeof(*pBFH)), (void*)((ULONG)pBIH + sizeof(*pBIH)), 2*sizeof(RGB));
|
|---|
| 226 | *pulSize = Convert1BitTo4Bit(
|
|---|
| 227 | (PVOID)((ULONG)pBFH + sizeof(BITMAPFILEHEADER) + 16 * sizeof(RGB)),
|
|---|
| 228 | (PBYTE)((ULONG)pBHdr + sizeof(BITMAPINFOHEADER) + cbPalette),
|
|---|
| 229 | pBFH->bmp.cx,
|
|---|
| 230 | pBFH->bmp.cy
|
|---|
| 231 | );
|
|---|
| 232 |
|
|---|
| 233 | /* update infoheader */
|
|---|
| 234 | pBFH->bmp.cBitCount = 4;
|
|---|
| 235 | cbPalette = 16 * sizeof(RGB); //used in fileheader
|
|---|
| 236 | }
|
|---|
| 237 | else
|
|---|
| 238 | {
|
|---|
| 239 | /* copy entire bitmap from infoheader */
|
|---|
| 240 | memcpy(&pBFH->bmp, pBIH, ulSize);
|
|---|
| 241 | *pulSize = CalcBitmapSize(pBIH->cBitCount, pBIH->cx, pBIH->cy);
|
|---|
| 242 | ltassert(*pulSize != 0);
|
|---|
| 243 | }
|
|---|
| 244 | *pulSize += sizeof(BITMAPFILEHEADER) + cbPalette;
|
|---|
| 245 |
|
|---|
| 246 | /* fileheader */
|
|---|
| 247 | pBFH->usType = BFT_BMAP;
|
|---|
| 248 | pBFH->cbSize = sizeof(BITMAPFILEHEADER);
|
|---|
| 249 | pBFH->xHotspot = 0;
|
|---|
| 250 | pBFH->yHotspot = 0;
|
|---|
| 251 | pBFH->offBits = sizeof(BITMAPFILEHEADER) + cbPalette;
|
|---|
| 252 |
|
|---|
| 253 | /* log info */
|
|---|
| 254 | dprintf(("OS/2 v1.x bitmap"));
|
|---|
| 255 | dprintf((" Width: %d", pBFH->bmp.cx));
|
|---|
| 256 | dprintf((" Height: %d", pBFH->bmp.cy));
|
|---|
| 257 | dprintf((" Bitcount: %d", pBFH->bmp.cBitCount));
|
|---|
| 258 | dprintf((" PaletteSize: %d", cbPalette));
|
|---|
| 259 | dprintf(("debug 1"));
|
|---|
| 260 |
|
|---|
| 261 | return (void*)pBFH;
|
|---|
| 262 | }
|
|---|
| 263 |
|
|---|
| 264 | /**************************************/
|
|---|
| 265 | /* OS/2 v2.0 bitmap - highly unlikely!*/
|
|---|
| 266 | /**************************************/
|
|---|
| 267 | case sizeof(BITMAPINFOHEADER2):
|
|---|
| 268 | {//no conversion needed - only build fileheader
|
|---|
| 269 | PBITMAPFILEHEADER2 pBFH;
|
|---|
| 270 |
|
|---|
| 271 | pBFH = (PBITMAPFILEHEADER2)malloc(ulSize + sizeof(BITMAPFILEHEADER2) - sizeof(BITMAPINFOHEADER2));
|
|---|
| 272 | ltassert(pBFH != NULL);
|
|---|
| 273 |
|
|---|
| 274 | memcpy(&pBFH->bmp2, pBHdr, ulSize);
|
|---|
| 275 |
|
|---|
| 276 | pBFH->usType = BFT_BMAP;
|
|---|
| 277 | pBFH->cbSize = sizeof(BITMAPFILEHEADER2);
|
|---|
| 278 | pBFH->xHotspot = 0;
|
|---|
| 279 | pBFH->yHotspot = 0;
|
|---|
| 280 | pBFH->offBits = sizeof(BITMAPFILEHEADER2);
|
|---|
| 281 |
|
|---|
| 282 | dprintf(("OS/2 v2.0 bitmap"));
|
|---|
| 283 | dprintf((" Width: %d", pBFH->bmp2.cx));
|
|---|
| 284 | dprintf((" Height: %d", pBFH->bmp2.cy));
|
|---|
| 285 | dprintf((" Bitcount: %d", pBFH->bmp2.cBitCount));
|
|---|
| 286 |
|
|---|
| 287 | if (pBFH->bmp2.cBitCount < 24)
|
|---|
| 288 | pBFH->offBits += ( 1, pBFH->bmp2.cBitCount ) * sizeof(RGB2);
|
|---|
| 289 | else pBFH->offBits += pBFH->bmp2.cclrUsed;
|
|---|
| 290 |
|
|---|
| 291 | return pBFH;
|
|---|
| 292 | }
|
|---|
| 293 |
|
|---|
| 294 |
|
|---|
| 295 | /**************************************/
|
|---|
| 296 | /* Unknown */
|
|---|
| 297 | /**************************************/
|
|---|
| 298 | default: //fail
|
|---|
| 299 | dprintf(("ConvertBitmap - default - fail!"));
|
|---|
| 300 | return NULL;
|
|---|
| 301 | }
|
|---|
| 302 |
|
|---|
| 303 | return NULL;
|
|---|
| 304 | }
|
|---|
| 305 | //******************************************************************************
|
|---|
| 306 | //******************************************************************************
|
|---|
| 307 | /* Converting 1 bit bitmaps to 4 bit bitmaps
|
|---|
| 308 | */
|
|---|
| 309 | //******************************************************************************
|
|---|
| 310 | //******************************************************************************
|
|---|
| 311 | static ULONG Convert1BitTo4Bit(void *pNewData, PBYTE pbOldData, LONG cx, LONG cy)
|
|---|
| 312 | {
|
|---|
| 313 | PBYTE pbNewData = (PBYTE)pNewData;
|
|---|
| 314 |
|
|---|
| 315 | dprintf((" 1->4 convert"));
|
|---|
| 316 |
|
|---|
| 317 | //negative height
|
|---|
| 318 | cy = cy < 0 ? -cy : cy;
|
|---|
| 319 |
|
|---|
| 320 | *pbNewData = 0;
|
|---|
| 321 | for (int y = 0; y < cy; y++)
|
|---|
| 322 | {//outer loop: lines
|
|---|
| 323 | int x;
|
|---|
| 324 |
|
|---|
| 325 | for (x = 0; x < cx; x++)
|
|---|
| 326 | {//inner loop: scanline
|
|---|
| 327 | int iBit = 7-(x%8);
|
|---|
| 328 | *pbNewData |= (((0x1, iBit) & *pbOldData) >> iBit), (iBit%2)*4;
|
|---|
| 329 |
|
|---|
| 330 | if (x % 2)
|
|---|
| 331 | {
|
|---|
| 332 | pbNewData++;
|
|---|
| 333 | *pbNewData = 0;
|
|---|
| 334 | }
|
|---|
| 335 |
|
|---|
| 336 | if ((x+1) % 8 == 0)
|
|---|
| 337 | pbOldData++;
|
|---|
| 338 | }
|
|---|
| 339 |
|
|---|
| 340 | //next byte
|
|---|
| 341 | if (x % 2)
|
|---|
| 342 | {
|
|---|
| 343 | pbNewData++;
|
|---|
| 344 | *pbNewData = 0;
|
|---|
| 345 | }
|
|---|
| 346 | if ((x+1) % 8 == 0)
|
|---|
| 347 | pbOldData++;
|
|---|
| 348 |
|
|---|
| 349 | //aligning
|
|---|
| 350 | for (int a = ((x+1)/2)%4; a < 4 && a != 0; a++)
|
|---|
| 351 | {
|
|---|
| 352 | pbNewData++;
|
|---|
| 353 | *pbNewData = 0;
|
|---|
| 354 | }
|
|---|
| 355 | for (int b = ((x+7)/8)%4; b < 4 && b != 0; b++)
|
|---|
| 356 | pbOldData++;
|
|---|
| 357 | }
|
|---|
| 358 |
|
|---|
| 359 | return (int)pbNewData - (int)pNewData;
|
|---|
| 360 | }
|
|---|
| 361 | //******************************************************************************
|
|---|
| 362 | //******************************************************************************
|
|---|
| 363 | static ULONG QueryPaletteSize(WINBITMAPINFOHEADER *pBHdr)
|
|---|
| 364 | {
|
|---|
| 365 | ULONG cbPalette;
|
|---|
| 366 |
|
|---|
| 367 | switch (pBHdr->biBitCount)
|
|---|
| 368 | {
|
|---|
| 369 | case 1:
|
|---|
| 370 | case 4:
|
|---|
| 371 | case 8:
|
|---|
| 372 | /* Windows Bitmaps seems to have a full palette even when it don't use all of it - OS/2 does not...
|
|---|
| 373 | Good for us, the fileheader holds the offset to the bitmap data - which means that this not should be a problem, luckily. */
|
|---|
| 374 | //cbPalette = ((pBHdr->biClrUsed != 0) ? pBHdr->biClrUsed : 1, pBHdr->biBitCount) * sizeof(RGB2);
|
|---|
| 375 | cbPalette = (1, pBHdr->biBitCount) * sizeof(RGB2);
|
|---|
| 376 | break;
|
|---|
| 377 |
|
|---|
| 378 | case 16:
|
|---|
| 379 | case 32:
|
|---|
| 380 | #ifdef BITFIELDS
|
|---|
| 381 | if (pBHdr->biCompression == BI_BITFIELDS)
|
|---|
| 382 | {
|
|---|
| 383 | cbPalette = 3* sizeof(DWORD);
|
|---|
| 384 | break;
|
|---|
| 385 | }
|
|---|
| 386 | #endif
|
|---|
| 387 | case 24:
|
|---|
| 388 | /* docs have it that there may be a palette used for optmizing processing of 16, 24 and 32 bits bitmaps */
|
|---|
| 389 | /* the size of the palette is contained in biClrUsed - don't know if it stored as number of colors or as bytes... */
|
|---|
| 390 | cbPalette = pBHdr->biClrUsed; //size in bytes or in (*sizeof(RGB2))?
|
|---|
| 391 | break;
|
|---|
| 392 |
|
|---|
| 393 | default:
|
|---|
| 394 | dprintf(("QueryPaletteSize: error pBHdr->biBitCount = %d", pBHdr->biBitCount));
|
|---|
| 395 | cbPalette = -1;
|
|---|
| 396 | }
|
|---|
| 397 |
|
|---|
| 398 | return cbPalette;
|
|---|
| 399 | }
|
|---|
| 400 | //******************************************************************************
|
|---|
| 401 | //******************************************************************************
|
|---|
| 402 | static ULONG QueryPaletteSize(BITMAPINFOHEADER *pBHdr)
|
|---|
| 403 | {
|
|---|
| 404 | ULONG cbPalette;
|
|---|
| 405 |
|
|---|
| 406 | switch (pBHdr->cBitCount)
|
|---|
| 407 | {
|
|---|
| 408 | case 1:
|
|---|
| 409 | case 4:
|
|---|
| 410 | case 8:
|
|---|
| 411 | cbPalette = (1, pBHdr->cBitCount) * sizeof(RGB);
|
|---|
| 412 | break;
|
|---|
| 413 |
|
|---|
| 414 | case 16:
|
|---|
| 415 | case 24:
|
|---|
| 416 | case 32:
|
|---|
| 417 | cbPalette = 0;
|
|---|
| 418 | break;
|
|---|
| 419 |
|
|---|
| 420 | default:
|
|---|
| 421 | dprintf(("QueryPaletteSize: error pBHdr->biBitCount = %d", pBHdr->cBitCount));
|
|---|
| 422 | cbPalette = -1;
|
|---|
| 423 | }
|
|---|
| 424 |
|
|---|
| 425 | return cbPalette;
|
|---|
| 426 | }
|
|---|
| 427 | //******************************************************************************
|
|---|
| 428 | //******************************************************************************
|
|---|
| 429 | static ULONG QueryPaletteSize(BITMAPINFOHEADER2 *pBHdr)
|
|---|
| 430 | {
|
|---|
| 431 | ULONG cbPalette;
|
|---|
| 432 |
|
|---|
| 433 | switch (pBHdr->cBitCount)
|
|---|
| 434 | {
|
|---|
| 435 | case 1:
|
|---|
| 436 | case 4:
|
|---|
| 437 | case 8:
|
|---|
| 438 | cbPalette = ((pBHdr->cclrUsed != 0) ? pBHdr->cclrUsed : 1, pBHdr->cBitCount) * sizeof(RGB2);
|
|---|
| 439 | //cbPalette = (1, pBHdr->cBitCount) * sizeof(RGB2);
|
|---|
| 440 | break;
|
|---|
| 441 |
|
|---|
| 442 | case 16:
|
|---|
| 443 | case 32:
|
|---|
| 444 | case 24:
|
|---|
| 445 | /* docs have it that there may be a palette used for optmizing processing of 16, 24 and 32 bits bitmaps */
|
|---|
| 446 | /* the size of the palette is contained in biClrUsed - don't know if it stored as number of colors or as bytes... */
|
|---|
| 447 | cbPalette = pBHdr->cclrUsed; //size in bytes or in (*sizeof(RGB2))?
|
|---|
| 448 | break;
|
|---|
| 449 |
|
|---|
| 450 | default:
|
|---|
| 451 | dprintf(("QueryPaletteSize: error pBHdr->biBitCount = %d", pBHdr->cBitCount));
|
|---|
| 452 | cbPalette = -1;
|
|---|
| 453 | }
|
|---|
| 454 |
|
|---|
| 455 | return cbPalette;
|
|---|
| 456 | }
|
|---|
| 457 | //******************************************************************************
|
|---|
| 458 | //******************************************************************************
|
|---|
| 459 | static ULONG CalcBitmapSize(ULONG cBits, LONG cx, LONG cy)
|
|---|
| 460 | {
|
|---|
| 461 | ULONG alignment;
|
|---|
| 462 | ULONG factor;
|
|---|
| 463 | BOOL flag = TRUE; //true: '*' false: '/'
|
|---|
| 464 |
|
|---|
| 465 | cy = cy < 0 ? -cy : cy;
|
|---|
| 466 |
|
|---|
| 467 | switch(cBits)
|
|---|
| 468 | {
|
|---|
| 469 | case 1:
|
|---|
| 470 | factor = 8;
|
|---|
| 471 | flag = FALSE;
|
|---|
| 472 | break;
|
|---|
| 473 |
|
|---|
| 474 | case 4:
|
|---|
| 475 | factor = 2;
|
|---|
| 476 | flag = FALSE;
|
|---|
| 477 | break;
|
|---|
| 478 |
|
|---|
| 479 | case 8:
|
|---|
| 480 | factor = 1;
|
|---|
| 481 | break;
|
|---|
| 482 |
|
|---|
| 483 | case 16:
|
|---|
| 484 | factor = 2;
|
|---|
| 485 | break;
|
|---|
| 486 |
|
|---|
| 487 | case 24:
|
|---|
| 488 | factor = 3;
|
|---|
| 489 | break;
|
|---|
| 490 |
|
|---|
| 491 | case 32:
|
|---|
| 492 | return cx*cy;
|
|---|
| 493 |
|
|---|
| 494 | default:
|
|---|
| 495 | return 0;
|
|---|
| 496 | }
|
|---|
| 497 |
|
|---|
| 498 | if (flag)
|
|---|
| 499 | alignment = (cx = (cx*factor)) % 4;
|
|---|
| 500 | else
|
|---|
| 501 | alignment = (cx = ((cx+factor-1)/factor)) % 4;
|
|---|
| 502 |
|
|---|
| 503 | if (alignment != 0)
|
|---|
| 504 | cx += 4 - alignment;
|
|---|
| 505 |
|
|---|
| 506 | return cx*cy;
|
|---|
| 507 | }
|
|---|
| 508 | //******************************************************************************
|
|---|
| 509 | //******************************************************************************
|
|---|
| 510 | ULONG QueryConvertedBitmapSize(WINBITMAPINFOHEADER *pBHdr, ULONG ulSize)
|
|---|
| 511 | {
|
|---|
| 512 | ULONG retSize;
|
|---|
| 513 | ltassert((ULONG)pBHdr > MINPTR && (ULONG)pBHdr+ulSize < MAXPTR);
|
|---|
| 514 |
|
|---|
| 515 | switch (pBHdr->biSize)
|
|---|
| 516 | {
|
|---|
| 517 | /**************************************/
|
|---|
| 518 | /* Windows v3.0 bitmap */
|
|---|
| 519 | /**************************************/
|
|---|
| 520 | case sizeof(WINBITMAPINFOHEADER):
|
|---|
| 521 | {//convert to OS/2 v2.0 bitmap
|
|---|
| 522 | #ifdef BITFIELDS
|
|---|
| 523 | if (pBHdr->biCompression == BI_RGB || pBHdr->biCompression == BI_BITFIELDS)
|
|---|
| 524 | #else
|
|---|
| 525 | if (pBHdr->biCompression == BI_RGB)
|
|---|
| 526 | #endif
|
|---|
| 527 | {
|
|---|
| 528 | if (Need1BitTo4BitConvertWIN(pBHdr))
|
|---|
| 529 | retSize = CalcBitmapSize(4, pBHdr->biWidth, pBHdr->biHeight);
|
|---|
| 530 | else retSize = CalcBitmapSize(pBHdr->biBitCount, pBHdr->biWidth, pBHdr->biHeight);
|
|---|
| 531 | }
|
|---|
| 532 | else
|
|---|
| 533 | {
|
|---|
| 534 | retSize = pBHdr->biSizeImage;
|
|---|
| 535 | if (retSize == 0)
|
|---|
| 536 | retSize = ulSize - sizeof(WINBITMAPINFOHEADER) + sizeof(BITMAPFILEHEADER2);
|
|---|
| 537 | }
|
|---|
| 538 | ltassert(retSize != 0);
|
|---|
| 539 |
|
|---|
| 540 | ULONG a = QueryPaletteSize(pBHdr);
|
|---|
| 541 | ltassert(a != -1);
|
|---|
| 542 | retSize += sizeof(BITMAPFILEHEADER2) + a;
|
|---|
| 543 | break;
|
|---|
| 544 | }
|
|---|
| 545 |
|
|---|
| 546 | /**************************************/
|
|---|
| 547 | /* Windows v4.0 bitmap */
|
|---|
| 548 | /**************************************/
|
|---|
| 549 | case sizeof(BITMAPV4HEADER):
|
|---|
| 550 | {//convert to OS/2 v2.0 bitmap - some other day when I find the specs.
|
|---|
| 551 | ltassert(FALSE && "Windows v4.0 bitmap");
|
|---|
| 552 | break;
|
|---|
| 553 | }
|
|---|
| 554 |
|
|---|
| 555 | /**************************************/
|
|---|
| 556 | /* OS/2 v1.x bitmap */
|
|---|
| 557 | /**************************************/
|
|---|
| 558 | case sizeof(BITMAPINFOHEADER):
|
|---|
| 559 | {//no conversion needed - only build fileheader
|
|---|
| 560 | PBITMAPINFOHEADER pBIH = (PBITMAPINFOHEADER)pBHdr;
|
|---|
| 561 |
|
|---|
| 562 | if (Need1BitTo4BitConvertOS2(pBIH))
|
|---|
| 563 | {
|
|---|
| 564 | retSize = CalcBitmapSize(4, pBIH->cx, pBIH->cy);
|
|---|
| 565 | ltassert(retSize != 0);
|
|---|
| 566 |
|
|---|
| 567 | retSize += sizeof(RGB)*16; //palette
|
|---|
| 568 | }
|
|---|
| 569 | else
|
|---|
| 570 | {
|
|---|
| 571 | retSize = CalcBitmapSize(pBIH->cBitCount, pBIH->cx, pBIH->cy);
|
|---|
| 572 | ltassert(retSize != 0);
|
|---|
| 573 |
|
|---|
| 574 | ULONG a = QueryPaletteSize(pBIH);
|
|---|
| 575 | ltassert(a != -1);
|
|---|
| 576 | retSize += a;
|
|---|
| 577 | }
|
|---|
| 578 |
|
|---|
| 579 | retSize += sizeof(BITMAPFILEHEADER);
|
|---|
| 580 | }
|
|---|
| 581 |
|
|---|
| 582 | /**************************************/
|
|---|
| 583 | /* OS/2 v2.0 bitmap - highly unlikely!*/
|
|---|
| 584 | /**************************************/
|
|---|
| 585 | case sizeof(BITMAPINFOHEADER2):
|
|---|
| 586 | {//no conversion needed - only build fileheader
|
|---|
| 587 | return ulSize + sizeof(BITMAPFILEHEADER2) - sizeof(BITMAPINFOHEADER2);
|
|---|
| 588 | }
|
|---|
| 589 |
|
|---|
| 590 | /**************************************/
|
|---|
| 591 | /* Unknown */
|
|---|
| 592 | /**************************************/
|
|---|
| 593 | default: //fail
|
|---|
| 594 | dprintf(("QueryConvertedBitmapSize - default - fail!"));
|
|---|
| 595 | return 0;
|
|---|
| 596 | }
|
|---|
| 597 |
|
|---|
| 598 | return retSize;
|
|---|
| 599 | }
|
|---|
| 600 | //******************************************************************************
|
|---|
| 601 | //******************************************************************************
|
|---|
