Fixes #7041.

4 files changed, 1960 insertions, 11 deletions

diff --git a/media-video/mpeg-tools/ChangeLog b/media-video/mpeg-tools/ChangeLog
index 802093dada96..ed18a2d745e5 100644
--- a/media-video/mpeg-tools/ChangeLog
+++ b/media-video/mpeg-tools/ChangeLog
@@ -1,13 +1,11 @@
 # ChangeLog for media-video/mpeg-tools
 # Copyright 2002 Gentoo Technologies, Inc.; Distributed under the GPL
-# $Header: /var/cvsroot/gentoo-x86/media-video/mpeg-tools/ChangeLog,v 1.1 2002/02/01 21:53:31 gbevin Exp $
+# $Header: /var/cvsroot/gentoo-x86/media-video/mpeg-tools/ChangeLog,v 1.2 2002/08/28 12:47:18 karltk Exp $
 
 *mpeg-tools-1.5b (1 Feb 2002)
 
+  28 Aug 2002; Karl Trygve Kalleberg <karltk@gentoo.org> mpeg-tools-1.5b files/1.5b/libpnmrw.c files/1.5b/libpnmrw.h :
+  Fixed a few files so that it compiles with gcc-3.2. Fixes #7041.
+
   1 Feb 2002; G.Bevin <gbevin@gentoo.org> ChangeLog :
-  
-  Added initial ChangeLog which should be updated whenever the package is
-  updated in any way. This changelog is targetted to users. This means that the
-  comments should well explained and written in clean English. The details about
-  writing correct changelogs are explained in the skel.ChangeLog file which you
-  can find in the root directory of the portage repository.
+  Added initial ChangeLog.
diff --git a/media-video/mpeg-tools/files/1.5b/libpnmrw.c b/media-video/mpeg-tools/files/1.5b/libpnmrw.c
new file mode 100644
index 000000000000..570192b6921c
--- /dev/null
+++ b/media-video/mpeg-tools/files/1.5b/libpnmrw.c
@@ -0,0 +1,1757 @@
+/* libpnmrw.c - PBM/PGM/PPM read/write library
+ **
+ ** Copyright (C) 1988, 1989, 1991, 1992 by Jef Poskanzer.
+ **
+ ** Permission to use, copy, modify, and distribute this software and its
+ ** documentation for any purpose and without fee is hereby granted, provided
+ ** that the above copyright notice appear in all copies and that both that
+ ** copyright notice and this permission notice appear in supporting
+ ** documentation.  This software is provided "as is" without express or
+ ** implied warranty.
+ */
+
+#define pm_error(x) exit(1)
+
+
+#if defined(SVR2) || defined(SVR3) || defined(SVR4)
+#define SYSV
+#endif
+#if ! ( defined(BSD) || defined(SYSV) || defined(MSDOS) )
+/* CONFIGURE: If your system is >= 4.2BSD, set the BSD option; if you're a
+ ** System V site, set the SYSV option; and if you're IBM-compatible, set
+** MSDOS.  If your compiler is ANSI C, you're probably better off setting
+** SYSV - all it affects is string handling.
+*/
+#define BSD
+/* #define SYSV */
+/* #define MSDOS */
+#endif
+
+#include <stdio.h>
+#include "libpnmrw.h"
+
+/* if don't have string.h, try strings.h */
+#include <string.h>
+#define rindex(s,c) strrchr(s,c)
+
+
+/* Definitions. */
+
+#define pbm_allocarray( cols, rows ) ((bit**) pm_allocarray( cols, rows, sizeof(bit) ))
+#define pbm_allocrow( cols ) ((bit*) pm_allocrow( cols, sizeof(bit) ))
+#define pbm_freearray( bits, rows ) pm_freearray( (char**) bits, rows )
+#define pbm_freerow( bitrow ) pm_freerow( (char*) bitrow )
+#define pgm_allocarray( cols, rows ) ((gray**) pm_allocarray( cols, rows, sizeof(gray) ))
+#define pgm_allocrow( cols ) ((gray*) pm_allocrow( cols, sizeof(gray) ))
+#define pgm_freearray( grays, rows ) pm_freearray( (char**) grays, rows )
+#define pgm_freerow( grayrow ) pm_freerow( (char*) grayrow )
+#define ppm_allocarray( cols, rows ) ((pixel**) pm_allocarray( cols, rows, sizeof(pixel) ))
+#define ppm_allocrow( cols ) ((pixel*) pm_allocrow( cols, sizeof(pixel) ))
+#define ppm_freearray( pixels, rows ) pm_freearray( (char**) pixels, rows )
+#define ppm_freerow( pixelrow ) pm_freerow( (char*) pixelrow )
+
+
+/* Variables. */
+
+static char* progname;
+
+
+/* Variable-sized arrays. */
+
+char*
+  pm_allocrow( cols, size )
+int cols;
+int size;
+{
+  register char* itrow;
+
+  itrow = (char*) malloc( cols * size );
+  if ( itrow == (char*) 0 )
+    {
+      (void) fprintf(
+		     stderr, "%s: out of memory allocating a row\n", progname );
+      return (char*) 0;
+    }
+  return itrow;
+}
+
+void
+  pm_freerow( itrow )
+char* itrow;
+{
+  free( itrow );
+}
+
+char**
+  pm_allocarray( cols, rows, size )
+int cols, rows;
+int size;
+{
+  char** its;
+  int i;
+
+  its = (char**) malloc( rows * sizeof(char*) );
+  if ( its == (char**) 0 )
+    {
+      (void) fprintf(
+		     stderr, "%s: out of memory allocating an array\n", progname );
+      return (char**) 0;
+    }
+  its[0] = (char*) malloc( rows * cols * size );
+  if ( its[0] == (char*) 0 )
+    {
+      (void) fprintf(
+		     stderr, "%s: out of memory allocating an array\n", progname );
+      free( (char*) its );
+      return (char**) 0;
+    }
+  for ( i = 1; i < rows; ++i )
+    its[i] = &(its[0][i * cols * size]);
+  return its;
+}
+
+void
+  pm_freearray( its, rows )
+char** its;
+int rows;
+{
+  free( its[0] );
+  free( its );
+}
+
+
+/* File open/close that handles "-" as stdin and checks errors. */
+
+static void
+  pm_perror( reason )
+char* reason;
+{
+  extern __const char *__const sys_errlist[];
+  extern int errno;
+  char* e;
+
+  e = sys_errlist[errno];
+
+  if ( reason != 0 && reason[0] != '\0' )
+    (void) fprintf( stderr, "%s: %s - %s\n", progname, reason, e );
+  else
+    (void) fprintf( stderr, "%s: %s\n", progname, e );
+}
+
+FILE*
+  pm_openr( name )
+char* name;
+{
+  FILE* f;
+
+  if ( strcmp( name, "-" ) == 0 )
+    f = stdin;
+  else
+    {
+      f = fopen( name, "rb" );
+      if ( f == NULL )
+	{
+	  pm_perror( name );
+	  return (FILE*) 0;
+	}
+    }
+  return f;
+}
+
+FILE*
+  pm_openw( name )
+char* name;
+{
+  FILE* f;
+
+  f = fopen( name, "wb" );
+  if ( f == NULL ) {
+    pm_perror( name );
+    return (FILE*) 0;
+  }
+  return f;
+}
+
+int
+  pm_closer( f )
+FILE* f;
+{
+  if ( ferror( f ) )
+    {
+      (void) fprintf(
+		     stderr, "%s: a file read error occurred at some point\n",
+		     progname );
+      return -1;
+    }
+  if ( f != stdin )
+    if ( fclose( f ) != 0 )
+      {
+	pm_perror( "fclose" );
+	return -1;
+      }
+  return 0;
+}
+
+int
+  pm_closew( f )
+FILE* f;
+{
+  fflush( f );
+  if ( ferror( f ) )
+    {
+      (void) fprintf(
+		     stderr, "%s: a file write error occurred at some point\n",
+		     progname );
+      return -1;
+    }
+  if ( f != stdout )
+    if ( fclose( f ) != 0 )
+      {
+	pm_perror( "fclose" );
+	return -1;
+      }
+  return 0;
+}
+
+static int
+  pbm_getc( file )
+FILE* file;
+{
+  register int ich;
+
+  ich = getc( file );
+  if ( ich == EOF )
+    {
+      (void) fprintf( stderr, "%s: EOF / read error\n", progname );
+      return EOF;
+    }
+    
+  if ( ich == '#' )
+    {
+      do
+	{
+	  ich = getc( file );
+	  if ( ich == EOF )
+	    {
+	      (void) fprintf( stderr, "%s: EOF / read error\n", progname );
+	      return EOF;
+	    }
+	}
+      while ( ich != '\n' && ich != '\r' );
+    }
+
+  return ich;
+}
+
+static bit
+  pbm_getbit( file )
+FILE* file;
+{
+  register int ich;
+
+  do
+    {
+      ich = pbm_getc( file );
+      if ( ich == EOF )
+	return -1;
+    }
+  while ( ich == ' ' || ich == '\t' || ich == '\n' || ich == '\r' );
+
+  if ( ich != '0' && ich != '1' )
+    {
+      (void) fprintf(
+		     stderr, "%s: junk in file where bits should be\n", progname );
+      return -1;
+    }
+
+  return ( ich == '1' ) ? 1 : 0;
+}
+
+static int
+  pbm_readmagicnumber( file )
+FILE* file;
+{
+  int ich1, ich2;
+
+  ich1 = getc( file );
+  if ( ich1 == EOF )
+    {
+      (void) fprintf(
+		     stderr, "%s: EOF / read error reading magic number\n", progname );
+      return -1;
+    }
+  ich2 = getc( file );
+  if ( ich2 == EOF )
+    {
+      (void) fprintf(
+		     stderr, "%s: EOF / read error reading magic number\n", progname );
+      return -1;
+    }
+  return ich1 * 256 + ich2;
+}
+
+static int
+  pbm_getint( file )
+FILE* file;
+{
+  register int ich;
+  register int i;
+
+  do
+    {
+      ich = pbm_getc( file );
+      if ( ich == EOF )
+	return -1;
+    }
+  while ( ich == ' ' || ich == '\t' || ich == '\n' || ich == '\r' );
+
+  if ( ich < '0' || ich > '9' )
+    {
+      (void) fprintf(
+		     stderr, "%s: junk in file where an integer should be\n", progname );
+      return -1;
+    }
+
+  i = 0;
+  do
+    {
+      i = i * 10 + ich - '0';
+      ich = pbm_getc( file );
+      if ( ich == EOF )
+	return -1;
+    }
+  while ( ich >= '0' && ich <= '9' );
+
+  return i;
+}
+
+static int
+  pbm_readpbminitrest( file, colsP, rowsP )
+FILE* file;
+int* colsP;
+int* rowsP;
+{
+  /* Read size. */
+  *colsP = pbm_getint( file );
+  *rowsP = pbm_getint( file );
+  if ( *colsP == -1 || *rowsP == -1 )
+    return -1;
+  return 0;
+}
+
+static int
+  pbm_getrawbyte( file )
+FILE* file;
+{
+  register int iby;
+
+  iby = getc( file );
+  if ( iby == EOF )
+    {
+      (void) fprintf( stderr, "%s: EOF / read error\n", progname );
+      return -1;
+    }
+  return iby;
+}
+
+static int
+  pbm_readpbmrow( file, bitrow, cols, format )
+FILE* file;
+bit* bitrow;
+int cols, format;
+{
+  register int col, bitshift, b;
+  register int item;
+  register bit* bP;
+
+  switch ( format )
+    {
+    case PBM_FORMAT:
+      for ( col = 0, bP = bitrow; col < cols; ++col, ++bP )
+	{
+	  b = pbm_getbit( file );
+	  if ( b == -1 )
+	    return -1;
+	  *bP = b;
+	}
+      break;
+
+    case RPBM_FORMAT:
+      bitshift = -1;
+      for ( col = 0, bP = bitrow; col < cols; ++col, ++bP )
+	{
+	  if ( bitshift == -1 )
+	    {
+	      item = pbm_getrawbyte( file );
+	      if ( item == -1 )
+		return -1;
+	      bitshift = 7;
+	    }
+	  *bP = ( item >> bitshift ) & 1;
+	  --bitshift;
+	}
+      break;
+
+    default:
+      (void) fprintf( stderr, "%s: can't happen\n", progname );
+      return -1;
+    }
+  return 0;
+}
+
+static void
+  pbm_writepbminit( file, cols, rows, forceplain )
+FILE* file;
+int cols, rows;
+int forceplain;
+{
+  if ( ! forceplain )
+    (void) fprintf(
+		   file, "%c%c\n%d %d\n", PBM_MAGIC1, RPBM_MAGIC2, cols, rows );
+  else
+    (void) fprintf(
+		   file, "%c%c\n%d %d\n", PBM_MAGIC1, PBM_MAGIC2, cols, rows );
+}
+
+static void
+  pbm_writepbmrowraw( file, bitrow, cols )
+FILE* file;
+bit* bitrow;
+int cols;
+{
+  register int col, bitshift;
+  register unsigned char item;
+  register bit* bP;
+
+  bitshift = 7;
+  item = 0;
+  for ( col = 0, bP = bitrow; col < cols; ++col, ++bP )
+    {
+      if ( *bP )
+	item += 1 << bitshift;
+      --bitshift;
+      if ( bitshift == -1 )
+	{
+	  (void) putc( item, file );
+	  bitshift = 7;
+	  item = 0;
+	}
+    }
+  if ( bitshift != 7 )
+    (void) putc( item, file );
+}
+
+static void
+  pbm_writepbmrowplain( file, bitrow, cols )
+FILE* file;
+bit* bitrow;
+int cols;
+{
+  register int col, charcount;
+  register bit* bP;
+
+  charcount = 0;
+  for ( col = 0, bP = bitrow; col < cols; ++col, ++bP )
+    {
+      if ( charcount >= 70 )
+	{
+	  (void) putc( '\n', file );
+	  charcount = 0;
+	}
+      putc( *bP ? '1' : '0', file );
+      ++charcount;
+    }
+  (void) putc( '\n', file );
+}
+
+static void
+  pbm_writepbmrow( file, bitrow, cols, forceplain )
+FILE* file;
+bit* bitrow;
+int cols;
+int forceplain;
+{
+  if ( ! forceplain )
+    pbm_writepbmrowraw( file, bitrow, cols );
+  else
+    pbm_writepbmrowplain( file, bitrow, cols );
+}
+
+static int
+  pgm_readpgminitrest( file, colsP, rowsP, maxvalP )
+FILE* file;
+int* colsP;
+int* rowsP;
+gray* maxvalP;
+{
+  int maxval;
+
+  /* Read size. */
+  *colsP = pbm_getint( file );
+  *rowsP = pbm_getint( file );
+  if ( *colsP == -1 || *rowsP == -1 )
+    return -1;
+
+  /* Read maxval. */
+  maxval = pbm_getint( file );
+  if ( maxval == -1 )
+    return -1;
+  if ( maxval > PGM_MAXMAXVAL )
+    {
+      (void) fprintf( stderr, "%s: maxval is too large\n", progname );
+      return -1;
+    }
+  *maxvalP = maxval;
+  return 0;
+}
+
+#if __STDC__
+static int
+  pgm_readpgmrow( FILE* file, gray* grayrow, int cols, gray maxval, int format )
+#else /*__STDC__*/
+static int
+  pgm_readpgmrow( file, grayrow, cols, maxval, format )
+FILE* file;
+gray* grayrow;
+int cols;
+gray maxval;
+int format;
+#endif /*__STDC__*/
+{
+  register int col, val;
+  register gray* gP;
+  /*
+    bit* bitrow;
+    register bit* bP;
+    */
+
+  switch ( format )
+    {
+    case PGM_FORMAT:
+      for ( col = 0, gP = grayrow; col < cols; ++col, ++gP )
+	{
+	  val = pbm_getint( file );
+	  if ( val == -1 )
+	    return -1;
+	  *gP = val;
+	}
+      break;
+	
+    case RPGM_FORMAT:
+      if ( fread( grayrow, 1, cols, file ) != cols )
+	{
+	  (void) fprintf( stderr, "%s: EOF / read error\n", progname );
+	  return -1;
+	}
+      break;
+
+    default:
+      (void) fprintf( stderr, "%s: can't happen\n", progname );
+      return -1;
+    }
+  return 0;
+}
+
+#if __STDC__
+static void
+  pgm_writepgminit( FILE* file, int cols, int rows, gray maxval, int forceplain )
+#else /*__STDC__*/
+static void
+  pgm_writepgminit( file, cols, rows, maxval, forceplain )
+FILE* file;
+int cols, rows;
+gray maxval;
+int forceplain;
+#endif /*__STDC__*/
+{
+  if ( maxval <= 255 && ! forceplain )
+    fprintf(
+	    file, "%c%c\n%d %d\n%d\n", PGM_MAGIC1, RPGM_MAGIC2,
+	    cols, rows, maxval );
+  else
+    fprintf(
+	    file, "%c%c\n%d %d\n%d\n", PGM_MAGIC1, PGM_MAGIC2,
+	    cols, rows, maxval );
+}
+
+static void
+  putus( n, file )
+unsigned short n;
+FILE* file;
+{
+  if ( n >= 10 )
+    putus( n / 10, file );
+  putc( n % 10 + '0', file );
+}
+
+static int
+  pgm_writepgmrowraw( file, grayrow, cols, maxval )
+FILE* file;
+gray* grayrow;
+int cols;
+gray maxval;
+{
+  if ( fwrite( grayrow, 1, cols, file ) != cols )
+    {
+      (void) fprintf( stderr, "%s: write error\n", progname );
+      return -1;
+    }
+  return 0;
+}
+
+static int
+  pgm_writepgmrowplain( file, grayrow, cols, maxval )
+FILE* file;
+gray* grayrow;
+int cols;
+gray maxval;
+{
+  register int col, charcount;
+  register gray* gP;
+
+  charcount = 0;
+  for ( col = 0, gP = grayrow; col < cols; ++col, ++gP )
+    {
+      if ( charcount >= 65 )
+	{
+	  (void) putc( '\n', file );
+	  charcount = 0;
+	}
+      else if ( charcount > 0 )
+	{
+	  (void) putc( ' ', file );
+	  ++charcount;
+	}
+      putus( (unsigned short) *gP, file );
+      charcount += 3;
+    }
+  if ( charcount > 0 )
+    (void) putc( '\n', file );
+  return 0;
+}
+
+#if __STDC__
+static int
+  pgm_writepgmrow( FILE* file, gray* grayrow, int cols, gray maxval, int forceplain )
+#else /*__STDC__*/
+static int
+  pgm_writepgmrow( file, grayrow, cols, maxval, forceplain )
+FILE* file;
+gray* grayrow;
+int cols;
+gray maxval;
+int forceplain;
+#endif /*__STDC__*/
+{
+  if ( maxval <= 255 && ! forceplain )
+    return pgm_writepgmrowraw( file, grayrow, cols, maxval );
+  else
+    return pgm_writepgmrowplain( file, grayrow, cols, maxval );
+}
+
+static int
+  ppm_readppminitrest( file, colsP, rowsP, maxvalP )
+FILE* file;
+int* colsP;
+int* rowsP;
+pixval* maxvalP;
+{
+  int maxval;
+
+  /* Read size. */
+  *colsP = pbm_getint( file );
+  *rowsP = pbm_getint( file );
+  if ( *colsP == -1 || *rowsP == -1 )
+    return -1;
+
+  /* Read maxval. */
+  maxval = pbm_getint( file );
+  if ( maxval == -1 )
+    return -1;
+  if ( maxval > PPM_MAXMAXVAL )
+    {
+      (void) fprintf( stderr, "%s: maxval is too large\n", progname );
+      return -1;
+    }
+  *maxvalP = maxval;
+  return 0;
+}
+
+#if __STDC__
+static int
+  ppm_readppmrow( FILE* file, pixel* pixelrow, int cols, pixval maxval, int format )
+#else /*__STDC__*/
+static int
+  ppm_readppmrow( file, pixelrow, cols, maxval, format )
+FILE* file;
+pixel* pixelrow;
+int cols, format;
+pixval maxval;
+#endif /*__STDC__*/
+{
+  register int col;
+  register pixel* pP;
+  register int r, g, b;
+  gray* grayrow;
+  register gray* gP;
+  /*
+    bit* bitrow;
+    register bit* bP;
+    */
+
+  switch ( format )
+    {
+    case PPM_FORMAT:
+      for ( col = 0, pP = pixelrow; col < cols; ++col, ++pP )
+	{
+	  r = pbm_getint( file );
+	  g = pbm_getint( file );
+	  b = pbm_getint( file );
+	  if ( r == -1 || g == -1 || b == -1 )
+	    return -1;
+	  PPM_ASSIGN( *pP, r, g, b );
+	}
+      break;
+
+    case RPPM_FORMAT:
+      grayrow = pgm_allocrow( 3 * cols );
+      if ( grayrow == (gray*) 0 )
+	return -1;
+      if ( fread( grayrow, 1, 3 * cols, file ) != 3 * cols )
+	{
+	  (void) fprintf( stderr, "%s: EOF / read error\n", progname );
+	  return -1;
+	}
+      for ( col = 0, gP = grayrow, pP = pixelrow; col < cols; ++col, ++pP )
+	{
+	  r = *gP++;
+	  g = *gP++;
+	  b = *gP++;
+	  PPM_ASSIGN( *pP, r, g, b );
+	}
+      pgm_freerow( grayrow );
+      break;
+
+    default:
+      (void) fprintf( stderr, "%s: can't happen\n", progname );
+      return -1;
+    }
+  return 0;
+}
+
+#if __STDC__
+static void
+  ppm_writeppminit( FILE* file, int cols, int rows, pixval maxval, int forceplain )
+#else /*__STDC__*/
+static void
+  ppm_writeppminit( file, cols, rows, maxval, forceplain )
+FILE* file;
+int cols, rows;
+pixval maxval;
+int forceplain;
+#endif /*__STDC__*/
+{
+  if ( maxval <= 255 && ! forceplain )
+    fprintf(
+	    file, "%c%c\n%d %d\n%d\n", PPM_MAGIC1, RPPM_MAGIC2,
+	    cols, rows, maxval );
+  else
+    fprintf(
+	    file, "%c%c\n%d %d\n%d\n", PPM_MAGIC1, PPM_MAGIC2,
+	    cols, rows, maxval );
+}
+
+static int
+  ppm_writeppmrowraw( file, pixelrow, cols, maxval )
+FILE* file;
+pixel* pixelrow;
+int cols;
+pixval maxval;
+{
+  register int col;
+  register pixel* pP;
+  gray* grayrow;
+  register gray* gP;
+
+  grayrow = pgm_allocrow( 3 * cols );
+  if ( grayrow == (gray*) 0 )
+    return -1;
+  for ( col = 0, pP = pixelrow, gP = grayrow; col < cols; ++col, ++pP )
+    {
+      *gP++ = PPM_GETR( *pP );
+      *gP++ = PPM_GETG( *pP );
+      *gP++ = PPM_GETB( *pP );
+    }
+  if ( fwrite( grayrow, 1, 3 * cols, file ) != 3 * cols )
+    {
+      (void) fprintf( stderr, "%s: write error\n", progname );
+      return -1;
+    }
+  pgm_freerow( grayrow );
+  return 0;
+}
+
+static int
+  ppm_writeppmrowplain( file, pixelrow, cols, maxval )
+FILE* file;
+pixel* pixelrow;
+int cols;
+pixval maxval;
+{
+  register int col, charcount;
+  register pixel* pP;
+  register pixval val;
+
+  charcount = 0;
+  for ( col = 0, pP = pixelrow; col < cols; ++col, ++pP )
+    {
+      if ( charcount >= 65 )
+	{
+	  (void) putc( '\n', file );
+	  charcount = 0;
+	}
+      else if ( charcount > 0 )
+	{
+	  (void) putc( ' ', file );
+	  (void) putc( ' ', file );
+	  charcount += 2;
+	}
+      val = PPM_GETR( *pP );
+      putus( val, file );
+      (void) putc( ' ', file );
+      val = PPM_GETG( *pP );
+      putus( val, file );
+      (void) putc( ' ', file );
+      val = PPM_GETB( *pP );
+      putus( val, file );
+      charcount += 11;
+    }
+  if ( charcount > 0 )
+    (void) putc( '\n', file );
+  return 0;
+}
+
+#if __STDC__
+static int
+  ppm_writeppmrow( FILE* file, pixel* pixelrow, int cols, pixval maxval, int forceplain )
+#else /*__STDC__*/
+static int
+  ppm_writeppmrow( file, pixelrow, cols, maxval, forceplain )
+FILE* file;
+pixel* pixelrow;
+int cols;
+pixval maxval;
+int forceplain;
+#endif /*__STDC__*/
+{
+  if ( maxval <= 255 && ! forceplain )
+    return ppm_writeppmrowraw( file, pixelrow, cols, maxval );
+  else
+    return ppm_writeppmrowplain( file, pixelrow, cols, maxval );
+}
+
+void
+  pnm_init2( pn )
+char* pn;
+{
+  /* Save program name. */
+  progname = pn;
+}
+
+xelval pnm_pbmmaxval = 1;
+
+int
+  pnm_readpnminit( file, colsP, rowsP, maxvalP, formatP )
+FILE* file;
+int* colsP;
+int* rowsP;
+int* formatP;
+xelval* maxvalP;
+{
+  gray gmaxval;
+
+  /* Check magic number. */
+  *formatP = pbm_readmagicnumber( file );
+  if ( *formatP == -1 )
+    return -1;
+  switch ( PNM_FORMAT_TYPE(*formatP) )
+    {
+    case PPM_TYPE:
+      if ( ppm_readppminitrest( file, colsP, rowsP, (pixval*) maxvalP ) < 0 )
+	return -1;
+      break;
+
+    case PGM_TYPE:
+      if ( pgm_readpgminitrest( file, colsP, rowsP, &gmaxval ) < 0 )
+	return -1;
+      *maxvalP = (xelval) gmaxval;
+      break;
+
+    case PBM_TYPE:
+      if ( pbm_readpbminitrest( file, colsP, rowsP ) < 0 )
+	return -1;
+      *maxvalP = pnm_pbmmaxval;
+      break;
+
+    default:
+      (void) fprintf(
+		     stderr, "%s: bad magic number - not a ppm, pgm, or pbm file\n",
+		     progname );
+      return -1;
+    }
+  return 0;
+}
+
+#if __STDC__
+int
+  pnm_readpnmrow( FILE* file, xel* xelrow, int cols, xelval maxval, int format )
+#else /*__STDC__*/
+int
+  pnm_readpnmrow( file, xelrow, cols, maxval, format )
+FILE* file;
+xel* xelrow;
+xelval maxval;
+int cols, format;
+#endif /*__STDC__*/
+{
+  register int col;
+  register xel* xP;
+  gray* grayrow;
+  register gray* gP;
+  bit* bitrow;
+  register bit* bP;
+
+  switch ( PNM_FORMAT_TYPE(format) )
+    {
+    case PPM_TYPE:
+      if ( ppm_readppmrow( file, (pixel*) xelrow, cols, (pixval) maxval, format ) < 0 )
+	return -1;
+      break;
+
+    case PGM_TYPE:
+      grayrow = pgm_allocrow( cols );
+      if ( grayrow == (gray*) 0 )
+	return -1;
+      if ( pgm_readpgmrow( file, grayrow, cols, (gray) maxval, format ) < 0 )
+	return -1;
+      for ( col = 0, xP = xelrow, gP = grayrow; col < cols; ++col, ++xP, ++gP )
+	PNM_ASSIGN1( *xP, *gP );
+      pgm_freerow( grayrow );
+      break;
+
+    case PBM_TYPE:
+      bitrow = pbm_allocrow( cols );
+      if ( bitrow == (bit*) 0 )
+	return -1;
+      if ( pbm_readpbmrow( file, bitrow, cols, format ) < 0 )
+	{
+	  pbm_freerow( bitrow );
+	  return -1;
+	}
+      for ( col = 0, xP = xelrow, bP = bitrow; col < cols; ++col, ++xP, ++bP )
+	PNM_ASSIGN1( *xP, *bP == PBM_BLACK ? 0: pnm_pbmmaxval );
+      pbm_freerow( bitrow );
+      break;
+
+    default:
+      (void) fprintf( stderr, "%s: can't happen\n", progname );
+      return -1;
+    }
+  return 0;
+}
+
+xel**
+  pnm_readpnm( file, colsP, rowsP, maxvalP, formatP )
+FILE* file;
+int* colsP;
+int* rowsP;
+int* formatP;
+xelval* maxvalP;
+{
+  xel** xels;
+  int row;
+
+  if ( pnm_readpnminit( file, colsP, rowsP, maxvalP, formatP ) < 0 )
+    return (xel**) 0;
+
+  xels = pnm_allocarray( *colsP, *rowsP );
+  if ( xels == (xel**) 0 )
+    return (xel**) 0;
+
+  for ( row = 0; row < *rowsP; ++row )
+    if ( pnm_readpnmrow( file, xels[row], *colsP, *maxvalP, *formatP ) < 0 )
+      {
+	pnm_freearray( xels, *rowsP );
+	return (xel**) 0;
+      }
+
+  return xels;
+}
+
+#if __STDC__
+int
+  pnm_writepnminit( FILE* file, int cols, int rows, xelval maxval, int format, int forceplain )
+#else /*__STDC__*/
+int
+  pnm_writepnminit( file, cols, rows, maxval, format, forceplain )
+FILE* file;
+int cols, rows, format;
+xelval maxval;
+int forceplain;
+#endif /*__STDC__*/
+{
+  switch ( PNM_FORMAT_TYPE(format) )
+    {
+    case PPM_TYPE:
+      ppm_writeppminit( file, cols, rows, (pixval) maxval, forceplain );
+      break;
+
+    case PGM_TYPE:
+      pgm_writepgminit( file, cols, rows, (gray) maxval, forceplain );
+      break;
+
+    case PBM_TYPE:
+      pbm_writepbminit( file, cols, rows, forceplain );
+      break;
+
+    default:
+      (void) fprintf( stderr, "%s: can't happen\n", progname );
+      return -1;
+    }
+  return 0;
+}
+
+#if __STDC__
+int
+  pnm_writepnmrow( FILE* file, xel* xelrow, int cols, xelval maxval, int format, int forceplain )
+#else /*__STDC__*/
+int
+  pnm_writepnmrow( file, xelrow, cols, maxval, format, forceplain )
+FILE* file;
+xel* xelrow;
+int cols, format;
+xelval maxval;
+int forceplain;
+#endif /*__STDC__*/
+{
+  register int col;
+  register xel* xP;
+  gray* grayrow;
+  register gray* gP;
+  bit* bitrow;
+  register bit* bP;
+
+  switch ( PNM_FORMAT_TYPE(format) )
+    {
+    case PPM_TYPE:
+      if ( ppm_writeppmrow( file, (pixel*) xelrow, cols, (pixval) maxval, forceplain ) < 0 )
+	return -1;
+      break;
+
+    case PGM_TYPE:
+      grayrow = pgm_allocrow( cols );
+      if ( grayrow == (gray*) 0 )
+	return -1;
+      for ( col = 0, gP = grayrow, xP = xelrow; col < cols; ++col, ++gP, ++xP )
+	*gP = PNM_GET1( *xP );
+      if ( pgm_writepgmrow( file, grayrow, cols, (gray) maxval, forceplain ) < 0 )
+	{
+	  pgm_freerow( grayrow );
+	  return -1;
+	}
+      pgm_freerow( grayrow );
+      break;
+
+    case PBM_TYPE:
+      bitrow = pbm_allocrow( cols );
+      if ( bitrow == (bit*) 0 )
+	return -1;
+      for ( col = 0, bP = bitrow, xP = xelrow; col < cols; ++col, ++bP, ++xP )
+	*bP = PNM_GET1( *xP ) == 0 ? PBM_BLACK : PBM_WHITE;
+      pbm_writepbmrow( file, bitrow, cols, forceplain );
+      pbm_freerow( bitrow );
+      break;
+
+    default:
+      (void) fprintf( stderr, "%s: can't happen\n", progname );
+      return -1;
+    }
+  return 0;
+}
+
+#if __STDC__
+int
+  pnm_writepnm( FILE* file, xel** xels, int cols, int rows, xelval maxval, int format, int forceplain )
+#else /*__STDC__*/
+int
+  pnm_writepnm( file, xels, cols, rows, maxval, format, forceplain )
+FILE* file;
+xel** xels;
+xelval maxval;
+int cols, rows, format;
+int forceplain;
+#endif /*__STDC__*/
+{
+  int row;
+
+  if ( pnm_writepnminit( file, cols, rows, maxval, format, forceplain ) < 0 )
+    return -1;
+
+  for ( row = 0; row < rows; ++row )
+    if ( pnm_writepnmrow( file, xels[row], cols, maxval, format, forceplain ) < 0 )
+      return -1;
+  return 0;
+}
+
+
+/* Colormap stuff. */
+
+#define HASH_SIZE 20023
+
+#define ppm_hashpixel(p) ( ( ( (long) PPM_GETR(p) * 33023 + (long) PPM_GETG(p) * 30013 + (long) PPM_GETB(p) * 27011 ) & 0x7fffffff ) % HASH_SIZE )
+
+colorhist_vector
+  ppm_computecolorhist( pixels, cols, rows, maxcolors, colorsP )
+pixel** pixels;
+int cols, rows, maxcolors;
+int* colorsP;
+{
+  colorhash_table cht;
+  colorhist_vector chv;
+
+  cht = ppm_computecolorhash( pixels, cols, rows, maxcolors, colorsP );
+  if ( cht == (colorhash_table) 0 )
+    return (colorhist_vector) 0;
+  chv = ppm_colorhashtocolorhist( cht, maxcolors );
+  ppm_freecolorhash( cht );
+  return chv;
+}
+
+void
+  ppm_addtocolorhist( chv, colorsP, maxcolors, colorP, value, position )
+colorhist_vector chv;
+pixel* colorP;
+int* colorsP;
+int maxcolors, value, position;
+{
+  int i, j;
+
+  /* Search colorhist for the color. */
+  for ( i = 0; i < *colorsP; ++i )
+    if ( PPM_EQUAL( chv[i].color, *colorP ) )
+      {
+	/* Found it - move to new slot. */
+	if ( position > i )
+	  {
+	    for ( j = i; j < position; ++j )
+	      chv[j] = chv[j + 1];
+	  }
+	else if ( position < i )
+	  {
+	    for ( j = i; j > position; --j )
+	      chv[j] = chv[j - 1];
+	  }
+	chv[position].color = *colorP;
+	chv[position].value = value;
+	return;
+      }
+  if ( *colorsP < maxcolors )
+    {
+      /* Didn't find it, but there's room to add it; so do so. */
+      for ( i = *colorsP; i > position; --i )
+	chv[i] = chv[i - 1];
+      chv[position].color = *colorP;
+      chv[position].value = value;
+      ++(*colorsP);
+    }
+}
+
+colorhash_table
+  ppm_computecolorhash( pixels, cols, rows, maxcolors, colorsP )
+pixel** pixels;
+int cols, rows, maxcolors;
+int* colorsP;
+{
+  colorhash_table cht;
+  register pixel* pP;
+  colorhist_list chl;
+  int col, row, hash;
+
+  cht = ppm_alloccolorhash( );
+  if ( cht == (colorhash_table) 0 )
+    return (colorhash_table) 0;
+  *colorsP = 0;
+
+  /* Go through the entire image, building a hash table of colors. */
+  for ( row = 0; row < rows; ++row )
+    for ( col = 0, pP = pixels[row]; col < cols; ++col, ++pP )
+      {
+	hash = ppm_hashpixel( *pP );
+	for ( chl = cht[hash]; chl != (colorhist_list) 0; chl = chl->next )
+	  if ( PPM_EQUAL( chl->ch.color, *pP ) )
+	    break;
+	if ( chl != (colorhist_list) 0 )
+	  ++(chl->ch.value);
+	else
+	  {
+	    if ( ++(*colorsP) > maxcolors )
+	      {
+		ppm_freecolorhash( cht );
+		return (colorhash_table) 0;
+	      }
+	    chl = (colorhist_list) malloc( sizeof(struct colorhist_list_item) );
+	    if ( chl == 0 )
+	      {
+		(void) fprintf(
+			       stderr, "%s: out of memory computing hash table\n",
+			       progname );
+		ppm_freecolorhash( cht );
+		return (colorhash_table) 0;
+	      }
+	    chl->ch.color = *pP;
+	    chl->ch.value = 1;
+	    chl->next = cht[hash];
+	    cht[hash] = chl;
+	  }
+      }
+    
+  return cht;
+}
+
+colorhash_table
+  ppm_alloccolorhash( )
+{
+  colorhash_table cht;
+  int i;
+
+  cht = (colorhash_table) malloc( HASH_SIZE * sizeof(colorhist_list) );
+  if ( cht == 0 )
+    {
+      (void) fprintf(
+		     stderr, "%s: out of memory allocating hash table\n", progname );
+      return (colorhash_table) 0;
+    }
+
+  for ( i = 0; i < HASH_SIZE; ++i )
+    cht[i] = (colorhist_list) 0;
+
+  return cht;
+}
+
+int
+  ppm_addtocolorhash( cht, colorP, value )
+colorhash_table cht;
+pixel* colorP;
+int value;
+{
+  register int hash;
+  register colorhist_list chl;
+
+  chl = (colorhist_list) malloc( sizeof(struct colorhist_list_item) );
+  if ( chl == 0 )
+    return -1;
+  hash = ppm_hashpixel( *colorP );
+  chl->ch.color = *colorP;
+  chl->ch.value = value;
+  chl->next = cht[hash];
+  cht[hash] = chl;
+  return 0;
+}
+
+colorhist_vector
+  ppm_colorhashtocolorhist( cht, maxcolors )
+colorhash_table cht;
+int maxcolors;
+{
+  colorhist_vector chv;
+  colorhist_list chl;
+  int i, j;
+
+  /* Now collate the hash table into a simple colorhist array. */
+  chv = (colorhist_vector) malloc( maxcolors * sizeof(struct colorhist_item) );
+  /* (Leave room for expansion by caller.) */
+  if ( chv == (colorhist_vector) 0 )
+    {
+      (void) fprintf(
+		     stderr, "%s: out of memory generating histogram\n", progname );
+      return (colorhist_vector) 0;
+    }
+
+  /* Loop through the hash table. */
+  j = 0;
+  for ( i = 0; i < HASH_SIZE; ++i )
+    for ( chl = cht[i]; chl != (colorhist_list) 0; chl = chl->next )
+      {
+	/* Add the new entry. */
+	chv[j] = chl->ch;
+	++j;
+      }
+
+  /* All done. */
+  return chv;
+}
+
+colorhash_table
+  ppm_colorhisttocolorhash( chv, colors )
+colorhist_vector chv;
+int colors;
+{
+  colorhash_table cht;
+  int i, hash;
+  pixel color;
+  colorhist_list chl;
+
+  cht = ppm_alloccolorhash( );
+  if ( cht == (colorhash_table) 0 )
+    return (colorhash_table) 0;
+
+  for ( i = 0; i < colors; ++i )
+    {
+      color = chv[i].color;
+      hash = ppm_hashpixel( color );
+      for ( chl = cht[hash]; chl != (colorhist_list) 0; chl = chl->next )
+	if ( PPM_EQUAL( chl->ch.color, color ) )
+	  {
+	    (void) fprintf(
+			   stderr, "%s: same color found twice - %d %d %d\n", progname,
+			   PPM_GETR(color), PPM_GETG(color), PPM_GETB(color) );
+	    ppm_freecolorhash( cht );
+	    return (colorhash_table) 0;
+	  }
+      chl = (colorhist_list) malloc( sizeof(struct colorhist_list_item) );
+      if ( chl == (colorhist_list) 0 )
+	{
+	  (void) fprintf( stderr, "%s: out of memory\n", progname );
+	  ppm_freecolorhash( cht );
+	  return (colorhash_table) 0;
+	}
+      chl->ch.color = color;
+      chl->ch.value = i;
+      chl->next = cht[hash];
+      cht[hash] = chl;
+    }
+
+  return cht;
+}
+
+int
+  ppm_lookupcolor( cht, colorP )
+colorhash_table cht;
+pixel* colorP;
+{
+  int hash;
+  colorhist_list chl;
+
+  hash = ppm_hashpixel( *colorP );
+  for ( chl = cht[hash]; chl != (colorhist_list) 0; chl = chl->next )
+    if ( PPM_EQUAL( chl->ch.color, *colorP ) )
+      return chl->ch.value;
+
+  return -1;
+}
+
+void
+  ppm_freecolorhist( chv )
+colorhist_vector chv;
+{
+  free( (char*) chv );
+}
+
+void
+  ppm_freecolorhash( cht )
+colorhash_table cht;
+{
+  int i;
+  colorhist_list chl, chlnext;
+
+  for ( i = 0; i < HASH_SIZE; ++i )
+    for ( chl = cht[i]; chl != (colorhist_list) 0; chl = chlnext )
+      {
+	chlnext = chl->next;
+	free( (char*) chl );
+      }
+  free( (char*) cht );
+}
+
+
+
+
+/* added from libpnm3.c: */
+
+/* libpnm3.c - pnm utility library part 3
+ **
+ ** Copyright (C) 1989, 1991 by Jef Poskanzer.
+ **
+ ** Permission to use, copy, modify, and distribute this software and its
+ ** documentation for any purpose and without fee is hereby granted, provided
+ ** that the above copyright notice appear in all copies and that both that
+ ** copyright notice and this permission notice appear in supporting
+ ** documentation.  This software is provided "as is" without express or
+ ** implied warranty.
+ */
+
+#if __STDC__
+xel
+  pnm_backgroundxel( xel** xels, int cols, int rows, xelval maxval, int format )
+#else /*__STDC__*/
+xel
+  pnm_backgroundxel( xels, cols, rows, maxval, format )
+xel** xels;
+int cols, rows, format;
+xelval maxval;
+#endif /*__STDC__*/
+{
+  xel bgxel, ul, ur, ll, lr;
+
+  /* Guess a good background value. */
+  ul = xels[0][0];
+  ur = xels[0][cols-1];
+  ll = xels[rows-1][0];
+  lr = xels[rows-1][cols-1];
+
+  /* First check for three corners equal. */
+  if ( PNM_EQUAL( ul, ur ) && PNM_EQUAL( ur, ll ) )
+    bgxel = ul;
+  else if ( PNM_EQUAL( ul, ur ) && PNM_EQUAL( ur, lr ) )
+    bgxel = ul;
+  else if ( PNM_EQUAL( ul, ll ) && PNM_EQUAL( ll, lr ) )
+    bgxel = ul;
+  else if ( PNM_EQUAL( ur, ll ) && PNM_EQUAL( ll, lr ) )
+    bgxel = ur;
+  /* Nope, check for two corners equal. */
+  else if ( PNM_EQUAL( ul, ur ) || PNM_EQUAL( ul, ll ) ||
+	   PNM_EQUAL( ul, lr ) )
+    bgxel = ul;
+  else if ( PNM_EQUAL( ur, ll ) || PNM_EQUAL( ur, lr ) )
+    bgxel = ur;
+  else if ( PNM_EQUAL( ll, lr ) )
+    bgxel = ll;
+  else
+    {
+      /* Nope, we have to average the four corners.  This breaks the
+       ** rules of pnm, but oh well.  Let's try to do it portably. */
+      switch ( PNM_FORMAT_TYPE(format) )
+	{
+	case PPM_TYPE:
+	  PPM_ASSIGN( bgxel,
+		     PPM_GETR(ul) + PPM_GETR(ur) + PPM_GETR(ll) + PPM_GETR(lr) / 4,
+		     PPM_GETG(ul) + PPM_GETG(ur) + PPM_GETG(ll) + PPM_GETG(lr) / 4,
+		     PPM_GETB(ul) + PPM_GETB(ur) + PPM_GETB(ll) + PPM_GETB(lr) / 4 );
+	  break;
+
+	case PGM_TYPE:
+	  {
+	    gray gul, gur, gll, glr;
+	    gul = (gray) PNM_GET1( ul );
+	    gur = (gray) PNM_GET1( ur );
+	    gll = (gray) PNM_GET1( ll );
+	    glr = (gray) PNM_GET1( lr );
+	    PNM_ASSIGN1( bgxel, ( ( gul + gur + gll + glr ) / 4 ) );
+	    break;
+	  }
+
+	case PBM_TYPE:
+	  pm_error(
+		   "pnm_backgroundxel: four bits no two of which equal each other??" );
+
+	default:
+	  pm_error( "can't happen" );
+	}
+    }
+
+  return bgxel;
+}
+
+#if __STDC__
+xel
+  pnm_backgroundxelrow( xel* xelrow, int cols, xelval maxval, int format )
+#else /*__STDC__*/
+xel
+  pnm_backgroundxelrow( xelrow, cols, maxval, format )
+xel* xelrow;
+int cols, format;
+xelval maxval;
+#endif /*__STDC__*/
+{
+  xel bgxel, l, r;
+
+  /* Guess a good background value. */
+  l = xelrow[0];
+  r = xelrow[cols-1];
+
+  /* First check for both corners equal. */
+  if ( PNM_EQUAL( l, r ) )
+    bgxel = l;
+  else
+    {
+      /* Nope, we have to average the two corners.  This breaks the
+       ** rules of pnm, but oh well.  Let's try to do it portably. */
+      switch ( PNM_FORMAT_TYPE(format) )
+	{
+	case PPM_TYPE:
+	  PPM_ASSIGN( bgxel, PPM_GETR(l) + PPM_GETR(r) / 2,
+		     PPM_GETG(l) + PPM_GETG(r) / 2, PPM_GETB(l) + PPM_GETB(r) / 2 );
+	  break;
+
+	case PGM_TYPE:
+	  {
+	    gray gl, gr;
+	    gl = (gray) PNM_GET1( l );
+	    gr = (gray) PNM_GET1( r );
+	    PNM_ASSIGN1( bgxel, ( ( gl + gr ) / 2 ) );
+	    break;
+	  }
+
+	case PBM_TYPE:
+	  {
+	    int col, blacks;
+
+	    /* One black, one white.  Gotta count. */
+	    for ( col = 0, blacks = 0; col < cols; ++col )
+	      {
+		if ( PNM_GET1( xelrow[col] ) == 0 )
+		  ++blacks;
+	      }
+	    if ( blacks >= cols / 2 )
+	      PNM_ASSIGN1( bgxel, 0 );
+	    else
+	      PNM_ASSIGN1( bgxel, pnm_pbmmaxval );
+	    break;
+	  }
+
+	default:
+	  pm_error( "can't happen" );
+	}
+    }
+
+  return bgxel;
+}
+
+#if __STDC__
+xel
+  pnm_whitexel( xelval maxval, int format )
+#else /*__STDC__*/
+xel
+  pnm_whitexel( maxval, format )
+xelval maxval;
+int format;
+#endif /*__STDC__*/
+{
+  xel x;
+
+  switch ( PNM_FORMAT_TYPE(format) )
+    {
+    case PPM_TYPE:
+      PPM_ASSIGN( x, maxval, maxval, maxval );
+      break;
+
+    case PGM_TYPE:
+      PNM_ASSIGN1( x, maxval );
+      break;
+
+    case PBM_TYPE:
+      PNM_ASSIGN1( x, pnm_pbmmaxval );
+      break;
+
+    default:
+      pm_error( "can't happen" );
+    }
+
+  return x;
+}
+
+#if __STDC__
+xel
+  pnm_blackxel( xelval maxval, int format )
+#else /*__STDC__*/
+xel
+  pnm_blackxel( maxval, format )
+xelval maxval;
+int format;
+#endif /*__STDC__*/
+{
+  xel x;
+
+  switch ( PNM_FORMAT_TYPE(format) )
+    {
+    case PPM_TYPE:
+      PPM_ASSIGN( x, 0, 0, 0 );
+      break;
+
+    case PGM_TYPE:
+      PNM_ASSIGN1( x, (xelval) 0 );
+      break;
+
+    case PBM_TYPE:
+      PNM_ASSIGN1( x, (xelval) 0 );
+      break;
+
+    default:
+      pm_error( "can't happen" );
+    }
+
+  return x;
+}
+
+#if __STDC__
+void
+  pnm_invertxel( xel* xP, xelval maxval, int format )
+#else /*__STDC__*/
+void
+  pnm_invertxel( xP, maxval, format )
+xel* xP;
+xelval maxval;
+int format;
+#endif /*__STDC__*/
+{
+  switch ( PNM_FORMAT_TYPE(format) )
+    {
+    case PPM_TYPE:
+      PPM_ASSIGN(
+		 *xP, maxval - PPM_GETR( *xP ),
+		 maxval - PPM_GETG( *xP ), maxval - PPM_GETB( *xP ) );
+      break;
+
+    case PGM_TYPE:
+      PNM_ASSIGN1( *xP, (gray) maxval - (gray) PNM_GET1( *xP ) );
+      break;
+
+    case PBM_TYPE:
+      PNM_ASSIGN1( *xP, ( PNM_GET1( *xP ) == 0 ) ? pnm_pbmmaxval : 0 );
+      break;
+
+    default:
+      pm_error( "can't happen" );
+    }
+}
+
+#if __STDC__
+void
+  pnm_promoteformat( xel** xels, int cols, int rows, xelval maxval, int format, xelval newmaxval, int newformat )
+#else /*__STDC__*/
+void
+  pnm_promoteformat( xels, cols, rows, maxval, format, newmaxval, newformat )
+xel** xels;
+xelval maxval, newmaxval;
+int cols, rows, format, newformat;
+#endif /*__STDC__*/
+{
+  int row;
+
+  for ( row = 0; row < rows; ++row )
+    pnm_promoteformatrow(
+			 xels[row], cols, maxval, format, newmaxval, newformat );
+}
+
+#if __STDC__
+void
+  pnm_promoteformatrow( xel* xelrow, int cols, xelval maxval, int format, xelval newmaxval, int newformat )
+#else /*__STDC__*/
+void
+  pnm_promoteformatrow( xelrow, cols, maxval, format, newmaxval, newformat )
+xel* xelrow;
+xelval maxval, newmaxval;
+int cols, format, newformat;
+#endif /*__STDC__*/
+{
+  register int col;
+  register xel* xP;
+
+  if ( ( PNM_FORMAT_TYPE(format) == PPM_TYPE &&
+	( PNM_FORMAT_TYPE(newformat) == PGM_TYPE ||
+	 PNM_FORMAT_TYPE(newformat) == PBM_TYPE ) ) ||
+      ( PNM_FORMAT_TYPE(format) == PGM_TYPE &&
+       PNM_FORMAT_TYPE(newformat) == PBM_TYPE ) )
+    pm_error( "pnm_promoteformatrow: can't promote downwards!" );
+
+  /* Are we promoting to the same type? */
+  if ( PNM_FORMAT_TYPE(format) == PNM_FORMAT_TYPE(newformat) )
+    {
+      if ( PNM_FORMAT_TYPE(format) == PBM_TYPE )
+	return;
+      if ( newmaxval < maxval )
+	pm_error(
+		 "pnm_promoteformatrow: can't decrease maxval - try using pnmdepth" );
+      if ( newmaxval == maxval )
+	return;
+      /* Increase maxval. */
+      switch ( PNM_FORMAT_TYPE(format) )
+	{
+	case PGM_TYPE:
+	  for ( col = 0, xP = xelrow; col < cols; ++col, ++xP )
+	    PNM_ASSIGN1(
+			*xP, (int) PNM_GET1(*xP) * newmaxval / maxval );
+	  break;
+
+	case PPM_TYPE:
+	  for ( col = 0, xP = xelrow; col < cols; ++col, ++xP )
+	    PPM_DEPTH( *xP, *xP, maxval, newmaxval );
+	  break;
+
+	default:
+	  pm_error( "shouldn't happen" );
+	}
+      return;
+    }
+
+  /* We must be promoting to a higher type. */
+  switch ( PNM_FORMAT_TYPE(format) )
+    {
+    case PBM_TYPE:
+      switch ( PNM_FORMAT_TYPE(newformat) )
+	{
+	case PGM_TYPE:
+	  for ( col = 0, xP = xelrow; col < cols; ++col, ++xP )
+	    if ( PNM_GET1(*xP) == 0 )
+	      PNM_ASSIGN1( *xP, 0 );
+	    else
+	      PNM_ASSIGN1( *xP, newmaxval );
+	  break;
+
+	case PPM_TYPE:
+	  for ( col = 0, xP = xelrow; col < cols; ++col, ++xP )
+	    if ( PNM_GET1(*xP) == 0 )
+	      PPM_ASSIGN( *xP, 0, 0, 0 );
+	    else
+	      PPM_ASSIGN( *xP, newmaxval, newmaxval, newmaxval );
+	  break;
+
+	default:
+	  pm_error( "can't happen" );
+	}
+      break;
+
+    case PGM_TYPE:
+      switch ( PNM_FORMAT_TYPE(newformat) )
+	{
+	case PPM_TYPE:
+	  if ( newmaxval < maxval )
+	    pm_error(
+		     "pnm_promoteformatrow: can't decrease maxval - try using pnmdepth" );
+	  if ( newmaxval == maxval )
+	    {
+	      for ( col = 0, xP = xelrow; col < cols; ++col, ++xP )
+		PPM_ASSIGN(
+			   *xP, PNM_GET1(*xP), PNM_GET1(*xP), PNM_GET1(*xP) );
+	    }
+	  else
+	    {			/* Increase maxval. */
+	      for ( col = 0, xP = xelrow; col < cols; ++col, ++xP )
+		PPM_ASSIGN(
+			   *xP, (int) PNM_GET1(*xP) * newmaxval / maxval,
+			   (int) PNM_GET1(*xP) * newmaxval / maxval,
+			   (int) PNM_GET1(*xP) * newmaxval / maxval );
+	    }
+	  break;
+
+	default:
+	  pm_error( "can't happen" );
+	}
+      break;
+
+    default:
+      pm_error( "can't happen" );
+    }
+}
+
+
diff --git a/media-video/mpeg-tools/files/1.5b/libpnmrw.h b/media-video/mpeg-tools/files/1.5b/libpnmrw.h
new file mode 100644
index 000000000000..efa89b790dec
--- /dev/null
+++ b/media-video/mpeg-tools/files/1.5b/libpnmrw.h
@@ -0,0 +1,194 @@
+/* pnmrw.h - header file for PBM/PGM/PPM read/write library
+**
+** Copyright (C) 1988, 1989, 1991 by Jef Poskanzer.
+**
+** Permission to use, copy, modify, and distribute this software and its
+** documentation for any purpose and without fee is hereby granted, provided
+** that the above copyright notice appear in all copies and that both that
+** copyright notice and this permission notice appear in supporting
+** documentation.  This software is provided "as is" without express or
+** implied warranty.
+*/
+
+#ifndef _PNMRW_H_
+#define _PNMRW_H_
+
+/* CONFIGURE: On some systems, malloc.h doesn't declare these, so we have
+** to do it.  On other systems, for example HP/UX, it declares them
+** incompatibly.  And some systems, for example Dynix, don't have a
+** malloc.h at all.  A sad situation.  If you have compilation problems
+** that point here, feel free to tweak or remove these declarations.
+*/
+#include <malloc.h>
+/* End of configurable definitions. */
+
+
+/* Definitions to make PBMPLUS work with either ANSI C or C Classic. */
+
+#if __STDC__
+#define ARGS(alist) alist
+#else /*__STDC__*/
+#define ARGS(alist) ()
+#define const
+#endif /*__STDC__*/
+
+
+/* Types. */
+
+typedef unsigned char bit;
+#define PBM_WHITE 0
+#define PBM_BLACK 1
+#define PBM_FORMAT_TYPE(f) ((f) == PBM_FORMAT || (f) == RPBM_FORMAT ? PBM_TYPE : -1)
+
+typedef unsigned char gray;
+#define PGM_MAXMAXVAL 255
+#define PGM_FORMAT_TYPE(f) ((f) == PGM_FORMAT || (f) == RPGM_FORMAT ? PGM_TYPE : PBM_FORMAT_TYPE(f))
+
+typedef gray pixval;
+#define PPM_MAXMAXVAL PGM_MAXMAXVAL
+typedef struct
+    {
+    pixval r, g, b;
+    } pixel;
+#define PPM_GETR(p) ((p).r)
+#define PPM_GETG(p) ((p).g)
+#define PPM_GETB(p) ((p).b)
+#define PPM_ASSIGN(p,red,grn,blu) do { (p).r = (red); (p).g = (grn); (p).b = (blu); } while ( 0 )
+#define PPM_EQUAL(p,q) ( (p).r == (q).r && (p).g == (q).g && (p).b == (q).b )
+#define PPM_FORMAT_TYPE(f) ((f) == PPM_FORMAT || (f) == RPPM_FORMAT ? PPM_TYPE : PGM_FORMAT_TYPE(f))
+
+typedef pixel xel;
+typedef pixval xelval;
+#define PNM_MAXMAXVAL PPM_MAXMAXVAL
+#define PNM_GET1(x) PPM_GETB(x)
+#define PNM_ASSIGN1(x,v) PPM_ASSIGN(x,0,0,v)
+#define PNM_EQUAL(x,y) PPM_EQUAL(x,y)
+#define PNM_FORMAT_TYPE(f) PPM_FORMAT_TYPE(f)
+
+
+/* Magic constants. */
+
+#define PBM_MAGIC1 'P'
+#define PBM_MAGIC2 '1'
+#define RPBM_MAGIC2 '4'
+#define PBM_FORMAT (PBM_MAGIC1 * 256 + PBM_MAGIC2)
+#define RPBM_FORMAT (PBM_MAGIC1 * 256 + RPBM_MAGIC2)
+#define PBM_TYPE PBM_FORMAT
+
+#define PGM_MAGIC1 'P'
+#define PGM_MAGIC2 '2'
+#define RPGM_MAGIC2 '5'
+#define PGM_FORMAT (PGM_MAGIC1 * 256 + PGM_MAGIC2)
+#define RPGM_FORMAT (PGM_MAGIC1 * 256 + RPGM_MAGIC2)
+#define PGM_TYPE PGM_FORMAT
+
+#define PPM_MAGIC1 'P'
+#define PPM_MAGIC2 '3'
+#define RPPM_MAGIC2 '6'
+#define PPM_FORMAT (PPM_MAGIC1 * 256 + PPM_MAGIC2)
+#define RPPM_FORMAT (PPM_MAGIC1 * 256 + RPPM_MAGIC2)
+#define PPM_TYPE PPM_FORMAT
+
+
+/* Color scaling macro -- to make writing ppmtowhatever easier. */
+
+#define PPM_DEPTH(newp,p,oldmaxval,newmaxval) \
+    PPM_ASSIGN( (newp), \
+	( (int) PPM_GETR(p) * (newmaxval) + (oldmaxval) / 2 ) / (oldmaxval), \
+	( (int) PPM_GETG(p) * (newmaxval) + (oldmaxval) / 2 ) / (oldmaxval), \
+	( (int) PPM_GETB(p) * (newmaxval) + (oldmaxval) / 2 ) / (oldmaxval) )
+
+
+/* Luminance macro. */
+
+#define PPM_LUMIN(p) ( 0.299 * PPM_GETR(p) + 0.587 * PPM_GETG(p) + 0.114 * PPM_GETB(p) )
+
+
+/* Declarations of pnmrw routines. */
+
+void pnm_init2 ARGS(( char* pn ));
+
+char** pm_allocarray ARGS(( int cols, int rows, int size ));
+#define pnm_allocarray( cols, rows ) ((xel**) pm_allocarray( cols, rows, sizeof(xel) ))
+char* pm_allocrow ARGS(( int cols, int size ));
+#define pnm_allocrow( cols ) ((xel*) pm_allocrow( cols, sizeof(xel) ))
+void pm_freearray ARGS(( char** its, int rows ));
+#define pnm_freearray( xels, rows ) pm_freearray( (char**) xels, rows )
+void pm_freerow ARGS(( char* itrow ));
+#define pnm_freerow( xelrow ) pm_freerow( (char*) xelrow )
+
+xel** pnm_readpnm ARGS(( FILE* file, int* colsP, int* rowsP, xelval* maxvalP, int* formatP ));
+int pnm_readpnminit ARGS(( FILE* file, int* colsP, int* rowsP, xelval* maxvalP, int* formatP ));
+int pnm_readpnmrow ARGS(( FILE* file, xel* xelrow, int cols, xelval maxval, int format ));
+
+int pnm_writepnm ARGS(( FILE* file, xel** xels, int cols, int rows, xelval maxval, int format, int forceplain ));
+int pnm_writepnminit ARGS(( FILE* file, int cols, int rows, xelval maxval, int format, int forceplain ));
+int pnm_writepnmrow ARGS(( FILE* file, xel* xelrow, int cols, xelval maxval, int format, int forceplain ));
+
+extern xelval pnm_pbmmaxval;
+/* This is the maxval used when a PNM program reads a PBM file.  Normally
+** it is 1; however, for some programs, a larger value gives better results
+*/
+
+
+/* File open/close that handles "-" as stdin and checks errors. */
+
+FILE* pm_openr ARGS(( char* name ));
+FILE* pm_openw ARGS(( char* name ));
+int pm_closer ARGS(( FILE* f ));
+int pm_closew ARGS(( FILE* f ));
+
+
+/* Colormap stuff. */
+
+typedef struct colorhist_item* colorhist_vector;
+struct colorhist_item
+    {
+    pixel color;
+    int value;
+    };
+
+typedef struct colorhist_list_item* colorhist_list;
+struct colorhist_list_item
+    {
+    struct colorhist_item ch;
+    colorhist_list next;
+    };
+
+typedef colorhist_list* colorhash_table;
+
+colorhist_vector ppm_computecolorhist ARGS(( pixel** pixels, int cols, int rows, int maxcolors, int* colorsP ));
+/* Returns a colorhist *colorsP long (with space allocated for maxcolors. */
+
+void ppm_addtocolorhist ARGS(( colorhist_vector chv, int* colorsP, int maxcolors, pixel* colorP, int value, int position ));
+
+void ppm_freecolorhist ARGS(( colorhist_vector chv ));
+
+colorhash_table ppm_computecolorhash ARGS(( pixel** pixels, int cols, int rows, int maxcolors, int* colorsP ));
+
+int
+ppm_lookupcolor ARGS(( colorhash_table cht, pixel* colorP ));
+
+colorhist_vector ppm_colorhashtocolorhist ARGS(( colorhash_table cht, int maxcolors ));
+colorhash_table ppm_colorhisttocolorhash ARGS(( colorhist_vector chv, int colors ));
+
+int ppm_addtocolorhash ARGS(( colorhash_table cht, pixel* colorP, int value ));
+/* Returns -1 on failure. */
+
+colorhash_table ppm_alloccolorhash ARGS(( void ));
+
+void ppm_freecolorhash ARGS(( colorhash_table cht ));
+
+/* Other function declarations */
+void pnm_promoteformat ARGS(( xel** xels, int cols, int rows, xelval maxval,
+int format, xelval newmaxval, int newformat ));
+void pnm_promoteformatrow ARGS(( xel* xelrow, int cols, xelval maxval, 
+int format, xelval newmaxval, int newformat ));
+
+xel pnm_backgroundxel ARGS(( xel** xels, int cols, int rows, xelval maxval, int format ));
+xel pnm_backgroundxelrow ARGS(( xel* xelrow, int cols, xelval maxval, int format ));
+xel pnm_whitexel ARGS(( xelval maxval, int format ));
+xel pnm_blackxel ARGS(( xelval maxval, int format ));
+void pnm_invertxel ARGS(( xel* xP, xelval maxval, int format ));
+
+#endif /*_PNMRW_H_*/
diff --git a/media-video/mpeg-tools/mpeg-tools-1.5b.ebuild b/media-video/mpeg-tools/mpeg-tools-1.5b.ebuild
index 7b133c241041..b728b07a8ff1 100644
--- a/media-video/mpeg-tools/mpeg-tools-1.5b.ebuild
+++ b/media-video/mpeg-tools/mpeg-tools-1.5b.ebuild
@@ -1,6 +1,6 @@
 # Copyright 1999-2002 Gentoo Technologies, Inc.
 # Distributed under the terms of the GNU General Public License, v2 or later
-# $Header: /var/cvsroot/gentoo-x86/media-video/mpeg-tools/mpeg-tools-1.5b.ebuild,v 1.9 2002/07/19 10:47:49 seemant Exp $
+# $Header: /var/cvsroot/gentoo-x86/media-video/mpeg-tools/mpeg-tools-1.5b.ebuild,v 1.10 2002/08/28 12:47:18 karltk Exp $
 
 MY_PN=mpeg_encode
 S=${WORKDIR}/${MY_PN}
@@ -17,10 +17,10 @@ KEYWORDS="x86"
 src_unpack () {
 	unpack ${A}
 	cd ${S}
-	cp libpnmrw.c libpnmrw.c.orig
-	sed -e "s:extern char\* sys_errlist:extern __const char \*__const sys_errlist:" \
-	libpnmrw.c.orig > libpnmrw.c
+	cp ${FILESDIR}/${PV}/libpnmrw.c .
+	cp ${FILESDIR}/${PV}/libpnmrw.h headers/
 }
+
 src_compile() {
 
 	cd ${S}