User:AtteSmythe/yppRAW/yppRAWrd.c

/* bmpread.c	reads any bitmap I could get for testing */ /* Alexander.Schulz@stud.uni-karlsruhe.de               */

/* * The GIMP -- an image manipulation program * Copyright (C) 1995 Spencer Kimball and Peter Mattis * * 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. * * Modified - atteSmythe@atteSmythe.com - 10 Aug 05 */


 * 1) include "config.h"


 * 1) include 
 * 2) include 
 * 3) include 
 * 4) include 


 * 1) include 


 * 1) include 


 * 1) include "yppRAW.h"


 * 1) include "libgimp/stdplugins-intl.h"
 * 2) if !defined(WIN32) || defined(__MINGW32__)
 * 3) define BI_RGB 		0
 * 4) define BI_RLE8 	1
 * 5) define BI_RLE4 	2
 * 6) define BI_BITFIELDS 	3
 * 7) else
 * 8) include 
 * 9) endif

static gint32 ReadImage (                        FILE     *fd,                         guint    width,                         guint    height,                         guchar   *alpha,                         guchar   **palette,                         guint    colors                         );

static gint32 ToL (const guchar *puffer) { return (puffer[3] | puffer[2] << 8 | puffer[1] << 16 | puffer[0] << 24); }

static gint16 ToS (const guchar *puffer) { return (puffer[1] | puffer[0] << 8); }

static gboolean ReadPalette(FILE *fd, guchar *alpha, guchar **colors, guint entries) { guint i; guchar ABGR[4];

for (i=0; i < entries; ++i) { if (!ReadOK (fd, ABGR, sizeof(ABGR))) { g_message(_("Palette Incomplete")); return FALSE; } // Since we want to do A(RGB), not A(BGR), we'll have to swap here, // so as only to swap once. alpha[i]    = ABGR[0]; colors[0][i] = ABGR[1]; colors[1][i] = ABGR[2]; colors[2][i] = ABGR[3]; }

return TRUE; } /*

static gboolean ReadColorMap (FILE    *fd,	      guchar    buffer[256][3],	      gint      number,	      gint      size,	      gboolean *grey) { gint   i;  guchar rgb[4]; *grey = (number > 2); for (i = 0; i < number ; i++) {   if (!ReadOK (fd, rgb, size)) {     g_message (_("Bad colormap")); return FALSE; }   // Bitmap save the colors in another order! But change only once! buffer[i][0] = rgb[2]; buffer[i][1] = rgb[1]; buffer[i][2] = rgb[0]; *grey = ((*grey) && (rgb[0]==rgb[1]) && (rgb[1]==rgb[2])); } return TRUE; } static gboolean ReadChannelMasks (FILE *fd, Bitmap_Channel *masks, guint channels) { guint32 tmp[3]; guint32 mask; gint   nbits, offset, bit; guint  i;

if (!ReadOK (fd, tmp, 3 * sizeof (guint32))) return FALSE;

for (i = 0; i < channels; i++) {     mask = ToL ((guchar*) &tmp[i]); masks[i].mask = mask; nbits = 0; offset = -1; for (bit = 0; bit < 32; bit++) {         if (mask & 1) {             nbits++; if (offset == -1) offset = bit; }         mask = mask >> 1; }     masks[i].shiftin = offset; masks[i].shiftout = 8 - nbits; g_print ("Channel %d mask %08x in %d out %d\n", i, masks[i].mask, masks[i].shiftin, masks[i].shiftout); } return TRUE; } gint32 ReadRAW (const gchar *name) { FILE     *fd; gchar   *temp_buf;
 * 1) ifdef DEBUG
 * 1) endif

struct RAW_File_Head_Struct { _int32 Xsize; _int32 Ysize; _int32 PaletteUsed; _int32 PaletteSize; } RAW_File_Head; guchar   *palAlpha; guchar   **palColors; gint32   image_ID;

gint     i;

filename = name; fd = fopen (filename, "rb"); if (!fd) { g_message (_("Could not open '%s' for reading: %s"),     gimp_filename_to_utf8 (filename), g_strerror (errno)); return -1; } temp_buf = g_strdup_printf (_("Opening '%s'..."),    gimp_filename_to_utf8 (name)); gimp_progress_init (temp_buf); g_free (temp_buf); // It is a File. Now is it a valid RAWfile? Read the shortest possible header if (!ReadOK (fd, &RAW_File_Head, sizeof(RAW_File_Head))) { g_message (_("Could not read file header in '%s'"),     gimp_filename_to_utf8 (filename)); return -1; } RAW_File_Head.Xsize = ToL((unsigned char*)&RAW_File_Head.Xsize); RAW_File_Head.Ysize = ToL((unsigned char*)&RAW_File_Head.Ysize); RAW_File_Head.PaletteUsed = ToL((unsigned char *)&RAW_File_Head.PaletteUsed); RAW_File_Head.PaletteSize = ToL((unsigned char *)&RAW_File_Head.PaletteSize);

if (RAW_File_Head.PaletteSize < RAW_File_Head.PaletteUsed) { g_message (_("'%s' is not a valid Y!PP RAW file"),     gimp_filename_to_utf8 (filename)); return -1; } // How about a palette? I'd like a palette. And an alpha palette! // First check for no colors... if (RAW_File_Head.PaletteSize == 0 ||      RAW_File_Head.Xsize == 0 ||      RAW_File_Head.Ysize == 0) { g_message (_("Error reading Y!PP RAW file header from '%s'"),              gimp_filename_to_utf8(filename)); return -1; }

palAlpha = (guchar*)g_malloc(RAW_File_Head.PaletteSize); palColors = (guchar**)g_malloc(sizeof(unsigned char*[3])); for (i=0; i<3; ++i) { palColors[i] = (guchar*)g_malloc(RAW_File_Head.PaletteSize); }

if (!ReadPalette(fd, palAlpha, palColors, RAW_File_Head.PaletteSize)) { g_message (_("'%s' is not a valid Y!PP RAW file"),              gimp_filename_to_utf8 (filename)); return -1; }

// Get the Image and return the ID or -1 on error image_ID = ReadImage (fd,   RAW_File_Head.Xsize,    RAW_File_Head.Ysize,    palAlpha,    palColors,    RAW_File_Head.PaletteSize    );

g_free(palAlpha); for (i=0; i<3; ++i) { g_free(palColors[i]); } g_free(palColors); return image_ID; }

static gint32 ReadImage (          FILE     *fd,           guint    width,           guint    height,           guchar   *alpha,           guchar   **palette,           guint    colors           ) { /*  guchar        v, n;  guchar       *dest, *temp, *buffer; guchar       gimp_cmap[768]; gushort      rgb; glong        rowstride, channels; */ gint32        image; gint32       layer; glong        rowstride, channels; GimpPixelRgn pixel_rgn; GimpDrawable *drawable;

guchar      *dest, *temp, *buffer; gint         cur_progress, max_progress; guint         xpos, ypos; guint        cidx;

// Create an image in the GIMP image = gimp_image_new (width, height, GIMP_RGB); layer = gimp_layer_new (image, _("Background"),   width, height,    GIMP_RGBA_IMAGE, 100, GIMP_NORMAL_MODE);

channels = 4; // RGB+A gimp_image_set_filename (image, filename); gimp_image_add_layer (image, layer, 0); drawable = gimp_drawable_get (layer); // create a temporary, uncompressed version from which to transfer to GIMP dest     = g_malloc (drawable->width * drawable->height * channels); // read buffer - size = 1 row of _source_ buffer   = g_malloc (drawable->width); // how far to advance the pointer into the dest array each iteration rowstride = drawable->width * channels; cur_progress = 0; max_progress = height;

for (ypos=0; ypos < height; ++ypos) { if (!ReadOK(fd,buffer,drawable->width)) { break; }

temp = dest + ypos*rowstride; for (xpos=0; xpos < width; ++xpos) { cidx = buffer[xpos]; *(temp++)=palette[0][cidx]; // R     *(temp++)=palette[1][cidx]; // G      *(temp++)=palette[2][cidx]; // B      *(temp++)=alpha[cidx];      // A    } ++cur_progress; if ((cur_progress %5) == 0) { gimp_progress_update((gdouble) cur_progress / (gdouble)max_progress); } }

fclose (fd); gimp_progress_update (1); gimp_pixel_rgn_init (&pixel_rgn, drawable,   0, 0, drawable->width, drawable->height, TRUE, FALSE); gimp_pixel_rgn_set_rect (&pixel_rgn, dest,   0, 0, drawable->width, drawable->height); gimp_drawable_flush (drawable); gimp_drawable_detach (drawable); g_free (dest); g_free (buffer);

return image; }