/* Copyright (C) 2001-2017 Peter Selinger. * This file is part of Potrace. It is free software and it is covered * by the GNU General Public License. See the file COPYING for details. */ /* Routines for manipulating bitmaps, including reading pbm files. */ #ifdef HAVE_CONFIG_H #include #endif #include #include "bitmap.h" #include "bitmap_io.h" #include "bitops.h" #define INTBITS ( 8 * sizeof( int ) ) static int bm_readbody_bmp( FILE* f, double threshold, potrace_bitmap_t** bmp ); static int bm_readbody_pnm( FILE* f, double threshold, potrace_bitmap_t** bmp, int magic ); #define TRY( x ) \ if( x ) \ goto try_error #define TRY_EOF( x ) \ if( x ) \ goto eof #define TRY_STD( x ) \ if( x ) \ goto std_error /* ---------------------------------------------------------------------- */ /* routines for reading pnm streams */ /* read next character after whitespace and comments. Return EOF on * end of file or error. */ static int fgetc_ws( FILE* f ) { int c; while( 1 ) { c = fgetc( f ); if( c == '#' ) { while( 1 ) { c = fgetc( f ); if( c == '\n' || c == EOF ) { break; } } } /* space, tab, line feed, carriage return, form-feed */ if( c != ' ' && c != '\t' && c != '\r' && c != '\n' && c != 12 ) { return c; } } } /* skip whitespace and comments, then read a non-negative decimal * number from a stream. Return -1 on EOF. Tolerate other errors (skip * bad characters). Do not the read any characters following the * number (put next character back into the stream) */ static int readnum( FILE* f ) { int c; int acc; /* skip whitespace and comments */ while( 1 ) { c = fgetc_ws( f ); if( c == EOF ) { return -1; } if( c >= '0' && c <= '9' ) { break; } } /* first digit is already in c */ acc = c - '0'; while( 1 ) { c = fgetc( f ); if( c == EOF ) { break; } if( c < '0' || c > '9' ) { ungetc( c, f ); break; } acc *= 10; acc += c - '0'; } return acc; } /* similar to readnum, but read only a single 0 or 1, and do not read * any characters after it. */ static int readbit( FILE* f ) { int c; /* skip whitespace and comments */ while( 1 ) { c = fgetc_ws( f ); if( c == EOF ) { return -1; } if( c >= '0' && c <= '1' ) { break; } } return c - '0'; } /* ---------------------------------------------------------------------- */ /* read a PNM stream: P1-P6 format (see pnm(5)), or a BMP stream, and * convert the output to a bitmap. Return bitmap in *bmp. Return 0 on * success, -1 on error with errno set, -2 on bad file format (with * error message in bm_read_error), and 1 on premature end of file, -3 * on empty file (including files which contain only whitespace and * comments), -4 if wrong magic number. If the return value is >=0, * bmp is valid. */ const char* bm_read_error = NULL; int bm_read( FILE* f, double threshold, potrace_bitmap_t** bmp ) { int magic[2]; /* read magic number. We ignore whitespace and comments before the * magic, for the benefit of concatenated files in P1-P3 format. * Multiple P1-P3 images in a single file are not formally allowed * by the PNM standard, but there is no harm in being lenient. */ magic[0] = fgetc_ws( f ); if( magic[0] == EOF ) { return -3; } magic[1] = fgetc( f ); if( magic[0] == 'P' && magic[1] >= '1' && magic[1] <= '6' ) { return bm_readbody_pnm( f, threshold, bmp, magic[1] ); } if( magic[0] == 'B' && magic[1] == 'M' ) { return bm_readbody_bmp( f, threshold, bmp ); } return -4; } /* ---------------------------------------------------------------------- */ /* read PNM format */ /* read PNM stream after magic number. Return values as for bm_read */ static int bm_readbody_pnm( FILE* f, double threshold, potrace_bitmap_t** bmp, int magic ) { potrace_bitmap_t* bm; int x, y, i, b, b1, sum; int bpr; /* bytes per row (as opposed to 4*bm->c) */ int w, h, max; int realheight; /* in case of incomplete file, keeps track of how * many scan lines actually contain data */ bm = NULL; w = readnum( f ); if( w < 0 ) { goto format_error; } h = readnum( f ); if( h < 0 ) { goto format_error; } /* allocate bitmap */ bm = bm_new( w, h ); if( !bm ) { goto std_error; } realheight = 0; switch( magic ) { default: /* not reached */ goto format_error; case '1': /* read P1 format: PBM ascii */ for( y = 0; y < h; y++ ) { realheight = y + 1; for( x = 0; x < w; x++ ) { b = readbit( f ); if( b < 0 ) { goto eof; } BM_UPUT( bm, x, y, b ); } } break; case '2': /* read P2 format: PGM ascii */ max = readnum( f ); if( max < 1 ) { goto format_error; } for( y = 0; y < h; y++ ) { realheight = y + 1; for( x = 0; x < w; x++ ) { b = readnum( f ); if( b < 0 ) { goto eof; } BM_UPUT( bm, x, y, b > threshold * max ? 0 : 1 ); } } break; case '3': /* read P3 format: PPM ascii */ max = readnum( f ); if( max < 1 ) { goto format_error; } for( y = 0; y < h; y++ ) { realheight = y + 1; for( x = 0; x < w; x++ ) { sum = 0; for( i = 0; i < 3; i++ ) { b = readnum( f ); if( b < 0 ) { goto eof; } sum += b; } BM_UPUT( bm, x, y, sum > 3 * threshold * max ? 0 : 1 ); } } break; case '4': /* read P4 format: PBM raw */ b = fgetc( f ); /* read single white-space character after height */ if( b == EOF ) { goto format_error; } bpr = ( w + 7 ) / 8; for( y = 0; y < h; y++ ) { realheight = y + 1; for( i = 0; i < bpr; i++ ) { b = fgetc( f ); if( b == EOF ) { goto eof; } *bm_index( bm, i * 8, y ) |= ( (potrace_word) b ) << ( 8 * ( BM_WORDSIZE - 1 - ( i % BM_WORDSIZE ) ) ); } } break; case '5': /* read P5 format: PGM raw */ max = readnum( f ); if( max < 1 ) { goto format_error; } b = fgetc( f ); /* read single white-space character after max */ if( b == EOF ) { goto format_error; } for( y = 0; y < h; y++ ) { realheight = y + 1; for( x = 0; x < w; x++ ) { b = fgetc( f ); if( b == EOF ) goto eof; if( max >= 256 ) { b <<= 8; b1 = fgetc( f ); if( b1 == EOF ) goto eof; b |= b1; } BM_UPUT( bm, x, y, b > threshold * max ? 0 : 1 ); } } break; case '6': /* read P6 format: PPM raw */ max = readnum( f ); if( max < 1 ) { goto format_error; } b = fgetc( f ); /* read single white-space character after max */ if( b == EOF ) { goto format_error; } for( y = 0; y < h; y++ ) { realheight = y + 1; for( x = 0; x < w; x++ ) { sum = 0; for( i = 0; i < 3; i++ ) { b = fgetc( f ); if( b == EOF ) { goto eof; } if( max >= 256 ) { b <<= 8; b1 = fgetc( f ); if( b1 == EOF ) goto eof; b |= b1; } sum += b; } BM_UPUT( bm, x, y, sum > 3 * threshold * max ? 0 : 1 ); } } break; } bm_flip( bm ); *bmp = bm; return 0; eof: TRY_STD( bm_resize( bm, realheight ) ); bm_flip( bm ); *bmp = bm; return 1; format_error: bm_free( bm ); if( magic == '1' || magic == '4' ) { bm_read_error = "invalid pbm file"; } else if( magic == '2' || magic == '5' ) { bm_read_error = "invalid pgm file"; } else { bm_read_error = "invalid ppm file"; } return -2; std_error: bm_free( bm ); return -1; } /* ---------------------------------------------------------------------- */ /* read BMP format */ struct bmp_info_s { unsigned int FileSize; unsigned int reserved; unsigned int DataOffset; unsigned int InfoSize; unsigned int w; /* width */ unsigned int h; /* height */ unsigned int Planes; unsigned int bits; /* bits per sample */ unsigned int comp; /* compression mode */ unsigned int ImageSize; unsigned int XpixelsPerM; unsigned int YpixelsPerM; unsigned int ncolors; /* number of colors in palette */ unsigned int ColorsImportant; unsigned int RedMask; unsigned int GreenMask; unsigned int BlueMask; unsigned int AlphaMask; unsigned int ctbits; /* sample size for color table */ int topdown; /* top-down mode? */ }; typedef struct bmp_info_s bmp_info_t; /* auxiliary */ static int bmp_count = 0; /* counter for byte padding */ static int bmp_pos = 0; /* counter from start of BMP data */ /* read n-byte little-endian integer. Return 1 on EOF or error, else * 0. Assume n<=4. */ static int bmp_readint( FILE* f, int n, unsigned int* p ) { int i; unsigned int sum = 0; int b; for( i = 0; i < n; i++ ) { b = fgetc( f ); if( b == EOF ) { return 1; } sum += (unsigned) b << ( 8 * i ); } bmp_count += n; bmp_pos += n; *p = sum; return 0; } /* reset padding boundary */ static void bmp_pad_reset( void ) { bmp_count = 0; } /* read padding bytes to 4-byte boundary. Return 1 on EOF or error, * else 0. */ static int bmp_pad( FILE* f ) { int c, i, b; c = ( -bmp_count ) & 3; for( i = 0; i < c; i++ ) { b = fgetc( f ); if( b == EOF ) { return 1; } } bmp_pos += c; bmp_count = 0; return 0; } /* forward to the new file position. Return 1 on EOF or error, else 0 */ static int bmp_forward( FILE* f, int pos ) { int b; while( bmp_pos < pos ) { b = fgetc( f ); if( b == EOF ) { return 1; } bmp_pos++; bmp_count++; } return 0; } /* safe colortable access */ #define COLTABLE( c ) ( ( c ) < bmpinfo.ncolors ? coltable[( c )] : 0 ) /* read BMP stream after magic number. Return values as for bm_read. * We choose to be as permissive as possible, since there are many * programs out there which produce BMP. For instance, ppmtobmp can * produce codings with anywhere from 1-8 or 24 bits per sample, * although most specifications only allow 1,4,8,24,32. We can also * read both the old and new OS/2 BMP formats in addition to the * Windows BMP format. */ static int bm_readbody_bmp( FILE* f, double threshold, potrace_bitmap_t** bmp ) { bmp_info_t bmpinfo; int* coltable; unsigned int b, c; unsigned int i; potrace_bitmap_t* bm; int mask; unsigned int x, y; int col[2]; unsigned int bitbuf; unsigned int n; unsigned int redshift, greenshift, blueshift; int col1[2]; int realheight; /* in case of incomplete file, keeps track of how * many scan lines actually contain data */ bm_read_error = NULL; bm = NULL; coltable = NULL; bmp_pos = 2; /* set file position */ /* file header (minus magic number) */ TRY( bmp_readint( f, 4, &bmpinfo.FileSize ) ); TRY( bmp_readint( f, 4, &bmpinfo.reserved ) ); TRY( bmp_readint( f, 4, &bmpinfo.DataOffset ) ); /* info header */ TRY( bmp_readint( f, 4, &bmpinfo.InfoSize ) ); if( bmpinfo.InfoSize == 40 || bmpinfo.InfoSize == 64 || bmpinfo.InfoSize == 108 || bmpinfo.InfoSize == 124 ) { /* Windows or new OS/2 format */ bmpinfo.ctbits = 32; /* sample size in color table */ TRY( bmp_readint( f, 4, &bmpinfo.w ) ); TRY( bmp_readint( f, 4, &bmpinfo.h ) ); TRY( bmp_readint( f, 2, &bmpinfo.Planes ) ); TRY( bmp_readint( f, 2, &bmpinfo.bits ) ); TRY( bmp_readint( f, 4, &bmpinfo.comp ) ); TRY( bmp_readint( f, 4, &bmpinfo.ImageSize ) ); TRY( bmp_readint( f, 4, &bmpinfo.XpixelsPerM ) ); TRY( bmp_readint( f, 4, &bmpinfo.YpixelsPerM ) ); TRY( bmp_readint( f, 4, &bmpinfo.ncolors ) ); TRY( bmp_readint( f, 4, &bmpinfo.ColorsImportant ) ); if( bmpinfo.InfoSize >= 108 ) { /* V4 and V5 bitmaps */ TRY( bmp_readint( f, 4, &bmpinfo.RedMask ) ); TRY( bmp_readint( f, 4, &bmpinfo.GreenMask ) ); TRY( bmp_readint( f, 4, &bmpinfo.BlueMask ) ); TRY( bmp_readint( f, 4, &bmpinfo.AlphaMask ) ); } if( bmpinfo.w > 0x7fffffff ) { goto format_error; } if( bmpinfo.h > 0x7fffffff ) { bmpinfo.h = ( -bmpinfo.h ) & 0xffffffff; bmpinfo.topdown = 1; } else { bmpinfo.topdown = 0; } if( bmpinfo.h > 0x7fffffff ) { goto format_error; } } else if( bmpinfo.InfoSize == 12 ) { /* old OS/2 format */ bmpinfo.ctbits = 24; /* sample size in color table */ TRY( bmp_readint( f, 2, &bmpinfo.w ) ); TRY( bmp_readint( f, 2, &bmpinfo.h ) ); TRY( bmp_readint( f, 2, &bmpinfo.Planes ) ); TRY( bmp_readint( f, 2, &bmpinfo.bits ) ); bmpinfo.comp = 0; bmpinfo.ncolors = 0; bmpinfo.topdown = 0; } else { goto format_error; } if( bmpinfo.comp == 3 && bmpinfo.InfoSize < 108 ) { /* bitfield feature is only understood with V4 and V5 format */ goto format_error; } if( bmpinfo.comp > 3 || bmpinfo.bits > 32 ) { goto format_error; } /* forward to color table (e.g., if bmpinfo.InfoSize == 64) */ TRY( bmp_forward( f, 14 + bmpinfo.InfoSize ) ); if( bmpinfo.Planes != 1 ) { bm_read_error = "cannot handle bmp planes"; goto format_error; /* can't handle planes */ } if( bmpinfo.ncolors == 0 && bmpinfo.bits <= 8 ) { bmpinfo.ncolors = 1 << bmpinfo.bits; } /* color table, present only if bmpinfo.bits <= 8. */ if( bmpinfo.bits <= 8 ) { coltable = (int*) calloc( bmpinfo.ncolors, sizeof( int ) ); if( !coltable ) { goto std_error; } /* NOTE: since we are reading a bitmap, we can immediately convert * the color table entries to bits. */ for( i = 0; i < bmpinfo.ncolors; i++ ) { TRY( bmp_readint( f, bmpinfo.ctbits / 8, &c ) ); c = ( ( c >> 16 ) & 0xff ) + ( ( c >> 8 ) & 0xff ) + ( c & 0xff ); coltable[i] = ( c > 3 * threshold * 255 ? 0 : 1 ); if( i < 2 ) { col1[i] = c; } } } /* forward to data */ if( bmpinfo.InfoSize != 12 ) { /* not old OS/2 format */ TRY( bmp_forward( f, bmpinfo.DataOffset ) ); } /* allocate bitmap */ bm = bm_new( bmpinfo.w, bmpinfo.h ); if( !bm ) { goto std_error; } realheight = 0; switch( bmpinfo.bits + 0x100 * bmpinfo.comp ) { default: goto format_error; break; case 0x001: /* monochrome palette */ if( col1[0] < col1[1] ) { /* make the darker color black */ mask = 0xff; } else { mask = 0; } /* raster data */ for( y = 0; y < bmpinfo.h; y++ ) { realheight = y + 1; bmp_pad_reset(); for( i = 0; 8 * i < bmpinfo.w; i++ ) { TRY_EOF( bmp_readint( f, 1, &b ) ); b ^= mask; *bm_index( bm, i * 8, y ) |= ( (potrace_word) b ) << ( 8 * ( BM_WORDSIZE - 1 - ( i % BM_WORDSIZE ) ) ); } TRY( bmp_pad( f ) ); } break; case 0x002: /* 2-bit to 8-bit palettes */ case 0x003: case 0x004: case 0x005: case 0x006: case 0x007: case 0x008: for( y = 0; y < bmpinfo.h; y++ ) { realheight = y + 1; bmp_pad_reset(); bitbuf = 0; /* bit buffer: bits in buffer are high-aligned */ n = 0; /* number of bits currently in bitbuffer */ for( x = 0; x < bmpinfo.w; x++ ) { if( n < bmpinfo.bits ) { TRY_EOF( bmp_readint( f, 1, &b ) ); bitbuf |= b << ( INTBITS - 8 - n ); n += 8; } b = bitbuf >> ( INTBITS - bmpinfo.bits ); bitbuf <<= bmpinfo.bits; n -= bmpinfo.bits; BM_UPUT( bm, x, y, COLTABLE( b ) ); } TRY( bmp_pad( f ) ); } break; case 0x010: /* 16-bit encoding */ /* can't do this format because it is not well-documented and I * don't have any samples */ bm_read_error = "cannot handle bmp 16-bit coding"; goto format_error; break; case 0x018: /* 24-bit encoding */ case 0x020: /* 32-bit encoding */ for( y = 0; y < bmpinfo.h; y++ ) { realheight = y + 1; bmp_pad_reset(); for( x = 0; x < bmpinfo.w; x++ ) { TRY_EOF( bmp_readint( f, bmpinfo.bits / 8, &c ) ); c = ( ( c >> 16 ) & 0xff ) + ( ( c >> 8 ) & 0xff ) + ( c & 0xff ); BM_UPUT( bm, x, y, c > 3 * threshold * 255 ? 0 : 1 ); } TRY( bmp_pad( f ) ); } break; case 0x320: /* 32-bit encoding with bitfields */ if( bmpinfo.RedMask == 0 || bmpinfo.GreenMask == 0 || bmpinfo.BlueMask == 0 ) { goto format_error; } redshift = lobit( bmpinfo.RedMask ); greenshift = lobit( bmpinfo.GreenMask ); blueshift = lobit( bmpinfo.BlueMask ); for( y = 0; y < bmpinfo.h; y++ ) { realheight = y + 1; bmp_pad_reset(); for( x = 0; x < bmpinfo.w; x++ ) { TRY_EOF( bmp_readint( f, bmpinfo.bits / 8, &c ) ); c = ( ( c & bmpinfo.RedMask ) >> redshift ) + ( ( c & bmpinfo.GreenMask ) >> greenshift ) + ( ( c & bmpinfo.BlueMask ) >> blueshift ); BM_UPUT( bm, x, y, c > 3 * threshold * 255 ? 0 : 1 ); } TRY( bmp_pad( f ) ); } break; case 0x204: /* 4-bit runlength compressed encoding (RLE4) */ x = 0; y = 0; while( 1 ) { TRY_EOF( bmp_readint( f, 1, &b ) ); /* opcode */ TRY_EOF( bmp_readint( f, 1, &c ) ); /* argument */ if( b > 0 ) { /* repeat count */ col[0] = COLTABLE( ( c >> 4 ) & 0xf ); col[1] = COLTABLE( c & 0xf ); for( i = 0; i < b && x < bmpinfo.w; i++ ) { if( x >= bmpinfo.w ) { x = 0; y++; } if( x >= bmpinfo.w || y >= bmpinfo.h ) { break; } realheight = y + 1; BM_PUT( bm, x, y, col[i & 1] ); x++; } } else if( c == 0 ) { /* end of line */ y++; x = 0; } else if( c == 1 ) { /* end of bitmap */ break; } else if( c == 2 ) { /* "delta": skip pixels in x and y directions */ TRY_EOF( bmp_readint( f, 1, &b ) ); /* x offset */ TRY_EOF( bmp_readint( f, 1, &c ) ); /* y offset */ x += b; y += c; } else { /* verbatim segment */ for( i = 0; i < c; i++ ) { if( ( i & 1 ) == 0 ) { TRY_EOF( bmp_readint( f, 1, &b ) ); } if( x >= bmpinfo.w ) { x = 0; y++; } if( x >= bmpinfo.w || y >= bmpinfo.h ) { break; } realheight = y + 1; BM_PUT( bm, x, y, COLTABLE( ( b >> ( 4 - 4 * ( i & 1 ) ) ) & 0xf ) ); x++; } if( ( c + 1 ) & 2 ) { /* pad to 16-bit boundary */ TRY_EOF( bmp_readint( f, 1, &b ) ); } } } break; case 0x108: /* 8-bit runlength compressed encoding (RLE8) */ x = 0; y = 0; while( 1 ) { TRY_EOF( bmp_readint( f, 1, &b ) ); /* opcode */ TRY_EOF( bmp_readint( f, 1, &c ) ); /* argument */ if( b > 0 ) { /* repeat count */ for( i = 0; i < b; i++ ) { if( x >= bmpinfo.w ) { x = 0; y++; } if( x >= bmpinfo.w || y >= bmpinfo.h ) { break; } realheight = y + 1; BM_PUT( bm, x, y, COLTABLE( c ) ); x++; } } else if( c == 0 ) { /* end of line */ y++; x = 0; } else if( c == 1 ) { /* end of bitmap */ break; } else if( c == 2 ) { /* "delta": skip pixels in x and y directions */ TRY_EOF( bmp_readint( f, 1, &b ) ); /* x offset */ TRY_EOF( bmp_readint( f, 1, &c ) ); /* y offset */ x += b; y += c; } else { /* verbatim segment */ for( i = 0; i < c; i++ ) { TRY_EOF( bmp_readint( f, 1, &b ) ); if( x >= bmpinfo.w ) { x = 0; y++; } if( x >= bmpinfo.w || y >= bmpinfo.h ) { break; } realheight = y + 1; BM_PUT( bm, x, y, COLTABLE( b ) ); x++; } if( c & 1 ) { /* pad input to 16-bit boundary */ TRY_EOF( bmp_readint( f, 1, &b ) ); } } } break; } /* switch */ /* skip any potential junk after the data section, but don't * complain in case EOF is encountered */ bmp_forward( f, bmpinfo.FileSize ); free( coltable ); if( bmpinfo.topdown ) { bm_flip( bm ); } *bmp = bm; return 0; eof: TRY_STD( bm_resize( bm, realheight ) ); free( coltable ); if( bmpinfo.topdown ) { bm_flip( bm ); } *bmp = bm; return 1; format_error: try_error: free( coltable ); bm_free( bm ); if( !bm_read_error ) { bm_read_error = "invalid bmp file"; } return -2; std_error: free( coltable ); bm_free( bm ); return -1; } /* ---------------------------------------------------------------------- */ /* output pbm format */ void bm_writepbm( FILE* f, potrace_bitmap_t* bm ) { int w, h, bpr, y, i, c; w = bm->w; h = bm->h; bpr = ( w + 7 ) / 8; fprintf( f, "P4\n%d %d\n", w, h ); for( y = h - 1; y >= 0; y-- ) { for( i = 0; i < bpr; i++ ) { c = ( *bm_index( bm, i * 8, y ) >> ( 8 * ( BM_WORDSIZE - 1 - ( i % BM_WORDSIZE ) ) ) ) & 0xff; fputc( c, f ); } } } /* ---------------------------------------------------------------------- */ /* output - for primitive debugging purposes only! */ /* print bitmap to screen */ int bm_print( FILE* f, potrace_bitmap_t* bm ) { int x, y; int xx, yy; int d; int sw, sh; sw = bm->w < 79 ? bm->w : 79; sh = bm->w < 79 ? bm->h : bm->h * sw * 44 / ( 79 * bm->w ); for( yy = sh - 1; yy >= 0; yy-- ) { for( xx = 0; xx < sw; xx++ ) { d = 0; for( x = xx * bm->w / sw; x < ( xx + 1 ) * bm->w / sw; x++ ) { for( y = yy * bm->h / sh; y < ( yy + 1 ) * bm->h / sh; y++ ) { if( BM_GET( bm, x, y ) ) { d++; } } } fputc( d ? '*' : ' ', f ); } fputc( '\n', f ); } return 0; }