home *** CD-ROM | disk | FTP | other *** search
/ PC PowerPlay 22 / PCPP #22.iso / Quake2 / q2source_12_11 / utils3 / common / lbmlib.c < prev    next >
Encoding:
C/C++ Source or Header  |  1997-08-09  |  16.3 KB  |  803 lines
  1. // lbmlib.c
  2.  
  3. #include "cmdlib.h"
  4. #include "lbmlib.h"
  5.  
  6.  
  7.  
  8. /*
  9. ============================================================================
  10.  
  11.                         LBM STUFF
  12.  
  13. ============================================================================
  14. */
  15.  
  16.  
  17. typedef unsigned char    UBYTE;
  18. //conflicts with windows typedef short            WORD;
  19. typedef unsigned short    UWORD;
  20. typedef long            LONG;
  21.  
  22. typedef enum
  23. {
  24.     ms_none,
  25.     ms_mask,
  26.     ms_transcolor,
  27.     ms_lasso
  28. } mask_t;
  29.  
  30. typedef enum
  31. {
  32.     cm_none,
  33.     cm_rle1
  34. } compress_t;
  35.  
  36. typedef struct
  37. {
  38.     UWORD        w,h;
  39.     short        x,y;
  40.     UBYTE        nPlanes;
  41.     UBYTE        masking;
  42.     UBYTE        compression;
  43.     UBYTE        pad1;
  44.     UWORD        transparentColor;
  45.     UBYTE        xAspect,yAspect;
  46.     short        pageWidth,pageHeight;
  47. } bmhd_t;
  48.  
  49. extern    bmhd_t    bmhd;                        // will be in native byte order
  50.  
  51.  
  52.  
  53. #define FORMID ('F'+('O'<<8)+((int)'R'<<16)+((int)'M'<<24))
  54. #define ILBMID ('I'+('L'<<8)+((int)'B'<<16)+((int)'M'<<24))
  55. #define PBMID  ('P'+('B'<<8)+((int)'M'<<16)+((int)' '<<24))
  56. #define BMHDID ('B'+('M'<<8)+((int)'H'<<16)+((int)'D'<<24))
  57. #define BODYID ('B'+('O'<<8)+((int)'D'<<16)+((int)'Y'<<24))
  58. #define CMAPID ('C'+('M'<<8)+((int)'A'<<16)+((int)'P'<<24))
  59.  
  60.  
  61. bmhd_t  bmhd;
  62.  
  63. int    Align (int l)
  64. {
  65.     if (l&1)
  66.         return l+1;
  67.     return l;
  68. }
  69.  
  70.  
  71.  
  72. /*
  73. ================
  74. LBMRLEdecompress
  75.  
  76. Source must be evenly aligned!
  77. ================
  78. */
  79. byte  *LBMRLEDecompress (byte *source,byte *unpacked, int bpwidth)
  80. {
  81.     int     count;
  82.     byte    b,rept;
  83.  
  84.     count = 0;
  85.  
  86.     do
  87.     {
  88.         rept = *source++;
  89.  
  90.         if (rept > 0x80)
  91.         {
  92.             rept = (rept^0xff)+2;
  93.             b = *source++;
  94.             memset(unpacked,b,rept);
  95.             unpacked += rept;
  96.         }
  97.         else if (rept < 0x80)
  98.         {
  99.             rept++;
  100.             memcpy(unpacked,source,rept);
  101.             unpacked += rept;
  102.             source += rept;
  103.         }
  104.         else
  105.             rept = 0;               // rept of 0x80 is NOP
  106.  
  107.         count += rept;
  108.  
  109.     } while (count<bpwidth);
  110.  
  111.     if (count>bpwidth)
  112.         Error ("Decompression exceeded width!\n");
  113.  
  114.  
  115.     return source;
  116. }
  117.  
  118.  
  119. /*
  120. =================
  121. LoadLBM
  122. =================
  123. */
  124. void LoadLBM (char *filename, byte **picture, byte **palette)
  125. {
  126.     byte    *LBMbuffer, *picbuffer, *cmapbuffer;
  127.     int             y;
  128.     byte    *LBM_P, *LBMEND_P;
  129.     byte    *pic_p;
  130.     byte    *body_p;
  131.  
  132.     int    formtype,formlength;
  133.     int    chunktype,chunklength;
  134.  
  135. // qiet compiler warnings
  136.     picbuffer = NULL;
  137.     cmapbuffer = NULL;
  138.  
  139. //
  140. // load the LBM
  141. //
  142.     LoadFile (filename, (void **)&LBMbuffer);
  143.  
  144. //
  145. // parse the LBM header
  146. //
  147.     LBM_P = LBMbuffer;
  148.     if ( *(int *)LBMbuffer != LittleLong(FORMID) )
  149.        Error ("No FORM ID at start of file!\n");
  150.  
  151.     LBM_P += 4;
  152.     formlength = BigLong( *(int *)LBM_P );
  153.     LBM_P += 4;
  154.     LBMEND_P = LBM_P + Align(formlength);
  155.  
  156.     formtype = LittleLong(*(int *)LBM_P);
  157.  
  158.     if (formtype != ILBMID && formtype != PBMID)
  159.         Error ("Unrecognized form type: %c%c%c%c\n", formtype&0xff
  160.         ,(formtype>>8)&0xff,(formtype>>16)&0xff,(formtype>>24)&0xff);
  161.  
  162.     LBM_P += 4;
  163.  
  164. //
  165. // parse chunks
  166. //
  167.  
  168.     while (LBM_P < LBMEND_P)
  169.     {
  170.         chunktype = LBM_P[0] + (LBM_P[1]<<8) + (LBM_P[2]<<16) + (LBM_P[3]<<24);
  171.         LBM_P += 4;
  172.         chunklength = LBM_P[3] + (LBM_P[2]<<8) + (LBM_P[1]<<16) + (LBM_P[0]<<24);
  173.         LBM_P += 4;
  174.  
  175.         switch ( chunktype )
  176.         {
  177.         case BMHDID:
  178.             memcpy (&bmhd,LBM_P,sizeof(bmhd));
  179.             bmhd.w = BigShort(bmhd.w);
  180.             bmhd.h = BigShort(bmhd.h);
  181.             bmhd.x = BigShort(bmhd.x);
  182.             bmhd.y = BigShort(bmhd.y);
  183.             bmhd.pageWidth = BigShort(bmhd.pageWidth);
  184.             bmhd.pageHeight = BigShort(bmhd.pageHeight);
  185.             break;
  186.  
  187.         case CMAPID:
  188.             cmapbuffer = malloc (768);
  189.             memset (cmapbuffer, 0, 768);
  190.             memcpy (cmapbuffer, LBM_P, chunklength);
  191.             break;
  192.  
  193.         case BODYID:
  194.             body_p = LBM_P;
  195.  
  196.             pic_p = picbuffer = malloc (bmhd.w*bmhd.h);
  197.             if (formtype == PBMID)
  198.             {
  199.             //
  200.             // unpack PBM
  201.             //
  202.                 for (y=0 ; y<bmhd.h ; y++, pic_p += bmhd.w)
  203.                 {
  204.                     if (bmhd.compression == cm_rle1)
  205.                         body_p = LBMRLEDecompress ((byte *)body_p
  206.                         , pic_p , bmhd.w);
  207.                     else if (bmhd.compression == cm_none)
  208.                     {
  209.                         memcpy (pic_p,body_p,bmhd.w);
  210.                         body_p += Align(bmhd.w);
  211.                     }
  212.                 }
  213.  
  214.             }
  215.             else
  216.             {
  217.             //
  218.             // unpack ILBM
  219.             //
  220.                 Error ("%s is an interlaced LBM, not packed", filename);
  221.             }
  222.             break;
  223.         }
  224.  
  225.         LBM_P += Align(chunklength);
  226.     }
  227.  
  228.     free (LBMbuffer);
  229.  
  230.     *picture = picbuffer;
  231.  
  232.     if (palette)
  233.         *palette = cmapbuffer;
  234. }
  235.  
  236.  
  237. /*
  238. ============================================================================
  239.  
  240.                             WRITE LBM
  241.  
  242. ============================================================================
  243. */
  244.  
  245. /*
  246. ==============
  247. WriteLBMfile
  248. ==============
  249. */
  250. void WriteLBMfile (char *filename, byte *data,
  251.                    int width, int height, byte *palette)
  252. {
  253.     byte    *lbm, *lbmptr;
  254.     int    *formlength, *bmhdlength, *cmaplength, *bodylength;
  255.     int    length;
  256.     bmhd_t  basebmhd;
  257.  
  258.     lbm = lbmptr = malloc (width*height+1000);
  259.  
  260. //
  261. // start FORM
  262. //
  263.     *lbmptr++ = 'F';
  264.     *lbmptr++ = 'O';
  265.     *lbmptr++ = 'R';
  266.     *lbmptr++ = 'M';
  267.  
  268.     formlength = (int*)lbmptr;
  269.     lbmptr+=4;                      // leave space for length
  270.  
  271.     *lbmptr++ = 'P';
  272.     *lbmptr++ = 'B';
  273.     *lbmptr++ = 'M';
  274.     *lbmptr++ = ' ';
  275.  
  276. //
  277. // write BMHD
  278. //
  279.     *lbmptr++ = 'B';
  280.     *lbmptr++ = 'M';
  281.     *lbmptr++ = 'H';
  282.     *lbmptr++ = 'D';
  283.  
  284.     bmhdlength = (int *)lbmptr;
  285.     lbmptr+=4;                      // leave space for length
  286.  
  287.     memset (&basebmhd,0,sizeof(basebmhd));
  288.     basebmhd.w = BigShort((short)width);
  289.     basebmhd.h = BigShort((short)height);
  290.     basebmhd.nPlanes = BigShort(8);
  291.     basebmhd.xAspect = BigShort(5);
  292.     basebmhd.yAspect = BigShort(6);
  293.     basebmhd.pageWidth = BigShort((short)width);
  294.     basebmhd.pageHeight = BigShort((short)height);
  295.  
  296.     memcpy (lbmptr,&basebmhd,sizeof(basebmhd));
  297.     lbmptr += sizeof(basebmhd);
  298.  
  299.     length = lbmptr-(byte *)bmhdlength-4;
  300.     *bmhdlength = BigLong(length);
  301.     if (length&1)
  302.         *lbmptr++ = 0;          // pad chunk to even offset
  303.  
  304. //
  305. // write CMAP
  306. //
  307.     *lbmptr++ = 'C';
  308.     *lbmptr++ = 'M';
  309.     *lbmptr++ = 'A';
  310.     *lbmptr++ = 'P';
  311.  
  312.     cmaplength = (int *)lbmptr;
  313.     lbmptr+=4;                      // leave space for length
  314.  
  315.     memcpy (lbmptr,palette,768);
  316.     lbmptr += 768;
  317.  
  318.     length = lbmptr-(byte *)cmaplength-4;
  319.     *cmaplength = BigLong(length);
  320.     if (length&1)
  321.         *lbmptr++ = 0;          // pad chunk to even offset
  322.  
  323. //
  324. // write BODY
  325. //
  326.     *lbmptr++ = 'B';
  327.     *lbmptr++ = 'O';
  328.     *lbmptr++ = 'D';
  329.     *lbmptr++ = 'Y';
  330.  
  331.     bodylength = (int *)lbmptr;
  332.     lbmptr+=4;                      // leave space for length
  333.  
  334.     memcpy (lbmptr,data,width*height);
  335.     lbmptr += width*height;
  336.  
  337.     length = lbmptr-(byte *)bodylength-4;
  338.     *bodylength = BigLong(length);
  339.     if (length&1)
  340.         *lbmptr++ = 0;          // pad chunk to even offset
  341.  
  342. //
  343. // done
  344. //
  345.     length = lbmptr-(byte *)formlength-4;
  346.     *formlength = BigLong(length);
  347.     if (length&1)
  348.         *lbmptr++ = 0;          // pad chunk to even offset
  349.  
  350. //
  351. // write output file
  352. //
  353.     SaveFile (filename, lbm, lbmptr-lbm);
  354.     free (lbm);
  355. }
  356.  
  357.  
  358. /*
  359. ============================================================================
  360.  
  361. LOAD PCX
  362.  
  363. ============================================================================
  364. */
  365.  
  366. typedef struct
  367. {
  368.     char    manufacturer;
  369.     char    version;
  370.     char    encoding;
  371.     char    bits_per_pixel;
  372.     unsigned short    xmin,ymin,xmax,ymax;
  373.     unsigned short    hres,vres;
  374.     unsigned char    palette[48];
  375.     char    reserved;
  376.     char    color_planes;
  377.     unsigned short    bytes_per_line;
  378.     unsigned short    palette_type;
  379.     char    filler[58];
  380.     unsigned char    data;            // unbounded
  381. } pcx_t;
  382.  
  383.  
  384. /*
  385. ==============
  386. LoadPCX
  387. ==============
  388. */
  389. void LoadPCX (char *filename, byte **pic, byte **palette, int *width, int *height)
  390. {
  391.     byte    *raw;
  392.     pcx_t    *pcx;
  393.     int        x, y;
  394.     int        len;
  395.     int        dataByte, runLength;
  396.     byte    *out, *pix;
  397.  
  398.     //
  399.     // load the file
  400.     //
  401.     len = LoadFile (filename, (void **)&raw);
  402.  
  403.     //
  404.     // parse the PCX file
  405.     //
  406.     pcx = (pcx_t *)raw;
  407.     raw = &pcx->data;
  408.  
  409.     pcx->xmin = LittleShort(pcx->xmin);
  410.     pcx->ymin = LittleShort(pcx->ymin);
  411.     pcx->xmax = LittleShort(pcx->xmax);
  412.     pcx->ymax = LittleShort(pcx->ymax);
  413.     pcx->hres = LittleShort(pcx->hres);
  414.     pcx->vres = LittleShort(pcx->vres);
  415.     pcx->bytes_per_line = LittleShort(pcx->bytes_per_line);
  416.     pcx->palette_type = LittleShort(pcx->palette_type);
  417.  
  418.     if (pcx->manufacturer != 0x0a
  419.         || pcx->version != 5
  420.         || pcx->encoding != 1
  421.         || pcx->bits_per_pixel != 8
  422.         || pcx->xmax >= 640
  423.         || pcx->ymax >= 480)
  424.         Error ("Bad pcx file %s", filename);
  425.     
  426.     if (palette)
  427.     {
  428.         *palette = malloc(768);
  429.         memcpy (*palette, (byte *)pcx + len - 768, 768);
  430.     }
  431.  
  432.     if (width)
  433.         *width = pcx->xmax+1;
  434.     if (height)
  435.         *height = pcx->ymax+1;
  436.  
  437.     if (!pic)
  438.         return;
  439.  
  440.     out = malloc ( (pcx->ymax+1) * (pcx->xmax+1) );
  441.     if (!out)
  442.         Error ("Skin_Cache: couldn't allocate");
  443.  
  444.     *pic = out;
  445.  
  446.     pix = out;
  447.  
  448.     for (y=0 ; y<=pcx->ymax ; y++, pix += pcx->xmax+1)
  449.     {
  450.         for (x=0 ; x<=pcx->xmax ; )
  451.         {
  452.             dataByte = *raw++;
  453.  
  454.             if((dataByte & 0xC0) == 0xC0)
  455.             {
  456.                 runLength = dataByte & 0x3F;
  457.                 dataByte = *raw++;
  458.             }
  459.             else
  460.                 runLength = 1;
  461.  
  462.             while(runLength-- > 0)
  463.                 pix[x++] = dataByte;
  464.         }
  465.  
  466.     }
  467.  
  468.     if ( raw - (byte *)pcx > len)
  469.         Error ("PCX file %s was malformed", filename);
  470.  
  471.     free (pcx);
  472. }
  473.  
  474. /* 
  475. ============== 
  476. WritePCXfile 
  477. ============== 
  478. */ 
  479. void WritePCXfile (char *filename, byte *data, 
  480.                    int width, int height, byte *palette) 
  481. {
  482.     int        i, j, length;
  483.     pcx_t    *pcx;
  484.     byte        *pack;
  485.       
  486.     pcx = malloc (width*height*2+1000);
  487.     memset (pcx, 0, sizeof(*pcx));
  488.  
  489.     pcx->manufacturer = 0x0a;    // PCX id
  490.     pcx->version = 5;            // 256 color
  491.      pcx->encoding = 1;        // uncompressed
  492.     pcx->bits_per_pixel = 8;        // 256 color
  493.     pcx->xmin = 0;
  494.     pcx->ymin = 0;
  495.     pcx->xmax = LittleShort((short)(width-1));
  496.     pcx->ymax = LittleShort((short)(height-1));
  497.     pcx->hres = LittleShort((short)width);
  498.     pcx->vres = LittleShort((short)height);
  499.     pcx->color_planes = 1;        // chunky image
  500.     pcx->bytes_per_line = LittleShort((short)width);
  501.     pcx->palette_type = LittleShort(2);        // not a grey scale
  502.  
  503.     // pack the image
  504.     pack = &pcx->data;
  505.     
  506.     for (i=0 ; i<height ; i++)
  507.     {
  508.         for (j=0 ; j<width ; j++)
  509.         {
  510.             if ( (*data & 0xc0) != 0xc0)
  511.                 *pack++ = *data++;
  512.             else
  513.             {
  514.                 *pack++ = 0xc1;
  515.                 *pack++ = *data++;
  516.             }
  517.         }
  518.     }
  519.             
  520.     // write the palette
  521.     *pack++ = 0x0c;    // palette ID byte
  522.     for (i=0 ; i<768 ; i++)
  523.         *pack++ = *palette++;
  524.         
  525. // write output file 
  526.     length = pack - (byte *)pcx;
  527.     SaveFile (filename, pcx, length);
  528.  
  529.     free (pcx);
  530. } 
  531.  
  532.  
  533. /*
  534. ============================================================================
  535.  
  536. LOAD IMAGE
  537.  
  538. ============================================================================
  539. */
  540.  
  541. /*
  542. ==============
  543. Load256Image
  544.  
  545. Will load either an lbm or pcx, depending on extension.
  546. Any of the return pointers can be NULL if you don't want them.
  547. ==============
  548. */
  549. void Load256Image (char *name, byte **pixels, byte **palette,
  550.                    int *width, int *height)
  551. {
  552.     char    ext[128];
  553.  
  554.     ExtractFileExtension (name, ext);
  555.     if (!Q_strcasecmp (ext, "lbm"))
  556.     {
  557.         LoadLBM (name, pixels, palette);
  558.         if (width)
  559.             *width = bmhd.w;
  560.         if (height)
  561.             *height = bmhd.h;
  562.     }
  563.     else if (!Q_strcasecmp (ext, "pcx"))
  564.     {
  565.         LoadPCX (name, pixels, palette, width, height);
  566.     }
  567.     else
  568.         Error ("%s doesn't have a known image extension", name);
  569. }
  570.  
  571.  
  572. /*
  573. ==============
  574. Save256Image
  575.  
  576. Will save either an lbm or pcx, depending on extension.
  577. ==============
  578. */
  579. void Save256Image (char *name, byte *pixels, byte *palette,
  580.                    int width, int height)
  581. {
  582.     char    ext[128];
  583.  
  584.     ExtractFileExtension (name, ext);
  585.     if (!Q_strcasecmp (ext, "lbm"))
  586.     {
  587.         WriteLBMfile (name, pixels, width, height, palette);
  588.     }
  589.     else if (!Q_strcasecmp (ext, "pcx"))
  590.     {
  591.         WritePCXfile (name, pixels, width, height, palette);
  592.     }
  593.     else
  594.         Error ("%s doesn't have a known image extension", name);
  595. }
  596.  
  597.  
  598.  
  599.  
  600. /*
  601. ============================================================================
  602.  
  603. TARGA IMAGE
  604.  
  605. ============================================================================
  606. */
  607.  
  608. typedef struct _TargaHeader {
  609.     unsigned char     id_length, colormap_type, image_type;
  610.     unsigned short    colormap_index, colormap_length;
  611.     unsigned char    colormap_size;
  612.     unsigned short    x_origin, y_origin, width, height;
  613.     unsigned char    pixel_size, attributes;
  614. } TargaHeader;
  615.  
  616. int fgetLittleShort (FILE *f)
  617. {
  618.     byte    b1, b2;
  619.  
  620.     b1 = fgetc(f);
  621.     b2 = fgetc(f);
  622.  
  623.     return (short)(b1 + b2*256);
  624. }
  625.  
  626. int fgetLittleLong (FILE *f)
  627. {
  628.     byte    b1, b2, b3, b4;
  629.  
  630.     b1 = fgetc(f);
  631.     b2 = fgetc(f);
  632.     b3 = fgetc(f);
  633.     b4 = fgetc(f);
  634.  
  635.     return b1 + (b2<<8) + (b3<<16) + (b4<<24);
  636. }
  637.  
  638.  
  639. /*
  640. =============
  641. LoadTGA
  642. =============
  643. */
  644. void LoadTGA (char *name, byte **pixels, int *width, int *height)
  645. {
  646.     int                columns, rows, numPixels;
  647.     byte            *pixbuf;
  648.     int                row, column;
  649.     FILE            *fin;
  650.     byte            *targa_rgba;
  651.     TargaHeader        targa_header;
  652.  
  653.     fin = fopen (name, "rb");
  654.     if (!fin)
  655.         Error ("Couldn't read %s", name);
  656.  
  657.     targa_header.id_length = fgetc(fin);
  658.     targa_header.colormap_type = fgetc(fin);
  659.     targa_header.image_type = fgetc(fin);
  660.     
  661.     targa_header.colormap_index = fgetLittleShort(fin);
  662.     targa_header.colormap_length = fgetLittleShort(fin);
  663.     targa_header.colormap_size = fgetc(fin);
  664.     targa_header.x_origin = fgetLittleShort(fin);
  665.     targa_header.y_origin = fgetLittleShort(fin);
  666.     targa_header.width = fgetLittleShort(fin);
  667.     targa_header.height = fgetLittleShort(fin);
  668.     targa_header.pixel_size = fgetc(fin);
  669.     targa_header.attributes = fgetc(fin);
  670.  
  671.     if (targa_header.image_type!=2 
  672.         && targa_header.image_type!=10) 
  673.         Error ("LoadTGA: Only type 2 and 10 targa RGB images supported\n");
  674.  
  675.     if (targa_header.colormap_type !=0 
  676.         || (targa_header.pixel_size!=32 && targa_header.pixel_size!=24))
  677.         Error ("Texture_LoadTGA: Only 32 or 24 bit images supported (no colormaps)\n");
  678.  
  679.     columns = targa_header.width;
  680.     rows = targa_header.height;
  681.     numPixels = columns * rows;
  682.  
  683.     if (width)
  684.         *width = columns;
  685.     if (height)
  686.         *height = rows;
  687.     targa_rgba = malloc(numPixels*4);
  688.     *pixels = targa_rgba;
  689.  
  690.     if (targa_header.id_length != 0)
  691.         fseek(fin, targa_header.id_length, SEEK_CUR);  // skip TARGA image comment
  692.     
  693.     if (targa_header.image_type==2) {  // Uncompressed, RGB images
  694.         for(row=rows-1; row>=0; row--) {
  695.             pixbuf = targa_rgba + row*columns*4;
  696.             for(column=0; column<columns; column++) {
  697.                 unsigned char red,green,blue,alphabyte;
  698.                 switch (targa_header.pixel_size) {
  699.                     case 24:
  700.                             
  701.                             blue = getc(fin);
  702.                             green = getc(fin);
  703.                             red = getc(fin);
  704.                             *pixbuf++ = red;
  705.                             *pixbuf++ = green;
  706.                             *pixbuf++ = blue;
  707.                             *pixbuf++ = 255;
  708.                             break;
  709.                     case 32:
  710.                             blue = getc(fin);
  711.                             green = getc(fin);
  712.                             red = getc(fin);
  713.                             alphabyte = getc(fin);
  714.                             *pixbuf++ = red;
  715.                             *pixbuf++ = green;
  716.                             *pixbuf++ = blue;
  717.                             *pixbuf++ = alphabyte;
  718.                             break;
  719.                 }
  720.             }
  721.         }
  722.     }
  723.     else if (targa_header.image_type==10) {   // Runlength encoded RGB images
  724.         unsigned char red,green,blue,alphabyte,packetHeader,packetSize,j;
  725.         for(row=rows-1; row>=0; row--) {
  726.             pixbuf = targa_rgba + row*columns*4;
  727.             for(column=0; column<columns; ) {
  728.                 packetHeader=getc(fin);
  729.                 packetSize = 1 + (packetHeader & 0x7f);
  730.                 if (packetHeader & 0x80) {        // run-length packet
  731.                     switch (targa_header.pixel_size) {
  732.                         case 24:
  733.                                 blue = getc(fin);
  734.                                 green = getc(fin);
  735.                                 red = getc(fin);
  736.                                 alphabyte = 255;
  737.                                 break;
  738.                         case 32:
  739.                                 blue = getc(fin);
  740.                                 green = getc(fin);
  741.                                 red = getc(fin);
  742.                                 alphabyte = getc(fin);
  743.                                 break;
  744.                     }
  745.     
  746.                     for(j=0;j<packetSize;j++) {
  747.                         *pixbuf++=red;
  748.                         *pixbuf++=green;
  749.                         *pixbuf++=blue;
  750.                         *pixbuf++=alphabyte;
  751.                         column++;
  752.                         if (column==columns) { // run spans across rows
  753.                             column=0;
  754.                             if (row>0)
  755.                                 row--;
  756.                             else
  757.                                 goto breakOut;
  758.                             pixbuf = targa_rgba + row*columns*4;
  759.                         }
  760.                     }
  761.                 }
  762.                 else {                            // non run-length packet
  763.                     for(j=0;j<packetSize;j++) {
  764.                         switch (targa_header.pixel_size) {
  765.                             case 24:
  766.                                     blue = getc(fin);
  767.                                     green = getc(fin);
  768.                                     red = getc(fin);
  769.                                     *pixbuf++ = red;
  770.                                     *pixbuf++ = green;
  771.                                     *pixbuf++ = blue;
  772.                                     *pixbuf++ = 255;
  773.                                     break;
  774.                             case 32:
  775.                                     blue = getc(fin);
  776.                                     green = getc(fin);
  777.                                     red = getc(fin);
  778.                                     alphabyte = getc(fin);
  779.                                     *pixbuf++ = red;
  780.                                     *pixbuf++ = green;
  781.                                     *pixbuf++ = blue;
  782.                                     *pixbuf++ = alphabyte;
  783.                                     break;
  784.                         }
  785.                         column++;
  786.                         if (column==columns) { // pixel packet run spans across rows
  787.                             column=0;
  788.                             if (row>0)
  789.                                 row--;
  790.                             else
  791.                                 goto breakOut;
  792.                             pixbuf = targa_rgba + row*columns*4;
  793.                         }                        
  794.                     }
  795.                 }
  796.             }
  797.             breakOut:;
  798.         }
  799.     }
  800.     
  801.     fclose(fin);
  802. }
  803.