/* pnmpaste.c - paste a rectangle into a PNM image
**
** Copyright (C) 1989 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.
*/
#include <assert.h>
#include "pm_c_util.h"
#include "mallocvar.h"
#include "nstring.h"
#include "shhopt.h"
#include "pnm.h"
enum boolOp {REPLACE, AND, OR, XOR /*, NAND, NOR, NXOR */ };
struct CmdlineInfo {
/* All the information the user supplied in the command line,
in a form easy for the program to use.
*/
const char * baseFilename;
const char * insetFilename;
int insertCol; /* Negative means from right edge */
int insertRow; /* Negative means from bottom edge */
enum boolOp operation;
};
static void
parseCommandLine(int argc, const char ** argv,
struct CmdlineInfo * const cmdlineP) {
/*----------------------------------------------------------------------------
Note that the file spec array we return is stored in the storage that
was passed to us as the argv array.
-----------------------------------------------------------------------------*/
optEntry *option_def;
/* Instructions to OptParseOptions3 on how to parse our options.
*/
optStruct3 opt;
unsigned int option_def_index;
unsigned int replaceOpt, andOpt, orOpt, xorOpt;
MALLOCARRAY_NOFAIL(option_def, 100);
option_def_index = 0; /* incremented by OPTENT3 */
OPTENT3(0, "replace", OPT_FLAG, NULL,
&replaceOpt, 0);
OPTENT3(0, "and", OPT_FLAG, NULL,
&andOpt, 0);
OPTENT3(0, "or", OPT_FLAG, NULL,
&orOpt, 0);
OPTENT3(0, "xor", OPT_FLAG, NULL,
&xorOpt, 0);
opt.opt_table = option_def;
opt.short_allowed = FALSE; /* We have no short (old-fashioned) options */
opt.allowNegNum = TRUE; /* We have parms that are negative numbers */
pm_optParseOptions3(&argc, (char **)argv, opt, sizeof opt, 0);
/* Uses and sets argc, argv, and some of *cmdlineP and others. */
if (replaceOpt + andOpt + orOpt + xorOpt > 1)
pm_error("You may specify only one of -replace, -and, -or, and -xor");
cmdlineP->operation =
replaceOpt ? REPLACE :
andOpt ? AND :
orOpt ? OR :
xorOpt ? XOR :
replaceOpt;
if (argc-1 >= 3) {
cmdlineP->insetFilename = argv[1];
cmdlineP->insertCol = atoi(argv[2]);
cmdlineP->insertRow = atoi(argv[3]);
if (argc-1 >= 4) {
cmdlineP->baseFilename = argv[4];
if (argc-1 > 4)
pm_error("Too many arguments: %u. This program takes "
"at most 4", argc-1);
} else
cmdlineP->baseFilename = "-";
} else
pm_error("You must specify at least 3 arguments: \"from\" file "
"name, insert-at column, and insert-at row. "
"You specified %u", argc-1);
if (streq(cmdlineP->baseFilename, "-") &&
streq(cmdlineP->insetFilename, "-"))
pm_error("You can't use Standard Input for both the input images");
}
static unsigned char
leftBits(unsigned char const x,
unsigned int const n){
/*----------------------------------------------------------------------------
'x' with the leftmost (high) n bits retained and the rest cleared to zero.
-----------------------------------------------------------------------------*/
assert(n <= 8);
return (x >> (8-n)) << (8-n);
}
static unsigned char
rightBits(unsigned char const x,
unsigned int const n){
/*----------------------------------------------------------------------------
The rightmost 'n' bits of 'x'.
-----------------------------------------------------------------------------*/
assert(n <= 8);
return ((unsigned char)(x << (8-n))) >> (8-n);
}
static void
insertDirect(FILE * const ifP,
unsigned char * const destrow,
unsigned int const cols,
int const format,
enum boolOp const operation,
unsigned char * const buffer) {
/*----------------------------------------------------------------------------
Read the next row from PBM file 'ifP' and merge it according to
'operation' into 'destrow', flush left in packed PBM format.
'cols' and 'format' describe the 'ifP' image.
'buffer' is a scratch buffer for our use, at least wide enough to hold
a packed PBM row of 'ifP'.
-----------------------------------------------------------------------------*/
/* We use pbm_readpbmrow_packed() to read whole bytes rounded up and merge
those into 'destrow', which means we update more than we're supposed to
if the image is not a multiple of 8 columns. In that case, we then fix
up the last byte by replacing the bits from the original image that we
messed up.
*/
unsigned int const colBytes = pbm_packed_bytes(cols);
unsigned int const last = colBytes - 1;
unsigned char const origRight = destrow[last];
if (operation == REPLACE)
pbm_readpbmrow_packed(ifP, destrow, cols, format);
else {
unsigned int i;
pbm_readpbmrow_packed(ifP, buffer, cols, format);
for (i = 0; i < colBytes; ++i) {
switch (operation) {
case AND: destrow[i] |= buffer[i]; break;
case OR : destrow[i] &= buffer[i]; break;
case XOR: destrow[i] = ~( destrow[i] ^ buffer[i] ) ; break;
/*
case NAND: destrow[i] = ~( destrow[i] | buffer[i] ) ; break;
case NOR : destrow[i] = ~( destrow[i] & buffer[i] ) ; break;
case NXOR: destrow[i] ^= buffer[i] ; break;
*/
case REPLACE: assert(false); break;
}
}
}
/* destrow[] now contains garbage in all but the cols % 8 leftmost bits of
the last byte we touched. Those are supposed to be unchanged from the
input, so we restore them now.
*/
if (cols % 8 > 0)
destrow[last] = leftBits(destrow[last], cols % 8)
| rightBits(origRight, 8 - cols % 8);
}
static void
insertShift(FILE * const ifP,
unsigned char * const destrow,
unsigned int const cols,
unsigned int const format,
unsigned int const offset,
enum boolOp const operation,
unsigned char * const buffer) {
/*----------------------------------------------------------------------------
Same as insertDirect(), but start merging 'offset' bits from the left
end of 'destrow'. 'offset' is less than 8.
buffer[] is wide enough to hold a packed PBM row of *ifP plus two
bytes of margin.
-----------------------------------------------------------------------------*/
unsigned int const shiftByteCt = pbm_packed_bytes(cols + offset);
unsigned int const last = shiftByteCt - 1;
unsigned char const origLeft = destrow[0];
unsigned char const origRight = destrow[last];
unsigned int const padOffset = (cols + offset) % 8;
unsigned int i;
assert(offset < 8);
pbm_readpbmrow_packed(ifP, &buffer[1], cols, format);
/* Note that buffer[0] is undefined. */
for (i = 0; i < shiftByteCt; ++i) {
unsigned int const rsh = offset;
unsigned int const lsh = 8-rsh;
unsigned char const t = buffer[i] << lsh | buffer[i+1] >> rsh;
switch (operation) {
case REPLACE: destrow[i] = t; break;
case AND: destrow[i] |= t; break;
case OR : destrow[i] &= t; break;
case XOR: destrow[i] = ~ (destrow[i] ^ t); break;
/*
case NAND: destrow[i] = ~ (destrow[i] | t); break;
case NOR : destrow[i] = ~ (destrow[i] & t); break;
case NXOR: destrow[i] ^= t; break;
*/
}
}
/* destrow[] now contains garbage in the 'offset' leftmost bits and
8-offset rightmost bits of the last byte we touched. Those are
supposed to be unchanged from the input, so we restore them now.
*/
destrow[0] = leftBits(origLeft, offset) |
rightBits(destrow[0], 8-offset);
if (padOffset % 8 > 0)
destrow[last] = leftBits(destrow[last], padOffset) |
rightBits(origRight , 8-padOffset);
}
static void
pastePbm(FILE * const fpInset,
FILE * const fpBase,
int const insetFormat,
int const baseFormat,
unsigned int const insetRows,
unsigned int const baseRows,
unsigned int const insetCols,
unsigned int const baseCols,
unsigned int const insertCol,
unsigned int const insertRow,
enum boolOp const operation) {
/*----------------------------------------------------------------------------
Fast paste for PBM
-----------------------------------------------------------------------------*/
unsigned char * const baserow = pbm_allocrow_packed(baseCols);
unsigned char * const buffer = pbm_allocrow_packed(insetCols+16);
unsigned int const shiftByteCt = insertCol / 8;
unsigned int const shiftOffset = insertCol % 8;
unsigned int const baseColByteCt = pbm_packed_bytes(baseCols);
unsigned int row;
pbm_writepbminit(stdout, baseCols, baseRows, 0);
for (row = 0; row < baseRows; ++row) {
pbm_readpbmrow_packed(fpBase, baserow, baseCols, baseFormat);
if (row >= insertRow && row < insertRow + insetRows) {
if (shiftOffset == 0)
insertDirect(fpInset, &baserow[shiftByteCt], insetCols,
insetFormat, operation, buffer);
else
insertShift(fpInset, &baserow[shiftByteCt], insetCols,
insetFormat, shiftOffset, operation, buffer);
}
if (baseCols % 8 > 0)
baserow[baseColByteCt-1]
= leftBits(baserow[baseColByteCt-1] , baseCols % 8);
pbm_writepbmrow_packed(stdout, baserow, baseCols, 0);
}
pbm_freerow_packed(buffer);
pbm_freerow_packed(baserow);
}
static void
pasteNonPbm(FILE * const fpInset,
FILE * const fpBase,
int const formatInset,
int const formatBase,
int const newformat,
xelval const maxvalInset,
xelval const maxvalBase,
unsigned int const rowsInset,
unsigned int const rowsBase,
unsigned int const colsInset,
unsigned int const colsBase,
unsigned int const insertCol,
unsigned int const insertRow) {
/* Logic works for PBM, but cannot do bitwise operations */
xelval const newmaxval = MAX(maxvalInset, maxvalBase);
xel * const xelrowInset = pnm_allocrow(colsInset);
xel * const xelrowBase = pnm_allocrow(colsBase);
unsigned int row;
pnm_writepnminit(stdout, colsBase, rowsBase, newmaxval, newformat, 0);
for (row = 0; row < rowsBase; ++row) {
pnm_readpnmrow(fpBase, xelrowBase, colsBase, maxvalBase, formatBase);
pnm_promoteformatrow(xelrowBase, colsBase, maxvalBase, formatBase,
newmaxval, newformat);
if (row >= insertRow && row < insertRow + rowsInset) {
unsigned int colInset;
pnm_readpnmrow(fpInset, xelrowInset, colsInset, maxvalInset,
formatInset);
pnm_promoteformatrow(xelrowInset, colsInset, maxvalInset,
formatInset, newmaxval, newformat );
for (colInset = 0; colInset < colsInset; ++colInset)
xelrowBase[insertCol + colInset] = xelrowInset[colInset];
}
pnm_writepnmrow(stdout, xelrowBase, colsBase, newmaxval, newformat, 0);
}
pnm_freerow(xelrowBase);
pnm_freerow(xelrowInset);
}
int
main(int argc, const char ** argv) {
struct CmdlineInfo cmdline;
FILE * fpInset;
FILE * fpBase;
xelval maxvalInset, maxvalBase;
int rowsInset, colsInset;
int formatInset;
int rowsBase, colsBase;
int formatBase;
int newformat;
unsigned int insertRow, insertCol;
pm_proginit(&argc, argv);
parseCommandLine(argc, argv, &cmdline);
fpInset = pm_openr(cmdline.insetFilename);
fpBase = pm_openr(cmdline.baseFilename);
pnm_readpnminit(fpInset, &colsInset, &rowsInset,
&maxvalInset, &formatInset);
pnm_readpnminit(fpBase, &colsBase, &rowsBase, &maxvalBase, &formatBase);
if (colsBase < colsInset)
pm_error(
"Image to paste is wider than base image by %u cols",
colsInset - colsBase);
else if (cmdline.insertCol <= -colsBase)
pm_error(
"x is too negative -- the second image has only %u cols",
colsBase);
else if (cmdline.insertCol >= colsBase)
pm_error(
"x is too large -- the second image has only %u cols",
colsBase);
if (rowsBase < rowsInset)
pm_error(
"Image to paste is taller than base image by %u rows",
rowsInset - rowsBase);
else if (cmdline.insertRow <= -rowsBase)
pm_error(
"y is too negative -- the second image has only %u rows",
rowsBase);
else if (cmdline.insertRow >= rowsBase)
pm_error(
"y is too large -- the second image has only %d rows",
rowsBase);
insertCol = cmdline.insertCol < 0 ?
colsBase + cmdline.insertCol : cmdline.insertCol;
insertRow = cmdline.insertRow < 0 ?
rowsBase + cmdline.insertRow : cmdline.insertRow;
if (insertCol + colsInset > colsBase)
pm_error("Extends over right edge by %u pixels",
(insertCol + colsInset) - colsBase);
if (insertRow + rowsInset > rowsBase)
pm_error("Extends over bottom edge by %u pixels",
(insertRow + rowsInset) - rowsBase);
newformat = MAX(PNM_FORMAT_TYPE(formatInset), PNM_FORMAT_TYPE(formatBase));
if (cmdline.operation != REPLACE && newformat != PBM_TYPE)
pm_error("no logical operations allowed for a non-PBM image");
if (newformat == PBM_TYPE)
pastePbm(fpInset, fpBase, formatInset, formatBase,
rowsInset, rowsBase, colsInset, colsBase,
insertCol, insertRow, cmdline.operation);
else
pasteNonPbm(fpInset, fpBase,
formatInset, formatBase, newformat,
maxvalInset, maxvalBase,
rowsInset, rowsBase, colsInset, colsBase,
insertCol, insertRow);
pm_close(fpInset);
pm_close(fpBase);
pm_close(stdout);
return 0;
}