/*
** THIS SOFTWARE IS SUBJECT TO COPYRIGHT PROTECTION AND IS OFFERED ONLY
** PURSUANT TO THE 3DFX GLIDE GENERAL PUBLIC LICENSE. THERE IS NO RIGHT
** TO USE THE GLIDE TRADEMARK WITHOUT PRIOR WRITTEN PERMISSION OF 3DFX
** INTERACTIVE, INC. A COPY OF THIS LICENSE MAY BE OBTAINED FROM THE 
** DISTRIBUTOR OR BY CONTACTING 3DFX INTERACTIVE INC(info@3dfx.com). 
** THIS PROGRAM IS PROVIDED "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER 
** EXPRESSED OR IMPLIED. SEE THE 3DFX GLIDE GENERAL PUBLIC LICENSE FOR A
** FULL TEXT OF THE NON-WARRANTY PROVISIONS.  
** 
** 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
**
** $Id$
*/
#include <string.h>
#include <glide.h>
#include <malloc.h>
#include "texus.h"
#include "texusint.h"

void _txDefaultErrorCallback( const char *string, FxBool fatal );

TxErrorCallbackFnc_t _txErrorCallback = _txDefaultErrorCallback;

void _txDefaultErrorCallback( const char *string, FxBool fatal )
{
  fprintf(stderr, "Texus: %s", string );
  if( fatal )
    exit( -1 );
}

#ifdef GLIDE3
    static FxU32 _gr_aspect_index_table[] =
    {
       0,
       1,
       2,
       3
    };
#else
    static FxU32 _gr_aspect_index_table[] =
    {
       3,
       2,
       1,
       0,
       1,
       2,
       3,
    };
#endif

/* size in texels  */
static FxU32 _grMipMapHostSize[4][16] = 
{
    {   /* 1:1 aspect ratio */
        65536, /* 0 : 256x256  */
        16384, /* 1 : 128x128  */
         4096, /* 2 :  64x64   */
         1024, /* 3 :  32x32   */
          256, /* 4 :  16x16   */
           64, /* 5 :   8x8    */
           16, /* 6 :   4x4    */
            4, /* 7 :   2x2    */
            1, /* 8 :   1x1    */
    }, 
    {   /* 2:1 aspect ratio */
        32768, /* 0 : 256x128  */
         8192, /* 1 : 128x64   */
         2048, /* 2 :  64x32   */
          512, /* 3 :  32x16   */
          128, /* 4 :  16x8    */
           32, /* 5 :   8x4    */
            8, /* 6 :   4x2    */
            2, /* 7 :   2x1    */
            1, /* 8 :   1x1    */
    }, 
    {   /* 4:1 aspect ratio */
        16384, /* 0 : 256x64   */
         4096, /* 1 : 128x32   */
         1024, /* 2 :  64x16   */
          256, /* 3 :  32x8    */
           64, /* 4 :  16x4    */
           16, /* 5 :   8x2    */
            4, /* 6 :   4x1    */
            2, /* 7 :   2x1    */
            1, /* 8 :   1x1    */
    },
    {   /* 8:1 aspect ratio */
         8192, /* 0 : 256x32   */
         2048, /* 1 : 128x16   */
          512, /* 2 :  64x8    */
          128, /* 3 :  32x4    */
           32, /* 4 :  16x2    */
            8, /* 5 :   8x1    */
            4, /* 6 :   4x1    */
            2, /* 7 :   2x1    */
            1, /* 8 :   1x1    */
    }
};

FxU32
txTexCalcMemRequired( GrLOD_t small_lod, GrLOD_t large_lod,
                      GrAspectRatio_t aspect, GrTextureFormat_t format ) {
    size_t memRequired;
    FxI32 lod;
    memRequired = 0;

#ifdef GLIDE3
    for( lod = small_lod; lod <= large_lod; lod++ ) {
#else
    for( lod = large_lod; lod <= small_lod; lod++ ) {
#endif
        memRequired +=
#ifdef GLIDE3
           /* Quick port to Glide3. Not the most general way. We would need
           ** something like GR_ASPECT_MAX, GR_ASPECT_MIN, GR_LOD_MAX and GR_LOD_MIN...
           ** because this current implementation will break when we have more
           ** than 8 levels of mipmapping for example.
           */
           _grMipMapHostSize[_gr_aspect_index_table[((aspect>=0)?aspect:-aspect)]] [8-lod] << (format>=GR_TEXFMT_16BIT);
#else
           _grMipMapHostSize[_gr_aspect_index_table[aspect]] [lod] << (format>=GR_TEXFMT_16BIT);
#endif 
    }
    return memRequired ;
}

static GrLOD_t _txLengthToLOD( int len )
{
#ifdef GLIDE3
  switch( len )
    {
    case 256:
      return GR_LOD_LOG2_256;
    case 128:
      return GR_LOD_LOG2_128;
    case 64:
      return GR_LOD_LOG2_64;
    case 32:
      return GR_LOD_LOG2_32;
    case 16:
      return GR_LOD_LOG2_16;
    case 8:
      return GR_LOD_LOG2_8;
    case 4:
      return GR_LOD_LOG2_4;
    case 2:
      return GR_LOD_LOG2_2;
    case 1:
      return GR_LOD_LOG2_1;
    }
  /*
   * This is only here to make the compiler shut up.
   */
  return GR_LOD_LOG2_1;
#else
  switch( len )
    {
    case 256:
      return GR_LOD_256;
    case 128:
      return GR_LOD_128;
    case 64:
      return GR_LOD_64;
    case 32:
      return GR_LOD_32;
    case 16:
      return GR_LOD_16;
    case 8:
      return GR_LOD_8;
    case 4:
      return GR_LOD_4;
    case 2:
      return GR_LOD_2;
    case 1:
      return GR_LOD_1;
    }
  /*
   * This is only here to make the compiler shut up.
   */
  return GR_LOD_1;
#endif

}

static GrAspectRatio_t _txDimensionsToAspectRatio( int width, int height )
{
  int aspect;

  aspect = ( 8 * width ) / height;

#ifdef GLIDE3
  switch( aspect )
    {
    case 64:
      return GR_ASPECT_LOG2_8x1;
    case 32:
      return GR_ASPECT_LOG2_4x1;
    case 16:
      return GR_ASPECT_LOG2_2x1;
    case 8:
      return GR_ASPECT_LOG2_1x1;
    case 4:
      return GR_ASPECT_LOG2_1x2;
    case 2:
      return GR_ASPECT_LOG2_1x4;
    case 1:
      return GR_ASPECT_LOG2_1x8;
    }

  /*
   * Make the compiler shut up.
   */
  return GR_ASPECT_LOG2_1x8;
#else
  switch( aspect )
    {
    case 64:
      return GR_ASPECT_8x1;
    case 32:
      return GR_ASPECT_4x1;
    case 16:
      return GR_ASPECT_2x1;
    case 8:
      return GR_ASPECT_1x1;
    case 4:
      return GR_ASPECT_1x2;
    case 2:
      return GR_ASPECT_1x4;
    case 1:
      return GR_ASPECT_1x8;
    }

  /*
   * Make the compiler shut up.
   */
  return GR_ASPECT_1x8;
#endif
}

/*
 * Return the smallest LOD given an aspect ratio
 * assuming that the LODs "stop" as soon as a side
 * length becomes 1.
 */
static GrLOD_t _txSmallestLOD( GrAspectRatio_t aspect )
{
#ifdef GLIDE3
  switch( aspect )
    {
    case GR_ASPECT_LOG2_8x1:
    case GR_ASPECT_LOG2_1x8:
      return GR_LOD_LOG2_8;
    case GR_ASPECT_LOG2_4x1:
    case GR_ASPECT_LOG2_1x4:
      return GR_LOD_LOG2_4;
    case GR_ASPECT_LOG2_2x1:
    case GR_ASPECT_LOG2_1x2:
      return GR_LOD_LOG2_2;
    case GR_ASPECT_LOG2_1x1:
      return GR_LOD_LOG2_1;
    }
  /*
   * Make the compiler shut up.
   */
  return GR_LOD_LOG2_1;
#else
  switch( aspect )
    {
    case GR_ASPECT_8x1:
    case GR_ASPECT_1x8:
      return GR_LOD_8;
    case GR_ASPECT_4x1:
    case GR_ASPECT_1x4:
      return GR_LOD_4;
    case GR_ASPECT_2x1:
    case GR_ASPECT_1x2:
      return GR_LOD_2;
    case GR_ASPECT_1x1:
      return GR_LOD_1;
    }
  /*
   * Make the compiler shut up.
   */
  return GR_LOD_1;

#endif /* GLIDE3 */
}

void txNccToPal( FxU32 *pal, const GuNccTable *ncc_table ) 
{
  int i, j;

  for( i = 0; i < 16; i++ )
    {
      pal[i] = ncc_table->yRGB[i];
    }
      
  for( i = 0; i < 4; i++ )
    {
      for( j = 0; j < 3; j++ )
        {
            pal[16 + 3 * i + j] = ncc_table->iRGB[i][j];
            pal[28 + 3 * i + j] = ncc_table->qRGB[i][j];
        }
    }
}

void txPalToNcc( GuNccTable *ncc_table, const FxU32 *pal ) {
  int i, j;

  for( i = 0; i < 16; i++ )
    {
      ncc_table->yRGB[i] = ( FxU8 )pal[i];
    }
      
  for( i = 0; i < 4; i++ )
    {
      for( j = 0; j < 3; j++ )
        {
          ncc_table->iRGB[i][j] = ( FxI16 )( pal[16 + 3 * i + j] );
          ncc_table->qRGB[i][j] = ( FxI16 )( pal[28 + 3 * i + j] );
        }
    }
  
  /*
  ** pack the table Y entries
  */
  for ( i = 0; i < 4; i++ )
    {
      FxU32 packedvalue;
      
      packedvalue  = ( ( FxU32 )( ncc_table->yRGB[i*4+0] & 0xff ) );
      packedvalue |= ( ( FxU32 )( ncc_table->yRGB[i*4+1] & 0xff ) ) << 8;
      packedvalue |= ( ( FxU32 )( ncc_table->yRGB[i*4+2] & 0xff ) ) << 16;
      packedvalue |= ( ( FxU32 )( ncc_table->yRGB[i*4+3] & 0xff ) ) << 24;

      ncc_table->packed_data[i] = packedvalue;
    }
  
  /*
  ** pack the table I entries
  */
  for ( i = 0; i < 4; i++ )
    {
      FxU32 packedvalue;
      
      packedvalue  = ( ( FxU32 )( ncc_table->iRGB[i][0] & 0x1ff ) ) << 18;
      packedvalue |= ( ( FxU32 )( ncc_table->iRGB[i][1] & 0x1ff ) ) << 9;

      packedvalue |= ( ( FxU32 )( ncc_table->iRGB[i][2] & 0x1ff ) ) << 0;
      
      ncc_table->packed_data[i+4] = packedvalue;
    }
  
  /*
  ** pack the table Q entries
  */
  for ( i = 0; i < 4; i++ )
    {
      FxU32 packedvalue;
      
      packedvalue  = ( ( FxU32 )( ncc_table->qRGB[i][0] & 0x1ff ) ) << 18;
      packedvalue |= ( ( FxU32 )( ncc_table->qRGB[i][1] & 0x1ff ) ) << 9;;
      packedvalue |= ( ( FxU32 )( ncc_table->qRGB[i][2] & 0x1ff ) ) << 0;
      
      ncc_table->packed_data[i+8] = packedvalue;
    }
}

size_t txInit3dfInfoFromFile( FILE *file, 
                              Gu3dfInfo *info, GrTextureFormat_t destFormat,
                              int *destWidth, int *destHeight,
                              int mipLevels, FxU32 flags )
{
  long file_start_position;
  size_t size_retval;
  int input_format;
  TxMip txMip;

#if 0
  printf( "enter: txInit3dfInfoFromFile\n" );
  fflush( stdout );
#endif

  /*
   * Save the current position of the input file so that we can
   * later recent it.
   */
  file_start_position = ftell( file );

  /*
   * Read the header of the input file to find out some information
   * about it.
   */
  if( ( input_format = _txReadHeader( file, &txMip ) ) == 0 )
    {
      return 0;
    }

  *destWidth = txMip.width;
  *destHeight = txMip.height;

  size_retval = txInit3dfInfo( info, destFormat, destWidth, destHeight,
                               mipLevels, flags );


  /*
   * Set the file offset back to where it was when we entered this 
   * function.
   */
  fseek( file, file_start_position, SEEK_SET );
  
  /*
   * Return the memory required for this texture.
   */
#if 0
  printf( "txInit3dfInfoFromFile returning %ld\n", ( long )size_retval );
  fflush( stdout );
#endif
  return size_retval;
}

size_t txInit3dfInfo( Gu3dfInfo *info, GrTextureFormat_t destFormat,
                      int *destWidth, int *destHeight,
                      int mipLevels, FxU32 flags )
{
  /*
   * If auto-resize is enabled,
   */
  if( ( flags & TX_AUTORESIZE_MASK ) != TX_AUTORESIZE_DISABLE )
    {
      /*
       * Make sure that the texture dimensions are power of two.
       */
      if( ( flags & TX_AUTORESIZE_MASK ) == TX_AUTORESIZE_SHRINK )
        {
          *destWidth  = txFloorPow2( *destWidth );
          *destHeight = txFloorPow2( *destHeight );
        }
      else
        {
          *destWidth  = txCeilPow2( *destWidth );
          *destHeight = txCeilPow2( *destHeight );
        }
      
      /*
       * Make sure the dimensions are in range.
       */
      while( *destWidth > 256 )
        *destWidth >>= 1;
      while( *destHeight > 256 )
        *destHeight >>= 1;

      /*
       * Make sure the aspect ratio is valid.
       */
      while( ( *destWidth / *destHeight ) > 8 )
        {
          *destWidth >>= 1;
        }

      while( ( *destHeight/ *destWidth ) > 8 )
        {
          *destHeight >>= 1;
        }
    }

  /*
   * Calculate the aspect ratio of the texture . . this assumse that
   * the desired texture size is valid!
   */
  info->header.aspect_ratio = _txDimensionsToAspectRatio( *destWidth, *destHeight );

  /*
   * Calculate the min and max LODs for the texture.
   */
  info->header.large_lod = _txLengthToLOD( ( *destHeight > *destWidth ) ? *destHeight : *destWidth );
  info->header.small_lod = _txSmallestLOD( info->header.aspect_ratio );

  /*
   * Make sure that we have the correct number of mipmap levels given
   * the parameter "mipLevels".
   * If mipLevels is -1, then we want all levels.
   */
  if( mipLevels != -1 )
    {
      int tmpNumLevels;
#ifdef GLIDE3
      tmpNumLevels = info->header.large_lod - info->header.small_lod + 1;
#else
      tmpNumLevels = info->header.small_lod - info->header.large_lod + 1;
#endif
      if( tmpNumLevels > mipLevels )
        {
#ifdef GLIDE3
          info->header.small_lod += tmpNumLevels - mipLevels;
#else
          info->header.small_lod -= tmpNumLevels - mipLevels;
#endif
        }
    }

  /*
   * Store the geometry of the texture.
   */
  info->header.width    = *destWidth;
  info->header.height   = *destHeight;

  /*
   * Store the format of the texture.
   */
  info->header.format   = destFormat;
  
  info->mem_required = txTexCalcMemRequired( info->header.small_lod,
                                             info->header.large_lod,
                                             info->header.aspect_ratio,
                                             info->header.format );

  /*
   * Return the amount of texture memory required for this texture.
   * The user is responsible for allocating the space for the texture.
   */
  return info->mem_required;
}


FxBool txConvertFromFile( FILE *file, Gu3dfInfo *info, 
                          FxU32 flags, const void *palNcc )
{
  long file_start_position;
  FxBool retval;
  TxMip txMip;
  
  /*
   * Save the current position of the input file so that we can
   * later recent it.
   */
  file_start_position = ftell( file );

  txMipReadFromFP( &txMip, "(FILE*)", file, GR_TEXFMT_ANY );

  retval = txConvert( info, txMip.format, txMip.width, txMip.height,
                      txMip.data[0], flags, palNcc );
  txFree( txMip.data[0] );

  return retval;
}

FxBool txConvert( Gu3dfInfo *info, GrTextureFormat_t srcFormat,
                  int srcWidth, int srcHeight,
                  const void *srcImage, FxU32 flags,
                  const void *palNcc )
{
  TxMip srcMip;
  TxMip trueColorMip;
  TxMip outputMip;
  TxMip tmpMip;

  /*
   * Make a txMip out of the passed data.
   */
  memset( &srcMip, 0, sizeof( srcMip ) );
  srcMip.format         = srcFormat;
  srcMip.width          = srcWidth;
  srcMip.height         = srcHeight;
  srcMip.depth          = 1;

  if( palNcc )
    {
      switch( srcFormat )
        {
        case GR_TEXFMT_YIQ_422:
        case GR_TEXFMT_AYIQ_8422:
         txNccToPal( srcMip.pal, palNcc);
          break;
        case GR_TEXFMT_P_8:
          memcpy( srcMip.pal, palNcc, sizeof( FxU32 ) * 256 );
          break;
        }
    }
  srcMip.data[0]        = ( void * )srcImage;

  /*
   * Set up a txMip to put a true color version of the texture in.
   */
  memset( &trueColorMip, 0, sizeof( trueColorMip ) );
  trueColorMip.format         = GR_TEXFMT_ARGB_8888;
  trueColorMip.width          = srcWidth;
  trueColorMip.height         = srcHeight;
  /*
   * Set the depth to the mipmapped depth to allocate the image.
   */
#ifdef GLIDE3
  trueColorMip.depth          = info->header.large_lod - info->header.small_lod + 1;
#else
  trueColorMip.depth          = info->header.small_lod - info->header.large_lod + 1;
#endif
  if( !txMipAlloc( &trueColorMip ) )
    return FXFALSE;

  /*
   * Set to one level only since we only want to dequant the first 
   * level.
   */
  trueColorMip.depth          = 1;

  /*
   * Convert from the input format to truecolor.
   */
  txMipDequantize( &trueColorMip, &srcMip );

  /*
   * We realy have more than one level, so. . . 
   */
#ifdef GLIDE3
  trueColorMip.depth          = info->header.large_lod - info->header.small_lod + 1;
#else
  trueColorMip.depth          = info->header.small_lod - info->header.large_lod + 1;
#endif

  /*
   * WARNING!  I do not free srcMip.data[0] since it is passed in by the users.
   */

  /*
   * Resample the true color version of the input image to 
   * the passed in size. . . . this should be a valid
   * size for the hardware to handle.
   */
  tmpMip = trueColorMip;
  tmpMip.width = info->header.width;
  tmpMip.height = info->header.height;
  txMipAlloc( &tmpMip );

  if( ( flags & TX_CLAMP_MASK ) == TX_CLAMP_DISABLE )
    {
      txMipResample( &tmpMip, &trueColorMip );
    }
  else
    {
      txMipClamp( &tmpMip, &trueColorMip );
#if 0
      txMipView( &tmpMip, "blah", FXTRUE, 0 );
#endif
    }
    
  
#if 0
  if( _heapchk() != _HEAPOK )
    txPanic( "_heapchk failed" );
#endif
  txFree( trueColorMip.data[0] );

  trueColorMip = tmpMip;

  /*
   * Generate mipmap levels.
   */
#ifdef GLIDE3
  trueColorMip.depth          = info->header.large_lod - info->header.small_lod + 1;
#else
  trueColorMip.depth          = info->header.small_lod - info->header.large_lod + 1;
#endif
  txMipMipmap( &trueColorMip );

#if 0
  txMipView( &trueColorMip, "blah", FXTRUE, 0 );
#endif

  /*
   * Convert from true color to the output color format.
   */
  memset( &outputMip, 0, sizeof( outputMip ) );
  outputMip.format         = info->header.format;
  outputMip.width          = info->header.width;
  outputMip.height         = info->header.height;
  outputMip.depth          = trueColorMip.depth;
  outputMip.data[0]        = info->data;
#if 0
  txMipAlloc( &outputMip );
#else
  txMipSetMipPointers( &outputMip );
#endif
  
  if( ( flags & TX_TARGET_PALNCC_MASK ) == TX_TARGET_PALNCC_SOURCE )
    {
      txMipTrueToFixedPal( &outputMip, &trueColorMip, palNcc, 
                           flags & TX_FIXED_PAL_QUANT_MASK );
    }
  else
    {
      txMipQuantize( &outputMip, &trueColorMip, outputMip.format, 
                     flags & TX_DITHER_MASK, flags & TX_COMPRESSION_MASK );
    }

  info->data = outputMip.data[0];

  if( ( info->header.format == GR_TEXFMT_YIQ_422 ) ||
      ( info->header.format == GR_TEXFMT_AYIQ_8422 ) )
    {
      txPalToNcc( &info->table.nccTable, outputMip.pal );
    }
  
  if( info->header.format == GR_TEXFMT_P_8 || info->header.format == GR_TEXFMT_AP_88 )
    {
      memcpy( info->table.palette.data, outputMip.pal, sizeof( FxU32 ) * 256 );
    }

  txFree( trueColorMip.data[0] );

  return FXTRUE;
}


