source: trunk/src/pe2lx/bitmap.cpp

Last change on this file was 97, checked in by phaller, 26 years ago

Add: added cvs variable $Id$ to source files.
File size: 30.5 KB
Line 
1/* $Id: bitmap.cpp,v 1.3 1999-06-10 17:08:52 phaller 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 <os2.h>
21#include <stdio.h>
22#include <string.h>
23#include <stdlib.h>
24#include <iostream.h>
25#include <string.h>
26#include <assert.h>
27#include "pefile.h"
28#include "lx.h"
29#include "icon.h"
30#include "bitmap.h"
31#include "misc.h"
32
33
34#define __StackToFlat(a) a
35#define ltassert(a)
36#define MAXPTR
37#define MINPTR
38
39
40/*
41 * HISTORY
42 * * * * * *
43 * KSO - Aug 3 1998 6:30pm:
44 * -Fixed some bugs.
45 * -Standalone bitmap converter.
46 * -Need a 16 and/or 32bit bitmaps to test these and to implement bitfields
47 *
48 * KSO - Aug 1 1998 6:22pm:
49 * -Rewrote everything.
50 * -New bitmaps from nt/win9x are not supported but detected. Need docs!!!
51 * -2 COLOR (not BW) bitmaps are now converted to 16 color bitmaps.
52 * Converting of OS/2 v1.x bitmaps (2 color -> 16 color) are not tested
53 * -All Resources should have 3 operation: Show<rsrc>, Convert<rsrc> and QuerySize<rsrc>
54 */
55
56
57/* COMPILETIME CONVERSION OPTIONS */
58//#define NO_1BIT_TO_4BIT_CONVERSION
59//#define DUMP_BMPS_TO_FILES
60
61#ifdef DUMP_BMPS_TO_FILES
62 #include <stdio.h>
63#endif
64
65static ULONG Convert1BitTo4Bit(void *pNewData, PBYTE pbOldData, LONG cx, LONG cy);
66static ULONG QueryPaletteSize(WINBITMAPINFOHEADER *pBHdr);
67static ULONG QueryPaletteSize(BITMAPINFOHEADER *pBHdr);
68static ULONG QueryPaletteSize(BITMAPINFOHEADER2 *pBHdr);
69static ULONG CalcBitmapSize(ULONG cBits, LONG cx, LONG cy);
70
71
72
73/**********/
74/* Macros */
75/**********/
76#define Need1BitTo4BitConvertWIN(pBHdr) \
77 ( \
78 pBHdr->biBitCount == 1 \
79 && !( \
80 (((PULONG)pBHdr)[10] == 0x00000000 && (pBHdr->biClrUsed == 1 || ((PULONG)pBHdr)[11] == 0x00ffffff)) /*black and white*/ \
81 || (((PULONG)pBHdr)[10] == 0x00ffffff && (pBHdr->biClrUsed == 1 || ((PULONG)pBHdr)[11] == 0x00000000)) /*white and black*/ \
82 ) \
83 )
84
85#define Need1BitTo4BitConvertOS2(pBIH) \
86 ( \
87 pBIH->cBitCount == 1 \
88 && !( \
89 (((PULONG)pBIH)[3] == 0x0ff00000 && ((PUSHORT)pBIH)[8] == 0xffff) /*black and white*/ \
90 || (((PULONG)pBIH)[3] == 0x00ffffff && ((PUSHORT)pBIH)[8] == 0x0000) /*white and black*/ \
91 ) \
92 )
93
94
95
96/*************/
97/* Functions */
98/*************/
99#ifndef BITMAPCONVERTER
100
101BOOL ShowBitmap(LXHeader &OS2Exe, int id, WINBITMAPINFOHEADER *bhdr, int size)
102{
103 void *pConvertedBitmap;
104 ULONG ulSize;
105 BOOL rc;
106
107 pConvertedBitmap = ConvertBitmap(bhdr, size, (PULONG)__StackToFlat(&ulSize));
108 if (pConvertedBitmap != NULL)
109 {
110 OS2Exe.StoreResource(id, RT_BITMAP, ulSize, (char *)pConvertedBitmap);
111
112 #ifdef DUMP_BMPS_TO_FILES
113 /* debug option to dump bitmaps to file(s). */
114 char szFilename[CCHMAXPATH];
115 sprintf(__StackToFlat(szFilename), "%d.bmp", id);
116 FILE *pFile = fopen(szFilename, "wb");
117 if (pFile != NULL)
118 {
119 fwrite(pConvertedBitmap, 1, ulSize, pFile);
120 fclose(pFile);
121 }
122 else
123 cout << "warning: could not open " << szFilename << endl;
124
125 sprintf(__StackToFlat(szFilename), "w%d.bmp", id);
126 pFile = fopen(szFilename, "wb");
127 if (pFile != NULL)
128 {
129 PBITMAPFILEHEADER pBFHConv = (PBITMAPFILEHEADER)pConvertedBitmap;
130 BITMAPFILEHEADER BFHWin;
131 memcpy( (void*)&BFHWin, (void*)pConvertedBitmap, sizeof(BFHWin));
132 BFHWin.cbSize -= pBFHConv->bmp.cbFix - bhdr->biSize;
133 BFHWin.offBits -= pBFHConv->bmp.cbFix - bhdr->biSize;
134
135 fwrite(&BFHWin, 1, 14, pFile);
136 fwrite(bhdr, 1, size, pFile);
137 fclose(pFile);
138 }
139 else
140 cout << "warning: could not open " << szFilename << endl;
141
142 #endif //DUMP_BMPS_TO_FILES
143 free(pConvertedBitmap);
144 }
145 else
146 rc = FALSE;
147
148 return rc;
149}
150
151#endif //#ifndef BITMAPCONVERTER
152
153
154void *ConvertBitmap(WINBITMAPINFOHEADER *pBHdr, ULONG ulSize, PULONG pulSize)
155{
156 ltassert((ULONG)pBHdr > MINPTR && (ULONG)pBHdr+ulSize < MAXPTR);
157
158 switch (pBHdr->biSize)
159 {
160 /**************************************/
161 /* Windows v3.0 bitmap */
162 /**************************************/
163 case sizeof(WINBITMAPINFOHEADER):
164 {//convert to OS/2 v2.0 bitmap
165 PBITMAPFILEHEADER2 pBFH;
166 ULONG cbPalette;
167 ULONG cbImage;
168 BOOL fConvert1Bit = FALSE;
169
170 cout << "Windows v3.0 bitmap" << endl;
171 cout << " Size: " << pBHdr->biSizeImage << endl;
172 cout << " Width: " << pBHdr->biWidth << endl;
173 cout << " Height: " << pBHdr->biHeight << endl;
174 cout << " Bitcount: " << pBHdr->biBitCount << endl;
175 cout << " Compress: " << pBHdr->biCompression << endl;
176
177 #ifndef NO_1BIT_TO_4BIT_CONVERSION
178 fConvert1Bit = Need1BitTo4BitConvertWIN(pBHdr);
179 #endif
180
181 cbPalette = QueryPaletteSize(pBHdr);
182 ltassert(cbPalette != -1);
183 cout << " PaletteSize: " << cbPalette << endl;
184
185
186 /* calc bitmap size and allocate */
187 #ifdef BITFIELDS
188 if (pBHdr->biCompression == BI_RGB || pBHdr->biCompression == BI_BITFIELDS)
189 #else
190 if (pBHdr->biCompression == BI_RGB)
191 #endif
192 {
193 /* recalc for non-compressed images */
194 if (fConvert1Bit)
195 cbImage = CalcBitmapSize(4, pBHdr->biWidth, pBHdr->biHeight);
196 else
197 cbImage = CalcBitmapSize(pBHdr->biBitCount, pBHdr->biWidth, pBHdr->biHeight);
198 }
199 else
200 {
201 ltassert(!fConvert1Bit);
202 cbImage = pBHdr->biSizeImage;
203 if (cbImage == 0)
204 cbImage = ulSize - sizeof(WINBITMAPINFOHEADER) + sizeof(BITMAPFILEHEADER2);
205 }
206 ltassert(cbImage != 0);
207
208 //bounds checking
209 if (!fConvert1Bit)
210 { /* brackets must not be removed! */
211 ltassert(cbImage <= ulSize - sizeof(WINBITMAPINFOHEADER) - cbPalette);
212 }
213 else
214 {
215 ltassert(CalcBitmapSize(pBHdr->biBitCount, pBHdr->biWidth, pBHdr->biHeight) <= ulSize - sizeof(WINBITMAPINFOHEADER) - cbPalette);
216 }
217
218 *pulSize = sizeof(BITMAPFILEHEADER2) + cbPalette + cbImage;
219
220 cout << " Debug: Size(recalced): " << cbImage << endl;
221 cout << " Debug: Size in : " << ulSize << endl;
222 cout << " Debug: Size out : " << *pulSize << endl;
223
224 pBFH = (PBITMAPFILEHEADER2)malloc(*pulSize + 0x10);//allocate more than we need!
225 ltassert(pBFH);
226
227
228 /* file header */
229 pBFH->usType = BFT_BMAP;
230 pBFH->cbSize = sizeof(BITMAPFILEHEADER2);
231 pBFH->xHotspot = 0;
232 pBFH->yHotspot = 0;
233 pBFH->offBits = sizeof(BITMAPFILEHEADER2) + cbPalette;
234
235
236 /* info header*/
237 memset((void*)&pBFH->bmp2, 0, sizeof(BITMAPINFOHEADER2));
238 memcpy((void*)&pBFH->bmp2, (void*)pBHdr, sizeof(WINBITMAPINFOHEADER));
239 pBFH->bmp2.cbFix = sizeof(BITMAPINFOHEADER2);
240
241 /* bitfields */
242 if (pBFH->bmp2.ulCompression == BI_BITFIELDS)
243 {//TODO: Identical except for BI_BITFIELDS (3L) type! - cast a warning note
244 /* KSO: I need files to test it on */
245 #ifndef BITFIELDS
246 cout << "Warning: ulCompression = BI_BITFIELDS" << endl;
247 pBFH->bmp2.ulCompression = BCA_UNCOMP; //since BI_BITFIELDS == BCA_RLE24
248 #else
249 #error("Sorry, BITFIELDS are not implmented yet.")
250 /* generate new palette */
251 /* convert bitmap data */
252 /* update fileheader */
253 #endif //#ifdef BITFIELDS
254 #ifdef RING0
255 ltassert(FALSE && "bitfields are fatal\n");
256 #endif
257 }
258
259
260 /* palette */
261 if (cbPalette > 0)
262 memcpy((void*)((ULONG)pBFH + sizeof(BITMAPFILEHEADER2)), (void*)((ULONG)pBHdr + sizeof(WINBITMAPINFOHEADER)), cbPalette);
263
264
265 /* bitmap data */
266 if (fConvert1Bit)
267 {
268 /* convert */
269 Convert1BitTo4Bit(
270 (PVOID)((ULONG)pBFH + sizeof(BITMAPFILEHEADER2) + cbPalette),
271 (PBYTE)((ULONG)pBHdr + sizeof(WINBITMAPINFOHEADER)+ cbPalette),
272 pBFH->bmp2.cx,
273 pBFH->bmp2.cy
274 );
275
276 /* update some infoheader fields */
277 pBFH->bmp2.cBitCount = 4;
278 if (pBFH->bmp2.cclrUsed == 0)
279 pBFH->bmp2.cclrUsed = 2;
280 if (pBFH->bmp2.cbImage != 0)
281 pBFH->bmp2.cbImage = cbImage;
282 }
283 else
284 memcpy((void*)((ULONG)pBFH + sizeof(BITMAPFILEHEADER2) + cbPalette), (void*)((ULONG)pBHdr + sizeof(WINBITMAPINFOHEADER) + cbPalette), cbImage);
285
286 return pBFH;
287 }
288
289
290
291 /**************************************/
292 /* Windows v4.0 bitmap */
293 /**************************************/
294 case sizeof(BITMAPV4HEADER):
295 {//convert to OS/2 v2.0 bitmap - some other day when I find the specs.
296 cout << "Windows v4.0 bitmap" << endl;
297 cout << " Not supported yet!" << endl;
298 ltassert(FALSE && "Windows v4.0 bitmap");
299 }
300 break;
301
302
303 /**************************************/
304 /* OS/2 v1.x bitmap */
305 /**************************************/
306 case sizeof(BITMAPINFOHEADER):
307 {//no conversion needed - only build fileheader
308 PBITMAPINFOHEADER pBIH = (PBITMAPINFOHEADER)pBHdr;
309 PBITMAPFILEHEADER pBFH ;
310 BOOL fConvert1Bit;
311 ULONG cbPalette;
312
313 cbPalette = QueryPaletteSize(pBIH);
314 ltassert(cbPalette != -1);
315 *pulSize = ulSize + sizeof(BITMAPFILEHEADER) - sizeof(BITMAPINFOHEADER);
316
317 fConvert1Bit = Need1BitTo4BitConvertOS2(pBIH);
318 #ifdef NO_1BIT_TO_4BIT_CONVERSION
319 fConvert1Bit = FALSE;
320 #endif
321
322 if (fConvert1Bit)
323 *pulSize += (ulSize - cbPalette - sizeof(BITMAPINFOHEADER))*3 + 14 * sizeof(RGB);
324
325 pBFH = (PBITMAPFILEHEADER)malloc(*pulSize);
326 ltassert(pBFH != NULL);
327
328 if (fConvert1Bit)
329 {
330 /* copy infoheader */
331 memcpy(&pBFH->bmp, pBIH, sizeof(pBFH->bmp));
332 memset((void*)((ULONG)pBFH + sizeof(*pBFH)), 0, 16*sizeof(RGB));
333 memcpy((void*)((ULONG)pBFH + sizeof(*pBFH)), (void*)((ULONG)pBIH + sizeof(*pBIH)), 2*sizeof(RGB));
334 *pulSize = Convert1BitTo4Bit(
335 (PVOID)((ULONG)pBFH + sizeof(BITMAPFILEHEADER) + 16 * sizeof(RGB)),
336 (PBYTE)((ULONG)pBHdr + sizeof(BITMAPINFOHEADER) + cbPalette),
337 pBFH->bmp.cx,
338 pBFH->bmp.cy
339 );
340
341 /* update infoheader */
342 pBFH->bmp.cBitCount = 4;
343 cbPalette = 16 * sizeof(RGB); //used in fileheader
344 }
345 else
346 {
347 /* copy entire bitmap from infoheader */
348 memcpy(&pBFH->bmp, pBIH, ulSize);
349 *pulSize = CalcBitmapSize(pBIH->cBitCount, pBIH->cx, pBIH->cy);
350 ltassert(*pulSize != 0);
351 }
352 *pulSize += sizeof(BITMAPFILEHEADER) + cbPalette;
353
354 /* fileheader */
355 pBFH->usType = BFT_BMAP;
356 pBFH->cbSize = sizeof(BITMAPFILEHEADER);
357 pBFH->xHotspot = 0;
358 pBFH->yHotspot = 0;
359 pBFH->offBits = sizeof(BITMAPFILEHEADER) + cbPalette;
360
361 /* log info */
362 cout << "OS/2 v1.x bitmap" << endl;
363 cout << " Width: " << pBFH->bmp.cx << endl;
364 cout << " Height: " << pBFH->bmp.cy << endl;
365 cout << " Bitcount: " << pBFH->bmp.cBitCount << endl;
366 cout << " PaletteSize: " << cbPalette << endl;
367 cout << "debug 1" << endl;
368
369 return (void*)pBFH;
370 }
371
372
373
374 /**************************************/
375 /* OS/2 v2.0 bitmap - highly unlikely!*/
376 /**************************************/
377 case sizeof(BITMAPINFOHEADER2):
378 {//no conversion needed - only build fileheader
379 PBITMAPFILEHEADER2 pBFH;
380 pBFH = (PBITMAPFILEHEADER2)malloc(ulSize + sizeof(BITMAPFILEHEADER2) - sizeof(BITMAPINFOHEADER2));
381 ltassert(pBFH != NULL);
382
383 memcpy(&pBFH->bmp2, pBHdr, ulSize);
384
385 pBFH->usType = BFT_BMAP;
386 pBFH->cbSize = sizeof(BITMAPFILEHEADER2);
387 pBFH->xHotspot = 0;
388 pBFH->yHotspot = 0;
389 pBFH->offBits = sizeof(BITMAPFILEHEADER2);
390
391 cout << "OS/2 v2.0 bitmap" << endl;
392 cout << " Width: " << pBFH->bmp2.cx << endl;
393 cout << " Height: " << pBFH->bmp2.cy << endl;
394 cout << " Bitcount: " << pBFH->bmp2.cBitCount << endl;
395
396 if (pBFH->bmp2.cBitCount < 24)
397 pBFH->offBits += ( 1 << pBFH->bmp2.cBitCount ) * sizeof(RGB2);
398 else
399 pBFH->offBits += pBFH->bmp2.cclrUsed;
400
401 return pBFH;
402 }
403
404
405 /**************************************/
406 /* Unknown */
407 /**************************************/
408 default: //fail
409 cout << "ConvertBitmap - default - fail!" << endl;
410 return NULL;
411 }
412
413 return NULL;
414}
415
416
417
418
419/* Converting 1 bit bitmaps to 4 bit bitmaps
420 */
421static ULONG Convert1BitTo4Bit(void *pNewData, PBYTE pbOldData, LONG cx, LONG cy)
422{
423 PBYTE pbNewData = (PBYTE)pNewData;
424
425 cout << " 1->4 convert" << endl;
426
427 //negative height
428 cy = cy < 0 ? -cy : cy;
429
430 *pbNewData = 0;
431 for (int y = 0; y < cy; y++)
432 {//outer loop: lines
433 int x;
434
435 for (x = 0; x < cx; x++)
436 {//inner loop: scanline
437 int iBit = 7-(x%8);
438 *pbNewData |= (((0x1 << iBit) & *pbOldData) >> iBit) << (iBit%2)*4;
439
440 if (x % 2)
441 {
442 pbNewData++;
443 *pbNewData = 0;
444 }
445
446 if ((x+1) % 8 == 0)
447 pbOldData++;
448 }
449
450 //next byte
451 if (x % 2)
452 {
453 pbNewData++;
454 *pbNewData = 0;
455 }
456 if ((x+1) % 8 == 0)
457 pbOldData++;
458
459 //aligning
460 for (int a = ((x+1)/2)%4; a < 4 && a != 0; a++)
461 {
462 pbNewData++;
463 *pbNewData = 0;
464 }
465 for (int b = ((x+7)/8)%4; b < 4 && b != 0; b++)
466 pbOldData++;
467 }
468
469 return (int)pbNewData - (int)pNewData;
470}
471
472
473
474static ULONG QueryPaletteSize(WINBITMAPINFOHEADER *pBHdr)
475{
476 ULONG cbPalette;
477
478 switch (pBHdr->biBitCount)
479 {
480 case 1:
481 case 4:
482 case 8:
483 /* Windows Bitmaps seems to have a full palette even when it don't use all of it - OS/2 does not...
484 Good for us, the fileheader holds the offset to the bitmap data - which means that this not should be a problem, luckily. */
485 //cbPalette = ((pBHdr->biClrUsed != 0) ? pBHdr->biClrUsed : 1 << pBHdr->biBitCount) * sizeof(RGB2);
486 cbPalette = (1 << pBHdr->biBitCount) * sizeof(RGB2);
487 break;
488
489 case 16:
490 case 32:
491 #ifdef BITFIELDS
492 if (pBHdr->biCompression == BI_BITFIELDS)
493 {
494 cbPalette = 3* sizeof(DWORD);
495 break;
496 }
497 #endif
498 case 24:
499 /* docs have it that there may be a palette used for optmizing processing of 16, 24 and 32 bits bitmaps */
500 /* the size of the palette is contained in biClrUsed - don't know if it stored as number of colors or as bytes... */
501 cbPalette = pBHdr->biClrUsed; //size in bytes or in (*sizeof(RGB2))?
502 break;
503
504 default:
505 cout << "QueryPaletteSize: error pBHdr->biBitCount = " << pBHdr->biBitCount << endl;
506 cbPalette = -1;
507 }
508
509 return cbPalette;
510}
511
512
513static ULONG QueryPaletteSize(BITMAPINFOHEADER *pBHdr)
514{
515 ULONG cbPalette;
516
517 switch (pBHdr->cBitCount)
518 {
519 case 1:
520 case 4:
521 case 8:
522 cbPalette = (1 << pBHdr->cBitCount) * sizeof(RGB);
523 break;
524
525 case 16:
526 case 24:
527 case 32:
528 cbPalette = 0;
529 break;
530
531 default:
532 cout << "QueryPaletteSize: error pBHdr->biBitCount = " << pBHdr->cBitCount << endl;
533 cbPalette = -1;
534 }
535
536 return cbPalette;
537}
538
539
540static ULONG QueryPaletteSize(BITMAPINFOHEADER2 *pBHdr)
541{
542 ULONG cbPalette;
543
544 switch (pBHdr->cBitCount)
545 {
546 case 1:
547 case 4:
548 case 8:
549 cbPalette = ((pBHdr->cclrUsed != 0) ? pBHdr->cclrUsed : 1 << pBHdr->cBitCount) * sizeof(RGB2);
550 //cbPalette = (1 << pBHdr->cBitCount) * sizeof(RGB2);
551 break;
552
553 case 16:
554 case 32:
555 case 24:
556 /* docs have it that there may be a palette used for optmizing processing of 16, 24 and 32 bits bitmaps */
557 /* the size of the palette is contained in biClrUsed - don't know if it stored as number of colors or as bytes... */
558 cbPalette = pBHdr->cclrUsed; //size in bytes or in (*sizeof(RGB2))?
559 break;
560
561 default:
562 cout << "QueryPaletteSize: error pBHdr->biBitCount = " << pBHdr->cBitCount << endl;
563 cbPalette = -1;
564 }
565
566 return cbPalette;
567}
568
569
570
571
572static ULONG CalcBitmapSize(ULONG cBits, LONG cx, LONG cy)
573{
574 ULONG alignment;
575 ULONG factor;
576 BOOL flag = TRUE; //true: '*' false: '/'
577
578 cy = cy < 0 ? -cy : cy;
579
580 switch(cBits)
581 {
582 case 1:
583 factor = 8;
584 flag = FALSE;
585 break;
586
587 case 4:
588 factor = 2;
589 flag = FALSE;
590 break;
591
592 case 8:
593 factor = 1;
594 break;
595
596 case 16:
597 factor = 2;
598 break;
599
600 case 24:
601 factor = 3;
602 break;
603
604 case 32:
605 return cx*cy;
606
607 default:
608 return 0;
609 }
610
611 if (flag)
612 alignment = (cx = (cx*factor)) % 4;
613 else
614 alignment = (cx = ((cx+factor-1)/factor)) % 4;
615
616 if (alignment != 0)
617 cx += 4 - alignment;
618
619 return cx*cy;
620}
621
622
623ULONG QuerySizeBitmap(WINBITMAPINFOHEADER *pBHdr, ULONG ulSize)
624{
625 ULONG retSize;
626 ltassert((ULONG)pBHdr > MINPTR && (ULONG)pBHdr+ulSize < MAXPTR);
627
628 switch (pBHdr->biSize)
629 {
630 /**************************************/
631 /* Windows v3.0 bitmap */
632 /**************************************/
633 case sizeof(WINBITMAPINFOHEADER):
634 {//convert to OS/2 v2.0 bitmap
635 #ifdef BITFIELDS
636 if (pBHdr->biCompression == BI_RGB || pBHdr->biCompression == BI_BITFIELDS)
637 #else
638 if (pBHdr->biCompression == BI_RGB)
639 #endif
640 {
641 if (Need1BitTo4BitConvertWIN(pBHdr))
642 retSize = CalcBitmapSize(4, pBHdr->biWidth, pBHdr->biHeight);
643 else
644 retSize = CalcBitmapSize(pBHdr->biBitCount, pBHdr->biWidth, pBHdr->biHeight);
645 }
646 else
647 {
648 retSize = pBHdr->biSizeImage;
649 if (retSize == 0)
650 retSize = ulSize - sizeof(WINBITMAPINFOHEADER) + sizeof(BITMAPFILEHEADER2);
651 }
652 ltassert(retSize != 0);
653
654 ULONG a = QueryPaletteSize(pBHdr);
655 ltassert(a != -1);
656 retSize += sizeof(BITMAPFILEHEADER2) + a;
657 }
658 break;
659
660 /**************************************/
661 /* Windows v4.0 bitmap */
662 /**************************************/
663 case sizeof(BITMAPV4HEADER):
664 {//convert to OS/2 v2.0 bitmap - some other day when I find the specs.
665 ltassert(FALSE && "Windows v4.0 bitmap");
666 }
667 break;
668
669 /**************************************/
670 /* OS/2 v1.x bitmap */
671 /**************************************/
672 case sizeof(BITMAPINFOHEADER):
673 {//no conversion needed - only build fileheader
674 PBITMAPINFOHEADER pBIH = (PBITMAPINFOHEADER)pBHdr;
675
676 if (Need1BitTo4BitConvertOS2(pBIH))
677 {
678 retSize = CalcBitmapSize(4, pBIH->cx, pBIH->cy);
679 ltassert(retSize != 0);
680
681 retSize += sizeof(RGB)*16; //palette
682 }
683 else
684 {
685 retSize = CalcBitmapSize(pBIH->cBitCount, pBIH->cx, pBIH->cy);
686 ltassert(retSize != 0);
687
688 ULONG a = QueryPaletteSize(pBIH);
689 ltassert(a != -1);
690 retSize += a;
691 }
692
693 retSize += sizeof(BITMAPFILEHEADER);
694 }
695
696 /**************************************/
697 /* OS/2 v2.0 bitmap - highly unlikely!*/
698 /**************************************/
699 case sizeof(BITMAPINFOHEADER2):
700 {//no conversion needed - only build fileheader
701 return ulSize + sizeof(BITMAPFILEHEADER2) - sizeof(BITMAPINFOHEADER2);
702 }
703
704 /**************************************/
705 /* Unknown */
706 /**************************************/
707 default: //fail
708 cout << "QuerySizeBitmap - default - fail!" << endl;
709 return 0;
710 }
711
712 return retSize;
713}
714
715
716#ifdef BITMAPCONVERTER
717
718ULONG fsize(FILE *ph)
719{
720 LONG lPos;
721 ULONG ulSize;
722
723 lPos = ftell(ph);
724 fseek(ph, 0, SEEK_END);
725 ulSize = ftell(ph);
726 fseek(ph, lPos, SEEK_SET);
727
728 return ulSize;
729}
730
731
732void main(int argi, char **argc)
733{
734 char *pF1Buf;
735 char *pF2Buf;
736 char *pszF1;
737 char *pszF2;
738 FILE *phF1;
739 FILE *phF2;
740 ULONG cbF1;
741 ULONG cbF2;
742
743 /* tittle */
744 cout << "PE2LX Resources: Bitmap Convert v0.0.2alpha" << endl;
745
746 /* quick test of arguments */
747 if (argi < 3)
748 {
749 cout << "error: incorrect number of parameters" << endl;
750 return;
751 }
752 pszF1 = argc[1];
753 pszF2 = argc[2];
754
755 /* open files */
756 phF1 = fopen(pszF1, "rb");
757 phF2 = fopen(pszF2, "wb");
758 if (phF1 == NULL || phF2 == NULL)
759 {
760 cout << "error: could not open file ";
761 if (phF1 == NULL)
762 cout << pszF1 << endl;
763 else
764 cout << pszF2 << endl;
765 }
766
767
768 /* read infile */
769 cbF1 = fsize(phF1);
770 if (cbF1 > sizeof(BITMAPFILEHEADER))
771 {
772 pF1Buf = (char*)malloc(cbF1);
773 assert(pF1Buf != NULL);
774
775 if (fread(pF1Buf, 1, cbF1, phF1))
776 {
777 ULONG ulOffset;
778 if (pF1Buf[0]=='B' && pF1Buf[1]=='M')
779 ulOffset = sizeof(BITMAPFILEHEADER) - sizeof(BITMAPINFOHEADER);
780 else
781 ulOffset = 0;
782 pF2Buf = (char*)ConvertBitmap((WINBITMAPINFOHEADER*)&pF1Buf[ulOffset], cbF1-ulOffset, &cbF2);
783 if (pF2Buf != NULL)
784 {
785 cout << "filesize: " << cbF2 << endl;
786 if (fwrite (pF2Buf, 1, cbF2, phF2))
787 cout << "Converted bitmap is successfully written to disk." << endl;
788 else
789 cout << "error: error occured while writing converted bitmap to disk." << endl;
790 free(pF2Buf);
791 }
792 else
793 cout << "error: failed!" << endl;
794 }
795 else
796 cout << "error: error while reading infile" << endl;
797
798 free(pF1Buf);
799 }
800 else
801 cout << "error: invalid infile" << endl;
802
803 /* finished */
804 fclose(phF1);
805 fclose(phF2);
806}
807
808#endif
Note: See TracBrowser for help on using the repository browser.