dnrops
/
gimp
mirror of https://github.com/GNOME/gimp.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity
gimp/plug-ins/common/pix.c

659 lines
16 KiB
C
Raw Blame History

/* The GIMP -- an image manipulation program
* Copyright (C) 1995 Spencer Kimball and Peter Mattis
* Alias|Wavefront pix/matte image reading and writing code
* Copyright (C) 1997 Mike Taylor
* (email: mtaylor@aw.sgi.com, WWW: http://reality.sgi.com/mtaylor)
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*
*/
/* This plug-in was written using the online documentation from
* Alias|Wavefront Inc's PowerAnimator product.
*
* Bug reports or suggestions should be e-mailed to mtaylor@aw.sgi.com
*/
/* Event history:
* V 1.0, MT, 02-Jul-97: initial version of plug-in
* V 1.1, MT, 04-Dec-97: added .als file extension
*/
/* Features
* - loads and saves
* - 24-bit (.pix)
* - 8-bit (.matte, .alpha, or .mask) images
*
* NOTE: pix and matte files do not support alpha channels or indexed
* colour, so neither does this plug-in
*/
static char ident[] = "@(#) GIMP Alias|Wavefront pix image file-plugin v1.0 24-jun-97";
#include <stdlib.h>
#include <string.h>
#include <stdio.h>
#include <sys/types.h>
#include <sys/stat.h>
#include "gtk/gtk.h"
#include "libgimp/gimp.h"
#include "libgimp/gimpui.h"
/* #define PIX_DEBUG */
#ifdef PIX_DEBUG
# define PIX_DEBUG_PRINT(a,b) fprintf(stderr,a,b)
#else
# define PIX_DEBUG_PRINT(a,b)
#endif
/**************
* Prototypes *
**************/
/* Standard Plug-in Functions */
static void query (void);
static void run (char *name, int nparams, GParam *param,
int *nreturn_vals, GParam **return_vals );
/* Local Helper Functions */
static gint32 load_image (char *filename );
static gint save_image (char *filename, gint32 image_ID, gint32 drawable_ID );
static guint16 get_short (FILE * file );
static void put_short (guint16 value, FILE * file );
static void init_gtk (void);
/******************
* Implementation *
******************/
GPlugInInfo PLUG_IN_INFO =
{
NULL, /* init_proc */
NULL, /* quit_proc */
query, /* query_proc */
run, /* run_proc */
};
MAIN ()
static void query ()
/*
* Description:
* Register the services provided by this plug-in
*/
{
static GParamDef load_args[] =
{
{ PARAM_INT32, "run_mode", "Interactive, non-interactive" },
{ PARAM_STRING, "filename", "The name of the file to load" },
{ PARAM_STRING, "raw_filename", "The name entered" },
};
static int nload_args =
sizeof (load_args) / sizeof (load_args[0]);
static GParamDef load_return_vals[] =
{
{ PARAM_IMAGE, "image", "Output image" },
};
static int nload_return_vals =
sizeof (load_return_vals) / sizeof (load_return_vals[0]);
static GParamDef save_args[] =
{
{ PARAM_INT32, "run_mode", "Interactive, non-interactive" },
{ PARAM_IMAGE, "image", "Input image" },
{ PARAM_DRAWABLE, "drawable", "Drawable to save" },
{ PARAM_STRING, "filename", "The name of the file to save the image in" },
{ PARAM_STRING, "raw_filename", "The name of the file to save the image in" }
};
static int nsave_args = sizeof (save_args) / sizeof (save_args[0]);
gimp_install_procedure ("file_pix_load",
"loads files of the PIX file format",
"loads files of the PIX file format",
"Michael Taylor",
"Michael Taylor",
"1997",
"<Load>/PIX",
NULL,
PROC_PLUG_IN,
nload_args, nload_return_vals,
load_args, load_return_vals);
gimp_install_procedure ("file_pix_save",
"save file in the Alias|Wavefront pix/matte file format",
"save file in the Alias|Wavefront pix/matte file format",
"Michael Taylor",
"Michael Taylor",
"1997",
"<Save>/PIX",
"RGB*, GRAY*",
PROC_PLUG_IN,
nsave_args, 0,
save_args, NULL);
gimp_register_load_handler ("file_pix_load", "pix,matte,mask,alpha,als", "");
gimp_register_save_handler ("file_pix_save", "pix,matte,mask,alpha,als", "");
}
static void
run (char *name,
int nparams,
GParam *param,
int *nreturn_vals,
GParam **return_vals )
/*
* Description:
* perform registered plug-in function
*
* Arguments:
* name - name of the function to perform
* nparams - number of parameters passed to the function
* param - parameters passed to the function
* nreturn_vals - number of parameters returned by the function
* return_vals - parameters returned by the function
*/
{
static GParam values[2];
GRunModeType run_mode;
GStatusType status = STATUS_SUCCESS;
gint32 image_ID;
gint32 drawable_ID;
GimpExportReturnType export = EXPORT_CANCEL;
run_mode = param[0].data.d_int32;
*nreturn_vals = 1;
*return_vals = values;
values[0].type = PARAM_STATUS;
values[0].data.d_status = STATUS_CALLING_ERROR;
if (strcmp (name, "file_pix_load") == 0)
{
/* Perform the image load */
image_ID = load_image (param[1].data.d_string);
if (image_ID != -1)
{
/* The image load was successful */
*nreturn_vals = 2;
values[0].data.d_status = STATUS_SUCCESS;
values[1].type = PARAM_IMAGE;
values[1].data.d_image = image_ID;
}
else
{
/* The image load falied */
values[0].data.d_status = STATUS_EXECUTION_ERROR;
}
}
else if (strcmp (name, "file_pix_save") == 0)
{
image_ID = param[1].data.d_int32;
drawable_ID = param[2].data.d_int32;
/* eventually export the image */
switch (run_mode)
{
case RUN_INTERACTIVE:
case RUN_WITH_LAST_VALS:
init_gtk ();
export = gimp_export_image (&image_ID, &drawable_ID, "PIX",
(CAN_HANDLE_RGB | CAN_HANDLE_GRAY));
if (export == EXPORT_CANCEL)
{
values[0].data.d_status = STATUS_EXECUTION_ERROR;
return;
}
break;
default:
break;
}
if (status == STATUS_SUCCESS)
{
if ( !save_image (param[3].data.d_string, image_ID, drawable_ID))
{
status = STATUS_EXECUTION_ERROR;
}
}
values[0].data.d_status = status;
if (export == EXPORT_EXPORT)
gimp_image_delete (image_ID);
}
else
{
g_assert (FALSE);
}
}
static guint16
get_short (FILE *file)
/*
* Description:
* Reads a 16-bit integer from a file in such a way that the machine's
* bit ordering should not matter
*/
{
guchar buf[2];
fread (buf, 2, 1, file);
return ( buf[0] << 8 ) + ( buf[1] << 0 );
}
static void
put_short (guint16 value,
FILE *file)
/*
* Description:
* Reads a 16-bit integer from a file in such a way that the machine's
* bit ordering should not matter
*/
{
guchar buf[2];
buf[0] = (guchar)( value >> 8 );
buf[1] = (guchar)( value % 256 );
fwrite( buf, 2, 1, file);
}
static gint32
load_image (char *filename)
/*
* Description:
* load the given image into gimp
*
* Arguments:
* filename - name on the file to read
*
* Return Value:
* Image id for the loaded image
*
*/
{
gint i, j, tile_height, row;
FILE * file = NULL;
gchar * progMessage;
guchar * dest;
guchar * dest_base;
GDrawable * drawable;
gint32 image_ID;
gint32 layer_ID;
GPixelRgn pixel_rgn;
gushort width, height, depth;
GImageType imgtype;
GDrawableType gdtype;
/* Set up progress display */
progMessage = malloc (strlen (filename) + 12);
if (!progMessage)
gimp_quit ();
sprintf (progMessage, "Loading %s:", filename);
gimp_progress_init (progMessage);
free (progMessage);
PIX_DEBUG_PRINT("Opening file: %s\n",filename);
/* Open the file */
file = fopen( filename, "r" );
if ( NULL == file )
{
return -1;
}
/* Read header information */
width = get_short( file );
height = get_short( file );
get_short( file ); /* Discard obsolete fields */
get_short( file ); /* Discard obsolete fields */
depth = get_short( file );
PIX_DEBUG_PRINT( "Width %hu\n", width );
PIX_DEBUG_PRINT( "Height %hu\n", height );
if ( depth == 8 )
{
/* Loading a matte file */
imgtype = GRAY;
gdtype = GRAY_IMAGE;
}
else if ( depth == 24 )
{
/* Loading an RGB file */
imgtype = RGB;
gdtype = RGB_IMAGE;
}
else
{
/* Header is invalid */
fclose( file );
return -1;
}
image_ID = gimp_image_new ( width, height, imgtype );
gimp_image_set_filename ( image_ID, filename );
layer_ID = gimp_layer_new ( image_ID, "Background",
width,
height,
gdtype, 100, NORMAL_MODE );
gimp_image_add_layer ( image_ID, layer_ID, 0);
drawable = gimp_drawable_get ( layer_ID );
gimp_pixel_rgn_init ( &pixel_rgn, drawable, 0, 0, drawable->width,
drawable->height, TRUE, FALSE );
tile_height = gimp_tile_height();
if ( depth == 24 )
{
/* Read a 24-bit Pix image */
guchar record[4];
gint readlen;
tile_height = gimp_tile_height();
dest_base = dest = g_new (guchar, 3 * width * tile_height);
for (i = 0; i < height;)
{
for ( dest = dest_base, row = 0;
row < tile_height && i < height;
i += 1, row += 1)
{
guchar count;
/* Read a row of the image */
j = 0;
while ( j < width )
{
readlen = fread( record, 1, 4, file );
if ( readlen < 4 )
break;
for ( count = 0; count < record[0]; ++count )
{
dest[0] = record[3];
dest[1] = record[2];
dest[2] = record[1];
dest += 3;
j++;
if ( j >= width )
break;
}
}
}
gimp_pixel_rgn_set_rect (&pixel_rgn, dest_base, 0, i-row,
width, row);
gimp_progress_update ((double) i / (double) height);
}
free( dest_base );
}
else
{
/* Read an 8-bit Matte image */
guchar record[2];
gint readlen;
dest_base = dest = g_new (guchar, width * tile_height);
for (i = 0; i < height;)
{
for ( dest = dest_base, row = 0;
row < tile_height && i < height;
i += 1, row += 1)
{
guchar count;
/* Read a row of the image */
j = 0;
while ( j < width )
{
readlen = fread( record, 1, 2, file );
if ( readlen < 2 ) break;
for ( count = 0; count < record[0]; ++count )
{
dest[j] = record[1];
j++;
if ( j >= width ) break;
}
}
dest += width;
}
gimp_pixel_rgn_set_rect (&pixel_rgn, dest_base, 0, i-row,
width, row);
gimp_progress_update ((double) i / (double) height);
}
free( dest_base );
}
gimp_drawable_flush (drawable);
gimp_drawable_detach (drawable);
fclose( file );
return image_ID;
}
static gint
save_image (char *filename,
gint32 image_ID,
gint32 drawable_ID )
/*
* Description:
* save the given file out as an alias pix or matte file
*
* Arguments:
* filename - name of file to save to
* image_ID - ID of image to save
* drawable_ID - current drawable
*/
{
gint depth, i, j, row, tile_height, writelen, rectHeight;
/* gboolean savingAlpha = FALSE; */
gboolean savingColor = TRUE;
guchar * src;
guchar * src_base;
gchar * progMessage;
GDrawable * drawable;
GPixelRgn pixel_rgn;
FILE * file;
/* Get info about image */
drawable = gimp_drawable_get(drawable_ID);
gimp_pixel_rgn_init(&pixel_rgn, drawable, 0, 0, drawable->width,
drawable->height, FALSE, FALSE);
switch (gimp_drawable_type(drawable_ID))
{
case GRAY_IMAGE:
savingColor = FALSE;
depth = 1;
break;
case GRAYA_IMAGE:
savingColor = FALSE;
depth = 2;
break;
case RGB_IMAGE:
savingColor = TRUE;
depth = 3;
break;
case RGBA_IMAGE:
savingColor = TRUE;
depth = 4;
break;
default:
return FALSE;
};
/* Open the output file. */
file = fopen (filename, "wb");
if ( !file )
{
return (FALSE);
}
/* Set up progress display */
progMessage = malloc (strlen (filename) + 12);
if (!progMessage)
gimp_quit ();
sprintf (progMessage, "Saving %s:", filename);
gimp_progress_init (progMessage);
free (progMessage);
/* Write the image header */
PIX_DEBUG_PRINT( "Width %hu\n", drawable->width );
PIX_DEBUG_PRINT( "Height %hu\n", drawable->height );
put_short( drawable->width, file );
put_short( drawable->height, file );
put_short( 0, file );
put_short( 0, file );
if ( savingColor )
{
put_short( 24, file );
}
else
{
put_short( 8, file );
}
tile_height = gimp_tile_height();
src_base = g_new( guchar, tile_height * drawable->width * depth );
if ( savingColor )
{
/* Writing a 24-bit Pix image */
guchar record[4];
for (i = 0; i < drawable->height;)
{
rectHeight = ( tile_height < ( drawable->height - i - 1 ) ) ?
tile_height : ( drawable->height - i - 1 );
gimp_pixel_rgn_get_rect (&pixel_rgn, src_base, 0, i,
drawable->width, rectHeight);
for ( src = src_base, row = 0;
row < tile_height && i < drawable->height;
i += 1, row += 1)
{
/* Write a row of the image */
record[0] = 1;
record[3] = src[0];
record[2] = src[1];
record[1] = src[2];
src += depth;
for ( j = 1; j < drawable->width; ++j )
{
if ( ( record[3] != src[0] ) ||
( record[2] != src[1] ) ||
( record[1] != src[2] ) ||
( record[0] == 255 ) )
{
/* Write current RLE record and start a new one */
writelen = fwrite( record, 1, 4, file );
record[0] = 1;
record[3] = src[0];
record[2] = src[1];
record[1] = src[2];
}
else
{
/* increment run length in current record */
record[0] ++;
}
src += depth;
}
/* Write last record in row */
writelen = fwrite( record, 1, 4, file );
}
gimp_progress_update ((double) i / (double) drawable->height);
}
}
else
{
/* Writing a 8-bit Matte (Mask) image */
guchar record[2];
for (i = 0; i < drawable->height;)
{
rectHeight = ( tile_height < ( drawable->height - i - 1 ) ) ?
tile_height : ( drawable->height - i - 1 );
gimp_pixel_rgn_get_rect (&pixel_rgn, src_base, 0, i,
drawable->width, rectHeight);
for ( src = src_base, row = 0;
row < tile_height && i < drawable->height;
i += 1, row += 1)
{
/* Write a row of the image */
record[0] = 1;
record[1] = src[0];
src += depth;
for ( j = 1; j < drawable->width; ++j )
{
if ( ( record[1] != src[0] ) || ( record[0] == 255 ) )
{
/* Write current RLE record and start a new one */
writelen = fwrite( record, 1, 2, file );
record[0] = 1;
record[1] = src[0];
}
else
{
/* increment run length in current record */
record[0] ++;
}
src += depth;
}
/* Write last record in row */
writelen = fwrite( record, 1, 2, file );
}
gimp_progress_update ((double) i / (double) drawable->height);
}
}
free( src_base );
fclose( file );
return (1);
}
static void
init_gtk (void)
{
gchar **argv;
gint argc;
argc = 1;
argv = g_new (gchar *, 1);
argv[0] = g_strdup ("pix");
gtk_init (&argc, &argv);
gtk_rc_parse (gimp_gtkrc ());
}
Reference in New Issue View Git Blame Copy Permalink