commonpb.cpp

/********************************************************************

"THIS SOFTWARE IS SUBJECT TO COPYRIGHT PROTECTION AND IS OFFERED ONLY
PURSUANT TO THE 3DFX FXT1 GENERAL PUBLIC LICENSE. A COPY OF THIS
LICENSE MAY BE OBTAINED FROM THE DISTRIBUTOR OR BY CONTACTING 3DFX
INTERACTIVE INC.  

TO THE EXTENT PERMITTED BY APPLICABLE LAW, THERE IS NO WARRANTY FOR
THIS PROGRAM. THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES PROVIDE THIS
PROGRAM "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR
IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE ENTIRE RISK
AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU. SHOULD
THIS PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY
SERVICING, REPAIR OR CORRECTION.

IN NO EVENT, UNLESS REQUIRED BY APPLICABLE LAW, WILL 3DFX INTERACTIVE,
INC., OR ANY OTHER COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY
AND/OR REDISTRIBUTE THIS PROGRAM OR DERIVATIVE WORKS AS PERMITTED
ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY GENERAL, SPECIAL,
INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR
INABILITY TO USE THIS PROGRAM OR DERIVATIVE WORKS (INCLUDING BUT NOT
LIMITED TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES
SUSTAINED BY YOU OR THIRD PARTIES OR A FAILURE OF THIS PROGRAM OR
DERIVATIVE WORKS TO OPERATE WITH ANY OTHER PROGRAMS), EVEN IF SUCH
HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH
DAMAGES.

USE, DUPLICATION OR DISCLOSURE BY THE GOVERNMENT IS SUBJECT TO
RESTRICTIONS AS SET FORTH IN SUBDIVISION (C)(1)(II) OF THE RIGHTS IN
TECHNICAL DATA AND COMPUTER SOFTWARE CLAUSE AT DFARS 252.227-7013,
AND/OR IN SIMILAR OR SUCCESSOR CLAUSES IN THE FAR, DOD OR NASA FAR
SUPPLEMENT. UNPUBLISHED RIGHTS RESERVED UNDER THE COPYRIGHT LAWS OF
THE UNITED STATES.  COPYRIGHT 3DFX INTERACTIVE, INC. 1999, ALL RIGHTS
RESERVED"

********************************************************************/

/*
** COMMONPB.C
**
** 9/02/99 rufus@3dfx.com
** Original release cleanup.
*/
//interface adjusted to Openglide by crazii, 07/2025

#include <stdio.h>
#include <stdlib.h>
#include <fcntl.h>
#ifdef __MSC__
#include <io.h>
#endif
#include <string.h>
#include <math.h>

#include "sdk2_3dfx.h"

#include <assert.h>
#include "comppb.h"

void
FillPallette4(int alpha, FxI32 colors[4][4], FxI32 lo[3], FxI32 hi[3])
{
  int i, j;
  if (alpha == 0)
    {
      for (i = 0; i < 4; i++) {
        for (j = 0; j < 3; j++) {
          colors[i][j] = ((3 - i) * lo[j] + i * hi[j] + 1) / 3;
        }       
        colors[i][3] = 255;
      }
    }
  else
    {
      for (i = 0; i < 3; i++)
        {
          for (j = 0; j < 3; j++)
            {
              colors[i][j] = ((2-i)*lo[j] + i*hi[j])/2;
            }
          colors[i][3] = 255;
        }
      for (j = 0; j < 4; j++)
        {
          colors[3][j] = 0;
        }
    }
}

void
FillPallette8(FxI32 colors[8][4], FxI32 lo[3], FxI32 hi[3])
{
  int i, j;
  for (i = 0; i < 7; i++) {
    for (j = 0; j < 3; j++) {
      colors[i][j] = ((6 - i) * lo[j] + i * hi[j] + 2) / 6;
    }
    colors[i][3] = 255;
  }
  for (j = 0; j < 4; j++)
    {
      colors[7][j] = 0;
    }
}

int colorBitsMIXED[2] = {CC_MIXED_COLOR_0, CC_MIXED_COLOR_2};
int texelBitsMIXED[2] = {CC_MIXED_TEXELS_LO, CC_MIXED_TEXELS_HI};
int texelBitsALPHA[2] = {CC_ALPHA_TEXELS_LO, CC_ALPHA_TEXELS_HI};

int channelShift[4] = {0, 8, 16, 24};

typedef void (*DecompFun)(FxU32 width, int x, int y,
                          FxI32 *pixelsOut,
                          const CCBlock& blockIn);

/*
 * decodes a cc_mixed block
 */
void
Decomp4x8CC_Mixed(FxU32 width, int x, int y,
                  FxI32 *pixelsOut,
                  const CCBlock& blockIn)
{
  
  int i, j, block, chan;
  int bx;
  int glsb;
  int alpha;
  FxI32 lo[3], hi[3];
  FxI32 colors[4][4];
  int index;
  
  bx = 0;
  
  alpha = CC_GETBIT(blockIn, CC_MIXED_ALPHA);
  
  for (block = 0; block < 2; block++, bx += 4) {
    
    if (block == 0) {
      glsb = CC_GETBIT(blockIn, CC_MIXED_GLSB_0);
    } else {
      glsb = CC_GETBIT(blockIn, CC_MIXED_GLSB_1);
    }
    
    for (chan = 0; chan < 3; chan++) {
      lo[chan] = hi[chan] = 0;
      for (i = 0; i < 5; i++) {
        lo[chan] |=
          CC_GETBIT(blockIn, colorBitsMIXED[block] + 5 * chan + 15 + i)
            << (i + 3);
        hi[chan] |=
          CC_GETBIT(blockIn, colorBitsMIXED[block] + 5 * chan +  0 + i)
            << (i + 3);
      }
      lo[chan] = lo[chan] | (lo[chan] >> 5);
      hi[chan] = hi[chan] | (hi[chan] >> 5);
    }
    
    if (alpha == 0)
      {
        lo[1] &= 0xf8;
        lo[1] |= (glsb ^ CC_GETBIT(blockIn, texelBitsMIXED[block] + 1)) << 2;
        lo[1] |= lo[1] >> 6;
      }
    
    hi[1] &= 0xf8;
    hi[1] |= glsb << 2;
    hi[1] |= hi[1] >> 6;
    
    FillPallette4(alpha, colors, lo, hi);
    
    for (i = 0; i < 4; i++) {
      for (j = 0; j < 4; j++) {
        index = 
          (CC_GETBIT(blockIn,
                     texelBitsMIXED[block] + 8 * i + 2 * j + 0) << 0) |
          (CC_GETBIT(blockIn,
                     texelBitsMIXED[block] + 8 * i + 2 * j + 1) << 1);
        
        for (chan = 0; chan < 4; chan++) {
          /* clear channel */
          pixelsOut[(y + i) * width + x  + bx + j] &= 
            ~(255 << channelShift[chan]);
          /* or in channel */
          pixelsOut[(y + i) * width + x + bx + j] |=
            colors[index][chan] << channelShift[chan];
        }
      }
    }
  }
}

/*
 * decodes a cc_hi block
 */
void
Decomp4x8CC_HI(FxU32 width, int x, int y,
               FxI32 *pixelsOut,
               const CCBlock& blockIn)
{
  int i, j, chan;
  FxI32 lo[3], hi[3];
  FxI32 colors[8][4];
  int index;
  
  for (chan = 0; chan < 3; chan++) {
    lo[chan] = hi[chan] = 0;
    for (i = 0; i < 5; i++) {
      lo[chan] |=
        CC_GETBIT(blockIn, CC_HI_COLOR_0 + 5 * chan + i)
          << (i + 3);
      hi[chan] |=
        CC_GETBIT(blockIn, CC_HI_COLOR_1 + 5 * chan + i)
          << (i + 3);
    }
    lo[chan] = lo[chan] | (lo[chan] >> 5);
    hi[chan] = hi[chan] | (hi[chan] >> 5);
    
  }
  
  FillPallette8(colors, lo, hi);
  
  for (i = 0; i < 4; i++) {
    for (j = 0; j < 8; j++) {
      int blockOffset = (j >= 4) ? 48 : 0;
      int texOffset = 12 * i + 3 * (j & 3);
      int offset = CC_HI_TEXELS + blockOffset + texOffset;
      index = 
        (CC_GETBIT(blockIn, offset + 0) << 0) |
        (CC_GETBIT(blockIn, offset + 1) << 1) |
        (CC_GETBIT(blockIn, offset + 2) << 2);
      
      for (chan = 0; chan < 4; chan++) {
        /* clear channel */
        pixelsOut[(y + i) * width + x + j] &= ~(255 << channelShift[chan]);
        /* or in channel */
        pixelsOut[(y + i) * width + x + j] |=
          colors[index][chan] << channelShift[chan];
      }
    }
  }
}

/*
 * decodes a cc_chroma block
 */
void
Decomp4x8CC_Chroma(FxU32 width, int x, int y,
                   FxI32 *pixelsOut,
                   const CCBlock& blockIn)
{
  
  int i, j, chan;
  int index;
  FxI32 colorVectors[4][4];
  
  for (chan = 0; chan < 3; chan++) {
    for (i = 0; i < 4; i++) {
      colorVectors[i][chan] = 0;
    }
    for (i = 0; i < 5; i++) {
      colorVectors[0][chan] |=
        CC_GETBIT(blockIn,
                  CC_CHROMA_COLOR_0 + 5 * chan + i) << (i + 3);
      colorVectors[1][chan] |=
        CC_GETBIT(blockIn,
                  CC_CHROMA_COLOR_1 + 5 * chan + i) << (i + 3);
      colorVectors[2][chan] |=
        CC_GETBIT(blockIn,
                  CC_CHROMA_COLOR_2 + 5 * chan + i) << (i + 3);
      colorVectors[3][chan] |=
        CC_GETBIT(blockIn,
                  CC_CHROMA_COLOR_3 + 5 * chan + i) << (i + 3);
    } 
    for (i = 0; i < 4; i++) {
      colorVectors[i][chan] |= colorVectors[i][chan] >> 5;
    }
  }
  chan = 3;
  for (i = 0; i < 4; i++)
    {
      colorVectors[i][3] = 255;
    }
  for (i = 0; i < 4; i++) {
    for (j = 0; j < 8; j++) {
      int blockOffset = (j >= 4) ? 32 : 0;
      int texOffset = 8 * i + 2 * (j & 3);
      int offset = CC_CHROMA_TEXELS + blockOffset + texOffset;
      index = 
        (CC_GETBIT(blockIn, offset + 0) << 0) |
        (CC_GETBIT(blockIn, offset + 1) << 1);
      
      for (chan = 0; chan < 4; chan++) {
        /* clear channel */
        pixelsOut[(y + i) * width + x + j] &=
          ~(255 << channelShift[chan]);
        /* or in channel */
        pixelsOut[(y + i) * width + x + j] |=
          colorVectors[index][chan] << channelShift[chan];
      }
    }
  }
}

/*
 * decodes a cc_alpha block
 */
void
Decomp4x8CC_Alpha(FxU32 width, int x, int y,
                  FxI32 *pixelsOut,
                  const CCBlock& blockIn)
{
  int i, j, block, chan;
  int lerp, bx;
  FxI32 colors[4][4];
  int index;
  FxI32 colorVectors[3][4];
  
  lerp = CC_GETBIT(blockIn, CC_ALPHA_LERP);
  for (chan = 0; chan < 4; chan++)
    {
      for (i = 0; i < 3; i++)
        {
          colorVectors[i][chan] = 0;
        }
    }
  for (chan = 0; chan < 4; chan++)
    {
      if (chan < 3)
        {
          for (i = 0; i < 5; i++)
            {
              colorVectors[0][chan] |= 
                CC_GETBIT(blockIn, CC_ALPHA_COLOR_0 + 5*chan+i) << (i + 3);
              colorVectors[1][chan] |= 
                CC_GETBIT(blockIn, CC_ALPHA_COLOR_1 + 5*chan+i) << (i + 3);
              colorVectors[2][chan] |= 
                CC_GETBIT(blockIn, CC_ALPHA_COLOR_2 + 5*chan+i) << (i + 3);
            }
        }
      else
        {
          for (i = 0; i < 5; i++)
            {
              colorVectors[0][3] |=
                CC_GETBIT(blockIn, CC_ALPHA_ALPHA_0 + i) << (i + 3);
              colorVectors[1][3] |=
                CC_GETBIT(blockIn, CC_ALPHA_ALPHA_1 + i) << (i + 3);
              colorVectors[2][3] |=
                CC_GETBIT(blockIn, CC_ALPHA_ALPHA_2 + i) << (i + 3);
            }
        }
      for (i = 0; i < 3; i++)
        {
          colorVectors[i][chan] |= colorVectors[i][chan] >> 5;
        }
    }
  
  if (lerp == 0)
    {
      for (i = 0; i < 4; i++)
        {
          for (chan = 0; chan < 4; chan++)
            {
              if (i != 3) colors[i][chan] = colorVectors[i][chan];
              else colors[i][chan] = 0;
            }
        }
      
      for (i = 0; i < 4; i++)
        {
          for (j = 0; j < 8; j++)
            {
              int blockOffset = (j >= 4)? 32 : 0;
              int texOffset = 8 * i + 2 * (j & 3);
              int offset = CC_ALPHA_TEXELS + blockOffset + texOffset;
              index = (CC_GETBIT(blockIn, offset + 0) << 0) |
                (CC_GETBIT(blockIn, offset + 1) << 1);
              for (chan = 0; chan < 4; chan++)
                {
                  /* clear channel */
                  pixelsOut[(y + i) * width + x + j] &= 
                    ~(255 << channelShift[chan]);
                  /* or in channel */
                  pixelsOut[(y + i) * width + x + j] |= 
                    colors[index][chan] << channelShift[chan];
                }
            }
        }
    }
  else
    {
      bx = 0;
      for (block = 0; block < 2; block++, bx +=4)
        {
          if (block == 0)
            {
              for (i = 0; i < 4; i++) {
                for (chan = 0; chan < 4; chan++) {
                  colors[i][chan] = 
                    ((3 - i) * colorVectors[0][chan] + 
                     i * colorVectors[1][chan] + 1) / 3;
                }       
              }
            }
          else
            {
              for (i = 0; i < 4; i++) {
                for (chan = 0; chan < 4; chan++) {
                  colors[i][chan] = 
                    ((3 - i) * colorVectors[2][chan] + 
                     i * colorVectors[1][chan] + 1) / 3;
                }       
              }
            }
          
          for (i = 0; i < 4; i++)
            {
              for (j = 0; j < 4; j++)
                {
                  int blockOffset = texelBitsALPHA[block];
                  int texOffset = 8 * i + 2 * j;
                  int offset = blockOffset + texOffset;
                  index = (CC_GETBIT(blockIn, offset + 0) << 0) |
                    (CC_GETBIT(blockIn, offset + 1) << 1);
                  for (chan = 0; chan < 4; chan++)
                    {
                      /* clear channel */
                      pixelsOut[(y + i) * width + x + bx + j] &= 
                        ~(255 << channelShift[chan]);
                      /* or in channel */
                      pixelsOut[(y + i) * width + x + bx + j] |= 
                        colors[index][chan] << channelShift[chan];
                    }
                }
            }
        }
    }
}

DecompFun DecompressionFunctions[] =
{
  Decomp4x8CC_Mixed,
  Decomp4x8CC_HI,
  Decomp4x8CC_Chroma,
  Decomp4x8CC_Alpha,
  0};

/*
 * decodes a block to color.
 * right now, only handles mixed with sel=1.
 */
void
DecodeCCBlock(FxU32 width, int x, int y,
              FxI32 *pixelsOut,
              const CCBlock& blockIn)
{
  int mode[3];
  
  mode[0] = CC_GETBIT(blockIn, CC_MIXED_MODE);
  mode[1] = CC_GETBIT(blockIn, CC_HI_MODE_0);
  mode[2] = CC_GETBIT(blockIn, CC_CHROMA_MODE_0);
  
  if (mode[0]) { 
    /* mixed mode = "1" */
    DecompressionFunctions[0](width, x, y, pixelsOut, blockIn); 
  } else if (mode[1] == 0) {
    /* cc-high mode = "00" */
    DecompressionFunctions[1](width, x, y, pixelsOut, blockIn); 
  } else if (mode[2] == 0) {
    /* cc-chroma mode = "010" */
    DecompressionFunctions[2](width, x, y, pixelsOut, blockIn); 
  } else {
    /* alpha mode = "011" */
    DecompressionFunctions[3](width, x, y, pixelsOut, blockIn); 
  }
} 

/* decode section */

void
decode4x8(FxU32 width, FxU32 height, const void* src, void* dest)
{
  FxU32 x,y;
  const CCBlock* ccblock;
  
  for (y=0; y + 3 < height; y += 4) {
    for (x=0; x + 7 < width; x += 8) {
      ccblock = (const CCBlock*)src;
      DecodeCCBlock(width, x, y, (FxI32 *)dest, *ccblock);
      src = (char*)src + sizeof(CCBlock);
    }
  }
}