zic2xpm.c

   1 /*
   2         zic2xpm.c
   3
   4         Program to convert pieces from ZIICS format to XPM & XIM format.
   5         (C version)  By Frank McIngvale <frankm@hiwaay.net>.
   6
   7         Copyright (C) 1996 Free Software Foundation, Inc.
   8
   9         NOTICE: The piece images distributed with ZIICS are
  10             copyrighted works of their original creators.  Images
  11             converted with zic2xpm may not be redistributed without
  12             the permission of the copyright holders.  Do not contact
  13             the authors of zic2xpm or of ZIICS itself to request
  14             permission.
  15
  16         NOTICE:  The format of the ZIICS piece file was gleaned from
  17             SHOWSETS.PAS, a part of ZIICS.  Thanks to Andy McFarland
  18             (Zek on ICC) for making this source available!  ZIICS is a
  19             completely separate and copyrighted work of Andy
  20             McFarland.  Use and distribution of ZIICS falls under the
  21             ZIICS license, NOT the GNU General Public License.
  22
  23         NOTICE: The format of the VGA imageblocks was determined
  24             by experimentation, and without access to any
  25             of Borland Inc.'s BGI library source code.
  26
  27         This program is free software; you can redistribute it and/or modify
  28         it under the terms of the GNU General Public License as published by
  29         the Free Software Foundation; either version 2 of the License, or
  30         (at your option) any later version.  However, the above notices
  31         MUST BE RETAINED in any copy that you redistribute or modify.
  32
  33         This program is distributed in the hope that it will be useful,
  34         but WITHOUT ANY WARRANTY; without even the implied warranty of
  35         MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  36         GNU General Public License for more details.
  37
  38         You should have received a copy of the GNU General Public License
  39         along with this program; if not, write to the Free Software
  40         Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111 USA.
  41
  42         ** If you find a bug in zic2xpm.c, please report it to me,
  43            Frank McIngvale (frankm@hiwaay.net) so that I may fix it. **
  44 */
  45
  46 /*
  47         Usage: zic2xpm file1 [file2 ...]
  48
  49         We split the ZIICS file(s) into 24 XPM & 24 XIM files with names:
  50
  51         <piece><type><size>.(xpm|xim).
  52
  53         Where:
  54                 piece = p, n, b, r, q, k
  55                 type = ll, ld, dl, dd
  56                 size = Piece size.
  57
  58         Plus 4 files for the light & dark squares.
  59
  60         This means that you can extract multiple SIZES in one directory
  61         without name clashes. Extracting two sets of the SAME
  62         size in a directory will cause the second to overwrite
  63         the first.
  64 */
  65
  66 /*
  67    Technical note: Yes, this file is huge. I made it by cramming
  68                    `zic2xpm' and `zic2xim' together. This should
  69                    be less confusing to use, though.
  70 */
  71
  72 #include "config.h"
  73 #include <stdio.h>
  74 #if STDC_HEADERS
  75 #include <stdlib.h>
  76 #endif
  77
  78 #ifndef SEEK_SET
  79 #define SEEK_SET 0
  80 #endif
  81
  82 /*
  83    XIM file format:
  84
  85    width        byte
  86    height       byte
  87
  88    Data (1 byte per pixel, row major)
  89 */
  90
  91 /*
  92    Map colors from ZIICS -> XIM :
  93
  94    0    0       Dark piece
  95    2    1       Dark square
  96    15   2       Light piece
  97    14   3       Light square
  98 */
  99
 100 typedef struct {
 101   int zval;             /* ZIICS value */
 102   int xval;             /* XIM value */
 103 } z2xim;
 104
 105 /* Associate VGA color with XPM color/sym */
 106
 107 typedef struct {
 108   int cval;             /* VGA pixel value */
 109   char xchar;   /* XPM character for this color */
 110   char *csym;   /* Symbolic name */
 111   char *cdefault; /* Default color */
 112 } z2xpm;
 113
 114 #define NR_ZIICS_COLORS 4
 115
 116 /* SHOWSETS.PAS (from ZIICS) states that images may only
 117    use color numbers 0, 2, 14, and 15 */
 118
 119 z2xim z2xim_tab[NR_ZIICS_COLORS] = {
 120   { 0, 0 },
 121   { 2, 1 },
 122   { 15, 2 },
 123   { 14, 3 } };
 124
 125 z2xpm z2xpm_tab[NR_ZIICS_COLORS] = {
 126   { 15, 'X', "light_piece", "white" },
 127   { 0, ' ', "dark_piece", "black" },
 128   { 14, '*', "light_square", "gray" },
 129   { 2, '.', "dark_square", "green" } };
 130
 131 void fatal( str )
 132          char *str;
 133 {
 134   printf("Fatal error: %s\n", str );
 135   exit(1);
 136 }
 137
 138 z2xim *lookup_xim_color( color )
 139          int color;
 140 {
 141   int i;
 142
 143   for( i=0; i<NR_ZIICS_COLORS; ++i )
 144         {
 145           if ( z2xim_tab[i].zval == color )
 146                 return (z2xim_tab + i);
 147         }
 148
 149   fatal("Illegal color in image.");
 150
 151   /* NOT REACHED */
 152   return NULL;                                  /* Make compiler happy */
 153 }
 154
 155 z2xpm *lookup_xpm_color( color )
 156          int color;
 157 {
 158   int i;
 159
 160   for( i=0; i<NR_ZIICS_COLORS; ++i )
 161         {
 162           if ( z2xpm_tab[i].cval == color )
 163                 return (z2xpm_tab + i);
 164         }
 165
 166   fatal("Illegal color in image.");
 167
 168   /* NOT REACHED */
 169   return NULL;                                  /* Make compiler happy */
 170 }
 171
 172 char *src_name;
 173
 174 int up8( i )
 175          int i;
 176 {
 177   int r;
 178
 179   r = i % 8;
 180   if ( r == 0 )
 181         return i;
 182
 183   return i + 8 - r;
 184 }
 185
 186 unsigned int vga_imagesize( w, h )
 187          int w, h;
 188 {
 189   int w8;
 190   unsigned int s;
 191
 192   w8 = up8( w );
 193
 194   s = 4 + w8/2 * h + 2;
 195
 196   return s;
 197 }
 198
 199 unsigned char *decode_byte( dest, b, w )
 200          unsigned char *dest, *b;
 201          int w;
 202 {
 203   int i, j;
 204   unsigned char byte, bit;
 205
 206   for( i=7; w > 0; --i, --w )
 207         {
 208           byte = 0;
 209
 210           /* 1 bit from each plane */
 211           for( j=0; j<4; ++j )
 212                 {
 213                   bit = b[j];
 214                   bit &= (1 << i);
 215                   bit >>= i;
 216                   bit <<= 3-j;
 217                   byte |= bit;
 218                 }
 219
 220           *(dest++) = byte;
 221         }
 222
 223   return dest;
 224 }
 225
 226 /*
 227    W is width of image in PIXELS.
 228    SRC is in packed pixel format.
 229    DEST is filled with 1 BYTE per PIXEL.
 230 */
 231 unsigned char *decode_line( dest, src, w )
 232          unsigned char *dest, *src;
 233          int w;
 234 {
 235   unsigned int w8;
 236   unsigned int bpp;
 237   unsigned char b[4];
 238   int i;
 239   unsigned char *p;
 240
 241   p = src;
 242   w8 = up8( w );
 243
 244   /* 4 planes, bpp BYTES per plane */
 245   /* Planes are MSB -> LSB */
 246   bpp = w8 >> 3;
 247
 248   while( w > 0 )
 249         {
 250           for( i=0; i<4; ++i )
 251                 b[i] = p[i*bpp];
 252
 253           if ( w > 8 )
 254                 dest = decode_byte( dest, b, 8 );
 255           else
 256                 dest = decode_byte( dest, b, w );
 257
 258           w -= 8;
 259           ++p;
 260         }
 261
 262   return (src + bpp * 4);
 263 }
 264
 265 int write_xim_header( fp, w, h )
 266          FILE *fp;
 267          int w, h;
 268 {
 269   fputc( w, fp );
 270   fputc( h, fp );
 271
 272   return 0;
 273 }
 274
 275 int write_xpm_header( fp, w, h )
 276          FILE *fp;
 277          int w, h;
 278 {
 279   int i;
 280   z2xpm *cv;
 281
 282   fprintf(fp, "/* XPM */\n");
 283   fprintf(fp, "/* This file was automatically generated from the file %s\n",
 284           src_name );
 285   fprintf(fp, "using the program ``zic2xpm''.\n");
 286   fprintf(fp, "\n    %s\n    %s\n    %s\n    %s\n    %s\n    %s */\n",
 287           "NOTICE: The piece images distributed with ZIICS are",
 288           "    copyrighted works of their original creators.  Images",
 289           "    converted with zic2xpm may not be redistributed without",
 290           "    the permission of the copyright holders.  Do not contact",
 291           "    the authors of zic2xpm or of ZIICS itself to request",
 292           "    permission.");
 293   fprintf( fp, "static char * image_name[] = {\n" );
 294   fprintf( fp, "\"%d %d %d 1\",\n", h, w, NR_ZIICS_COLORS );
 295
 296   cv = z2xpm_tab;
 297
 298   for( i=0; i<NR_ZIICS_COLORS; ++i, ++cv )
 299         {
 300           fprintf( fp, "\"%c\tc %s s %s\",\n", cv->xchar,
 301                           cv->cdefault, cv->csym );
 302         }
 303
 304   return 0;
 305 }
 306
 307 void create_piece_xim( outname, fpin, W, H )
 308          char *outname;
 309          FILE *fpin;
 310          int W, H;
 311 {
 312   FILE *fpout;
 313   int w, h, i, j, c;
 314   unsigned char *lump, *p, *line;
 315   long size;
 316   z2xim *ent;
 317
 318   fpout = fopen( outname, "wb" );
 319   if ( !fpout )
 320         fatal( "Can't create output file.");
 321
 322   /* Header is two ints -- Width then Height, x86 format */
 323   c = fgetc( fpin );
 324   w = (fgetc(fpin) << 8) | c;
 325
 326   c = fgetc( fpin );
 327   h = (fgetc(fpin) << 8) | c;
 328
 329   ++w; ++h;
 330
 331   if ( w != W || h != H )
 332         fatal( "Bad header." );
 333
 334   size = vga_imagesize( w, h ) - 4;
 335   lump = (unsigned char*)malloc( size );
 336   line = (unsigned char*)malloc( w );
 337
 338   if ( !lump || !line )
 339         fatal( "Out of memory." );
 340
 341   fread( lump, 1, size, fpin );
 342
 343   /* Write XIM header */
 344   write_xim_header( fpout, w, h );
 345
 346   p = lump;
 347
 348   /* Write XIM data */
 349   for( i=0; i<h; ++i )
 350         {
 351           p = decode_line( line, p, w );
 352
 353           for( j=0; j<w; ++j )
 354                 {
 355                   ent = lookup_xim_color( line[j] );
 356                   fputc( ent->xval, fpout );
 357                 }
 358         }
 359
 360   free( lump );
 361   free( line );
 362   fclose( fpout );
 363 }
 364
 365 void create_piece_xpm( outname, fpin, W, H )
 366          char *outname;
 367          FILE *fpin;
 368          int W, H;
 369 {
 370   FILE *fpout;
 371   int w, h, i, j, c;
 372   unsigned char *lump, *p, *line;
 373   long size;
 374   z2xpm *cv;
 375
 376   fpout = fopen( outname, "wb" );
 377   if ( !fpout )
 378         fatal( "Can't create output file.");
 379
 380   /* Header is two ints -- Width then Height, x86 format */
 381   c = fgetc( fpin );
 382   w = (fgetc(fpin) << 8) | c;
 383
 384   c = fgetc( fpin );
 385   h = (fgetc(fpin) << 8) | c;
 386
 387   ++w; ++h;
 388
 389   if ( w != W || h != H )
 390         fatal( "Bad header." );
 391
 392   size = vga_imagesize( w, h ) - 4;
 393   lump = (unsigned char*)malloc( size );
 394   line = (unsigned char*)malloc( w );
 395
 396   if ( !lump || !line )
 397         fatal( "Out of memory." );
 398
 399   fread( lump, 1, size, fpin );
 400
 401   /* Write XPM header */
 402   write_xpm_header( fpout, w, h );
 403
 404   p = lump;
 405
 406   /* Write XPM data */
 407   for( i=0; i<h; ++i )
 408         {
 409           p = decode_line( line, p, w );
 410
 411           fprintf( fpout, "\"" );
 412           for( j=0; j<w; ++j )
 413                 {
 414                   cv = lookup_xpm_color( line[j] );
 415                   fprintf( fpout, "%c", cv->xchar );
 416                 }
 417           fprintf( fpout, "\",\n" );
 418         }
 419
 420   fprintf( fpout, "};\n" );
 421
 422   free( lump );
 423   free( line );
 424   fclose( fpout );
 425 }
 426
 427 /* The order of the pieces in the ZIICS piece file (from SHOWSETS.PAS) */
 428 char *pieces = "prkqbn";
 429 char *pname[] = { "Pawn", "Rook", "King", "Queen", "Bishop", "Knight" };
 430
 431 /* The suborder - Light/Light, Light/Dark, etc. */
 432 char *prefixes[] = { "ll", "ld", "dl", "dd" };
 433
 434 int process_file_xim( filename )
 435          char *filename;
 436 {
 437   int w, h, piece, kind, c;
 438   int nr_pieces = 6;
 439   int nr_kinds = 4;
 440   FILE *fp;
 441   char buf[100];
 442
 443   src_name = filename;
 444
 445   fp = fopen( filename, "rb" );
 446   if ( !fp )
 447         fatal( "Can't open input file." );
 448
 449   /* Header is two ints -- Width then Height, x86 format */
 450   c = fgetc( fp );
 451   w = (fgetc(fp) << 8) | c;
 452
 453   c = fgetc( fp );
 454   h = (fgetc(fp) << 8) | c;
 455
 456   ++w; ++h;
 457
 458   if ( w != h )
 459         {
 460           printf("ERROR: Can only convert square pieces.\n");
 461           printf("       (This set is %dx%d)\n", w, h );
 462           exit(1);
 463         }
 464
 465   printf("Creating XIM files...\n");
 466   printf("File: %s, W=%d, H=%d\n", filename, w, h );
 467   fseek( fp, 0, SEEK_SET );
 468
 469   /* Write .XIM files */
 470   for( piece = 0; piece < nr_pieces; ++piece )
 471         {
 472           printf("%s ", pname[piece] );
 473
 474           for( kind = 0; kind < nr_kinds; ++kind )
 475                 {
 476                   printf( "." );
 477                   /* Form output filename -- <piece><kind><size>.xim */
 478                   sprintf(buf, "%c%s%d.xim", pieces[piece], prefixes[kind], w);
 479                   create_piece_xim( buf, fp, w, h );
 480                 }
 481           printf("\n");
 482         }
 483
 484   /* Write the light & dark squares */
 485   sprintf( buf, "lsq%d.xim", w );
 486   printf("Light Square" );
 487   create_piece_xim( buf, fp, w, h );
 488
 489   sprintf( buf, "dsq%d.xim", w );
 490   printf("\nDark Square" );
 491   create_piece_xim( buf, fp, w, h );
 492   printf("\n");
 493
 494   printf("Successfully converted!!\n" );
 495
 496   fclose( fp );
 497
 498   return 0;
 499 }
 500
 501 int process_file_xpm( filename )
 502          char *filename;
 503 {
 504   int w, h, piece, kind, c;
 505   int nr_pieces = 6;
 506   int nr_kinds = 4;
 507   FILE *fp;
 508   char buf[100];
 509
 510   src_name = filename;
 511
 512   fp = fopen( filename, "rb" );
 513   if ( !fp )
 514         fatal( "Can't open input file." );
 515
 516   /* Header is two ints -- Width then Height, x86 format */
 517   c = fgetc( fp );
 518   w = (fgetc(fp) << 8) | c;
 519
 520   c = fgetc( fp );
 521   h = (fgetc(fp) << 8) | c;
 522
 523   ++w; ++h;
 524
 525   if ( w != h )
 526         {
 527           printf("ERROR: Can only convert square pieces.\n");
 528           printf("       (This set is %dx%d)\n", w, h );
 529           exit(1);
 530         }
 531
 532   printf("Creating XPM files...\n");
 533   printf("File: %s, W=%d, H=%d\n", filename, w, h );
 534   fseek( fp, 0, SEEK_SET );
 535
 536   /* Write .XPM files */
 537   for( piece = 0; piece < nr_pieces; ++piece )
 538         {
 539           printf("%s ", pname[piece] );
 540
 541           for( kind = 0; kind < nr_kinds; ++kind )
 542                 {
 543                   printf( "." );
 544                   /* Form output filename -- <piece><kind><size>.xpm */
 545                   sprintf(buf, "%c%s%d.xpm", pieces[piece], prefixes[kind], w);
 546                   create_piece_xpm( buf, fp, w, h );
 547                 }
 548           printf("\n");
 549         }
 550
 551   /* Write the light & dark squares */
 552   sprintf( buf, "lsq%d.xpm", w );
 553   printf("Light Square" );
 554   create_piece_xpm( buf, fp, w, h );
 555
 556   sprintf( buf, "dsq%d.xpm", w );
 557   printf("\nDark Square" );
 558   create_piece_xpm( buf, fp, w, h );
 559   printf("\n");
 560
 561   printf("Successfully converted!!\n" );
 562
 563   fclose( fp );
 564
 565   return 0;
 566 }
 567
 568 int main( argc, argv )
 569          int argc;
 570          char *argv[];
 571 {
 572   int i;
 573
 574   if ( argc < 2 )
 575         {
 576           printf("ZIC2XPM 2.01 - by Frank McIngvale (frankm@hiwaay.net)\n");
 577           printf("Copyright (C) 1996 Free Software Foundation, Inc.\n\n");
 578           printf("Usage: zic2xpm file1 [file2 ...]\n\n");
 579           printf("  Splits each file (ZIICS piece files) into 26 XPM & XIM files\n");
 580           printf("  suitable for use in XBoard 3.5 or later.\n");
 581           printf("\n* ZIICS is a copyrighted work of Andy McFarland (Zek on ICC) *\n");
 582           return 1;
 583         }
 584
 585
 586   setbuf( stdout, NULL );
 587
 588   for( i=1; i<argc; ++i )
 589         {
 590           process_file_xpm( argv[i] );
 591           process_file_xim( argv[i] );
 592         }
 593
 594   fprintf(stderr, "%s\n%s\n%s\n%s\n%s\n%s\n",
 595           "NOTICE: The piece images distributed with ZIICS are",
 596           "    copyrighted works of their original creators.  Images",
 597           "    converted with zic2xpm may not be redistributed without",
 598           "    the permission of the copyright holders.  Do not contact",
 599           "    the authors of zic2xpm or of ZIICS itself to request",
 600           "    permission.");
 601   return 0;
 602 }