int optimgsize = bih.biWidth * bih.biHeight * 3;

int relimgsize = bfh.bfSize -  bfh.bfOffBits;

int optimgsize = bih.biWidth * bih.biHeight * 3;

int relimgsize = bfh.bfSize -  bfh.bfOffBits;

int countpixels = bih.biWidth * bih.biHeight;

int countbytesalignment = relimgsize - optimgsize;

int alignmentsize = 0;

int pixeloffset = 0;

if( relimgsize == optimgsize )

{

  pixeloffset = 3;

}

else

{

  alignmentsize = countbytesalignment / countpixels;

  pixeloffset = 3 + alignmentsize;

}

qboolean Image_SaveBMP( const char *name, rgbdata_t *pix )

{

  file_t		*pfile = NULL;

  BITMAPFILEHEADER	bmfh;

  BITMAPINFOHEADER	bmih;

  RGBQUAD		rgrgbPalette[256];

  dword		cbBmpBits;

  byte*		pbBmpBits;

  byte		*pb, *pbPal = NULL;

  dword		cbPalBytes;

  dword		biTrueWidth;

  int		i, rc = 0;

  if( FS_FileExists( name, false ) && !(image.cmd_flags & IL_ALLOW_OVERWRITE ))

    return false; // already existed

  // bogus parameter check

  if( !pix->palette || !pix->buffer )

    return false;

  switch( pix->type )

  {

  case PF_INDEXED_24:

    case PF_INDEXED_32:

        break;

    default:

        MsgDev( D_WARN, "Image_SaveBMP: unsupported image type %s\n", PFDesc[pix->type].name );

      return false;

    }

  pfile = FS_Open( name, "wb", false );

  if( !pfile ) return false;

  // NOTE: align transparency column will sucessfully removed

  // after create sprite or lump image, it's just standard requiriments

  biTrueWidth = ((pix->width + 3) & ~3);

  cbBmpBits = biTrueWidth * pix->height;

  cbPalBytes = 256 * sizeof( RGBQUAD );

  // Bogus file header check

  bmfh.bfType = MAKEWORD( 'B', 'M' );

  bmfh.bfSize = sizeof(bmfh) + sizeof(bmih) + cbBmpBits + cbPalBytes;

  bmfh.bfReserved1 = 0;

  bmfh.bfReserved2 = 0;

  bmfh.bfOffBits = sizeof(bmfh) + sizeof(bmih) + cbPalBytes;

  // write header

  FS_Write( pfile, &bmfh, sizeof(bmfh));

  // size of structure

  bmih.biSize = sizeof(bmih);

  bmih.biWidth = biTrueWidth;

  bmih.biHeight = pix->height;

  bmih.biPlanes = 1;

  bmih.biBitCount = 8;

  bmih.biCompression = BI_RGB;

  bmih.biSizeImage = 0;

  bmih.biXPelsPerMeter = 0;

  bmih.biYPelsPerMeter = 0;

  bmih.biClrUsed = 256;

  bmih.biClrImportant = 0;

  // Write info header

  FS_Write( pfile, &bmih, sizeof(bmih));

  pb = pix->palette;

  // copy over used entries

  for( i = 0; i < (int)bmih.biClrUsed; i++ )

  {

    rgrgbPalette[i].rgbRed = *pb++;

    rgrgbPalette[i].rgbGreen = *pb++;

    rgrgbPalette[i].rgbBlue = *pb++;

    // bmp feature - can store 32-bit palette if present

    // some viewers e.g. fimg.exe can show alpha-chanell for it

    if( pix->type == PF_INDEXED_32 )

      rgrgbPalette[i].rgbReserved = *pb++;

    else rgrgbPalette[i].rgbReserved = 0;

  }

  // make last color is 0 0 255, xwad expect this (but ignore decals)

  if( com.strrchr( name, '{' ) && pix->flags & IMAGE_HAS_ALPHA && !( pix->flags & IMAGE_COLORINDEX ))

  {

    rgrgbPalette[255].rgbRed = 0x00;

    rgrgbPalette[255].rgbGreen = 0x00;

    rgrgbPalette[255].rgbBlue = 0xFF;

    rgrgbPalette[255].rgbReserved = 0x00;

  }

  // write palette( bmih.biClrUsed entries )

  cbPalBytes = bmih.biClrUsed * sizeof( RGBQUAD );

  FS_Write( pfile, rgrgbPalette, cbPalBytes );

  pbBmpBits = Mem_Alloc( Sys.imagepool, cbBmpBits );

  Mem_Set( pbBmpBits, 0xFF, cbBmpBits );	// fill buffer with last palette color

  pb = pix->buffer;

  pb += (pix->height - 1) * pix->width;

  for( i = 0; i < bmih.biHeight; i++ )

  {

    Mem_Copy( &pbBmpBits[biTrueWidth * i], pb, pix->width );

    pb -= pix->width;

  }

  // write bitmap bits (remainder of file)

  FS_Write( pfile, pbBmpBits, cbBmpBits );

  FS_Close( pfile );

  Mem_Free( pbBmpBits );

  return true;

}