home *** CD-ROM | disk | FTP | other *** search
/ PC PowerPlay 58 / pcpp58a.iso / extras / quake 3 source / Q3A_ToolSource.exe / Main / LBMLIB.CPP < prev    next >
Encoding:
C/C++ Source or Header  |  2001-01-02  |  27.0 KB  |  1,309 lines
  1. // lbmlib.c
  2.  
  3. #include "stdafx.h"
  4. #include "cmdlib.h"
  5. #include "lbmlib.h"
  6. #include "bmp.h"
  7. #include "pakstuff.h"
  8. #include "jpeglib.h"
  9.  
  10.  
  11. /*
  12. ============================================================================
  13.  
  14.                         LBM STUFF
  15.  
  16. ============================================================================
  17. */
  18.  
  19.  
  20. typedef unsigned char    UBYTE;
  21. //conflicts with windows typedef short            WORD;
  22. typedef unsigned short    UWORD;
  23. typedef long            LONG;
  24.  
  25. typedef enum
  26. {
  27.     ms_none,
  28.     ms_mask,
  29.     ms_transcolor,
  30.     ms_lasso
  31. } mask_t;
  32.  
  33. typedef enum
  34. {
  35.     cm_none,
  36.     cm_rle1
  37. } compress_t;
  38.  
  39. typedef struct
  40. {
  41.     UWORD        w,h;
  42.     short        x,y;
  43.     UBYTE        nPlanes;
  44.     UBYTE        masking;
  45.     UBYTE        compression;
  46.     UBYTE        pad1;
  47.     UWORD        transparentColor;
  48.     UBYTE        xAspect,yAspect;
  49.     short        pageWidth,pageHeight;
  50. } bmhd_t;
  51.  
  52. extern    bmhd_t    bmhd;                        // will be in native byte order
  53.  
  54.  
  55.  
  56. #define FORMID ('F'+('O'<<8)+((int)'R'<<16)+((int)'M'<<24))
  57. #define ILBMID ('I'+('L'<<8)+((int)'B'<<16)+((int)'M'<<24))
  58. #define PBMID  ('P'+('B'<<8)+((int)'M'<<16)+((int)' '<<24))
  59. #define BMHDID ('B'+('M'<<8)+((int)'H'<<16)+((int)'D'<<24))
  60. #define BODYID ('B'+('O'<<8)+((int)'D'<<16)+((int)'Y'<<24))
  61. #define CMAPID ('C'+('M'<<8)+((int)'A'<<16)+((int)'P'<<24))
  62.  
  63.  
  64. bmhd_t  bmhd;
  65.  
  66. int    Align (int l)
  67. {
  68.     if (l&1)
  69.         return l+1;
  70.     return l;
  71. }
  72.  
  73.  
  74.  
  75. /*
  76. ================
  77. LBMRLEdecompress
  78.  
  79. Source must be evenly aligned!
  80. ================
  81. */
  82. byte  *LBMRLEDecompress (byte *source,byte *unpacked, int bpwidth)
  83. {
  84.     int     count;
  85.     byte    b,rept;
  86.  
  87.     count = 0;
  88.  
  89.     do
  90.     {
  91.         rept = *source++;
  92.  
  93.         if (rept > 0x80)
  94.         {
  95.             rept = (rept^0xff)+2;
  96.             b = *source++;
  97.             memset(unpacked,b,rept);
  98.             unpacked += rept;
  99.         }
  100.         else if (rept < 0x80)
  101.         {
  102.             rept++;
  103.             memcpy(unpacked,source,rept);
  104.             unpacked += rept;
  105.             source += rept;
  106.         }
  107.         else
  108.             rept = 0;               // rept of 0x80 is NOP
  109.  
  110.         count += rept;
  111.  
  112.     } while (count<bpwidth);
  113.  
  114.     if (count>bpwidth)
  115.         Error ("Decompression exceeded width!\n");
  116.  
  117.  
  118.     return source;
  119. }
  120.  
  121.  
  122. /*
  123. =================
  124. LoadLBM
  125. =================
  126. */
  127. void LoadLBM (char *filename, byte **picture, byte **palette)
  128. {
  129.     byte    *LBMbuffer, *picbuffer, *cmapbuffer;
  130.     int             y;
  131.     byte    *LBM_P, *LBMEND_P;
  132.     byte    *pic_p;
  133.     byte    *body_p;
  134.  
  135.     int    formtype,formlength;
  136.     int    chunktype,chunklength;
  137.  
  138. // qiet compiler warnings
  139.     picbuffer = NULL;
  140.     cmapbuffer = NULL;
  141.  
  142. //
  143. // load the LBM
  144. //
  145.     LoadFile (filename, (void **)&LBMbuffer);
  146.  
  147.   if (LBMbuffer == NULL)
  148.   {
  149.     return;
  150.   }
  151. //
  152. // parse the LBM header
  153. //
  154.     LBM_P = LBMbuffer;
  155.     if ( *(int *)LBMbuffer != LittleLong(FORMID) )
  156.        Error ("No FORM ID at start of file!\n");
  157.  
  158.     LBM_P += 4;
  159.     formlength = BigLong( *(int *)LBM_P );
  160.     LBM_P += 4;
  161.     LBMEND_P = LBM_P + Align(formlength);
  162.  
  163.     formtype = LittleLong(*(int *)LBM_P);
  164.  
  165.     if (formtype != ILBMID && formtype != PBMID)
  166.         Error ("Unrecognized form type: %c%c%c%c\n", formtype&0xff
  167.         ,(formtype>>8)&0xff,(formtype>>16)&0xff,(formtype>>24)&0xff);
  168.  
  169.     LBM_P += 4;
  170.  
  171. //
  172. // parse chunks
  173. //
  174.  
  175.     while (LBM_P < LBMEND_P)
  176.     {
  177.         chunktype = LBM_P[0] + (LBM_P[1]<<8) + (LBM_P[2]<<16) + (LBM_P[3]<<24);
  178.         LBM_P += 4;
  179.         chunklength = LBM_P[3] + (LBM_P[2]<<8) + (LBM_P[1]<<16) + (LBM_P[0]<<24);
  180.         LBM_P += 4;
  181.  
  182.         switch ( chunktype )
  183.         {
  184.         case BMHDID:
  185.             memcpy (&bmhd,LBM_P,sizeof(bmhd));
  186.             bmhd.w = BigShort(bmhd.w);
  187.             bmhd.h = BigShort(bmhd.h);
  188.             bmhd.x = BigShort(bmhd.x);
  189.             bmhd.y = BigShort(bmhd.y);
  190.             bmhd.pageWidth = BigShort(bmhd.pageWidth);
  191.             bmhd.pageHeight = BigShort(bmhd.pageHeight);
  192.             break;
  193.  
  194.         case CMAPID:
  195.             cmapbuffer = (unsigned char*)malloc (768);
  196.             memset (cmapbuffer, 0, 768);
  197.             memcpy (cmapbuffer, LBM_P, chunklength);
  198.             break;
  199.  
  200.         case BODYID:
  201.             body_p = LBM_P;
  202.  
  203.             pic_p = picbuffer = (unsigned char*)malloc (bmhd.w*bmhd.h);
  204.             if (formtype == PBMID)
  205.             {
  206.             //
  207.             // unpack PBM
  208.             //
  209.                 for (y=0 ; y<bmhd.h ; y++, pic_p += bmhd.w)
  210.                 {
  211.                     if (bmhd.compression == cm_rle1)
  212.                         body_p = LBMRLEDecompress ((byte *)body_p
  213.                         , pic_p , bmhd.w);
  214.                     else if (bmhd.compression == cm_none)
  215.                     {
  216.                         memcpy (pic_p,body_p,bmhd.w);
  217.                         body_p += Align(bmhd.w);
  218.                     }
  219.                 }
  220.  
  221.             }
  222.             else
  223.             {
  224.             //
  225.             // unpack ILBM
  226.             //
  227.                 Error ("%s is an interlaced LBM, not packed", filename);
  228.             }
  229.             break;
  230.         }
  231.  
  232.         LBM_P += Align(chunklength);
  233.     }
  234.  
  235.     free (LBMbuffer);
  236.  
  237.     *picture = picbuffer;
  238.  
  239.     if (palette)
  240.         *palette = cmapbuffer;
  241. }
  242.  
  243.  
  244. /*
  245. ============================================================================
  246.  
  247.                             WRITE LBM
  248.  
  249. ============================================================================
  250. */
  251.  
  252. /*
  253. ==============
  254. WriteLBMfile
  255. ==============
  256. */
  257. void WriteLBMfile (char *filename, byte *data,
  258.                    int width, int height, byte *palette)
  259. {
  260.     byte    *lbm, *lbmptr;
  261.     int    *formlength, *bmhdlength, *cmaplength, *bodylength;
  262.     int    length;
  263.     bmhd_t  basebmhd;
  264.  
  265.     lbm = lbmptr = (unsigned char*)malloc (width*height+1000);
  266.  
  267. //
  268. // start FORM
  269. //
  270.     *lbmptr++ = 'F';
  271.     *lbmptr++ = 'O';
  272.     *lbmptr++ = 'R';
  273.     *lbmptr++ = 'M';
  274.  
  275.     formlength = (int*)lbmptr;
  276.     lbmptr+=4;                      // leave space for length
  277.  
  278.     *lbmptr++ = 'P';
  279.     *lbmptr++ = 'B';
  280.     *lbmptr++ = 'M';
  281.     *lbmptr++ = ' ';
  282.  
  283. //
  284. // write BMHD
  285. //
  286.     *lbmptr++ = 'B';
  287.     *lbmptr++ = 'M';
  288.     *lbmptr++ = 'H';
  289.     *lbmptr++ = 'D';
  290.  
  291.     bmhdlength = (int *)lbmptr;
  292.     lbmptr+=4;                      // leave space for length
  293.  
  294.     memset (&basebmhd,0,sizeof(basebmhd));
  295.     basebmhd.w = BigShort((short)width);
  296.     basebmhd.h = BigShort((short)height);
  297.     basebmhd.nPlanes = 8;
  298.     basebmhd.xAspect = 5;
  299.     basebmhd.yAspect = 6;
  300.     basebmhd.pageWidth = BigShort((short)width);
  301.     basebmhd.pageHeight = BigShort((short)height);
  302.  
  303.     memcpy (lbmptr,&basebmhd,sizeof(basebmhd));
  304.     lbmptr += sizeof(basebmhd);
  305.  
  306.     length = lbmptr-(byte *)bmhdlength-4;
  307.     *bmhdlength = BigLong(length);
  308.     if (length&1)
  309.         *lbmptr++ = 0;          // pad chunk to even offset
  310.  
  311. //
  312. // write CMAP
  313. //
  314.     *lbmptr++ = 'C';
  315.     *lbmptr++ = 'M';
  316.     *lbmptr++ = 'A';
  317.     *lbmptr++ = 'P';
  318.  
  319.     cmaplength = (int *)lbmptr;
  320.     lbmptr+=4;                      // leave space for length
  321.  
  322.     memcpy (lbmptr,palette,768);
  323.     lbmptr += 768;
  324.  
  325.     length = lbmptr-(byte *)cmaplength-4;
  326.     *cmaplength = BigLong(length);
  327.     if (length&1)
  328.         *lbmptr++ = 0;          // pad chunk to even offset
  329.  
  330. //
  331. // write BODY
  332. //
  333.     *lbmptr++ = 'B';
  334.     *lbmptr++ = 'O';
  335.     *lbmptr++ = 'D';
  336.     *lbmptr++ = 'Y';
  337.  
  338.     bodylength = (int *)lbmptr;
  339.     lbmptr+=4;                      // leave space for length
  340.  
  341.     memcpy (lbmptr,data,width*height);
  342.     lbmptr += width*height;
  343.  
  344.     length = lbmptr-(byte *)bodylength-4;
  345.     *bodylength = BigLong(length);
  346.     if (length&1)
  347.         *lbmptr++ = 0;          // pad chunk to even offset
  348.  
  349. //
  350. // done
  351. //
  352.     length = lbmptr-(byte *)formlength-4;
  353.     *formlength = BigLong(length);
  354.     if (length&1)
  355.         *lbmptr++ = 0;          // pad chunk to even offset
  356.  
  357. //
  358. // write output file
  359. //
  360.     SaveFile (filename, lbm, lbmptr-lbm);
  361.     free (lbm);
  362. }
  363.  
  364. /*
  365. ============================================================================
  366.  
  367. LOAD PCX
  368.  
  369. ============================================================================
  370. */
  371. typedef struct
  372. {
  373.     char    manufacturer;
  374.     char    version;
  375.     char    encoding;
  376.     char    bits_per_pixel;
  377.     unsigned short    xmin,ymin,xmax,ymax;
  378.     unsigned short    hres,vres;
  379.     unsigned char    palette[48];
  380.     char    reserved;
  381.     char    color_planes;
  382.     unsigned short    bytes_per_line;
  383.     unsigned short    palette_type;
  384.     char    filler[58];
  385.     unsigned char    data;            // unbounded
  386. } pcx_t;
  387.  
  388. /*
  389. ==============
  390. LoadPCX
  391. ==============
  392. */
  393. void LoadPCX (char *filename, byte **pic, byte **palette, int *width, int *height)
  394. {
  395.     byte    *raw = 0;
  396.     pcx_t    *pcx;
  397.     int        x, y;
  398.     int        len;
  399.     int        dataByte, runLength;
  400.     byte    *out, *pix;
  401.  
  402.     if (pic)
  403.         *pic = NULL;
  404.     if (palette)
  405.         *palette = NULL;
  406.     if (width)
  407.         *width = 0;
  408.     if (height)
  409.         *height = 0;
  410.  
  411.     //
  412.     // load the file
  413.     //
  414.     len = LoadFile (filename, (void **)&raw);
  415.     if (len == -1)
  416.         return;
  417.  
  418.     //
  419.     // parse the PCX file
  420.     //
  421.     pcx = (pcx_t *)raw;
  422.     raw = &pcx->data;
  423.  
  424.     pcx->xmin = LittleShort(pcx->xmin);
  425.     pcx->ymin = LittleShort(pcx->ymin);
  426.     pcx->xmax = LittleShort(pcx->xmax);
  427.     pcx->ymax = LittleShort(pcx->ymax);
  428.     pcx->hres = LittleShort(pcx->hres);
  429.     pcx->vres = LittleShort(pcx->vres);
  430.     pcx->bytes_per_line = LittleShort(pcx->bytes_per_line);
  431.     pcx->palette_type = LittleShort(pcx->palette_type);
  432.  
  433.     if (pcx->manufacturer != 0x0a
  434.         || pcx->version != 5
  435.         || pcx->encoding != 1
  436.         || pcx->bits_per_pixel != 8
  437.         || pcx->xmax >= 640
  438.         || pcx->ymax >= 480)
  439.         Error ("Bad pcx file %s", filename);
  440.     
  441.     if (palette)
  442.     {
  443.         *palette = (unsigned char*)malloc(768);
  444.         memcpy (*palette, (byte *)pcx + len - 768, 768);
  445.     }
  446.  
  447.     if (width)
  448.         *width = pcx->xmax+1;
  449.     if (height)
  450.         *height = pcx->ymax+1;
  451.  
  452.     if (!pic)
  453.   {
  454.     free(pcx);
  455.         return;
  456.   }
  457.  
  458.     out = (unsigned char*)malloc ( (pcx->ymax+1) * (pcx->xmax+1) );
  459.     if (!out)
  460.         Error ("Skin_Cache: couldn't allocate");
  461.  
  462.     *pic = out;
  463.  
  464.     pix = out;
  465.  
  466.     for (y=0 ; y<=pcx->ymax ; y++, pix += pcx->xmax+1)
  467.     {
  468.         for (x=0 ; x<=pcx->xmax ; )
  469.         {
  470.             dataByte = *raw++;
  471.  
  472.             if((dataByte & 0xC0) == 0xC0)
  473.             {
  474.                 runLength = dataByte & 0x3F;
  475.                 dataByte = *raw++;
  476.             }
  477.             else
  478.                 runLength = 1;
  479.  
  480.             while(runLength-- > 0)
  481.                 pix[x++] = dataByte;
  482.         }
  483.  
  484.     }
  485.  
  486.     if ( raw - (byte *)pcx > len)
  487.         Error ("PCX file %s was malformed", filename);
  488.  
  489.     free (pcx);
  490. }
  491. /* 
  492. ============== 
  493. WritePCXfile 
  494. ============== 
  495. */ 
  496. void WritePCXfile (char *filename, byte *data, 
  497.                    int width, int height, byte *palette) 
  498. {
  499.     int        i, j, length;
  500.     pcx_t    *pcx;
  501.     byte        *pack;
  502.       
  503.     pcx = (pcx_t*)malloc (width*height*2+1000);
  504.     memset (pcx, 0, sizeof(*pcx));
  505.  
  506.     pcx->manufacturer = 0x0a;    // PCX id
  507.     pcx->version = 5;            // 256 color
  508.      pcx->encoding = 1;        // uncompressed
  509.     pcx->bits_per_pixel = 8;        // 256 color
  510.     pcx->xmin = 0;
  511.     pcx->ymin = 0;
  512.     pcx->xmax = LittleShort((short)(width-1));
  513.     pcx->ymax = LittleShort((short)(height-1));
  514.     pcx->hres = LittleShort((short)width);
  515.     pcx->vres = LittleShort((short)height);
  516.     pcx->color_planes = 1;        // chunky image
  517.     pcx->bytes_per_line = LittleShort((short)width);
  518.     pcx->palette_type = LittleShort(2);        // not a grey scale
  519.  
  520.     // pack the image
  521.     pack = &pcx->data;
  522.     
  523.     for (i=0 ; i<height ; i++)
  524.     {
  525.         for (j=0 ; j<width ; j++)
  526.         {
  527.             if ( (*data & 0xc0) != 0xc0)
  528.                 *pack++ = *data++;
  529.             else
  530.             {
  531.                 *pack++ = 0xc1;
  532.                 *pack++ = *data++;
  533.             }
  534.         }
  535.     }
  536.             
  537.     // write the palette
  538.     *pack++ = 0x0c;    // palette ID byte
  539.     for (i=0 ; i<768 ; i++)
  540.         *pack++ = *palette++;
  541.         
  542. // write output file 
  543.     length = pack - (byte *)pcx;
  544.     SaveFile (filename, pcx, length);
  545.  
  546.     free (pcx);
  547. } 
  548.  
  549. /*
  550. ============================================================================
  551.  
  552. LOAD IMAGE
  553.  
  554. ============================================================================
  555. */
  556.  
  557. /*
  558. ==============
  559. Load256Image
  560.  
  561. Will load either an lbm or pcx, depending on extension.
  562. Any of the return pointers can be NULL if you don't want them.
  563. ==============
  564. */
  565. void Load256Image (char *name, byte **pixels, byte **palette,
  566.                    int *width, int *height)
  567. {
  568.     char    ext[128];
  569.     bitmap_t    bmp;
  570.  
  571.     ExtractFileExtension (name, ext);
  572.     if (stricmp(ext, "lbm"))
  573.     {
  574.         LoadLBM (name, pixels, palette);
  575.         if (width)
  576.             *width = bmhd.w;
  577.         if (height)
  578.             *height = bmhd.h;
  579.     }
  580.     else if (stricmp (ext, "pcx"))
  581.     {
  582.         LoadPCX (name, pixels, palette, width, height);
  583.     }
  584.     else if (stricmp (ext, "bmp"))
  585.     {
  586.         LoadBMP (name, &bmp);
  587.         if (bmp.palette)
  588.         {
  589.             *palette = (unsigned char*)malloc (768);
  590.             memcpy (*palette, bmp.palette, 768);
  591.         }
  592.         FreeBMP (&bmp);        
  593.     }
  594.     else
  595.         Error ("%s doesn't have a known image extension", name);
  596. }
  597.  
  598.  
  599. /*
  600. ==============
  601. Save256Image
  602.  
  603. Will save either an lbm or pcx, depending on extension.
  604. ==============
  605. */
  606. void Save256Image (char *name, byte *pixels, byte *palette,
  607.                    int width, int height)
  608. {
  609.     char    ext[128];
  610.  
  611.     ExtractFileExtension (name, ext);
  612.     if (!strcmp (ext, "lbm"))
  613.     {
  614.         WriteLBMfile (name, pixels, width, height, palette);
  615.     }
  616.     else if (!stricmp (ext, "pcx"))
  617.     {
  618.         WritePCXfile (name, pixels, width, height, palette);
  619.     }
  620.     else
  621.         Error ("%s doesn't have a known image extension", name);
  622. }
  623.  
  624.  
  625.  
  626. /*
  627. ============================================================================
  628.  
  629. TARGA IMAGE
  630.  
  631. ============================================================================
  632. */
  633. typedef struct _TargaHeader {
  634.     unsigned char     id_length, colormap_type, image_type;
  635.     unsigned short    colormap_index, colormap_length;
  636.     unsigned char    colormap_size;
  637.     unsigned short    x_origin, y_origin, width, height;
  638.     unsigned char    pixel_size, attributes;
  639. } TargaHeader;
  640.  
  641. int fgetLittleShort (FILE *f)
  642. {
  643.     byte    b1, b2;
  644.  
  645.     b1 = fgetc(f);
  646.     b2 = fgetc(f);
  647.  
  648.     return (short)(b1 + b2*256);
  649. }
  650.  
  651. int getLittleShort (byte*& p)
  652. {
  653.     byte    b1, b2;
  654.     b1 = *p++;
  655.     b2 = *p++;
  656.     return (short)(b1 + b2*256);
  657. }
  658.  
  659. int getLittleLong (byte*& p)
  660. {
  661.     byte    b1, b2, b3, b4;
  662.  
  663.     b1 = *p++;
  664.     b2 = *p++;
  665.     b3 = *p++;
  666.     b4 = *p++;
  667.     return b1 + (b2<<8) + (b3<<16) + (b4<<24);
  668. }
  669.  
  670. char getc(byte*& p)
  671. {
  672.   return *p++;
  673. }
  674.  
  675. /*
  676. =========================================================
  677.  
  678. BMP LOADING
  679.  
  680. =========================================================
  681. */
  682. typedef struct
  683. {
  684.     char id[2];
  685.     unsigned long fileSize;
  686.     unsigned long reserved0;
  687.     unsigned long bitmapDataOffset;
  688.     unsigned long bitmapHeaderSize;
  689.     unsigned long width;
  690.     unsigned long height;
  691.     unsigned short planes;
  692.     unsigned short bitsPerPixel;
  693.     unsigned long compression;
  694.     unsigned long bitmapDataSize;
  695.     unsigned long hRes;
  696.     unsigned long vRes;
  697.     unsigned long colors;
  698.     unsigned long importantColors;
  699.     unsigned char palette[256][4];
  700. } BMPHeader_t;
  701.  
  702. static void LoadBMP( const char *name, byte **pic, int *width, int *height )
  703. {
  704.     int        columns, rows, numPixels;
  705.     byte    *pixbuf;
  706.     int        row, column;
  707.     byte    *buf_p;
  708.     byte    *buffer;
  709.     unsigned int        length;
  710.     BMPHeader_t bmpHeader;
  711.     byte        *bmpRGBA;
  712.  
  713.     *pic = NULL;
  714.  
  715.     //
  716.     // load the file
  717.     //
  718.     length = LoadFile( ( char * ) name, (void **)&buffer);
  719.     if (length == -1)
  720.   {
  721.     length = PakLoadAnyFile( (char*)name, (void**)&buffer);
  722.     if (length == -1)
  723.     {
  724.           return;
  725.     }
  726.   }
  727.  
  728.     buf_p = buffer;
  729.  
  730.     bmpHeader.id[0] = *buf_p++;
  731.     bmpHeader.id[1] = *buf_p++;
  732.     bmpHeader.fileSize = LittleLong( * ( long * ) buf_p );
  733.     buf_p += 4;
  734.     bmpHeader.reserved0 = LittleLong( * ( long * ) buf_p );
  735.     buf_p += 4;
  736.     bmpHeader.bitmapDataOffset = LittleLong( * ( long * ) buf_p );
  737.     buf_p += 4;
  738.     bmpHeader.bitmapHeaderSize = LittleLong( * ( long * ) buf_p );
  739.     buf_p += 4;
  740.     bmpHeader.width = LittleLong( * ( long * ) buf_p );
  741.     buf_p += 4;
  742.     bmpHeader.height = LittleLong( * ( long * ) buf_p );
  743.     buf_p += 4;
  744.     bmpHeader.planes = LittleShort( * ( short * ) buf_p );
  745.     buf_p += 2;
  746.     bmpHeader.bitsPerPixel = LittleShort( * ( short * ) buf_p );
  747.     buf_p += 2;
  748.     bmpHeader.compression = LittleLong( * ( long * ) buf_p );
  749.     buf_p += 4;
  750.     bmpHeader.bitmapDataSize = LittleLong( * ( long * ) buf_p );
  751.     buf_p += 4;
  752.     bmpHeader.hRes = LittleLong( * ( long * ) buf_p );
  753.     buf_p += 4;
  754.     bmpHeader.vRes = LittleLong( * ( long * ) buf_p );
  755.     buf_p += 4;
  756.     bmpHeader.colors = LittleLong( * ( long * ) buf_p );
  757.     buf_p += 4;
  758.     bmpHeader.importantColors = LittleLong( * ( long * ) buf_p );
  759.     buf_p += 4;
  760.  
  761.     memcpy( bmpHeader.palette, buf_p, sizeof( bmpHeader.palette ) );
  762.  
  763.     if ( bmpHeader.bitsPerPixel == 8 )
  764.         buf_p += 1024;
  765.  
  766.     if ( bmpHeader.id[0] != 'B' && bmpHeader.id[1] != 'M' ) 
  767.     {
  768.         Sys_Printf("LoadBMP: only Windows-style BMP files supported (%s)\n", name );
  769.     }
  770.     if ( bmpHeader.fileSize != length )
  771.     {
  772.         Sys_Printf("LoadBMP: header size does not match file size (%d vs. %d) (%s)\n", bmpHeader.fileSize, length, name );
  773.     }
  774.     if ( bmpHeader.compression != 0 )
  775.     {
  776.         Sys_Printf("LoadBMP: only uncompressed BMP files supported (%s)\n", name );
  777.     }
  778.     if ( bmpHeader.bitsPerPixel < 8 )
  779.     {
  780.         Sys_Printf("LoadBMP: monochrome and 4-bit BMP files not supported (%s)\n", name );
  781.     }
  782.  
  783.     columns = bmpHeader.width;
  784.     rows = bmpHeader.height;
  785.     if ( rows < 0 )
  786.         rows = -rows;
  787.     numPixels = columns * rows;
  788.  
  789.     if ( width ) 
  790.         *width = columns;
  791.     if ( height )
  792.         *height = rows;
  793.  
  794.     bmpRGBA = reinterpret_cast<unsigned char*>(malloc( numPixels * 4 ));
  795.     *pic = bmpRGBA;
  796.  
  797.  
  798.     for ( row = rows-1; row >= 0; row-- )
  799.     {
  800.         pixbuf = bmpRGBA + row*columns*4;
  801.  
  802.         for ( column = 0; column < columns; column++ )
  803.         {
  804.             unsigned char red, green, blue, alpha;
  805.             int palIndex;
  806.             unsigned short shortPixel;
  807.  
  808.             switch ( bmpHeader.bitsPerPixel )
  809.             {
  810.             case 8:
  811.                 palIndex = *buf_p++;
  812.                 *pixbuf++ = bmpHeader.palette[palIndex][2];
  813.                 *pixbuf++ = bmpHeader.palette[palIndex][1];
  814.                 *pixbuf++ = bmpHeader.palette[palIndex][0];
  815.                 *pixbuf++ = 0xff;
  816.                 break;
  817.             case 16:
  818.                 shortPixel = * ( unsigned short * ) pixbuf;
  819.                 pixbuf += 2;
  820.                 *pixbuf++ = ( shortPixel & ( 31 << 10 ) ) >> 7;
  821.                 *pixbuf++ = ( shortPixel & ( 31 << 5 ) ) >> 2;
  822.                 *pixbuf++ = ( shortPixel & ( 31 ) ) << 3;
  823.                 *pixbuf++ = 0xff;
  824.                 break;
  825.  
  826.             case 24:
  827.                 blue = *buf_p++;
  828.                 green = *buf_p++;
  829.                 red = *buf_p++;
  830.                 *pixbuf++ = red;
  831.                 *pixbuf++ = green;
  832.                 *pixbuf++ = blue;
  833.                 *pixbuf++ = 255;
  834.                 break;
  835.             case 32:
  836.                 blue = *buf_p++;
  837.                 green = *buf_p++;
  838.                 red = *buf_p++;
  839.                 alpha = *buf_p++;
  840.                 *pixbuf++ = red;
  841.                 *pixbuf++ = green;
  842.                 *pixbuf++ = blue;
  843.                 *pixbuf++ = alpha;
  844.                 break;
  845.             default:
  846.                 Sys_Printf("LoadBMP: illegal pixel_size '%d' in file '%s'\n", bmpHeader.bitsPerPixel, name );
  847.                 break;
  848.             }
  849.         }
  850.     }
  851.  
  852.     free( buffer );
  853.  
  854. }
  855.  
  856.  
  857. /*
  858. =================================================================
  859.  
  860. PCX LOADING
  861.  
  862. =================================================================
  863. */
  864.  
  865.  
  866. /*
  867. ==============
  868. LoadPCX
  869. ==============
  870. */
  871. static void LoadPCX ( const char *filename, byte **pic, byte **palette, int *width, int *height)
  872. {
  873.     byte    *raw;
  874.     pcx_t    *pcx;
  875.     int        x, y;
  876.     int        len;
  877.     int        dataByte, runLength;
  878.     byte    *out, *pix;
  879.     int        xmax, ymax;
  880.  
  881.     *pic = NULL;
  882.     *palette = NULL;
  883.  
  884.     //
  885.     // load the file
  886.     //
  887.     len = LoadFile( ( char * ) filename, (void **)&raw);
  888.     if (len == -1) 
  889.   {
  890.     len = PakLoadAnyFile( (char*)filename, (void**)&raw);
  891.     if (len == -1)
  892.     {
  893.           return;
  894.     }
  895.     }
  896.  
  897.     //
  898.     // parse the PCX file
  899.     //
  900.     pcx = (pcx_t *)raw;
  901.     raw = &pcx->data;
  902.  
  903.       xmax = LittleShort(pcx->xmax);
  904.     ymax = LittleShort(pcx->ymax);
  905.  
  906.     if (pcx->manufacturer != 0x0a
  907.         || pcx->version != 5
  908.         || pcx->encoding != 1
  909.         || pcx->bits_per_pixel != 8
  910.         || xmax >= 1024
  911.         || ymax >= 1024)
  912.     {
  913.         Sys_Printf ("Bad pcx file %s (%i x %i) (%i x %i)\n", filename, xmax+1, ymax+1, pcx->xmax, pcx->ymax);
  914.         return;
  915.     }
  916.  
  917.     out = reinterpret_cast<unsigned char*>(malloc ( (ymax+1) * (xmax+1) ));
  918.  
  919.     *pic = out;
  920.  
  921.     pix = out;
  922.  
  923.     if (palette)
  924.     {
  925.         *palette = reinterpret_cast<unsigned char*>(malloc(768));
  926.         memcpy (*palette, (byte *)pcx + len - 768, 768);
  927.     }
  928.  
  929.     if (width)
  930.         *width = xmax+1;
  931.     if (height)
  932.         *height = ymax+1;
  933. // FIXME: use bytes_per_line here?
  934.  
  935.     for (y=0 ; y<=ymax ; y++, pix += xmax+1)
  936.     {
  937.         for (x=0 ; x<=xmax ; )
  938.         {
  939.             dataByte = *raw++;
  940.  
  941.             if((dataByte & 0xC0) == 0xC0)
  942.             {
  943.                 runLength = dataByte & 0x3F;
  944.                 dataByte = *raw++;
  945.             }
  946.             else
  947.                 runLength = 1;
  948.  
  949.             while(runLength-- > 0)
  950.                 pix[x++] = dataByte;
  951.         }
  952.  
  953.     }
  954.  
  955.     if ( raw - (byte *)pcx > len)
  956.     {
  957.         Sys_Printf ("PCX file %s was malformed", filename);
  958.         free (*pic);
  959.         *pic = NULL;
  960.     }
  961.  
  962.     free(pcx);
  963. }
  964.  
  965.  
  966. /*
  967. ==============
  968. LoadPCX32
  969. ==============
  970. */
  971. static void LoadPCX32 ( const char *filename, byte **pic, int *width, int *height) {
  972.     byte    *palette;
  973.     byte    *pic8;
  974.     int        i, c, p;
  975.     byte    *pic32;
  976.  
  977.     LoadPCX (filename, &pic8, &palette, width, height);
  978.     if (!pic8) {
  979.         *pic = NULL;
  980.         return;
  981.     }
  982.  
  983.     c = (*width) * (*height);
  984.     pic32 = *pic = reinterpret_cast<unsigned char*>(malloc(4 * c ));
  985.     for (i = 0 ; i < c ; i++) {
  986.         p = pic8[i];
  987.         pic32[0] = palette[p*3];
  988.         pic32[1] = palette[p*3 + 1];
  989.         pic32[2] = palette[p*3 + 2];
  990.         pic32[3] = 255;
  991.         pic32 += 4;
  992.     }
  993.  
  994.     free (pic8);
  995.     free (palette);
  996. }
  997.  
  998. /*
  999. =========================================================
  1000.  
  1001. TARGA LOADING
  1002.  
  1003. =========================================================
  1004. */
  1005.  
  1006. /*
  1007. =============
  1008. LoadTGA
  1009. =============
  1010. */
  1011. void LoadTGA ( const char *name, byte **pic, int *width, int *height)
  1012. {
  1013.     int        columns, rows, numPixels;
  1014.     byte    *pixbuf;
  1015.     int        row, column;
  1016.     byte    *buf_p;
  1017.     byte    *buffer;
  1018.     TargaHeader    targa_header;
  1019.     byte        *targa_rgba;
  1020.  
  1021.     *pic = NULL;
  1022.  
  1023.     //
  1024.     // load the file
  1025.     //
  1026.     int nLen = LoadFile ( ( char * ) name, (void **)&buffer);
  1027.     if (nLen == -1) 
  1028.   {
  1029.     nLen = PakLoadAnyFile((char*)name, (void**)&buffer);
  1030.     if (nLen == -1)
  1031.     {
  1032.           return;
  1033.     }
  1034.     }
  1035.  
  1036.     buf_p = buffer;
  1037.  
  1038.     targa_header.id_length = *buf_p++;
  1039.     targa_header.colormap_type = *buf_p++;
  1040.     targa_header.image_type = *buf_p++;
  1041.     
  1042.     targa_header.colormap_index = LittleShort ( *(short *)buf_p );
  1043.     buf_p += 2;
  1044.     targa_header.colormap_length = LittleShort ( *(short *)buf_p );
  1045.     buf_p += 2;
  1046.     targa_header.colormap_size = *buf_p++;
  1047.     targa_header.x_origin = LittleShort ( *(short *)buf_p );
  1048.     buf_p += 2;
  1049.     targa_header.y_origin = LittleShort ( *(short *)buf_p );
  1050.     buf_p += 2;
  1051.     targa_header.width = LittleShort ( *(short *)buf_p );
  1052.     buf_p += 2;
  1053.     targa_header.height = LittleShort ( *(short *)buf_p );
  1054.     buf_p += 2;
  1055.     targa_header.pixel_size = *buf_p++;
  1056.     targa_header.attributes = *buf_p++;
  1057.  
  1058.     //++timo debug
  1059.     if (targa_header.pixel_size == 32)
  1060.         Sys_Printf("%s is 32bit\n", name);
  1061.     bool bAlphaOK = false;
  1062.  
  1063.     if (targa_header.image_type!=2 
  1064.         && targa_header.image_type!=10
  1065.         && targa_header.image_type != 3 ) 
  1066.     {
  1067.         Sys_Printf("LoadTGA: Only type 2 (RGB), 3 (gray), and 10 (RGB) TGA images supported\n");
  1068.     }
  1069.  
  1070.     if ( targa_header.colormap_type != 0 )
  1071.     {
  1072.         Sys_Printf("LoadTGA: colormaps not supported\n" );
  1073.     }
  1074.  
  1075.     if ( ( targa_header.pixel_size != 32 && targa_header.pixel_size != 24 ) && targa_header.image_type != 3 )
  1076.     {
  1077.         Sys_Printf("LoadTGA: Only 32 or 24 bit images supported (no colormaps)\n");
  1078.     }
  1079.  
  1080.     columns = targa_header.width;
  1081.     rows = targa_header.height;
  1082.     numPixels = columns * rows;
  1083.  
  1084.     if (width)
  1085.         *width = columns;
  1086.     if (height)
  1087.         *height = rows;
  1088.  
  1089.     targa_rgba = reinterpret_cast<unsigned char*>(malloc (numPixels*4));
  1090.     *pic = targa_rgba;
  1091.  
  1092.     if (targa_header.id_length != 0)
  1093.         buf_p += targa_header.id_length;  // skip TARGA image comment
  1094.     
  1095.     if ( targa_header.image_type==2 || targa_header.image_type == 3 )
  1096.     { 
  1097.         // Uncompressed RGB or gray scale image
  1098.         for(row=rows-1; row>=0; row--) 
  1099.         {
  1100.             pixbuf = targa_rgba + row*columns*4;
  1101.             for(column=0; column<columns; column++) 
  1102.             {
  1103.                 unsigned char red,green,blue,alphabyte;
  1104.                 switch (targa_header.pixel_size) 
  1105.                 {
  1106.                     
  1107.                 case 8:
  1108.                     blue = *buf_p++;
  1109.                     green = blue;
  1110.                     red = blue;
  1111.                     *pixbuf++ = red;
  1112.                     *pixbuf++ = green;
  1113.                     *pixbuf++ = blue;
  1114.                     *pixbuf++ = 255;
  1115.                     break;
  1116.  
  1117.                 case 24:
  1118.                     blue = *buf_p++;
  1119.                     green = *buf_p++;
  1120.                     red = *buf_p++;
  1121.                     *pixbuf++ = red;
  1122.                     *pixbuf++ = green;
  1123.                     *pixbuf++ = blue;
  1124.                     *pixbuf++ = 255;
  1125.                     break;
  1126.                 case 32:
  1127.                     blue = *buf_p++;
  1128.                     green = *buf_p++;
  1129.                     red = *buf_p++;
  1130.                     alphabyte = *buf_p++;
  1131.                     //++timo debug: detect if the whole alpha channel is 0
  1132.                     if (alphabyte != 0)
  1133.                         bAlphaOK = true;
  1134.                     *pixbuf++ = red;
  1135.                     *pixbuf++ = green;
  1136.                     *pixbuf++ = blue;
  1137.                     *pixbuf++ = alphabyte;
  1138.                     break;
  1139.                 default:
  1140.                     Sys_Printf("LoadTGA: illegal pixel_size '%d' in file '%s'\n", targa_header.pixel_size, name );
  1141.                     break;
  1142.                 }
  1143.             }
  1144.         }
  1145.  
  1146.         //++timo debug
  1147.         if (bAlphaOK)
  1148.             Sys_Printf("alpha channel OK");
  1149.         else
  1150.             Sys_Printf("empty alpha channel!");
  1151.     }
  1152.     else if (targa_header.image_type==10) {   // Runlength encoded RGB images
  1153.  
  1154.         //++timo debug
  1155.         Sys_Printf("runlength encode RGB image");
  1156.  
  1157.         unsigned char red,green,blue,alphabyte,packetHeader,packetSize,j;
  1158.  
  1159.         red = 0;
  1160.         green = 0;
  1161.         blue = 0;
  1162.         alphabyte = 0xff;
  1163.  
  1164.         for(row=rows-1; row>=0; row--) {
  1165.             pixbuf = targa_rgba + row*columns*4;
  1166.             for(column=0; column<columns; ) {
  1167.                 packetHeader= *buf_p++;
  1168.                 packetSize = 1 + (packetHeader & 0x7f);
  1169.                 if (packetHeader & 0x80) {        // run-length packet
  1170.                     switch (targa_header.pixel_size) {
  1171.                         case 24:
  1172.                                 blue = *buf_p++;
  1173.                                 green = *buf_p++;
  1174.                                 red = *buf_p++;
  1175.                                 alphabyte = 255;
  1176.                                 break;
  1177.                         case 32:
  1178.                                 blue = *buf_p++;
  1179.                                 green = *buf_p++;
  1180.                                 red = *buf_p++;
  1181.                                 alphabyte = *buf_p++;
  1182.                                 break;
  1183.                         default:
  1184.                             Sys_Printf("LoadTGA: illegal pixel_size '%d' in file '%s'\n", targa_header.pixel_size, name );
  1185.                             break;
  1186.                     }
  1187.     
  1188.                     for(j=0;j<packetSize;j++) {
  1189.                         *pixbuf++=red;
  1190.                         *pixbuf++=green;
  1191.                         *pixbuf++=blue;
  1192.                         *pixbuf++=alphabyte;
  1193.                         column++;
  1194.                         if (column==columns) { // run spans across rows
  1195.                             column=0;
  1196.                             if (row>0)
  1197.                                 row--;
  1198.                             else
  1199.                                 goto breakOut;
  1200.                             pixbuf = targa_rgba + row*columns*4;
  1201.                         }
  1202.                     }
  1203.                 }
  1204.                 else {                            // non run-length packet
  1205.                     for(j=0;j<packetSize;j++) {
  1206.                         switch (targa_header.pixel_size) {
  1207.                             case 24:
  1208.                                     blue = *buf_p++;
  1209.                                     green = *buf_p++;
  1210.                                     red = *buf_p++;
  1211.                                     *pixbuf++ = red;
  1212.                                     *pixbuf++ = green;
  1213.                                     *pixbuf++ = blue;
  1214.                                     *pixbuf++ = 255;
  1215.                                     break;
  1216.                             case 32:
  1217.                                     blue = *buf_p++;
  1218.                                     green = *buf_p++;
  1219.                                     red = *buf_p++;
  1220.                                     alphabyte = *buf_p++;
  1221.                                     *pixbuf++ = red;
  1222.                                     *pixbuf++ = green;
  1223.                                     *pixbuf++ = blue;
  1224.                                     *pixbuf++ = alphabyte;
  1225.                                     break;
  1226.                             default:
  1227.                                 Sys_Printf("LoadTGA: illegal pixel_size '%d' in file '%s'\n", targa_header.pixel_size, name );
  1228.                                 break;
  1229.                         }
  1230.                         column++;
  1231.                         if (column==columns) { // pixel packet run spans across rows
  1232.                             column=0;
  1233.                             if (row>0)
  1234.                                 row--;
  1235.                             else
  1236.                                 goto breakOut;
  1237.                             pixbuf = targa_rgba + row*columns*4;
  1238.                         }                        
  1239.                     }
  1240.                 }
  1241.             }
  1242.             breakOut:;
  1243.         }
  1244.     }
  1245.  
  1246.     free(buffer);
  1247. }
  1248.  
  1249.  
  1250.  
  1251.  
  1252. void LoadJPG( const char *filename, unsigned char **pic, int *width, int *height ) 
  1253. {
  1254.   byte    *fbuffer = NULL;
  1255.   int nLen = LoadFile( ( char * ) filename, (void **)&fbuffer);
  1256.   if (nLen == -1) 
  1257.   {
  1258.     nLen = PakLoadAnyFile((char*)filename, (void**)&fbuffer);
  1259.     if (nLen == -1)
  1260.     {
  1261.           return;
  1262.     }
  1263.   }
  1264.   LoadJPGBuff(fbuffer, pic, width, height);
  1265.   free(fbuffer);
  1266. }
  1267.  
  1268. //===================================================================
  1269.  
  1270. /*
  1271. =================
  1272. LoadImage
  1273.  
  1274. Loads any of the supported image types into a cannonical
  1275. 32 bit format.
  1276. =================
  1277. */
  1278. void LoadImage( const char *name, byte **pic, int *width, int *height ) 
  1279. {
  1280.     int        len;
  1281.     *pic = NULL;
  1282.     *width = 0;
  1283.     *height = 0;
  1284.  
  1285.     len = strlen(name);
  1286.     if (len<5) 
  1287.   {
  1288.         return;
  1289.     }
  1290.  
  1291.     if ( !stricmp( name+len-4, ".tga" ) ) 
  1292.   {
  1293.       LoadTGA( name, pic, width, height );
  1294.     }
  1295.   else if ( !stricmp(name+len-4, ".pcx") ) 
  1296.   {
  1297.     LoadPCX32( name, pic, width, height );
  1298.     } 
  1299.   else if ( !stricmp( name+len-4, ".bmp" ) ) 
  1300.   {
  1301.         LoadBMP( name, pic, width, height );
  1302.     } 
  1303.   else if ( !stricmp( name+len-4, ".jpg" ) ) 
  1304.   {
  1305.         LoadJPG( name, pic, width, height ); 
  1306.     }
  1307. }
  1308.  
  1309.