Unix/Linux Go Back    

RedHat 9 (Linux i386) - man page for libpbm (redhat section 3)

Linux & Unix Commands - Search Man Pages
Man Page or Keyword Search:   man
Select Man Page Set:       apropos Keyword Search (sections above)

libpbm(3)										libpbm(3)

       libpbm - functions to read and write PBM image files

       #include <pbm.h>

       int pm_keymatch(char * str, char * keyword, int minchars);

       int pm_maxvaltobits(int maxval);

       int pm_bitstomaxval(int bits);

       unsigned int pm_lcm(unsigned int x, unsigned int y, unsigned int z, unsigned int limit);

       void pm_message(char * fmt, ... );

       void pm_error(char * fmt, ... );

       void pm_perror(char * fmt, ... );

       void pm_usage(char * usage);

       FILE *pm_openr(char * name)

       FILE *pm_openw(char * name);

       FILE *pm_openr_seekable(const char * name);

       FILE *pm_close(FILE * fp);

       char *pm_read_unknown_size(FILE * fp, long *nread);

       unsigned int pm_tell(FILE * fileP);

       void pm_seek(FILE * fileP, unsigned long filepos);

       bit **pbm_allocarray(int cols,  int rows);

       bit *pbm_allocrow(int cols);

       pbm_freearray(bit **bits, int rows);

       pbm_freerow(bit *bitrow);

       void pbm_readpbminit(FILE * fp, int *colsP, int *rowsP, int *formatP);

       void pbm_readpbmrow(FILE * fp, bit *bitrow, int cols, int format);

       void pbm_readpbmrow_packed(FILE * fp,
       unsigned char * const packed_bits, const int cols, const int format);

       void bit** pbm_readpbm(FILE * fp, int *colsP, int *rowsP);

       void pbm_writepbminit(FILE * fp, int cols, int rows, int forceplain);

       void pbm_writepbmrow(FILE * fp, bit *bitrow, int cols, int forceplain);

       void pbm_writepbmrow_packed(FILE * fp,
       unsigned char * const packed_bits, const int cols, const int forceplain);

       void pbm_writepbm(FILE * fp, bit **bits, int cols, int rows, int forceplain);

       #define pbm_packed_bytes(cols) ...

       void pbm_nextimage( FILE *file, int * const eofP);

       void  pbm_check( FILE * file, const enum pm_check_type check_type, const int format, const
       int cols, const int rows, enum pm_check_code * const retval);

       int pm_readbigshort(FILE *in, short *sP);

       int pm_writebigshort(FILE *out, short s);

       int pm_readbiglong(FILE *in, long *lP);

       int pm_writebiglong(FILE *out, long l);

       int pm_readlittleshort(FILE *in, short *sP);

       int pm_writelittleshort(FILE *out, short s);

       int pm_readlittlelong(FILE *in, long *lP);

       int pm_writelittlelong(FILE *out, long l);

       pm_keymatch() does a case-insensitive match of str against keyword.  str can be a  leading
       sunstring of keyword, but at least minchars must be present.

       pm_maxvaltobits() and pm_bitstomaxval() convert between a maxval and the minimum number of
       bits required to hold it.

       pm_lcm() computes the least common multiple of 3 integers.  You also specify a  limit  and
       if the LCM would be higher than that limit, pm_lcm() just returns that limit.

       pm_message() is a printf() style routine to write an informational message to the Standard
       Error file stream.  pm_message() suppresses the message, however, if  the  user	specified
       the   -quiet  option  on  the  command  line.   See  the  initialization  functions,  e.g.
       pbm_init(), for information on the -quiet option.  Note that  Netpbm  programs  are  often
       used  interactively, but also often used by programs.  In the interactive case, it is nice
       to issue messages about what the program is doing, but in the program case, such  messages
       are  usually undesirable.  By using pm_message() for all your messages, you make your pro-
       gram usable in both cases.  Without any effort on your part, program users of your program
       can avoid the messages by specifying the -quiet option.

       pm_error()  is a printf() style routine that writes an error message to the Standard Error
       file stream and exits the program with an exit code of 1.

       pm_openr() opens the given file for reading, with appropriate error checking.  A  filename
       of  -  is taken to mean Standard Input.	pm_openw() opens the given file for writing, with
       appropriate error checking.  pm_close() closes the file descriptor, with appropriate error

       pm_openr_seekable()  appears  to  open  the  file  just like pm_openr(), but the file thus
       opened  is  guaranteed  to  be  seekable  (you  can  use  ftell()  and  fseek()	on   it).
       pm_openr_seekable() pulls this off by copying the entire file to a temporary file and giv-
       ing you the handle of the temporary file, if it has to.	If the file you name is a regular
       file, it's already seekable so pm_openr_seekable() just does the same thing as pm_openr().
       But if it is, say, a pipe, it isn't seekable.  So pm_openr_seekable() reads the pipe until
       EOF  into  a  temporary file, then opens that temporary file and returns the handle of the
       temporary file.	The temporary file is seekable.

       The file pm_openr_seekable() creates is one that the operating system recognizes as tempo-
       rary, so when you close the file, by any means, it gets deleted.

       You need a seekable file if you intend to make multiple passes through the file.  The only
       alternative is to read the entire image into memory and work from that copy.  That may use
       too  much memory.  Note that the image takes less space in the file cache than in a buffer
       in memory.  As much as 96 times less space!  Each sample is  an	integer  in  the  buffer,
       which  is usually 96 bits.  In the file, a sample may be as small as 1 bit and rarely more
       than 8 bits.

       pm_read_unknown_size() reads an entire file or input stream of unknown size to  a  buffer.
       Allocate  memory more memory as needed. The calling routine has to free the allocated buf-
       fer with free().

       pm_read_unknown_size() returns a pointer to  the  allocated  buffer.  The  nread  argument
       returns the number of bytes read.

       pm_tell()  returns a handle for the current position of the file, whether it be the header
       or a row of the raster.	Use the handle as an argument to pm_seek() to reposition the file
       there  later.   The  file  must	be  seekable  (which  you  can	ensure by opening it with

       pm_readbigshort(), pm_writebigshort(),  pm_readbiglong(),  pm_writebiglong(),  pm_readlit-
       tleshort(),  pm_writelittleshort(), pm_readlittlelong(), and pm_writelittlelong() are rou-
       tines to read and write short and long ints in either big- or  little-endian  byte  order.
       The return value is 0 upon success and -1 upon failure (either EOF or I/O error).

       typedef ... bit;

       #define PBM_WHITE ...

       #define PBM_BLACK ...

       Each bit should contain only the values of PBM_WHITE or PBM_BLACK.

       #define PBM_FORMAT ...

       #define RPBM_FORMAT ...

       #define PBM_TYPE PBM_FORMAT

       #define PBM_FORMAT_TYPE(f) ...

       These are for distinguishing different file formats and types.

       All PBM programs must call pbm_init just after invocation, before processing arguments.

       pbm_allocarray()  allocates an array of bits.  pbm_allocrow() allocates a row of the given
       number of bits.	pbm_freearray() frees the array allocated with pbm_allocarray()  contain-
       ing the given number of rows.  pbm_freerow() frees a row of bits.

       pbm_readpbminit()  reads  the  header from a PBM image in a PBM file, filling in the rows,
       cols and format variables.  pbm_readpbmrow() reads a row of bits into  the  bitrow  array.
       Format  and  cols  were	filled	in by pbm_readpbminit().  pbm_readpbmrow_packed() is like
       pbm_readrow() except instead of returning a bits array, it returns an array packed_bits of
       bytes  with  the  pixels  of the image row packed into them.  The pixels are in order from
       left to right across the row and from the beginning of the array to  the  end.	Within	a
       byte,  the  bits  are in order from the most significant bit to the least significant bit.
       If the number of pixels in the row is not a multiple of	8,  the  last  byte  returned  is
       padded  on  the	least signficant bit side with undefined bits.	White is represented by a
       PBM_WHITE bit; black by PBM_BLACK.

       pbm_readpbm() reads an entire bitmap file into memory, returning the allocated  array  and
       filling	in  the  rows  and  cols  variables.   This  function combines pbm_readpbminit(),
       pbm_allocarray() and pbm_readpbmrow().

       pbm_writepbminit() writes the header for a PBM image in a PBM file.  forceplain is a bool-
       ean  value  specifying  that a plain format (text) file to be written, as opposed to a raw
       format (binary) one.  pbm_writepbmrow()	writes	a  row	to  a  PBM  file.   pbm_writepbm-
       row_packed()  is  the same as pbm_writepbmrow() except that you supply the row to write as
       an array of bytes packed with bits instead of as a bits array.  The format of  packed_bits
       is the same as that returned by pbm_readpbmrow().

       pbm_writepbm()  writes  the header and all data for a PBM image to a PBM file.  This func-
       tion combines pbm_writepbminit() and pbm_writepbmrow().

       pbm_nextimage() positions a PBM input file to the next image in it (so that  a  subsequent
       pbm_readpbminit() reads its header).

       Immediately  before  a  call to pbm_nextimage(), the file must be positioned either at its
       beginning (i.e. nothing has been read from the file yet) or just after an image	(i.e.  as
       left by a pbm_readpbmrow() of the last row in the image).

       In  effect,  then,  all	pbm_nextimage() does is test whether there is a next image or the
       file is positioned at end-of-file.

       If pbm_nextimage() successfully positions to the next image, it returns *eofP  false  (0).
       If there is no next image in the file, it returns *eofP true (1).  If it can't position or
       determine the file status due to a file error, it issues an error message  and  exits  the
       program with an error exit code.

       pbm_check() checks for the common file integrity error where the file is the wrong size to
       contain all the image data.  pbm_check() assumes the file is  positioned  after	an  image
       header  (as  if pbm_readpbminit() was the last operation on the file).  It checks the file
       size to see if the number of bytes left in the file are the number required to contain the
       image  raster.	If  the file is too short, pbm_check() causes the program to exit with an
       error message and error completion code.  Otherwise, it returns one of the following  val-
       ues (enumerations of the enum pm_check_code type) as *retval:

	      The file's size is exactly what is required to hold the image raster.

	      format is not a format whose size pbm_check() can anticipate.  The only format with
	      which pbm_check() can deal is raw PBM format.

	      The file is longer than it needs to be to contain the image raster.  The extra data
	      might be another image.

	      The  file  is not a kind that has a predictable size, so there is no simple way for
	      pbm_check() to know if it is the right size.  Only a regular file  has  predictable
	      size.  A pipe is a common example of a file that does not.

       check_type  must  have  the value PM_CHECK_BASIC (an enumerated value of the pm_check_type
       enumerated type).  Otherwise, the effect of pbm_check() is unpredictable.   This  argument
       exists for future backward compatible expansion of the function of pbm_check().

       libpgm(3), libppm(3), libpnm(3), pbm(5)

       Copyright (C) 1989, 1991 by Tony Hansen and Jef Poskanzer.

Unix & Linux Commands & Man Pages : ©2000 - 2018 Unix and Linux Forums

All times are GMT -4. The time now is 10:30 AM.