/****************************************************************************
* ppm.c
*
* This module contains the code to read and write the PPM file format.
*
* from Persistence of Vision(tm) Ray Tracer
* Copyright 1996 Persistence of Vision Team
*---------------------------------------------------------------------------
* NOTICE: This source code file is provided so that users may experiment
* with enhancements to POV-Ray and to port the software to platforms other
* than those supported by the POV-Ray Team. There are strict rules under
* which you are permitted to use this file. The rules are in the file
* named POVLEGAL.DOC which should be distributed with this file. If
* POVLEGAL.DOC is not available or for more info please contact the POV-Ray
* Team Coordinator by leaving a message in CompuServe's Graphics Developer's
* Forum. The latest version of POV-Ray may be found there as well.
*
* This program is based on the popular DKB raytracer version 2.12.
* DKBTrace was originally written by David K. Buck.
* DKBTrace Ver 2.0-2.12 were written by David K. Buck & Aaron A. Collins.
*
* Original patch copyright 1994 Tim Rowley
* Updated for POV 3.0 by Chris Cason, Jan '95.
*
*****************************************************************************/
/****************************************************************************
* The format is as follows:
*
* (header:)
* P3 - ASCII data OR
* P6 - raw binary data
* # hello - optional comment(s)
* wwww hhhh - Width, Height (ASCII text)
* # world - optional comment(s)
* nnn - maximum color (nnn = bright, 0 = black)
*
* (each pixel: one of the following)
* rr gg bb - Red, green, blue of intensity 0-nnn (binary byte)
* RRR GGG BBB - Red, green, blue of intensity 0-nnn (ASCII number)
*
*****************************************************************************/
#include "frame.h"
#include "povproto.h"
#include "povray.h"
#include "optout.h"
#include "pgm.h"
#include "ppm.h"
/*****************************************************************************
* Local preprocessor defines
******************************************************************************/
/*****************************************************************************
* Local typedefs
******************************************************************************/
/*****************************************************************************
* Local variables
******************************************************************************/
static int PPM_Line_Number;
/*****************************************************************************
* Static functions
******************************************************************************/
static int Open_PPM_File PARAMS ((FILE_HANDLE *handle, char *name, int *width,
int *height, int buffer_size, int mode));
static void Write_PPM_Line PARAMS ((FILE_HANDLE *handle, COLOUR *line_data,
int line_number));
static int Read_PPM_Line PARAMS((FILE_HANDLE *handle, COLOUR *line_data,
int *line_number));
static void Close_PPM_File PARAMS((FILE_HANDLE *handle));
/*****************************************************************************
*
* FUNCTION
*
* INPUT
*
* OUTPUT
*
* RETURNS
*
* AUTHOR
*
* DESCRIPTION
*
* CHANGES
*
******************************************************************************/
FILE_HANDLE *Get_PPM_File_Handle()
{
FILE_HANDLE *handle;
handle = (FILE_HANDLE *) POV_MALLOC(sizeof(FILE_HANDLE), "PPM file handle") ;
handle->Open_File_p = Open_PPM_File;
handle->Write_Line_p = Write_PPM_Line;
handle->Read_Line_p = Read_PPM_Line;
handle->Read_Image_p = Read_PPM_Image;
handle->Close_File_p = Close_PPM_File;
handle->file = NULL;
handle->buffer = NULL;
handle->buffer_size = 0;
return (handle);
}
/*****************************************************************************
*
* FUNCTION
*
* INPUT
*
* OUTPUT
*
* RETURNS
*
* AUTHOR
*
* DESCRIPTION
*
* CHANGES
*
******************************************************************************/
static int Open_PPM_File(handle, name, width, height, buffer_size, mode)
FILE_HANDLE *handle;
char *name;
int *width;
int *height;
int buffer_size;
int mode;
{
char type;
int input;
char junk[512];
handle->mode = mode;
handle->filename = name;
PPM_Line_Number = 0;
switch (mode)
{
case READ_MODE:
/* We can't resume from stdout. */
if (opts.Options & TO_STDOUT ||
(handle->file = fopen(name, READ_FILE_STRING)) == NULL)
{
Status_Info("\n");
return(0);
}
if (buffer_size != 0)
{
handle->buffer = POV_MALLOC((size_t)buffer_size, "PPM file buffer") ;
setvbuf(handle->file, handle->buffer, _IOFBF, buffer_size);
}
if (fscanf(handle->file, "P%c\n", &type) != 1 || type != '6')
{
return(0);
}
/* Ignore any comments (if they are written) */
while ((input = fgetc(handle->file)) == '#')
{
fgets(junk, 512, handle->file);
}
ungetc(input, handle->file);
if (fscanf(handle->file, "%d %d\n255\n", width, height) != 2)
{
return(0);
}
Status_Info("\nResuming interrupted trace from %s",handle->filename);
handle->width = *width;
handle->height = *height;
handle->buffer_size = buffer_size;
break;
case WRITE_MODE:
if (opts.Options & TO_STDOUT)
{
buffer_size = 0;
handle->file = stdout;
}
else
{
if ((handle->file = fopen(name, WRITE_FILE_STRING)) == NULL)
{
return(0);
}
}
if (buffer_size != 0)
{
handle->buffer = POV_MALLOC((size_t)buffer_size, "PPM file buffer") ;
setvbuf(handle->file, handle->buffer, _IOFBF, buffer_size);
}
fprintf(handle->file, "P6\n");
#ifdef POV_COMMENTS
#ifdef TRACER
fprintf(handle->file, "# Author: %s\n", TRACER);
#endif
fprintf(handle->file, "# Source: Persistence of Vision(tm) Ray Tracer v%s%s\n",
POV_RAY_VERSION, COMPILER_VER);
if (!(opts.Options & TO_STDOUT))
{
fprintf(handle->file, "# Input File: %s\n", opts.Input_File_Name);
}
if (opts.FrameSeq.Clock_Value != 0)
{
fprintf(handle->file, "# POV Clock: %g\n", opts.FrameSeq.Clock_Value);
}
if (opts.Quality != 9)
{
fprintf(handle->file, "# Rendering Quality: %d\n", opts.Quality);
}
#endif /* POV_COMMENTS */
fprintf(handle->file, "%d %d\n255\n", *width, *height);
handle->width = *width;
handle->height = *height;
handle->buffer_size = buffer_size;
break;
case APPEND_MODE:
if (opts.Options & TO_STDOUT)
{
buffer_size = 0;
handle->file = stdout;
}
else
{
if ((handle->file = fopen(name, APPEND_FILE_STRING)) == NULL)
{
return(0);
}
}
if (buffer_size != 0)
{
handle->buffer = POV_MALLOC((size_t)buffer_size, "PPM file buffer") ;
setvbuf(handle->file, handle->buffer, _IOFBF, buffer_size);
}
handle->buffer_size = buffer_size;
break;
}
return(1);
}
/*****************************************************************************
*
* FUNCTION
*
* INPUT
*
* OUTPUT
*
* RETURNS
*
* AUTHOR
*
* DESCRIPTION
*
* CHANGES
*
******************************************************************************/
static void Write_PPM_Line(handle, line_data, line_number)
FILE_HANDLE *handle;
COLOUR *line_data;
int line_number;
{
unsigned int gray;
register int x;
for (x = 0 ; x < handle->width ; x++)
{
if (opts.Options & HF_GRAY_16) /* 16 bit grayscale output */
{
gray = ((0.30 * line_data[x][RED]) +
(0.59 * line_data[x][GREEN]) +
(0.11 * line_data[x][BLUE])) * 65535;
if ((putc((gray >> 8) & 0xFF, handle->file) == EOF) ||
(putc(gray & 0xFF, handle->file) == EOF) ||
(putc(0, handle->file) == EOF))
{
Error("Error writing PPM output data to %s.\n",handle->filename);
}
}
else /* Normal 24 bit pixel coloring */
{
if ((putc((int)floor(line_data[x][RED] * 255.0), handle->file) == EOF) ||
(putc((int)floor(line_data[x][GREEN]*255.0), handle->file) == EOF) ||
(putc((int)floor(line_data[x][BLUE]*255.0), handle->file) == EOF))
{
Error("Error writing PPM output data to %s.\n",handle->filename);
}
}
}
PPM_Line_Number++;
if (handle->buffer_size == 0)
{
/* close and reopen file for integrity in case we crash */
fflush(handle->file);
if (!(opts.Options & TO_STDOUT))
{
handle->file = freopen(handle->filename,APPEND_FILE_STRING,handle->file);
}
}
}
/*****************************************************************************
*
* FUNCTION
*
* INPUT
*
* OUTPUT
*
* RETURNS
*
* AUTHOR
*
* DESCRIPTION
*
* CHANGES
*
******************************************************************************/
static int Read_PPM_Line(handle, line_data, line_number)
FILE_HANDLE *handle;
COLOUR *line_data;
int *line_number;
{
int data, i;
if ((data = getc(handle->file)) == EOF)
{
return (0);
}
ungetc(data, handle->file);
*line_number = PPM_Line_Number++;
for (i = 0 ; i < handle->width ; i++)
{
if ((data = getc(handle->file)) == EOF)
{
return(-1);
}
line_data[i][RED] = (DBL) data / 255.0;
if ((data = getc(handle->file)) == EOF)
{
return(-1);
}
line_data[i][GREEN] = (DBL) data / 255.0;
if ((data = getc(handle->file)) == EOF)
{
return(-1);
}
line_data[i][BLUE] = (DBL) data / 255.0;
}
return (1);
}
/*****************************************************************************
*
* FUNCTION
*
* INPUT
*
* OUTPUT
*
* RETURNS
*
* AUTHOR
*
* DESCRIPTION
*
* CHANGES
*
******************************************************************************/
static void Close_PPM_File(handle)
FILE_HANDLE *handle;
{
if (handle->file)
{
fflush(handle->file);
/* Close and reopen file (if not stdout) for integrity in case we crash */
if (!(opts.Options & TO_STDOUT))
fclose(handle->file);
}
if (handle->buffer != NULL)
{
POV_FREE(handle->buffer);
}
handle->file = NULL;
handle->buffer = NULL;
}
/*****************************************************************************
*
* FUNCTION
*
* INPUT
*
* OUTPUT
*
* RETURNS
*
* AUTHOR
*
* DESCRIPTION
*
* CHANGES
*
******************************************************************************/
void Read_PPM_Image(Image, name)
IMAGE *Image;
char *name;
{
char type;
int width, height;
int depth;
char input;
char junk[512];
int x, y;
int data;
IMAGE_LINE *line_data;
FILE *infile;
if ((infile = Locate_File(name, READ_FILE_STRING, ".ppm", ".PPM",TRUE)) == NULL)
{
Error("Error opening PPM image %s.\n", name);
}
if (fscanf(infile, "P%c\n", &type) != 1 || (type != '3' && type != '6'))
{
Error ("File is not in PPM format.\n", name);
}
/* Ignore any comments */
while ((input = fgetc(infile)) == '#')
{
fgets(junk, 512, infile);
}
ungetc(input, infile);
if (fscanf(infile, "%d %d\n", &width, &height) != 2)
{
Error ("Error reading width or height from PPM image.\n", name);
}
/* Ignore any comments */
while ((input = fgetc(infile)) == '#')
{
fgets(junk, 512, infile);
}
ungetc(input, infile);
if (fscanf(infile, "%d\n", &depth) != 1 || depth > 255 || depth < 1)
{
Error ("Unsupported number of colors (%d) in PPM image.\n", depth);
}
Image->width = (DBL)(Image->iwidth = width);
Image->height = (DBL)(Image->iheight = height);
Image->Colour_Map_Size = 0;
Image->Colour_Map = NULL;
Image->data.rgb_lines = (IMAGE_LINE *) POV_MALLOC(Image->iheight * sizeof (IMAGE_LINE), "PPM image");
for (y = 0; y < height; y++)
{
line_data = &Image->data.rgb_lines[y];
line_data->red = (unsigned char *)POV_MALLOC(width,"PPM image line");
line_data->green = (unsigned char *)POV_MALLOC(width,"PPM image line");
line_data->blue = (unsigned char *)POV_MALLOC(width,"PPM image line");
line_data->transm = (unsigned char *)NULL;
if (type == '3') /* ASCII data to be input */
{
for (x = 0; x < width; x++)
{
if (fscanf(infile,"%d",&data) != 1)
{
Error("Error reading data from PPM image.\n");
}
line_data->red[x] = data*255/depth;
if (fscanf(infile,"%d",&data) != 1)
{
Error("Error reading data from PPM image.\n");
}
line_data->green[x] = data*255/depth;
if (fscanf(infile,"%d",&data) != 1)
{
Error("Error reading data from PPM image.\n");
}
line_data->blue[x] = data*255/depth;
}
}
else /* (type == '6') Raw binary data to be input */
{
for (x = 0; x < width; x++)
{
if ((data = getc(infile)) == EOF)
{
Error("Error reading data from PPM image.\n");
}
line_data->red[x] = data*255/depth;
if ((data = getc(infile)) == EOF)
{
Error("Error reading data from PPM image.\n");
}
line_data->green[x] = data*255/depth;
if ((data = getc(infile)) == EOF)
{
Error("Error reading data from PPM image.\n");
}
line_data->blue[x] = data*255/depth;
}
}
}
fclose(infile);
}
