gfx/povray/ppm.c

   1 /****************************************************************************
   2 *                ppm.c
   3 *
   4 *  This module contains the code to read and write the PPM file format.
   5 *
   6 *  from Persistence of Vision(tm) Ray Tracer
   7 *  Copyright 1996,1999 Persistence of Vision Team
   8 *---------------------------------------------------------------------------
   9 *  NOTICE: This source code file is provided so that users may experiment
  10 *  with enhancements to POV-Ray and to port the software to platforms other
  11 *  than those supported by the POV-Ray Team.  There are strict rules under
  12 *  which you are permitted to use this file.  The rules are in the file
  13 *  named POVLEGAL.DOC which should be distributed with this file.
  14 *  If POVLEGAL.DOC is not available or for more info please contact the POV-Ray
  15 *  Team Coordinator by email to team-coord@povray.org or visit us on the web at
  16 *  http://www.povray.org. The latest version of POV-Ray may be found at this site.
  17 *
  18 * This program is based on the popular DKB raytracer version 2.12.
  19 * DKBTrace was originally written by David K. Buck.
  20 * DKBTrace Ver 2.0-2.12 were written by David K. Buck & Aaron A. Collins.
  21 *
  22 * Original patch copyright 1994 Tim Rowley
  23 * Updated for POV 3.0 by Chris Cason, Jan '95.
  24 *
  25 * Modifications by Hans-Detlev Fink, January 1999, used with permission.
  26 *
  27 *****************************************************************************/
  28
  29 /****************************************************************************
  30 *  The format is as follows:
  31 *
  32 *  (header:)
  33 *    P3              - ASCII data OR
  34 *    P6              - raw binary data
  35 *    # hello         - optional comment(s)
  36 *    wwww hhhh       - Width, Height (ASCII text)
  37 *    # world         - optional comment(s)
  38 *    nnn             - maximum color (nnn = bright, 0 = black)
  39 *
  40 *  (each pixel: one of the following)
  41 *    rr gg bb        - Red, green, blue of intensity 0-nnn (binary byte)
  42 *    RRR GGG BBB     - Red, green, blue of intensity 0-nnn (ASCII number)
  43 *
  44 *****************************************************************************/
  45
  46 #include "frame.h"
  47 #include "povproto.h"
  48 #include "povray.h"
  49 #include "optout.h"
  50 #include "pgm.h"
  51 #include "ppm.h"
  52
  53 /*****************************************************************************
  54 * Local preprocessor defines
  55 ******************************************************************************/
  56
  57 /*****************************************************************************
  58 * Local typedefs
  59 ******************************************************************************/
  60
  61 /*****************************************************************************
  62 * Local variables
  63 ******************************************************************************/
  64
  65 static int PPM_Line_Number;
  66
  67 /*****************************************************************************
  68 * Static functions
  69 ******************************************************************************/
  70
  71 static int Open_PPM_File (FILE_HANDLE *handle, char *name, int *width, int *height, int buffer_size, int mode);
  72 static void Write_PPM_Line (FILE_HANDLE *handle, COLOUR *line_data, int line_number);
  73 static int Read_PPM_Line (FILE_HANDLE *handle, COLOUR *line_data, int *line_number);
  74 static void Close_PPM_File (FILE_HANDLE *handle);
  75
  76 /*****************************************************************************
  77 *
  78 * FUNCTION
  79 *
  80 * INPUT
  81 *
  82 * OUTPUT
  83 *
  84 * RETURNS
  85 *
  86 * AUTHOR
  87 *
  88 * DESCRIPTION
  89 *
  90 * CHANGES
  91 *
  92 ******************************************************************************/
  93
  94 FILE_HANDLE *Get_PPM_File_Handle()
  95 {
  96   FILE_HANDLE *handle;
  97
  98   handle = (FILE_HANDLE *) POV_MALLOC(sizeof(FILE_HANDLE), "PPM file handle") ;
  99
 100   handle->Open_File_p = Open_PPM_File;
 101   handle->Write_Line_p = Write_PPM_Line;
 102   handle->Read_Line_p = Read_PPM_Line;
 103   handle->Read_Image_p = Read_PPM_Image;
 104   handle->Close_File_p = Close_PPM_File;
 105
 106   handle->file = NULL;
 107   handle->buffer = NULL;
 108   handle->buffer_size = 0;
 109
 110   return (handle);
 111 }
 112
 113 /*****************************************************************************
 114 *
 115 * FUNCTION
 116 *
 117 * INPUT
 118 *
 119 * OUTPUT
 120 *
 121 * RETURNS
 122 *
 123 * AUTHOR
 124 *
 125 * DESCRIPTION
 126 *
 127 * CHANGES
 128 *
 129 ******************************************************************************/
 130
 131 static int Open_PPM_File(FILE_HANDLE *handle, char *name, int *width, int *height, int buffer_size, int mode)
 132 {
 133   char type;
 134   int input;
 135   char junk[512];
 136
 137   handle->mode = mode;
 138   handle->filename = name;
 139   PPM_Line_Number = 0;
 140
 141   switch (mode)
 142   {
 143     case READ_MODE:
 144
 145       /* We can't resume from stdout. */
 146       if (opts.Options & TO_STDOUT  ||
 147           (handle->file = fopen(name, READ_BINFILE_STRING)) == NULL)
 148       {
 149         Status_Info("\n");
 150         return(0);
 151       }
 152
 153       if (buffer_size != 0)
 154       {
 155         handle->buffer = (char *)POV_MALLOC((size_t)buffer_size, "PPM file buffer") ;
 156         setvbuf(handle->file, handle->buffer, _IOFBF, buffer_size);
 157       }
 158
 159       if (fscanf(handle->file, "P%c\n", &type) != 1 || type != '6')
 160       {
 161         return(0);
 162       }
 163
 164       /* Ignore any comments (if they are written) */
 165
 166       while ((input = fgetc(handle->file)) == '#')
 167       {
 168         fgets(junk, 512, handle->file);
 169       }
 170
 171       ungetc(input, handle->file);
 172
 173       if (fscanf(handle->file, "%d %d\n255\n", width, height) != 2)
 174       {
 175         return(0);
 176       }
 177
 178       Status_Info("\nResuming interrupted trace from %s",handle->filename);
 179
 180       handle->width = *width;
 181       handle->height = *height;
 182       handle->buffer_size = buffer_size;
 183
 184       break;
 185
 186     case WRITE_MODE:
 187
 188       if (opts.Options & TO_STDOUT)
 189       {
 190         buffer_size = 0;
 191         handle->file = stdout;
 192       }
 193       else
 194       {
 195         if ((handle->file = fopen(name, WRITE_BINFILE_STRING)) == NULL)
 196         {
 197           return(0);
 198         }
 199       }
 200
 201       if (buffer_size != 0)
 202       {
 203         handle->buffer = (char *)POV_MALLOC((size_t)buffer_size, "PPM file buffer") ;
 204         setvbuf(handle->file, handle->buffer, _IOFBF, buffer_size);
 205       }
 206
 207       fprintf(handle->file, "P6\n");
 208
 209 #ifdef POV_COMMENTS
 210 #ifdef TRACER
 211       fprintf(handle->file, "# Author: %s\n", TRACER);
 212 #endif
 213
 214       fprintf(handle->file, "# Source: Persistence of Vision(tm) Ray Tracer v%s%s\n",
 215               POV_RAY_VERSION, COMPILER_VER);
 216
 217       if (!(opts.Options & TO_STDOUT))
 218       {
 219         fprintf(handle->file, "# Input File: %s\n", opts.Input_File_Name);
 220       }
 221
 222       if (opts.FrameSeq.Clock_Value != 0)
 223       {
 224         fprintf(handle->file, "# POV Clock: %g\n", opts.FrameSeq.Clock_Value);
 225       }
 226
 227       if (opts.Quality != 9)
 228       {
 229         fprintf(handle->file, "# Rendering Quality: %d\n", opts.Quality);
 230       }
 231 #endif /* POV_COMMENTS */
 232
 233       fprintf(handle->file, "%d %d\n255\n", *width, *height);
 234
 235       handle->width = *width;
 236       handle->height = *height;
 237
 238       handle->buffer_size = buffer_size;
 239
 240       break;
 241
 242     case APPEND_MODE:
 243
 244       if (opts.Options & TO_STDOUT)
 245       {
 246         buffer_size = 0;
 247         handle->file = stdout;
 248       }
 249       else
 250       {
 251         if ((handle->file = fopen(name, APPEND_BINFILE_STRING)) == NULL)
 252         {
 253           return(0);
 254         }
 255       }
 256
 257       if (buffer_size != 0)
 258       {
 259         handle->buffer = (char *)POV_MALLOC((size_t)buffer_size, "PPM file buffer") ;
 260         setvbuf(handle->file, handle->buffer, _IOFBF, buffer_size);
 261       }
 262
 263       handle->buffer_size = buffer_size;
 264
 265       break;
 266   }
 267
 268   return(1);
 269 }
 270
 271 /*****************************************************************************
 272 *
 273 * FUNCTION
 274 *
 275 * INPUT
 276 *
 277 * OUTPUT
 278 *
 279 * RETURNS
 280 *
 281 * AUTHOR
 282 *
 283 * DESCRIPTION
 284 *
 285 * CHANGES
 286 *
 287 ******************************************************************************/
 288
 289 static void Write_PPM_Line(FILE_HANDLE *handle, COLOUR *line_data, int line_number)
 290 {
 291   unsigned int gray;
 292   register int x;
 293
 294   for (x = 0 ; x < handle->width ; x++)
 295   {
 296     if (opts.Options & HF_GRAY_16)  /* 16 bit grayscale output */
 297     {
 298       gray = ((0.30 * line_data[x][RED]) +
 299               (0.59 * line_data[x][GREEN]) +
 300               (0.11 * line_data[x][BLUE])) * 65535;
 301
 302       if ((putc((gray >> 8) & 0xFF, handle->file) == EOF) ||
 303           (putc(gray & 0xFF, handle->file) == EOF) ||
 304           (putc(0, handle->file) == EOF))
 305       {
 306         Error("Error writing PPM output data to %s.\n",handle->filename);
 307       }
 308     }
 309     else                            /* Normal 24 bit pixel coloring */
 310     {
 311       if ((putc((int)floor(line_data[x][RED] * 255.0), handle->file) == EOF) ||
 312           (putc((int)floor(line_data[x][GREEN]*255.0), handle->file) == EOF) ||
 313           (putc((int)floor(line_data[x][BLUE]*255.0), handle->file) == EOF))
 314       {
 315         Error("Error writing PPM output data to %s.\n",handle->filename);
 316       }
 317     }
 318   }
 319
 320   PPM_Line_Number++;
 321
 322   if (handle->buffer_size == 0)
 323   {
 324     /* close and reopen file for integrity in case we crash */
 325
 326     fflush(handle->file);
 327
 328     if (!(opts.Options & TO_STDOUT))
 329     {
 330       handle->file = freopen(handle->filename,APPEND_BINFILE_STRING,handle->file);
 331     }
 332   }
 333 }
 334
 335 /*****************************************************************************
 336 *
 337 * FUNCTION
 338 *
 339 * INPUT
 340 *
 341 * OUTPUT
 342 *
 343 * RETURNS
 344 *
 345 * AUTHOR
 346 *
 347 * DESCRIPTION
 348 *
 349 * CHANGES
 350 *
 351 ******************************************************************************/
 352
 353 static int Read_PPM_Line(FILE_HANDLE *handle, COLOUR *line_data, int *line_number)
 354 {
 355   int data, i;
 356
 357   if ((data = getc(handle->file)) == EOF)
 358   {
 359     return (0);
 360   }
 361
 362   ungetc(data, handle->file);
 363
 364   *line_number = PPM_Line_Number++;
 365
 366   for (i = 0 ; i < handle->width ; i++)
 367   {
 368     if ((data = getc(handle->file)) == EOF)
 369     {
 370       return(-1);
 371     }
 372
 373     line_data[i][RED] = (DBL) data / 255.0;
 374
 375     if ((data = getc(handle->file)) == EOF)
 376     {
 377       return(-1);
 378     }
 379
 380     line_data[i][GREEN] = (DBL) data / 255.0;
 381
 382     if ((data = getc(handle->file)) == EOF)
 383     {
 384       return(-1);
 385     }
 386
 387     line_data[i][BLUE] = (DBL) data / 255.0;
 388   }
 389
 390   return (1);
 391 }
 392
 393 /*****************************************************************************
 394 *
 395 * FUNCTION
 396 *
 397 * INPUT
 398 *
 399 * OUTPUT
 400 *
 401 * RETURNS
 402 *
 403 * AUTHOR
 404 *
 405 * DESCRIPTION
 406 *
 407 * CHANGES
 408 *
 409 ******************************************************************************/
 410
 411 static void Close_PPM_File(FILE_HANDLE *handle)
 412 {
 413   if (handle->file)
 414   {
 415     fflush(handle->file);
 416
 417     /* Close and reopen file (if not stdout) for integrity in case we crash */
 418
 419     if (!(opts.Options & TO_STDOUT))
 420       fclose(handle->file);
 421   }
 422
 423   if (handle->buffer != NULL)
 424   {
 425     POV_FREE(handle->buffer);
 426   }
 427
 428   handle->file = NULL;
 429   handle->buffer = NULL;
 430 }
 431
 432 /*****************************************************************************
 433 *
 434 * FUNCTION
 435 *
 436 * INPUT
 437 *
 438 * OUTPUT
 439 *
 440 * RETURNS
 441 *
 442 * AUTHOR
 443 *
 444 * DESCRIPTION
 445 *
 446 * CHANGES
 447 *
 448 ******************************************************************************/
 449
 450 void Read_PPM_Image(IMAGE *Image, char *name)
 451 {
 452   char type;
 453   int width, height;
 454   int depth;
 455   char input;
 456   char junk[512];
 457   int x, y;
 458   int data;
 459   IMAGE_LINE *line_data;
 460   FILE *infile;
 461
 462   if ((infile = Locate_File(name, READ_BINFILE_STRING, ".ppm", ".PPM",NULL,TRUE)) == NULL)
 463   {
 464     Error("Error opening PPM image %s.\n", name);
 465     return;     /* -hdf99- */
 466   }
 467
 468   if (fscanf(infile, "P%c\n", &type) != 1 || (type != '3' && type != '6'))
 469   {
 470     Error ("File is not in PPM format.\n", name);
 471     return;     /* -hdf99- */
 472   }
 473
 474   /* Ignore any comments */
 475
 476   while ((input = fgetc(infile)) == '#')
 477   {
 478     fgets(junk, 512, infile);
 479   }
 480
 481   ungetc(input, infile);
 482
 483   if (fscanf(infile, "%d %d\n", &width, &height) != 2)
 484   {
 485     Error ("Error reading width or height from PPM image.\n", name);
 486   }
 487
 488   /* Ignore any comments */
 489   while ((input = fgetc(infile)) == '#')
 490   {
 491     fgets(junk, 512, infile);
 492   }
 493
 494   ungetc(input, infile);
 495
 496   if (fscanf(infile, "%d\n", &depth) != 1 || depth > 255 || depth < 1)
 497   {
 498     Error ("Unsupported number of colors (%d) in PPM image.\n", depth);
 499   }
 500
 501   Image->width  = (DBL)(Image->iwidth = width);
 502   Image->height = (DBL)(Image->iheight = height);
 503
 504   Image->Colour_Map_Size = 0;
 505
 506   Image->Colour_Map = NULL;
 507
 508   Image->data.rgb_lines = (IMAGE_LINE *) POV_MALLOC(Image->iheight * sizeof (IMAGE_LINE), "PPM image");
 509
 510   for (y = 0; y < height; y++)
 511   {
 512     line_data = &Image->data.rgb_lines[y];
 513
 514     line_data->red   = (unsigned char *)POV_MALLOC(width,"PPM image line");
 515     line_data->green = (unsigned char *)POV_MALLOC(width,"PPM image line");
 516     line_data->blue  = (unsigned char *)POV_MALLOC(width,"PPM image line");
 517     line_data->transm = (unsigned char *)NULL;
 518
 519     if (type == '3') /* ASCII data to be input */
 520     {
 521       for (x = 0; x < width; x++)
 522       {
 523         if (fscanf(infile,"%d",&data) != 1)
 524         {
 525           Error("Error reading data from PPM image.\n");
 526         }
 527
 528         line_data->red[x] = data*255/depth;
 529
 530         if (fscanf(infile,"%d",&data) != 1)
 531         {
 532           Error("Error reading data from PPM image.\n");
 533         }
 534
 535         line_data->green[x] = data*255/depth;
 536
 537         if (fscanf(infile,"%d",&data) != 1)
 538         {
 539           Error("Error reading data from PPM image.\n");
 540         }
 541
 542         line_data->blue[x] = data*255/depth;
 543       }
 544     }
 545     else /* (type == '6') Raw binary data to be input */
 546     {
 547       for (x = 0; x < width; x++)
 548       {
 549         if ((data = getc(infile)) == EOF)
 550         {
 551           Error("Error reading data from PPM image.\n");
 552         }
 553
 554         line_data->red[x] = data*255/depth;
 555
 556         if ((data = getc(infile)) == EOF)
 557         {
 558           Error("Error reading data from PPM image.\n");
 559         }
 560
 561         line_data->green[x] = data*255/depth;
 562
 563         if ((data = getc(infile)) == EOF)
 564         {
 565           Error("Error reading data from PPM image.\n");
 566         }
 567
 568         line_data->blue[x] = data*255/depth;
 569       }
 570     }
 571   }
 572
 573   fclose(infile);
 574 }