koreader/k2pdfopt.c

/*
 ** k2pdfopt.c   K2pdfopt optimizes PDF/DJVU files for mobile e-readers
 **              (e.g. the Kindle) and smartphones. It works well on
 **              multi-column PDF/DJVU files. K2pdfopt is freeware.
 **
 ** Copyright (C) 2012  http://willus.com
 **
 ** This program is free software: you can redistribute it and/or modify
 ** it under the terms of the GNU Affero General Public License as
 ** published by the Free Software Foundation, either version 3 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 Affero General Public License for more details.
 **
 ** You should have received a copy of the GNU Affero General Public License
 ** along with this program.  If not, see <http://www.gnu.org/licenses/>.
 **
 /*
 ** WILLUSDEBUGX flags:
 ** 1 = Generic
 ** 2 = breakinfo row analysis
 ** 4 = word wrapping
 ** 8 = word wrapping II
 ** 16 = hyphens
 ** 32 = OCR
 **
 */
// #define WILLUSDEBUGX 32
// #define WILLUSDEBUG
#include <stdio.h>
#include <stdlib.h>
#include <stdarg.h>
#include <string.h>
#include <ctype.h>
#include <math.h>
#include "k2pdfopt.h"

#define HAVE_MUPDF

#define VERSION "v1.51"
#define GRAYLEVEL(r,g,b) ((int)(((r)*0.3+(g)*0.59+(b)*0.11)*1.002))
#if (defined(WIN32) || defined(WIN64))
#define TTEXT_BOLD    ANSI_WHITE
#define TTEXT_NORMAL  ANSI_NORMAL
#define TTEXT_BOLD2   ANSI_YELLOW
#define TTEXT_INPUT   ANSI_GREEN
#define TTEXT_WARN    ANSI_RED
#define TTEXT_HEADER  ANSI_CYAN
#define TTEXT_MAGENTA ANSI_MAGENTA
#else
#define TTEXT_BOLD    "\x1b[0m\x1b[34m"
#define TTEXT_NORMAL  "\x1b[0m"
#define TTEXT_BOLD2   "\x1b[0m\x1b[33m"
#define TTEXT_INPUT   "\x1b[0m\x1b[32m"
#define TTEXT_WARN    "\x1b[0m\x1b[31m"
#define TTEXT_HEADER  "\x1b[0m\x1b[36m"
#define TTEXT_MAGENTA "\x1b[0m\x1b[35m"
#endif

#ifndef __ANSI_H__
#define ANSI_RED            "\x1b[1m\x1b[31m"
#define ANSI_GREEN          "\x1b[1m\x1b[32m"
#define ANSI_YELLOW         "\x1b[1m\x1b[33m"
#define ANSI_BROWN          "\x1b[0m\x1b[33m"
#define ANSI_BLUE           "\x1b[1m\x1b[34m"
#define ANSI_MAGENTA        "\x1b[1m\x1b[35m"
#define ANSI_CYAN           "\x1b[1m\x1b[36m"
#define ANSI_WHITE          "\x1b[1m\x1b[37m"
#define ANSI_NORMAL         "\x1b[0m\x1b[37m"
#define ANSI_SAVE_CURSOR    "\x1b[s"
#define ANSI_RESTORE_CURSOR "\x1b[u"
#define ANSI_CLEAR_TO_END   "\x1b[K"
#define ANSI_BEGIN_LINE     "\x1b[80D"
#define ANSI_UP_ONE_LINE    "\x1b[1A"
#define ANSI_HOME           "\x1b[2J\x1b[0;0;H"
#define __ANSI_H__
#endif

/* bmp.c */
#define WILLUSBITMAP_TYPE_NATIVE       0
#define WILLUSBITMAP_TYPE_WIN32        1
#define BOUND(x,xmin,xmax)  if ((x)<(xmin)) (x)=(xmin); else { if ((x)>(xmax)) (x)=(xmax); }

#ifdef PI
#undef PI
#endif
/*
 ** Constants from the front of the CRC standard math tables
 ** (Accuracy = 50 digits)
 */
#define PI      3.14159265358979323846264338327950288419716939937511
#define SQRT2   1.41421356237309504880168872420969807856967187537695
#define SQRT3   1.73205080756887729352744634150587236694280525381039
#define LOG10E  0.43429448190325182765112891891660508229439700580367
#define DBPERNEP    (20.*LOG10E)

#define SRC_TYPE_PDF     1
#define SRC_TYPE_DJVU    2
#define SRC_TYPE_OTHER   3

/* DATA STRUCTURES */

typedef struct {
	int page; /* Source page */
	double rot_deg; /* Source rotation (happens first) */
	double x0, y0; /* x0,y0, in points, of lower left point on rectangle */
	double w, h; /* width and height of rectangle in points */
	double scale; /* Scale rectangle by this factor on destination page */
	double x1, y1; /* (x,y) position of lower left point on destination page, in points */
} PDFBOX;

typedef struct {
	PDFBOX *box;
	int n;
	int na;
} PDFBOXES;

typedef struct {
	int pageno; /* Source page number */
	double page_rot_deg; /* Source page rotation */
	PDFBOXES boxes;
} PAGEINFO;

typedef struct {
	int ch; /* Hyphen starting point -- < 0 for no hyphen */
	int c2; /* End of end region if hyphen is erased */
	int r1; /* Top of hyphen */
	int r2; /* Bottom of hyphen */
} HYPHENINFO;

typedef struct {
	int c1, c2; /* Left and right columns */
	int r1, r2; /* Top and bottom of region in pixels */
	int rowbase; /* Baseline of row */
	int gap; /* Gap to next region in pixels */
	int rowheight; /* text + gap */
	int capheight;
	int h5050;
	int lcheight;
	HYPHENINFO hyphen;
} TEXTROW;

typedef struct {
	TEXTROW *textrow;
	int rhmean_pixels; /* Mean row height (text) */
	int centered; /* Is this set of rows centered? */
	int n, na;
} BREAKINFO;

typedef struct {
	int red[256];
	int green[256];
	int blue[256];
	unsigned char *data; /* Top to bottom in native type, bottom to */
	/* top in Win32 type.                      */
	int width; /* Width of image in pixels */
	int height; /* Height of image in pixels */
	int bpp; /* Bits per pixel (only 8 or 24 allowed) */
	int size_allocated;
	int type; /* See defines above for WILLUSBITMAP_TYPE_... */
} WILLUSBITMAP;

typedef struct {
	int r1, r2; /* row position from top of bmp, inclusive */
	int c1, c2; /* column positions, inclusive */
	int rowbase; /* Baseline of text row */
	int capheight; /* capital letter height */
	int h5050;
	int lcheight; /* lower-case letter height */
	int bgcolor; /* 0 - 255 */
	HYPHENINFO hyphen;
	WILLUSBITMAP *bmp;
	WILLUSBITMAP *bmp8;
	WILLUSBITMAP *marked;
} BMPREGION;

typedef struct {
	WILLUSBITMAP bmp;
	int rows;
	int published_pages;
	int bgcolor;
	int fit_to_page;
	int wordcount;
	char debugfolder[256];
} MASTERINFO;

static int verbose = 0;
static int debug = 0;

#define DEFAULT_WIDTH 600
#define DEFAULT_HEIGHT 800
#define MIN_REGION_WIDTH_INCHES 1.0
#define SRCROT_AUTO   -999.
#define SRCROT_AUTOEP -998.

/*
 ** Blank Area Threshold Widths--average black pixel width, in inches, that
 ** prevents a region from being determined as "blank" or clear.
 */
static int src_rot = 0;
static double gtc_in = .005; // detecting gap between columns
static double gtr_in = .006; // detecting gap between rows
static double gtw_in = .0015; // detecting gap between words
// static double gtm_in=.005; // detecting margins for trimming
static int src_left_to_right = 1;
static int src_whitethresh = -1;
static int dst_dpi = 167;
static int fit_columns = 1;
static int src_dpi = 300;
static int dst_width = DEFAULT_WIDTH; /* Full device width in pixels */
static int dst_height = DEFAULT_HEIGHT;
static int dst_userwidth = DEFAULT_WIDTH;
static int dst_userheight = DEFAULT_HEIGHT;
static int dst_justify = -1; // 0 = left, 1 = center
static int dst_figure_justify = -1; // -1 = same as dst_justify.  0=left 1=center 2=right
static double dst_min_figure_height_in = 0.75;
static int dst_fulljustify = -1; // 0 = no, 1 = yes
static int dst_color = 0;
static int dst_landscape = 0;
static int src_autostraighten = 0;
static double dst_mar = 0.06;
static double dst_martop = -1.0;
static double dst_marbot = -1.0;
static double dst_marleft = -1.0;
static double dst_marright = -1.0;
static double min_column_gap_inches = 0.1;
static double max_column_gap_inches = 1.5; // max gap between columns
static double min_column_height_inches = 1.5;
static double mar_top = -1.0;
static double mar_bot = -1.0;
static double mar_left = -1.0;
static double mar_right = -1.0;
static double max_region_width_inches = 3.6; /* Max viewable width (device width minus margins) */
static int max_columns = 2;
static double column_gap_range = 0.33;
static double column_offset_max = 0.2;
static double column_row_gap_height_in = 1. / 72.;
static int text_wrap = 1;
static double word_spacing = 0.375;
static double display_width_inches = 3.6; /* Device width = dst_width / dst_dpi */
static int column_fitted = 0;
static double lm_org, bm_org, tm_org, rm_org, dpi_org;
static double contrast_max = 2.0;
static int show_marked_source = 0;
static double defect_size_pts = 1.0;
static double max_vertical_gap_inches = 0.25;
static double vertical_multiplier = 1.0;
static double vertical_line_spacing = -1.2;
static double vertical_break_threshold = 1.75;
static int erase_vertical_lines = 0;
static int k2_hyphen_detect = 1;
static int dst_fit_to_page = 0;
/*
 ** Undocumented cmd-line args
 */
static double no_wrap_ar_limit = 0.2; /* -arlim */
static double no_wrap_height_limit_inches = 0.55; /* -whmax */
static double little_piece_threshold_inches = 0.5; /* -rwmin */
/*
 ** Keeping track of vertical gaps
 */
static double last_scale_factor_internal = -1.0;
/* indicates desired vert. gap before next region is added. */
static int last_rowbase_internal; /* Pixels between last text row baseline and current end */
/* of destination bitmap. */
static int beginning_gap_internal = -1;
static int last_h5050_internal = -1;
static int just_flushed_internal = 0;
static int gap_override_internal; /* If > 0, apply this gap in wrapbmp_flush() and then reset. */

void adjust_params_init(void);
void set_region_widths(void);
static void mark_source_page(BMPREGION *region, int caller_id, int mark_flags);
static void fit_column_to_screen(double column_width_inches);
static void restore_output_dpi(void);
void adjust_contrast(WILLUSBITMAP *src, WILLUSBITMAP *srcgrey, int *white);
static int bmpregion_row_black_count(BMPREGION *region, int r0);
static void bmpregion_row_histogram(BMPREGION *region);
static int bmpregion_find_multicolumn_divider(BMPREGION *region,
		int *row_black_count, BMPREGION *pageregion, int *npr, int *colcount,
		int *rowcount);
static int bmpregion_column_height_and_gap_test(BMPREGION *column,
		BMPREGION *region, int r1, int r2, int cmid, int *colcount,
		int *rowcount);
static int bmpregion_is_clear(BMPREGION *region, int *row_is_clear,
		double gt_in);
void bmpregion_multicolumn_add(BMPREGION *region, MASTERINFO *masterinfo,
		int level, PAGEINFO *pageinfo, int colgap0_pixels);
static void bmpregion_vertically_break(BMPREGION *region,
		MASTERINFO *masterinfo, int allow_text_wrapping, double force_scale,
		int *colcount, int *rowcount, PAGEINFO *pageinfo, int colgap_pixels,
		int ncols);
static void bmpregion_add(BMPREGION *region, BREAKINFO *breakinfo,
		MASTERINFO *masterinfo, int allow_text_wrapping, int trim_flags,
		int allow_vertical_breaks, double force_scale, int justify_flags,
		int caller_id, int *colcount, int *rowcount, PAGEINFO *pageinfo,
		int mark_flags, int rowbase_delta);
static void dst_add_gap_src_pixels(char *caller, MASTERINFO *masterinfo,
		int pixels);
static void dst_add_gap(MASTERINFO *masterinfo, double inches);
static void bmp_src_to_dst(MASTERINFO *masterinfo, WILLUSBITMAP *src,
		int justification_flags, int whitethresh, int nocr, int dpi);
static void bmp_fully_justify(WILLUSBITMAP *jbmp, WILLUSBITMAP *src, int nocr,
		int whitethresh, int just);
#ifdef HAVE_OCR
static void ocrwords_fill_in(OCRWORDS *words,WILLUSBITMAP *src,int whitethresh,int dpi);
#endif
static void bmpregion_trim_margins(BMPREGION *region, int *colcount0,
		int *rowcount0, int flags);
static void bmpregion_hyphen_detect(BMPREGION *region);
#if (WILLUSDEBUGX & 6)
static void breakinfo_echo(BREAKINFO *bi);
#endif
#if (defined(WILLUSDEBUGX) || defined(WILLUSDEBUG))
static void bmpregion_write(BMPREGION *region,char *filename);
#endif
static int height2_calc(int *rc, int n);
static void trim_to(int *count, int *i1, int i2, double gaplen);
static void bmpregion_analyze_justification_and_line_spacing(BMPREGION *region,
		BREAKINFO *breakinfo, MASTERINFO *masterinfo, int *colcount,
		int *rowcount, PAGEINFO *pageinfo, int allow_text_wrapping,
		double force_scale);
static int bmpregion_is_centered(BMPREGION *region, BREAKINFO *breakinfo,
		int i1, int i2, int *textheight);
static double median_val(double *x, int n);
static void bmpregion_find_vertical_breaks(BMPREGION *region,
		BREAKINFO *breakinfo, int *colcount, int *rowcount, double apsize_in);
static void textrow_assign_bmpregion(TEXTROW *textrow, BMPREGION *region);
static void breakinfo_compute_row_gaps(BREAKINFO *breakinfo, int r2);
static void breakinfo_compute_col_gaps(BREAKINFO *breakinfo, int c2);
static void breakinfo_remove_small_col_gaps(BREAKINFO *breakinfo, int lcheight,
		double mingap);
static void breakinfo_remove_small_rows(BREAKINFO *breakinfo, double fracrh,
		double fracgap, BMPREGION *region, int *colcount, int *rowcount);
static void breakinfo_alloc(int index, BREAKINFO *breakinfo, int nrows);
static void breakinfo_free(int index, BREAKINFO *breakinfo);
static void breakinfo_sort_by_gap(BREAKINFO *breakinfo);
static void breakinfo_sort_by_row_position(BREAKINFO *breakinfo);
static void bmpregion_one_row_find_breaks(BMPREGION *region,
		BREAKINFO *breakinfo, int *colcount, int *rowcount, int add_to_dbase);
void wrapbmp_init(void);
static int wrapbmp_ends_in_hyphen(void);
static void wrapbmp_set_color(int is_color);
static void wrapbmp_free(void);
static void wrapbmp_set_maxgap(int value);
static int wrapbmp_width(void);
static int wrapbmp_remaining(void);
static void wrapbmp_add(BMPREGION *region, int gap, int line_spacing, int rbase,
		int gio, int justification_flags);
static void wrapbmp_flush(MASTERINFO *masterinfo, int allow_full_justify,
		PAGEINFO *pageinfo, int use_bgi);
static void wrapbmp_hyphen_erase(void);
static void bmpregion_one_row_wrap_and_add(BMPREGION *region,
		BREAKINFO *breakinfo, int index, int i0, int i1, MASTERINFO *masterinfo,
		int justflags, int *colcount, int *rowcount, PAGEINFO *pageinfo,
		int rheight, int mean_row_gap, int rowbase, int marking_flags, int pi);
static void white_margins(WILLUSBITMAP *src, WILLUSBITMAP *srcgrey);
static void get_white_margins(BMPREGION *region);
/* Bitmap orientation detection functions */
static double bitmap_orientation(WILLUSBITMAP *bmp);
static double bmp_inflections_vertical(WILLUSBITMAP *srcgrey, int ndivisions,
		int delta, int *wthresh);
static double bmp_inflections_horizontal(WILLUSBITMAP *srcgrey, int ndivisions,
		int delta, int *wthresh);
static int inflection_count(double *x, int n, int delta, int *wthresh);
static void pdfboxes_init(PDFBOXES *boxes);
static void pdfboxes_free(PDFBOXES *boxes);
/*
 static void pdfboxes_add_box(PDFBOXES *boxes,PDFBOX *box);
 static void pdfboxes_delete(PDFBOXES *boxes,int n);
 */
static void word_gaps_add(BREAKINFO *breakinfo, int lcheight,
		double *median_gap);
static void bmp_detect_vertical_lines(WILLUSBITMAP *bmp, WILLUSBITMAP *cbmp,
		double dpi, double minwidth_in, double maxwidth_in, double minheight_in,
		double anglemax_deg, int white_thresh);
static int vert_line_erase(WILLUSBITMAP *bmp, WILLUSBITMAP *cbmp,
		WILLUSBITMAP *tmp, int row0, int col0, double tanthx,
		double minheight_in, double minwidth_in, double maxwidth_in,
		int white_thresh);
static void willus_dmem_alloc_warn(int index, void **ptr, int size,
		char *funcname, int exitcode);
static void willus_dmem_free(int index, double **ptr, char *funcname);
static int willus_mem_alloc_warn(void **ptr, int size, char *name, int exitcode);
static void willus_mem_free(double **ptr, char *name);
static void sortd(double *x, int n);
static void sorti(int *x, int n);
static void bmp_init(WILLUSBITMAP *bmap);
static int bmp_alloc(WILLUSBITMAP *bmap);
static void bmp_free(WILLUSBITMAP *bmap);
static int bmp_copy(WILLUSBITMAP *dest, WILLUSBITMAP *src);
static void bmp_fill(WILLUSBITMAP *bmp,int r,int g,int b);
static int bmp_bytewidth(WILLUSBITMAP *bmp);
static unsigned char *bmp_rowptr_from_top(WILLUSBITMAP *bmp, int row);
static void bmp_more_rows(WILLUSBITMAP *bmp, double ratio, int pixval);
static int bmp_is_grayscale(WILLUSBITMAP *bmp);
static int bmp_resample(WILLUSBITMAP *dest, WILLUSBITMAP *src, double x1,
		double y1, double x2, double y2, int newwidth, int newheight);
static void bmp_contrast_adjust(WILLUSBITMAP *dest,WILLUSBITMAP *src,double contrast);
static void bmp_convert_to_greyscale_ex(WILLUSBITMAP *dst, WILLUSBITMAP *src);
static double bmp_autostraighten(WILLUSBITMAP *src, WILLUSBITMAP *srcgrey, int white,
		double maxdegrees, double mindegrees, int debug);
static int bmp_rotate_right_angle(WILLUSBITMAP *bmp, int degrees);
static int bmpmupdf_pixmap_to_bmp(WILLUSBITMAP *bmp, fz_context *ctx,
		fz_pixmap *pixmap);
static void handle(int wait, ddjvu_context_t *ctx);

static MASTERINFO _masterinfo, *masterinfo;
static int master_bmp_inited = 0;
static int master_bmp_width = 0;
static int master_bmp_height = 0;
static int max_page_width_pix = 3000;
static int max_page_height_pix = 4000;
static double shrink_factor = 0.9;
static double zoom_value = 1.0;
static double gamma_correction = 1.0;

static void k2pdfopt_reflow_bmp(MASTERINFO *masterinfo, WILLUSBITMAP *src) {
	PAGEINFO _pageinfo, *pageinfo;
	WILLUSBITMAP _srcgrey, *srcgrey;
	int i, white, dpi;
	double area_ratio;

	masterinfo->debugfolder[0] = '\0';
	white = src_whitethresh; /* Will be set by adjust_contrast() or set to src_whitethresh */
	dpi = src_dpi;
	adjust_params_init();
	set_region_widths();

	srcgrey = &_srcgrey;
	if (master_bmp_inited == 0) {
		bmp_init(&masterinfo->bmp);
		master_bmp_inited = 1;
	}

	bmp_free(&masterinfo->bmp);
	bmp_init(&masterinfo->bmp);
	bmp_init(srcgrey);

	wrapbmp_init();

	int ii;
	masterinfo->bmp.bpp = 8;
	for (ii = 0; ii < 256; ii++)
		masterinfo->bmp.red[ii] = masterinfo->bmp.blue[ii] =
				masterinfo->bmp.green[ii] = ii;
	masterinfo->rows = 0;
	masterinfo->bmp.width = dst_width;
	area_ratio = 8.5 * 11.0 * dst_dpi * dst_dpi / (dst_width * dst_height);
	masterinfo->bmp.height = dst_height * area_ratio * 1.5;
	bmp_alloc(&masterinfo->bmp);
	bmp_fill(&masterinfo->bmp, 255, 255, 255);

	if (src_rot != 0) {
		bmp_rotate_right_angle(src, src_rot);
	}

	BMPREGION region;
	bmp_copy(srcgrey, src);
	adjust_contrast(src, srcgrey, &white);
	white_margins(src, srcgrey);

	if (erase_vertical_lines > 0)
		bmp_detect_vertical_lines(srcgrey, src, (double) src_dpi, 0.005, 0.25,
				min_column_height_inches, src_autostraighten, white);
	if (src_autostraighten > 0.) {
		double rot;
		rot = bmp_autostraighten(src, srcgrey, white, src_autostraighten, 0.1, debug);
		pageinfo->page_rot_deg += rot;
	}

	region.r1 = 0;
	region.r2 = srcgrey->height - 1;
	region.c1 = 0;
	region.c2 = srcgrey->width - 1;
	region.bgcolor = white;
	region.bmp = src;
	region.bmp8 = srcgrey;

	masterinfo->bgcolor = white;
	masterinfo->fit_to_page = dst_fit_to_page;
	/* Check to see if master bitmap might need more room */
	bmpregion_multicolumn_add(&region, masterinfo, 1, pageinfo, (int) (0.25 * src_dpi + .5));

	master_bmp_width = masterinfo->bmp.width;
	master_bmp_height = masterinfo->rows;

	bmp_free(srcgrey);
}

void k2pdfopt_set_params(int bb_width, int bb_height, \
		double font_size, double page_margin, \
		double line_space, double word_space, \
		int wrapping, int straighten, int justification, \
		int columns, double contrast, int rotation) {
	dst_userwidth  = bb_width; // dst_width is adjusted in adjust_params_init
	dst_userheight = bb_height;
	zoom_value = font_size;
	vertical_line_spacing = line_space;
	word_spacing = word_space;
	text_wrap = wrapping;
	src_autostraighten = straighten;
	max_columns = columns;
	gamma_correction = contrast;  // contrast is only used by k2pdfopt_mupdf_reflow
	src_rot = rotation;

	// margin
	dst_mar = page_margin;
	dst_martop = -1.0;
	dst_marbot = -1.0;
	dst_marleft = -1.0;
	dst_marright = -1.0;

	// justification
	if (justification < 0) {
		dst_justify = -1;
		dst_fulljustify = -1;
	}
	else if (justification <= 2) {
		dst_justify = justification;
		dst_fulljustify = 0;
	}
	else {
		dst_justify = -1;
		dst_fulljustify = 1;
	}
}

void k2pdfopt_mupdf_reflow(fz_document *doc, fz_page *page, fz_context *ctx) {
	fz_device *dev;
	fz_pixmap *pix;
	fz_rect bounds,bounds2;
	fz_matrix ctm;
	fz_bbox bbox;
	WILLUSBITMAP _src, *src;

	double dpp,zoom;
	zoom = zoom_value;
	double dpi = 250*zoom;
	do {
		dpp = dpi / 72.;
		pix = NULL;
		fz_var(pix);
		bounds = fz_bound_page(doc, page);
		ctm = fz_scale(dpp, dpp);
		//    ctm=fz_concat(ctm,fz_rotate(rotation));
		bounds2 = fz_transform_rect(ctm, bounds);
		bbox = fz_round_rect(bounds2);
		printf("reading page:%d,%d,%d,%d zoom:%.2f dpi:%.0f\n",bbox.x0,bbox.y0,bbox.x1,bbox.y1,zoom,dpi);
		zoom_value = zoom;
		zoom *= shrink_factor;
		dpi *= shrink_factor;
	} while (bbox.x1 > max_page_width_pix | bbox.y1 > max_page_height_pix);
	//    ctm=fz_translate(0,-page->mediabox.y1);
	//    ctm=fz_concat(ctm,fz_scale(dpp,-dpp));
	//    ctm=fz_concat(ctm,fz_rotate(page->rotate));
	//    ctm=fz_concat(ctm,fz_rotate(0));
	//    bbox=fz_round_rect(fz_transform_rect(ctm,page->mediabox));
	//    pix=fz_new_pixmap_with_rect(colorspace,bbox);
	pix = fz_new_pixmap_with_bbox(ctx, fz_device_gray, bbox);
	fz_clear_pixmap_with_value(ctx, pix, 0xff);
	dev = fz_new_draw_device(ctx, pix);
#ifdef MUPDF_TRACE
	fz_device *tdev;
	fz_try(ctx) {
		tdev = fz_new_trace_device(ctx);
		fz_run_page(doc, page, tdev, ctm, NULL);
	}
	fz_always(ctx) {
		fz_free_device(tdev);
	}
#endif
	fz_run_page(doc, page, dev, ctm, NULL);
	fz_free_device(dev);

	if(gamma_correction >= 0.0) {
		fz_gamma_pixmap(ctx, pix, gamma_correction);
	}

	src = &_src;
	masterinfo = &_masterinfo;
	bmp_init(src);
	int status = bmpmupdf_pixmap_to_bmp(src, ctx, pix);
	k2pdfopt_reflow_bmp(masterinfo, src);
	bmp_free(src);

	fz_drop_pixmap(ctx, pix);
}

void k2pdfopt_djvu_reflow(ddjvu_page_t *page, ddjvu_context_t *ctx, \
		ddjvu_render_mode_t mode, ddjvu_format_t *fmt) {
	WILLUSBITMAP _src, *src;
	ddjvu_rect_t prect;
	ddjvu_rect_t rrect;
	int i, iw, ih, idpi, status;
	double zoom = zoom_value;
	double dpi = 250*zoom;

	while (!ddjvu_page_decoding_done(page))
			handle(1, ctx);

	iw = ddjvu_page_get_width(page);
	ih = ddjvu_page_get_height(page);
	idpi = ddjvu_page_get_resolution(page);
	prect.x = prect.y = 0;
	do {
		prect.w = iw * dpi / idpi;
		prect.h = ih * dpi / idpi;
		printf("reading page:%d,%d,%d,%d dpi:%.0f\n",prect.x,prect.y,prect.w,prect.h,dpi);
		zoom_value = zoom;
		zoom *= shrink_factor;
		dpi *= shrink_factor;
	} while (prect.w > max_page_width_pix | prect.h > max_page_height_pix);
	rrect = prect;

	src = &_src;
	masterinfo = &_masterinfo;
	bmp_init(src);

	src->width = prect.w = iw * dpi / idpi;
	src->height = prect.h = ih * dpi / idpi;
	src->bpp = 8;
	rrect = prect;
	bmp_alloc(src);
	if (src->bpp == 8) {
		int ii;
		for (ii = 0; ii < 256; ii++)
		src->red[ii] = src->blue[ii] = src->green[ii] = ii;
	}

	ddjvu_format_set_row_order(fmt, 1);

	status = ddjvu_page_render(page, mode, &prect, &rrect, fmt,
			bmp_bytewidth(src), (char *) src->data);

	k2pdfopt_reflow_bmp(masterinfo, src);
	bmp_free(src);
}

void k2pdfopt_rfbmp_size(int *width, int *height) {
	*width = master_bmp_width;
	*height = master_bmp_height;
}

void k2pdfopt_rfbmp_ptr(unsigned char** bmp_ptr_ptr) {
	*bmp_ptr_ptr = masterinfo->bmp.data;
}

void k2pdfopt_rfbmp_zoom(double *zoom) {
	*zoom = zoom_value;
}

/* ansi.c */
#define MAXSIZE 8000

static int ansi_on=1;
static char ansi_buffer[MAXSIZE];

int avprintf(FILE *f, char *fmt, va_list args)

{
	int status;
	{
		if (!ansi_on) {
			status = vsprintf(ansi_buffer, fmt, args);
			ansi_parse(f, ansi_buffer);
		} else
			status = vfprintf(f, fmt, args);
	}
	return (status);
}

int aprintf(char *fmt, ...)

{
	va_list args;
	int status;

	va_start(args, fmt);
	status = avprintf(stdout, fmt, args);
	va_end(args);
	return (status);
}

/*
 ** Ensure that max_region_width_inches will be > MIN_REGION_WIDTH_INCHES
 **
 ** Should only be called once, after all params are set.
 **
 */
void adjust_params_init(void)

{
	if (dst_landscape) {
		dst_width = dst_userheight;
		dst_height = dst_userwidth;
	} else {
		dst_width = dst_userwidth;
		dst_height = dst_userheight;
	}
	if (dst_mar < 0.)
		dst_mar = 0.02;
	if (dst_martop < 0.)
		dst_martop = dst_mar;
	if (dst_marbot < 0.)
		dst_marbot = dst_mar;
	if (dst_marleft < 0.)
		dst_marleft = dst_mar;
	if (dst_marright < 0.)
		dst_marright = dst_mar;
	if ((double) dst_width / dst_dpi - dst_marleft
			- dst_marright< MIN_REGION_WIDTH_INCHES) {
		int olddpi;
		olddpi = dst_dpi;
		dst_dpi = (int) ((double) dst_width
				/ (MIN_REGION_WIDTH_INCHES + dst_marleft + dst_marright));
		aprintf(
				TTEXT_BOLD2 "Output DPI of %d is too large.  Reduced to %d." TTEXT_NORMAL "\n\n",
				olddpi, dst_dpi);
	}
}

void set_region_widths(void)

{
	max_region_width_inches = display_width_inches = (double) dst_width
			/ dst_dpi;
	max_region_width_inches -= (dst_marleft + dst_marright);
	/* This is ensured by adjust_dst_dpi() as of v1.17 */
	/*
	 if (max_region_width_inches < MIN_REGION_WIDTH_INCHES)
	 max_region_width_inches = MIN_REGION_WIDTH_INCHES;
	 */
}

/*
 ** Process full source page bitmap into rectangular regions and add
 ** to the destination bitmap.  Start by looking for columns.
 **
 ** level = recursion level.  First call = 1, then 2, ...
 **
 */
void bmpregion_multicolumn_add(BMPREGION *region, MASTERINFO *masterinfo,
		int level, PAGEINFO *pageinfo, int colgap0_pixels)

{
	static char *funcname = "bmpregion_multicolumn_add";
	int *row_black_count;
	int r2, rh, r0, cgr, maxlevel;
	BMPREGION *srcregion, _srcregion;
	BMPREGION *newregion, _newregion;
	BMPREGION *pageregion;
	double minh;
	int ipr, npr, na;
	int *colcount, *rowcount;

	willus_dmem_alloc_warn(1, (void **) &colcount,
			sizeof(int) * (region->c2 + 1), funcname, 10);
	willus_dmem_alloc_warn(2, (void **) &rowcount,
			sizeof(int) * (region->r2 + 1), funcname, 10);
	maxlevel = max_columns / 2;
	if (debug)
		printf("@bmpregion_multicolumn_add (%d,%d) - (%d,%d) lev=%d\n",
				region->c1, region->r1, region->c2, region->r2, level);
	newregion = &_newregion;
	(*newregion) = (*region);
	/* Establish colcount, rowcount arrays */
	bmpregion_trim_margins(newregion, colcount, rowcount, 0xf);
	(*newregion) = (*region);
	srcregion = &_srcregion;
	(*srcregion) = (*region);
	/* How many page regions do we need? */
	minh = min_column_height_inches;
	if (minh < .01)
		minh = .1;
	na = (srcregion->r2 - srcregion->r1 + 1) / src_dpi / minh;
	if (na < 1)
		na = 1;
	na += 16;
	/* Allocate page regions */
	willus_dmem_alloc_warn(3, (void **) &pageregion, sizeof(BMPREGION) * na,
			funcname, 10);
#ifdef COMMENT
	mindr=src_dpi*.045; /* src->height/250; */
	if (mindr<1)
	mindr=1;
#endif
//    white=250;
//    for (i=0;i<src->width;i++)
//        colcount[i]=0;
	if (debug)
		bmpregion_row_histogram(region);

	/*
	 ** Store information about which rows are mostly clear for future
	 ** processing (saves processing time).
	 */
	willus_dmem_alloc_warn(4, (void **) &row_black_count,
			region->bmp8->height * sizeof(int), funcname, 10);
	for (cgr = 0, r0 = 0; r0 < region->bmp8->height; r0++) {
		row_black_count[r0] = bmpregion_row_black_count(region, r0);
		if (row_black_count[r0] == 0)
			cgr++;
		/*
		 int dr;
		 dr=mindr;
		 if (r0+dr>region->bmp8->height)
		 dr=region->bmp8->height-r0;
		 if ((row_is_clear[r0]=bmpregion_row_mostly_white(region,r0,dr))!=0)
		 cgr++;
		 */
// printf("row_is_clear[%d]=%d\n",r0,row_is_clear[r0]);
	}
	if (verbose)
		printf("%d clear rows.\n", cgr);

	if (max_columns == 1) {
		pageregion[0] = (*srcregion);
		/* Set c1 negative to indicate full span */
		pageregion[0].c1 = -1 - pageregion[0].c1;
		npr = 1;
	} else
		/* Find all column dividers in source region and store sequentially in pageregion[] array */
		for (npr = 0, rh = 0; srcregion->r1 <= srcregion->r2; srcregion->r1 +=
				rh) {
			static char *ierr =
					TTEXT_WARN "\n\aInternal error--not enough allocated regions.\n"
					"Please inform the developer at willus.com.\n\n" TTEXT_NORMAL;
			if (npr >= na - 3) {
				aprintf("%s", ierr);
				break;
			}
			rh = bmpregion_find_multicolumn_divider(srcregion, row_black_count,
					pageregion, &npr, colcount, rowcount);
			if (verbose)
				printf("rh=%d/%d\n", rh, region->r2 - region->r1 + 1);
		}

	/* Process page regions by column */
	if (debug)
		printf("Page regions:  %d\n", npr);
	r2 = -1;
	for (ipr = 0; ipr < npr;) {
		int r20, jpr, colnum, colgap_pixels;

		for (colnum = 1; colnum <= 2; colnum++) {
			if (debug) {
				printf("ipr = %d of %d...\n", ipr, npr);
				printf("COLUMN %d...\n", colnum);
			}
			r20 = r2;
			for (jpr = ipr; jpr < npr; jpr += 2) {
				/* If we get to a page region that spans the entire source, stop */
				if (pageregion[jpr].c1 < 0)
					break;
				/* See if we should suspend this column and start displaying the next one */
				if (jpr > ipr) {
					double cpdiff, cdiv1, cdiv2, rowgap1_in, rowgap2_in;

					if (column_offset_max < 0.)
						break;
					/* Did column divider move too much? */
					cdiv1 = (pageregion[jpr].c2 + pageregion[jpr + 1].c1) / 2.;
					cdiv2 = (pageregion[jpr - 2].c2 + pageregion[jpr - 1].c1)
							/ 2.;
					cpdiff = fabs(
							(double) (cdiv1 - cdiv2)
									/ (srcregion->c2 - srcregion->c1 + 1));
					if (cpdiff > column_offset_max)
						break;
					/* Is gap between this column region and next column region too big? */
					rowgap1_in = (double) (pageregion[jpr].r1
							- pageregion[jpr - 2].r2) / src_dpi;
					rowgap2_in = (double) (pageregion[jpr + 1].r1
							- pageregion[jpr - 1].r2) / src_dpi;
					if (rowgap1_in > 0.28 && rowgap2_in > 0.28)
						break;
				}
				(*newregion) = pageregion[
						src_left_to_right ?
								jpr + colnum - 1 : jpr + (2 - colnum)];
				/* Preserve vertical gap between this region and last region */
				if (r20 >= 0 && newregion->r1 - r20 >= 0)
					colgap_pixels = newregion->r1 - r20;
				else
					colgap_pixels = colgap0_pixels;
				if (level < maxlevel)
					bmpregion_multicolumn_add(newregion, masterinfo, level + 1,
							pageinfo, colgap_pixels);
				else {
					bmpregion_vertically_break(newregion, masterinfo, text_wrap,
							fit_columns ? -2.0 : -1.0, colcount, rowcount,
							pageinfo, colgap_pixels, 2 * level);
				}
				r20 = newregion->r2;
			}
			if (r20 > r2)
				r2 = r20;
			if (jpr == ipr)
				break;
		}
		if (jpr < npr && pageregion[jpr].c1 < 0) {
			if (debug)
				printf("SINGLE COLUMN REGION...\n");
			(*newregion) = pageregion[jpr];
			newregion->c1 = -1 - newregion->c1;
			/* dst_add_gap_src_pixels("Col level",masterinfo,newregion->r1-r2); */
			colgap_pixels = newregion->r1 - r2;
			bmpregion_vertically_break(newregion, masterinfo, text_wrap,
					(fit_columns && (level > 1)) ? -2.0 : -1.0, colcount,
					rowcount, pageinfo, colgap_pixels, level);
			r2 = newregion->r2;
			jpr++;
		}
		ipr = jpr;
	}
	willus_dmem_free(4, (double **) &row_black_count, funcname);
	willus_dmem_free(3, (double **) &pageregion, funcname);
	willus_dmem_free(2, (double **) &rowcount, funcname);
	willus_dmem_free(1, (double **) &colcount, funcname);
}

static void fit_column_to_screen(double column_width_inches)

{
	double text_width_pixels, lm_pixels, rm_pixels, tm_pixels, bm_pixels;

	if (!column_fitted) {
		dpi_org = dst_dpi;
		lm_org = dst_marleft;
		rm_org = dst_marright;
		tm_org = dst_martop;
		bm_org = dst_marbot;
	}
	text_width_pixels = max_region_width_inches * dst_dpi;
	lm_pixels = dst_marleft * dst_dpi;
	rm_pixels = dst_marright * dst_dpi;
	tm_pixels = dst_martop * dst_dpi;
	bm_pixels = dst_marbot * dst_dpi;
	dst_dpi = text_width_pixels / column_width_inches;
	dst_marleft = lm_pixels / dst_dpi;
	dst_marright = rm_pixels / dst_dpi;
	dst_martop = tm_pixels / dst_dpi;
	dst_marbot = bm_pixels / dst_dpi;
	set_region_widths();
	column_fitted = 1;
}

static void restore_output_dpi(void)

{
	if (column_fitted) {
		dst_dpi = dpi_org;
		dst_marleft = lm_org;
		dst_marright = rm_org;
		dst_martop = tm_org;
		dst_marbot = bm_org;
		set_region_widths();
	}
	column_fitted = 0;
}

void adjust_contrast(WILLUSBITMAP *src, WILLUSBITMAP *srcgrey, int *white)

{
	int i, j, tries, wc, tc, hist[256];
	double contrast, rat0;
	WILLUSBITMAP *dst, _dst;

	if (debug && verbose)
		printf("\nAt adjust_contrast.\n");
	if ((*white) <= 0)
		(*white) = 192;
	/* If contrast_max negative, use it as fixed contrast adjustment. */
	if (contrast_max < 0.) {
		bmp_contrast_adjust(srcgrey, srcgrey, -contrast_max);
		if (dst_color && fabs(contrast_max + 1.0) > 1e-4)
			bmp_contrast_adjust(src, src, -contrast_max);
		return;
	}
	dst = &_dst;
	bmp_init(dst);
	wc = 0; /* Avoid compiler warning */
	tc = srcgrey->width * srcgrey->height;
	rat0 = 0.5; /* Avoid compiler warning */
	for (contrast = 1.0, tries = 0; contrast < contrast_max + .01; tries++) {
		if (fabs(contrast - 1.0) > 1e-4)
			bmp_contrast_adjust(dst, srcgrey, contrast);
		else
			bmp_copy(dst, srcgrey);
		/*Get bitmap histogram */
		for (i = 0; i < 256; i++)
			hist[i] = 0;
		for (j = 0; j < dst->height; j++) {
			unsigned char *p;
			p = bmp_rowptr_from_top(dst, j);
			for (i = 0; i < dst->width; i++, p++)
				hist[p[0]]++;
		}
		if (tries == 0) {
			int h1;
			for (h1 = 0, j = (*white); j < 256; j++)
				h1 += hist[j];
			rat0 = (double) h1 / tc;
			if (debug && verbose)
				printf("    rat0 = rat[%d-255]=%.4f\n", (*white), rat0);
		}

		/* Find white ratio */
		/*
		 for (wc=hist[254],j=253;j>=252;j--)
		 if (hist[j]>wc1)
		 wc1=hist[j];
		 */
		for (wc = 0, j = 252; j <= 255; j++)
			wc += hist[j];
		/*
		 if ((double)wc/tc >= rat0*0.7 && (double)hist[255]/wc > 0.995)
		 break;
		 */
		if (debug && verbose)
			printf("    %2d. Contrast=%7.2f, rat[252-255]/rat0=%.4f\n",
					tries + 1, contrast, (double) wc / tc / rat0);
		if ((double) wc / tc >= rat0 * 0.94)
			break;
		contrast *= 1.05;
	}
	if (debug)
		printf("Contrast=%7.2f, rat[252-255]/rat0=%.4f\n", contrast,
				(double) wc / tc / rat0);
	/*
	 bmp_write(dst,"outc.png",stdout,100);
	 wfile_written_info("outc.png",stdout);
	 exit(10);
	 */
	bmp_copy(srcgrey, dst);
	/* Maybe don't adjust the contrast for the color bitmap? */
	if (dst_color && fabs(contrast - 1.0) > 1e-4)
		bmp_contrast_adjust(src, src, contrast);
	bmp_free(dst);
}

static int bmpregion_row_black_count(BMPREGION *region, int r0)

{
	unsigned char *p;
	int i, nc, c;

	p = bmp_rowptr_from_top(region->bmp8, r0) + region->c1;
	nc = region->c2 - region->c1 + 1;
	for (c = i = 0; i < nc; i++, p++)
		if (p[0] < region->bgcolor)
			c++;
	return (c);
}

/*
 ** Returns height of region found and divider position in (*divider_column).
 ** (*divider_column) is absolute position on source bitmap.
 **
 */
static int bmpregion_find_multicolumn_divider(BMPREGION *region,
		int *row_black_count, BMPREGION *pageregion, int *npr, int *colcount,
		int *rowcount)

{
	int itop, i, dm, middle, divider_column, min_height_pixels, mhp2,
			min_col_gap_pixels;
	BMPREGION _newregion, *newregion, column[2];
	BREAKINFO *breakinfo, _breakinfo;
	int *rowmin, *rowmax;
	static char *funcname = "bmpregion_find_multicolumn_divider";

	if (debug)
		printf("@bmpregion_find_multicolumn_divider(%d,%d)-(%d,%d)\n",
				region->c1, region->r1, region->c2, region->r2);
	breakinfo = &_breakinfo;
	breakinfo->textrow = NULL;
	breakinfo_alloc(101, breakinfo, region->r2 - region->r1 + 1);
	bmpregion_find_vertical_breaks(region, breakinfo, colcount, rowcount,
			column_row_gap_height_in);
	/*
	 {
	 printf("region (%d,%d)-(%d,%d) has %d breaks:\n",region->c1,region->r1,region->c2,region->r2,breakinfo->n);
	 for (i=0;i<breakinfo->n;i++)
	 printf("    Rows %d - %d\n",breakinfo->textrow[i].r1,breakinfo->textrow[i].r2);
	 }
	 */
	newregion = &_newregion;
	(*newregion) = (*region);
	min_height_pixels = min_column_height_inches * src_dpi; /* src->height/15; */
	mhp2 = min_height_pixels - 1;
	if (mhp2 < 0)
		mhp2 = 0;
	dm = 1 + (region->c2 - region->c1 + 1) * column_gap_range / 2.;
	middle = (region->c2 - region->c1 + 1) / 2;
	min_col_gap_pixels = (int) (min_column_gap_inches * src_dpi + .5);
	if (verbose) {
		printf("(dm=%d, width=%d, min_gap=%d)\n", dm,
				region->c2 - region->c1 + 1, min_col_gap_pixels);
		printf("Checking regions (r1=%d, r2=%d, minrh=%d)..", region->r1,
				region->r2, min_height_pixels);
		fflush(stdout);
	}
	breakinfo_sort_by_row_position(breakinfo);
	willus_dmem_alloc_warn(5, (void **) &rowmin,
			(region->c2 + 10) * 2 * sizeof(int), funcname, 10);
	rowmax = &rowmin[region->c2 + 10];
	for (i = 0; i < region->c2 + 2; i++) {
		rowmin[i] = region->r2 + 2;
		rowmax[i] = -1;
	}

	/* Start with top-most and bottom-most regions, look for column dividers */
	for (itop = 0;
			itop < breakinfo->n
					&& breakinfo->textrow[itop].r1
							< region->r2 + 1 - min_height_pixels; itop++) {
		int ibottom;

		for (ibottom = breakinfo->n - 1;
				ibottom >= itop
						&& breakinfo->textrow[ibottom].r2
								- breakinfo->textrow[itop].r1
								>= min_height_pixels; ibottom--) {
			/*
			 ** Look for vertical shaft of clear space that clearly demarcates
			 ** two columns
			 */
			for (i = 0; i < dm; i++) {
				int foundgap, ii, c1, c2, iiopt, status;

				newregion->c1 = region->c1 + middle - i;
				/* If we've effectively already checked this shaft, move on */
				if (itop >= rowmin[newregion->c1]
						&& ibottom <= rowmax[newregion->c1])
					continue;
				newregion->c2 = newregion->c1 + min_col_gap_pixels - 1;
				newregion->r1 = breakinfo->textrow[itop].r1;
				newregion->r2 = breakinfo->textrow[ibottom].r2;
				foundgap = bmpregion_is_clear(newregion, row_black_count,
						gtc_in);
				if (!foundgap && i > 0) {
					newregion->c1 = region->c1 + middle + i;
					newregion->c2 = newregion->c1 + min_col_gap_pixels - 1;
					foundgap = bmpregion_is_clear(newregion, row_black_count,
							gtc_in);
				}
				if (!foundgap)
					continue;
				/* Found a gap, but look for a better gap nearby */
				c1 = newregion->c1;
				c2 = newregion->c2;
				for (iiopt = 0, ii = -min_col_gap_pixels;
						ii <= min_col_gap_pixels; ii++) {
					int newgap;
					newregion->c1 = c1 + ii;
					newregion->c2 = c2 + ii;
					newgap = bmpregion_is_clear(newregion, row_black_count,
							gtc_in);
					if (newgap > 0 && newgap < foundgap) {
						iiopt = ii;
						foundgap = newgap;
						if (newgap == 1)
							break;
					}
				}
				newregion->c1 = c1 + iiopt;
				/* If we've effectively already checked this shaft, move on */
				if (itop >= rowmin[newregion->c1]
						&& ibottom <= rowmax[newregion->c1])
					continue;
				newregion->c2 = c2 + iiopt;
				divider_column = newregion->c1 + min_col_gap_pixels / 2;
				status = bmpregion_column_height_and_gap_test(column, region,
						breakinfo->textrow[itop].r1,
						breakinfo->textrow[ibottom].r2, divider_column,
						colcount, rowcount);
				/* If fails column height or gap test, mark as bad */
				if (status) {
					if (itop < rowmin[newregion->c1])
						rowmin[newregion->c1] = itop;
					if (ibottom > rowmax[newregion->c1])
						rowmax[newregion->c1] = ibottom;
				}
				/* If right column too short, stop looking */
				if (status & 2)
					break;
				if (!status) {
					int colheight;

					/* printf("    GOT COLUMN DIVIDER AT x=%d.\n",(*divider_column)); */
					if (verbose) {
						printf("\n    GOOD REGION: col gap=(%d,%d) - (%d,%d)\n"
								"                 r1=%d, r2=%d\n",
								newregion->c1, newregion->r1, newregion->c2,
								newregion->r2, breakinfo->textrow[itop].r1,
								breakinfo->textrow[ibottom].r2);
					}
					if (itop > 0) {
						/* add 1-column region */
						pageregion[(*npr)] = (*region);
						pageregion[(*npr)].r2 = breakinfo->textrow[itop - 1].r2;
						if (pageregion[(*npr)].r2
								> pageregion[(*npr)].bmp8->height - 1)
							pageregion[(*npr)].r2 =
									pageregion[(*npr)].bmp8->height - 1;
						bmpregion_trim_margins(&pageregion[(*npr)], colcount,
								rowcount, 0xf);
						/* Special flag to indicate full-width region */
						pageregion[(*npr)].c1 = -1 - pageregion[(*npr)].c1;
						(*npr) = (*npr) + 1;
					}
					pageregion[(*npr)] = column[0];
					(*npr) = (*npr) + 1;
					pageregion[(*npr)] = column[1];
					(*npr) = (*npr) + 1;
					colheight = breakinfo->textrow[ibottom].r2 - region->r1 + 1;
					breakinfo_free(101, breakinfo);
					/*
					 printf("Returning %d divider column = %d - %d\n",region->r2-region->r1+1,newregion->c1,newregion->c2);
					 */
					return (colheight);
				}
			}
		}
	}
	if (verbose)
		printf("NO GOOD REGION FOUND.\n");
	pageregion[(*npr)] = (*region);
	bmpregion_trim_margins(&pageregion[(*npr)], colcount, rowcount, 0xf);
	/* Special flag to indicate full-width region */
	pageregion[(*npr)].c1 = -1 - pageregion[(*npr)].c1;
	(*npr) = (*npr) + 1;
	/* (*divider_column)=region->c2+1; */
	willus_dmem_free(5, (double **) &rowmin, funcname);
	breakinfo_free(101, breakinfo);
	/*
	 printf("Returning %d\n",region->r2-region->r1+1);
	 */
	return (region->r2 - region->r1 + 1);
}

/*
 ** 1 = column 1 too short
 ** 2 = column 2 too short
 ** 3 = both too short
 ** 0 = both okay
 ** Both columns must pass height requirement.
 **
 ** Also, if gap between columns > max_column_gap_inches, fails test. (8-31-12)
 **
 */
static int bmpregion_column_height_and_gap_test(BMPREGION *column,
		BMPREGION *region, int r1, int r2, int cmid, int *colcount,
		int *rowcount)

{
	int min_height_pixels, status;

	status = 0;
	min_height_pixels = min_column_height_inches * src_dpi;
	column[0] = (*region);
	column[0].r1 = r1;
	column[0].r2 = r2;
	column[0].c2 = cmid - 1;
	bmpregion_trim_margins(&column[0], colcount, rowcount, 0xf);
	/*
	 printf("    COL1:  pix=%d (%d - %d)\n",newregion->r2-newregion->r1+1,newregion->r1,newregion->r2);
	 */
	if (column[0].r2 - column[0].r1 + 1 < min_height_pixels)
		status |= 1;
	column[1] = (*region);
	column[1].r1 = r1;
	column[1].r2 = r2;
	column[1].c1 = cmid;
	column[1].c2 = region->c2;
	bmpregion_trim_margins(&column[1], colcount, rowcount, 0xf);
	/*
	 printf("    COL2:  pix=%d (%d - %d)\n",newregion->r2-newregion->r1+1,newregion->r1,newregion->r2);
	 */
	if (column[1].r2 - column[1].r1 + 1 < min_height_pixels)
		status |= 2;
	/* Make sure gap between columns is not too large */
	if (max_column_gap_inches >= 0.
			&& column[1].c1 - column[0].c2 - 1
					> max_column_gap_inches * src_dpi)
		status |= 4;
	return (status);
}

/*
 ** Return 0 if there are dark pixels in the region.  NZ otherwise.
 */
static int bmpregion_is_clear(BMPREGION *region, int *row_black_count,
		double gt_in)

{
	int r, c, nc, pt;

	/*
	 ** row_black_count[] doesn't necessarily match up to this particular region's columns.
	 ** So if row_black_count[] == 0, the row is clear, otherwise it has to be counted.
	 ** because the columns are a subset.
	 */
	/* nr=region->r2-region->r1+1; */
	nc = region->c2 - region->c1 + 1;
	pt = (int) (gt_in * src_dpi * nc + .5);
	if (pt < 0)
		pt = 0;
	for (c = 0, r = region->r1; r <= region->r2; r++) {
		if (r < 0 || r >= region->bmp8->height)
			continue;
		if (row_black_count[r] == 0)
			continue;
		c += bmpregion_row_black_count(region, r);
		if (c > pt)
			return (0);
	}
	/*
	 printf("(%d,%d)-(%d,%d):  c=%d, pt=%d (gt_in=%g)\n",
	 region->c1,region->r1,region->c2,region->r2,c,pt,gt_in);
	 */
	return (1 + (int) 10 * c / pt);
}

static void bmpregion_row_histogram(BMPREGION *region)

{
	static char *funcname = "bmpregion_row_histogram";
	WILLUSBITMAP *src;
	FILE *out;
	static int *rowcount;
	static int *hist;
	int i, j, nn;

	willus_dmem_alloc_warn(6, (void **) &rowcount,
			(region->r2 - region->r1 + 1) * sizeof(int), funcname, 10);
	willus_dmem_alloc_warn(7, (void **) &hist,
			(region->c2 - region->c1 + 1) * sizeof(int), funcname, 10);
	src = region->bmp8;
	for (j = region->r1; j <= region->r2; j++) {
		unsigned char *p;
		p = bmp_rowptr_from_top(src, j) + region->c1;
		rowcount[j - region->r1] = 0;
		for (i = region->c1; i <= region->c2; i++, p++)
			if (p[0] < region->bgcolor)
				rowcount[j - region->r1]++;
	}
	for (i = region->c1; i <= region->c2; i++)
		hist[i - region->c1] = 0;
	for (i = region->r1; i <= region->r2; i++)
		hist[rowcount[i - region->r1]]++;
	for (i = region->c2 - region->c1 + 1; i >= 0; i--)
		if (hist[i] > 0)
			break;
	nn = i;
	out = fopen("hist.ep", "w");
	for (i = 0; i <= nn; i++)
		fprintf(out, "%5d %5d\n", i, hist[i]);
	fclose(out);
	out = fopen("rowcount.ep", "w");
	for (i = 0; i < region->r2 - region->r1 + 1; i++)
		fprintf(out, "%5d %5d\n", i, rowcount[i]);
	fclose(out);
	willus_dmem_free(7, (double **) &hist, funcname);
	willus_dmem_free(6, (double **) &rowcount, funcname);
}

/*
 ** Mark the region
 ** mark_flags & 1 :  Mark top
 ** mark_flags & 2 :  Mark bottom
 ** mark_flags & 4 :  Mark left
 ** mark_flags & 8 :  Mark right
 **
 */
static void mark_source_page(BMPREGION *region0, int caller_id, int mark_flags)

{
	static int display_order = 0;
	int i, n, nn, fontsize, r, g, b, shownum;
	char num[16];
	BMPREGION *region, _region;
	BMPREGION *clip, _clip;

	if (!show_marked_source)
		return;

	if (region0 == NULL) {
		display_order = 0;
		return;
	}

	region = &_region;
	(*region) = (*region0);

	/* Clip the region w/ignored margins */
	clip = &_clip;
	clip->bmp = region0->bmp;
	get_white_margins(clip);
	if (region->c1 < clip->c1)
		region->c1 = clip->c1;
	if (region->c2 > clip->c2)
		region->c2 = clip->c2;
	if (region->r1 < clip->r1)
		region->r1 = clip->r1;
	if (region->r2 > clip->r2)
		region->r2 = clip->r2;
	if (region->r2 <= region->r1 || region->c2 <= region->c1)
		return;

	/* printf("@mark_source_page(display_order=%d)\n",display_order); */
	if (caller_id == 1) {
		display_order++;
		shownum = 1;
		n = (int) (src_dpi / 60. + 0.5);
		if (n < 5)
			n = 5;
		r = 255;
		g = b = 0;
	} else if (caller_id == 2) {
		shownum = 0;
		n = 2;
		r = 0;
		g = 0;
		b = 255;
	} else if (caller_id == 3) {
		shownum = 0;
		n = (int) (src_dpi / 80. + 0.5);
		if (n < 4)
			n = 4;
		r = 0;
		g = 255;
		b = 0;
	} else if (caller_id == 4) {
		shownum = 0;
		n = 2;
		r = 255;
		g = 0;
		b = 255;
	} else {
		shownum = 0;
		n = 2;
		r = 140;
		g = 140;
		b = 140;
	}
	if (n < 2)
		n = 2;
	nn = (region->c2 + 1 - region->c1) / 2;
	if (n > nn)
		n = nn;
	nn = (region->r2 + 1 - region->r1) / 2;
	if (n > nn)
		n = nn;
	if (n < 1)
		n = 1;
	for (i = 0; i < n; i++) {
		int j;
		unsigned char *p;
		if (mark_flags & 1) {
			p = bmp_rowptr_from_top(region->marked, region->r1 + i)
					+ region->c1 * 3;
			for (j = region->c1; j <= region->c2; j++, p += 3) {
				p[0] = r;
				p[1] = g;
				p[2] = b;
			}
		}
		if (mark_flags & 2) {
			p = bmp_rowptr_from_top(region->marked, region->r2 - i)
					+ region->c1 * 3;
			for (j = region->c1; j <= region->c2; j++, p += 3) {
				p[0] = r;
				p[1] = g;
				p[2] = b;
			}
		}
		if (mark_flags & 16) /* rowbase */
		{
			p = bmp_rowptr_from_top(region->marked, region->rowbase - i)
					+ region->c1 * 3;
			for (j = region->c1; j <= region->c2; j++, p += 3) {
				p[0] = r;
				p[1] = g;
				p[2] = b;
			}
		}
		if (mark_flags & 4)
			for (j = region->r1; j <= region->r2; j++) {
				p = bmp_rowptr_from_top(region->marked, j)
						+ (region->c1 + i) * 3;
				p[0] = r;
				p[1] = g;
				p[2] = b;
			}
		if (mark_flags & 8)
			for (j = region->r1; j <= region->r2; j++) {
				p = bmp_rowptr_from_top(region->marked, j)
						+ (region->c2 - i) * 3;
				p[0] = r;
				p[1] = g;
				p[2] = b;
			}
	}
	if (!shownum)
		return;
	fontsize = region->c2 - region->c1 + 1;
	if (fontsize > region->r2 - region->r1 + 1)
		fontsize = region->r2 - region->r1 + 1;
	fontsize /= 2;
	if (fontsize > src_dpi)
		fontsize = src_dpi;
	if (fontsize < 5)
		return;
	fontrender_set_typeface("helvetica-bold");
	fontrender_set_fgcolor(r, g, b);
	fontrender_set_bgcolor(255, 255, 255);
	fontrender_set_pixel_size(fontsize);
	fontrender_set_justification(4);
	fontrender_set_or(1);
	sprintf(num, "%d", display_order);
	fontrender_render(region->marked, (double) (region->c1 + region->c2) / 2.,
			(double) (region->marked->height - ((region->r1 + region->r2) / 2.)),
			num, 0, NULL);
	/* printf("    done mark_source_page.\n"); */
}

/*
 ** Input:  A generic rectangular region from the source file.  It will not
 **         be checked for multiple columns, but the text may be wrapped
 **         (controlled by allow_text_wrapping input).
 **
 ** force_scale == -2 :  Use same scale for entire column--fit to device
 **
 ** This function looks for vertical gaps in the region and breaks it at
 ** the widest ones (if there are significantly wider ones).
 **
 */
static void bmpregion_vertically_break(BMPREGION *region,
		MASTERINFO *masterinfo, int allow_text_wrapping, double force_scale,
		int *colcount, int *rowcount, PAGEINFO *pageinfo, int colgap_pixels,
		int ncols)

{
	static int ncols_last = -1;
	int regcount, i, i1, biggap, revert, trim_flags, allow_vertical_breaks;
	int justification_flags, caller_id, marking_flags, rbdelta;
	// int trim_left_and_right;
	BMPREGION *bregion, _bregion;
	BREAKINFO *breakinfo, _breakinfo;
	double region_width_inches, region_height_inches;

#if (WILLUSDEBUGX & 1)
	printf("\n\n@bmpregion_vertically_break.  colgap_pixels=%d\n\n",colgap_pixels);
#endif
	trim_flags = 0xf;
	allow_vertical_breaks = 1;
	justification_flags = 0x8f; /* Don't know region justification status yet.  Use user settings. */
	rbdelta = -1;
	breakinfo = &_breakinfo;
	breakinfo->textrow = NULL;
	breakinfo_alloc(102, breakinfo, region->r2 - region->r1 + 1);
	bmpregion_find_vertical_breaks(region, breakinfo, colcount, rowcount, -1.0);
	/* Should there be a check for breakinfo->n==0 here? */
	/* Don't think it breaks anything to let it go.  -- 6-11-12 */
#if (WILLUSDEBUGX & 2)
	breakinfo_echo(breakinfo);
#endif
	breakinfo_remove_small_rows(breakinfo, 0.25, 0.5, region, colcount,
			rowcount);
#if (WILLUSDEBUGX & 2)
	breakinfo_echo(breakinfo);
#endif
	breakinfo->centered = bmpregion_is_centered(region, breakinfo, 0,
			breakinfo->n - 1, NULL);
#if (WILLUSDEBUGX & 2)
	breakinfo_echo(breakinfo);
#endif
	/*
	 newregion=&_newregion;
	 for (i=0;i<breakinfo->n;i++)
	 {
	 (*newregion)=(*region);
	 newregion->r1=breakinfo->textrow[i].r1;
	 newregion->r2=breakinfo->textrow[i].r2;
	 bmpregion_add(newregion,breakinfo,masterinfo,allow_text_wrapping,force_scale,0,1,
	 colcount,rowcount,pageinfo,0,0xf);
	 }
	 breakinfo_free(breakinfo);
	 return;
	 */
	/*
	 if (!vertical_breaks)
	 {
	 caller_id=100;
	 marking_flags=0;
	 bmpregion_add(region,breakinfo,masterinfo,allow_text_wrapping,trim_flags,
	 allow_vertical_breaks,force_scale,justification_flags,
	 caller_id,colcount,rowcount,pageinfo,marking_flags,rbdelta);
	 breakinfo_free(breakinfo);
	 return;
	 }
	 */
	/* Red, numbered region */
	mark_source_page(region, 1, 0xf);
	bregion = &_bregion;
	if (debug) {
		if (!allow_text_wrapping)
			printf(
					"@bmpregion_vertically_break (no break) (%d,%d) - (%d,%d) (scale=%g)\n",
					region->c1, region->r1, region->c2, region->r2,
					force_scale);
		else
			printf(
					"@bmpregion_vertically_break (allow break) (%d,%d) - (%d,%d) (scale=%g)\n",
					region->c1, region->r1, region->c2, region->r2,
					force_scale);
	}
	/*
	 ** Tag blank rows and columns
	 */
	if (vertical_break_threshold < 0. || breakinfo->n < 6)
		biggap = -1.;
	else {
		int gap_median;
		/*
		 int rowheight_median;

		 breakinfo_sort_by_rowheight(breakinfo);
		 rowheight_median = breakinfo->textrow[breakinfo->n/2].rowheight;
		 */
#ifdef WILLUSDEBUG
		for (i=0;i<breakinfo->n;i++)
		printf("    gap[%d]=%d\n",i,breakinfo->textrow[i].gap);
#endif
		breakinfo_sort_by_gap(breakinfo);
		gap_median = breakinfo->textrow[breakinfo->n / 2].gap;
#ifdef WILLUSDEBUG
		printf("    median=%d\n",gap_median);
#endif
		biggap = gap_median * vertical_break_threshold;
		breakinfo_sort_by_row_position(breakinfo);
	}
#ifdef WILLUSDEBUG
	printf("    biggap=%d\n",biggap);
#endif
	region_width_inches = (double) (region->c2 - region->c1 + 1) / src_dpi;
	region_height_inches = (double) (region->r2 - region->r1 + 1) / src_dpi;
	/*
	 trim_left_and_right = 1;
	 if (region_width_inches <= max_region_width_inches)
	 trim_left_and_right = 0;
	 */
	/*
	 printf("force_scale=%g, rwi = %g, rwi/mrwi = %g, rhi = %g\n",
	 force_scale,
	 region_width_inches,
	 region_width_inches / max_region_width_inches,
	 region_height_inches);
	 */
	if (force_scale < -1.5 && region_width_inches > MIN_REGION_WIDTH_INCHES
			&& region_width_inches / max_region_width_inches < 1.25
			&& region_height_inches > 0.5) {
		revert = 1;
		force_scale = -1.0;
		fit_column_to_screen(region_width_inches);
		// trim_left_and_right = 0;
		allow_text_wrapping = 0;
	} else
		revert = 0;
	/* Add the regions (broken vertically) */
	caller_id = 1;
	/*
	 if (trim_left_and_right)
	 trim_flags=0xf;
	 else
	 trim_flags=0xc;
	 */
	trim_flags = 0xf;
	for (regcount = i1 = i = 0; i1 < breakinfo->n; i++) {
		int i2;

		i2 = i < breakinfo->n ? i : breakinfo->n - 1;
		if (i >= breakinfo->n
				|| (biggap > 0. && breakinfo->textrow[i2].gap >= biggap)) {
			int j, c1, c2, nc, nowrap;
			double regwidth, ar1, rh1;

// printf("CALLER 1:  i1=%d, i2=%d (breakinfo->n=%d)\n",i1,i2,breakinfo->n);
			(*bregion) = (*region);
			bregion->r1 = breakinfo->textrow[i1].r1;
			bregion->r2 = breakinfo->textrow[i2].r2;
			c1 = breakinfo->textrow[i1].c1;
			c2 = breakinfo->textrow[i1].c2;
			nc = c2 - c1 + 1;
			if (nc <= 0)
				nc = 1;
			rh1 = (double) (breakinfo->textrow[i1].r2
					- breakinfo->textrow[i1].r1 + 1) / src_dpi;
			ar1 = (double) (breakinfo->textrow[i1].r2
					- breakinfo->textrow[i1].r1 + 1) / nc;
			for (j = i1 + 1; j <= i2; j++) {
				if (c1 > breakinfo->textrow[j].c1)
					c1 = breakinfo->textrow[j].c1;
				if (c2 < breakinfo->textrow[j].c2)
					c2 = breakinfo->textrow[j].c2;
			}
			regwidth = (double) (c2 - c1 + 1) / src_dpi;
			marking_flags = (i1 == 0 ? 0 : 1)
					| (i2 == breakinfo->n - 1 ? 0 : 2);
			/* Green */
			mark_source_page(bregion, 3, marking_flags);
			nowrap = ((regwidth <= max_region_width_inches
					&& allow_text_wrapping < 2)
					|| (ar1 > no_wrap_ar_limit
							&& rh1 > no_wrap_height_limit_inches));
			/*
			 ** If between regions, or if the next region isn't going to be
			 ** wrapped, or if the next region starts a different number of
			 ** columns than before, then "flush and gap."
			 */
			if (regcount > 0 || just_flushed_internal || nowrap
					|| (ncols_last > 0 && ncols_last != ncols)) {
				int gap;
#ifdef WILLUSDEBUG
				printf("wrapflush1\n");
#endif
				if (!just_flushed_internal)
					wrapbmp_flush(masterinfo, 0, pageinfo, 0);
				gap = regcount == 0 ?
						colgap_pixels : breakinfo->textrow[i1 - 1].gap;
				if (regcount == 0 && beginning_gap_internal > 0) {
					if (last_h5050_internal > 0) {
						if (fabs(
								1.
										- (double) breakinfo->textrow[i1].h5050
												/ last_h5050_internal) > .1)
							dst_add_gap_src_pixels("Col/Page break", masterinfo,
									colgap_pixels);
						last_h5050_internal = -1;
					}
					gap = beginning_gap_internal;
					beginning_gap_internal = -1;
				}
				dst_add_gap_src_pixels("Vert break", masterinfo, gap);
			} else {
				if (regcount == 0 && beginning_gap_internal < 0)
					beginning_gap_internal = colgap_pixels;
			}
			bmpregion_add(bregion, breakinfo, masterinfo, allow_text_wrapping,
					trim_flags, allow_vertical_breaks, force_scale,
					justification_flags, caller_id, colcount, rowcount,
					pageinfo, marking_flags, rbdelta);
			regcount++;
			i1 = i2 + 1;
		}
	}
	ncols_last = ncols;
	if (revert)
		restore_output_dpi();
	breakinfo_free(102, breakinfo);
}

/*
 **
 ** MAIN BITMAP REGION ADDING FUNCTION
 **
 ** NOTE:  This function calls itself recursively!
 **
 ** Input:  A generic rectangular region from the source file.  It will not
 **         be checked for multiple columns, but the text may be wrapped
 **         (controlled by allow_text_wrapping input).
 **
 ** First, excess margins are trimmed off of the region.
 **
 ** Then, if the resulting trimmed region is wider than the max desirable width
 ** and allow_text_wrapping is non-zero, then the
 ** bmpregion_analyze_justification_and_line_spacing() function is called.
 ** Otherwise the region is scaled to fit and added to the master set of pages.
 **
 ** justification_flags
 **     Bits 6-7:  0 = document is not fully justified
 **                1 = document is fully justified
 **                2 = don't know document justification yet
 **     Bits 4-5:  0 = Use user settings
 **                1 = fully justify
 **                2 = do not fully justify
 **     Bits 2-3:  0 = document is left justified
 **                1 = document is centered
 **                2 = document is right justified
 **                3 = don't know document justification yet
 **     Bits 0-1:  0 = left justify document
 **                1 = center document
 **                2 = right justify document
 **                3 = Use user settings
 **
 ** force_scale = -2.0 : Fit column width to display width
 ** force_scale = -1.0 : Use output dpi unless the region doesn't fit.
 **                      In that case, scale it down until it fits.
 ** force_scale > 0.0  : Scale region by force_scale.
 **
 ** mark_flags & 1 :  Mark top
 ** mark_flags & 2 :  Mark bottom
 ** mark_flags & 4 :  Mark left
 ** mark_flags & 8 :  Mark right
 **
 ** trim_flags & 0x80 :  Do NOT re-trim no matter what.
 **
 */
static void bmpregion_add(BMPREGION *region, BREAKINFO *breakinfo,
		MASTERINFO *masterinfo, int allow_text_wrapping, int trim_flags,
		int allow_vertical_breaks, double force_scale, int justification_flags,
		int caller_id, int *colcount, int *rowcount, PAGEINFO *pageinfo,
		int mark_flags, int rowbase_delta)

{
	int w, wmax, i, nc, nr, h, bpp, tall_region;
	double region_width_inches;
	WILLUSBITMAP *bmp, _bmp;
	BMPREGION *newregion, _newregion;

	newregion = &_newregion;
	(*newregion) = (*region);
#if (WILLUSDEBUGX & 1)
	printf("@bmpregion_add (%d,%d) - (%d,%d)\n",region->c1,region->r1,region->c2,region->r2);
	printf("    trimflags = %X\n",trim_flags);
#endif
	if (debug) {
		if (!allow_text_wrapping)
			printf("@bmpregion_add (no break) (%d,%d) - (%d,%d) (scale=%g)\n",
					region->c1, region->r1, region->c2, region->r2,
					force_scale);
		else
			printf(
					"@bmpregion_add (allow break) (%d,%d) - (%d,%d) (scale=%g)\n",
					region->c1, region->r1, region->c2, region->r2,
					force_scale);
	}
	/*
	 ** Tag blank rows and columns and trim the blank margins off
	 ** trimflags = 0xf for all margin trim.
	 ** trimflags = 0xc for just top and bottom margins.
	 */
	bmpregion_trim_margins(newregion, colcount, rowcount, trim_flags);
#if (WILLUSDEBUGX & 1)
	printf("    After trim:  (%d,%d) - (%d,%d)\n",newregion->c1,newregion->r1,newregion->c2,newregion->r2);
#endif
	nc = newregion->c2 - newregion->c1 + 1;
	nr = newregion->r2 - newregion->r1 + 1;
// printf("nc=%d, nr=%d\n",nc,nr);
	if (verbose) {
		printf("    row range adjusted to %d - %d\n", newregion->r1,
				newregion->r2);
		printf("    col range adjusted to %d - %d\n", newregion->c1,
				newregion->c2);
	}
	if (nc <= 5 || nr <= 1)
		return;
	region_width_inches = (double) nc / src_dpi;
// printf("regwidth = %g in\n",region_width_inches);
	/* Use untrimmed region left/right if possible */
	if (caller_id == 1 && region_width_inches <= max_region_width_inches) {
		int trimleft, trimright;
		int maxpix, dpix;

		maxpix = (int) (max_region_width_inches * src_dpi + .5);
#if (WILLUSDEBUGX & 1)
		printf("    Trimming.  C's = %4d %4d %4d %4d\n",region->c1,newregion->c1,newregion->c2,region->c2);
		printf("    maxpix = %d, regwidth = %d\n",maxpix,region->c2-region->c1+1);
#endif
		if (maxpix > (region->c2 - region->c1 + 1))
			maxpix = region->c2 - region->c1 + 1;
// printf("    maxpix = %d\n",maxpix);
		dpix = (region->c2 - region->c1 + 1 - maxpix) / 2;
// printf("    dpix = %d\n",dpix);
		trimright = region->c2 - newregion->c2;
		trimleft = newregion->c1 - region->c1;
		if (trimleft < trimright) {
			if (trimleft > dpix)
				newregion->c1 = region->c1 + dpix;
			newregion->c2 = newregion->c1 + maxpix - 1;
		} else {
			if (trimright > dpix)
				newregion->c2 = region->c2 - dpix;
			newregion->c1 = newregion->c2 - maxpix + 1;
		}
		if (newregion->c1 < region->c1)
			newregion->c1 = region->c1;
		if (newregion->c2 > region->c2)
			newregion->c2 = region->c2;
		nc = newregion->c2 - newregion->c1 + 1;
#if (WILLUSDEBUGX & 1)
		printf("    Post Trim.  C's = %4d %4d %4d %4d\n",region->c1,newregion->c1,newregion->c2,region->c2);
#endif
		region_width_inches = (double) nc / src_dpi;
	}

	/*
	 ** Try breaking the region into smaller horizontal pieces (wrap text lines)
	 */
	/*
	 printf("allow_text_wrapping=%d, region_width_inches=%g, max_region_width_inches=%g\n",
	 allow_text_wrapping,region_width_inches,max_region_width_inches);
	 */
	/* New in v1.50, if allow_text_wrapping==2, unwrap short lines. */
	if (allow_text_wrapping == 2
			|| (allow_text_wrapping == 1
					&& region_width_inches > max_region_width_inches)) {
		bmpregion_analyze_justification_and_line_spacing(newregion, breakinfo,
				masterinfo, colcount, rowcount, pageinfo, 1, force_scale);
		return;
	}

	/*
	 ** If allowed, re-submit each vertical region individually
	 */
	if (allow_vertical_breaks) {
		bmpregion_analyze_justification_and_line_spacing(newregion, breakinfo,
				masterinfo, colcount, rowcount, pageinfo, 0, force_scale);
		return;
	}

	/* AT THIS POINT, BITMAP IS NOT TO BE BROKEN UP HORIZONTALLY OR VERTICALLY */
	/* (IT CAN STILL BE FULLY JUSTIFIED IF ALLOWED.) */

	/*
	 ** Scale region to fit the destination device width and add to the master bitmap.
	 **
	 **
	 ** Start by copying source region to new bitmap
	 **
	 */
// printf("c1=%d\n",newregion->c1);
	/* Is it a figure? */
	tall_region = (double) (newregion->r2 - newregion->r1 + 1) / src_dpi
			>= dst_min_figure_height_in;
	/* Re-trim left and right? */
	if ((trim_flags & 0x80) == 0) {
		/* If tall region and figure justification turned on ... */
		if ((tall_region && dst_figure_justify >= 0)
				/* ... or if centered region ... */
				|| ((trim_flags & 3) != 3
						&& ((justification_flags & 3) == 1
								|| ((justification_flags & 3) == 3
										&& (dst_justify == 1
												|| (dst_justify < 0
														&& (justification_flags
																& 0xc) == 4)))))) {
			bmpregion_trim_margins(newregion, colcount, rowcount, 0x3);
			nc = newregion->c2 - newregion->c1 + 1;
			region_width_inches = (double) nc / src_dpi;
		}
	}
#if (WILLUSDEBUGX & 1)
	aprintf("atomic region:  " ANSI_CYAN "%.2f x %.2f in" ANSI_NORMAL " c1=%d, (%d x %d) (rbdel=%d) just=0x%02X\n",
			(double)(newregion->c2-newregion->c1+1)/src_dpi,
			(double)(newregion->r2-newregion->r1+1)/src_dpi,
			newregion->c1,
			(newregion->c2-newregion->c1+1),
			(newregion->r2-newregion->r1+1),
			rowbase_delta,justification_flags);
#endif
	/* Copy atomic region into bmp */
	bmp = &_bmp;
	bmp_init(bmp);
	bmp->width = nc;
	bmp->height = nr;
	if (dst_color)
		bmp->bpp = 24;
	else {
		bmp->bpp = 8;
		for (i = 0; i < 256; i++)
			bmp->red[i] = bmp->blue[i] = bmp->green[i] = i;
	}
	bmp_alloc(bmp);
	bpp = dst_color ? 3 : 1;
// printf("r1=%d, r2=%d\n",newregion->r1,newregion->r2);
	for (i = newregion->r1; i <= newregion->r2; i++) {
		unsigned char *psrc, *pdst;

		pdst = bmp_rowptr_from_top(bmp, i - newregion->r1);
		psrc = bmp_rowptr_from_top(dst_color ? newregion->bmp : newregion->bmp8,
				i) + bpp * newregion->c1;
		memcpy(pdst, psrc, nc * bpp);
	}
	/*
	 ** Now scale to appropriate destination size.
	 **
	 ** force_scale is used to maintain uniform scaling so that
	 ** most of the regions are scaled at the same value.
	 **
	 ** force_scale = -2.0 : Fit column width to display width
	 ** force_scale = -1.0 : Use output dpi unless the region doesn't fit.
	 **                      In that case, scale it down until it fits.
	 ** force_scale > 0.0  : Scale region by force_scale.
	 **
	 */
	/* Max viewable pixel width on device screen */
	wmax = (int) (masterinfo->bmp.width - (dst_marleft + dst_marright) * dst_dpi
			+ 0.5);
	if (force_scale > 0.)
		w = (int) (force_scale * bmp->width + 0.5);
	else {
		if (region_width_inches < max_region_width_inches)
			w = (int) (region_width_inches * dst_dpi + .5);
		else
			w = wmax;
	}
	/* Special processing for tall regions (likely figures) */
	if (tall_region && w < wmax && dst_fit_to_page != 0) {
		if (dst_fit_to_page < 0)
			w = wmax;
		else {
			w = (int) (w * (1. + (double) dst_fit_to_page / 100.) + 0.5);
			if (w > wmax)
				w = wmax;
		}
	}
	h = (int) (((double) w / bmp->width) * bmp->height + .5);

	/*
	 ** If scaled dimensions are finite, add to master bitmap.
	 */
	if (w > 0 && h > 0) {
		WILLUSBITMAP *tmp, _tmp;
		int nocr;

		last_scale_factor_internal = (double) w / bmp->width;
#ifdef HAVE_OCR
		if (dst_ocr)
		{
			nocr=(int)((double)bmp->width/w+0.5);
			if (nocr < 1)
			nocr=1;
			if (nocr > 10)
			nocr=10;
			w *= nocr;
			h *= nocr;
		}
		else
#endif
		nocr = 1;
		tmp = &_tmp;
		bmp_init(tmp);
		bmp_resample(tmp, bmp, (double) 0., (double) 0., (double) bmp->width,
				(double) bmp->height, w, h);
		bmp_free(bmp);
		/*
		 {
		 static int nn=0;
		 char filename[256];
		 sprintf(filename,"xxx%02d.png",nn++);
		 bmp_write(tmp,filename,stdout,100);
		 }
		 */
		/*
		 ** Add scaled bitmap to destination.
		 */
		/* Allocate more rows if necessary */
		while (masterinfo->rows + tmp->height / nocr > masterinfo->bmp.height)
			bmp_more_rows(&masterinfo->bmp, 1.4, 255);
		/* Check special justification for tall regions */
		if (tall_region && dst_figure_justify >= 0)
			justification_flags = dst_figure_justify;
		bmp_src_to_dst(masterinfo, tmp, justification_flags, region->bgcolor,
				nocr, (int) ((double) src_dpi * tmp->width / bmp->width + .5));
		bmp_free(tmp);
	}

	/* Store delta to base of text row (used by wrapbmp_flush()) */
	last_rowbase_internal = rowbase_delta;
	/* .05 was .072 in v1.35 */
	/* dst_add_gap(&masterinfo->bmp,&masterinfo->rows,0.05); */
	/*
	 if (revert)
	 restore_output_dpi();
	 */
}

static void dst_add_gap_src_pixels(char *caller, MASTERINFO *masterinfo,
		int pixels)

{
	double gap_inches;

	/*
	 aprintf("%s " ANSI_GREEN "dst_add" ANSI_NORMAL " %.3f in (%d pix)\n",caller,(double)pixels/src_dpi,pixels);
	 */
	if (last_scale_factor_internal < 0.)
		gap_inches = (double) pixels / src_dpi;
	else
		gap_inches = (double) pixels * last_scale_factor_internal / dst_dpi;
	gap_inches *= vertical_multiplier;
	if (gap_inches > max_vertical_gap_inches)
		gap_inches = max_vertical_gap_inches;
	dst_add_gap(masterinfo, gap_inches);
}

static void dst_add_gap(MASTERINFO *masterinfo, double inches)

{
	int n, bw;
	unsigned char *p;

	n = (int) (inches * dst_dpi + .5);
	if (n < 1)
		n = 1;
	while (masterinfo->rows + n > masterinfo->bmp.height)
		bmp_more_rows(&masterinfo->bmp, 1.4, 255);
	bw = bmp_bytewidth(&masterinfo->bmp) * n;
	p = bmp_rowptr_from_top(&masterinfo->bmp, masterinfo->rows);
	memset(p, 255, bw);
	masterinfo->rows += n;
}

/*
 **
 ** Add already-scaled source bmp to destination bmp.
 ** Source bmp may be narrower than destination--if so, it may be fully justifed.
 ** dst = destination bitmap
 ** src = source bitmap
 ** dst and src bpp must match!
 ** All rows of src are applied to masterinfo->bmp starting at row masterinfo->rows
 ** Full justification is done if requested.
 **
 */
static void bmp_src_to_dst(MASTERINFO *masterinfo, WILLUSBITMAP *src,
		int justification_flags, int whitethresh, int nocr, int dpi)

{
	WILLUSBITMAP *src1, _src1;
	WILLUSBITMAP *tmp;
#ifdef HAVE_OCR
	WILLUSBITMAP _tmp;
	OCRWORDS _words,*words;
#endif
	int dw, dw2;
	int i, srcbytespp, srcbytewidth, go_full;
	int destwidth, destx0, just;

	if (src->width <= 0 || src->height <= 0)
		return;
	/*
	 printf("@bmp_src_to_dst.  dst->bpp=%d, src->bpp=%d, src=%d x %d\n",masterinfo->bmp.bpp,src->bpp,src->width,src->height);
	 */
	/*
	 {
	 static int count=0;
	 static char filename[256];

	 printf("    @bmp_src_to_dst...\n");
	 sprintf(filename,"src%05d.png",count++);
	 bmp_write(src,filename,stdout,100);
	 }
	 */
	/*
	 if (fulljust && dst_fulljustify)
	 printf("srcbytespp=%d, srcbytewidth=%d, destwidth=%d, destx0=%d, destbytewidth=%d\n",
	 srcbytespp,srcbytewidth,destwidth,destx0,dstbytewidth);
	 */

	/* Determine what justification to use */
	/* Left? */
	if ((justification_flags & 3) == 0 /* Mandatory left just */
			|| ((justification_flags & 3) == 3 /* Use user settings */
					&& (dst_justify == 0
							|| (dst_justify < 0
									&& (justification_flags & 0xc) == 0))))
		just = 0;
	else if ((justification_flags & 3) == 2
			|| ((justification_flags & 3) == 3
					&& (dst_justify == 2
							|| (dst_justify < 0
									&& (justification_flags & 0xc) == 8))))
		just = 2;
	else
		just = 1;

	/* Full justification? */
	destwidth = (int) (masterinfo->bmp.width
			- (dst_marleft + dst_marright) * dst_dpi + .5);
	go_full = (destwidth * nocr > src->width
			&& (((justification_flags & 0x30) == 0x10)
					|| ((justification_flags & 0x30) == 0 // Use user settings
							&& (dst_fulljustify == 1
									|| (dst_fulljustify < 0
											&& (justification_flags & 0xc0)
													== 0x40)))));

	/* Put fully justified text into src1 bitmap */
	if (go_full) {
		src1 = &_src1;
		bmp_init(src1);
		bmp_fully_justify(src1, src, nocr * destwidth, whitethresh, just);
	} else
		src1 = src;

#if (WILLUSDEBUGX & 1)
	printf("@bmp_src_to_dst:  jflags=0x%02X just=%d, go_full=%d\n",justification_flags,just,go_full);
	printf("    destx0=%d, destwidth=%d, src->width=%d\n",destx0,destwidth,src->width);
#endif
#ifdef HAVE_OCR
	if (dst_ocr)
	{
		/* Run OCR on the bitmap */
		words=&_words;
		ocrwords_init(words);
		ocrwords_fill_in(words,src1,whitethresh,dpi);
		/* Scale bitmap and word positions to destination size */
		if (nocr>1)
		{
			tmp=&_tmp;
			bmp_init(tmp);
			bmp_integer_resample(tmp,src1,nocr);
			ocrwords_int_scale(words,nocr);
		}
		else
		tmp=src1;
	}
	else
#endif
	tmp = src1;
	/*
	 printf("writing...\n");
	 ocrwords_box(words,tmp);
	 bmp_write(tmp,"out.png",stdout,100);
	 exit(10);
	 */
	destx0 = (int) (dst_marleft * dst_dpi + .5);
	if (just == 0)
		dw = destx0;
	else if (just == 1)
		dw = destx0 + (destwidth - tmp->width) / 2;
	else
		dw = destx0 + destwidth - tmp->width;
	if (dw < 0)
		dw = 0;
	/* Add OCR words to destination list */
#ifdef HAVE_OCR
	if (dst_ocr)
	{
		ocrwords_offset(words,dw,masterinfo->rows);
		ocrwords_concatenate(dst_ocrwords,words);
		ocrwords_free(words);
	}
#endif

	/* Add tmp bitmap to dst */
	srcbytespp = tmp->bpp == 24 ? 3 : 1;
	srcbytewidth = tmp->width * srcbytespp;
	dw2 = masterinfo->bmp.width - tmp->width - dw;
	dw *= srcbytespp;
	dw2 *= srcbytespp;
	for (i = 0; i < tmp->height; i++, masterinfo->rows++) {
		unsigned char *pdst, *psrc;

		psrc = bmp_rowptr_from_top(tmp, i);
		pdst = bmp_rowptr_from_top(&masterinfo->bmp, masterinfo->rows);
		memset(pdst, 255, dw);
		pdst += dw;
		memcpy(pdst, psrc, srcbytewidth);
		pdst += srcbytewidth;
		memset(pdst, 255, dw2);
	}

#ifdef HAVE_OCR
	if (dst_ocr && nocr>1)
	bmp_free(tmp);
#endif
	if (go_full)
		bmp_free(src1);
}

/*
 ** Spread words out in src and put into jbmp at scaling nocr
 ** In case the text can't be expanded enough,
 **     just=0 (left justify), 1 (center), 2 (right justify)
 */
static void bmp_fully_justify(WILLUSBITMAP *jbmp, WILLUSBITMAP *src,
		int jbmpwidth, int whitethresh, int just)

{
	BMPREGION srcregion;
	BREAKINFO *colbreaks, _colbreaks;
	WILLUSBITMAP gray;
	int *gappos, *gapsize;
	int i, srcbytespp, srcbytewidth, jbmpbytewidth, newwidth, destx0, ng;
	static char *funcname = "bmp_fully_justify";

	/*
	 {
	 char filename[256];
	 count++;
	 sprintf(filename,"out%03d.png",count);
	 bmp_write(src,filename,stdout,100);
	 }
	 */
	/* Init/allocate destination bitmap */
	jbmp->width = jbmpwidth;
	jbmp->height = src->height;
	jbmp->bpp = src->bpp;
	if (jbmp->bpp == 8)
		for (i = 0; i < 256; i++)
			jbmp->red[i] = jbmp->green[i] = jbmp->blue[i] = i;
	bmp_alloc(jbmp);

	/* Find breaks in the text row */
	colbreaks = &_colbreaks;
	colbreaks->textrow = NULL;
	srcregion.bgcolor = whitethresh;
	srcregion.c1 = 0;
	srcregion.c2 = src->width - 1;
	srcregion.r1 = 0;
	srcregion.r2 = src->height - 1;
	srcbytespp = src->bpp == 24 ? 3 : 1;
	if (srcbytespp == 3) {
		srcregion.bmp = src;
		srcregion.bmp8 = &gray;
		bmp_init(srcregion.bmp8);
		bmp_convert_to_greyscale_ex(srcregion.bmp8, src);
	} else {
		srcregion.bmp = src;
		srcregion.bmp8 = src;
	}
	breakinfo_alloc(103, colbreaks, src->width);
	{
		int *colcount, *rowcount;

		colcount = rowcount = NULL;
		willus_dmem_alloc_warn(8, (void **) &colcount,
				sizeof(int) * (src->width + src->height), funcname, 10);
		rowcount = &colcount[src->width];
		bmpregion_one_row_find_breaks(&srcregion, colbreaks, colcount, rowcount,
				1);
		willus_dmem_free(8, (double **) &colcount, funcname);
	}
	if (srcbytespp == 3)
		bmp_free(srcregion.bmp8);
	ng = colbreaks->n - 1;
	gappos = NULL;
	if (ng > 0) {
		int maxsize, ms2, mingap, j;

		willus_dmem_alloc_warn(9, (void **) &gappos, (2 * sizeof(int)) * ng,
				funcname, 10);
		gapsize = &gappos[ng];
		for (i = 0; i < ng; i++) {
			gappos[i] = colbreaks->textrow[i].c2 + 1;
			gapsize[i] = colbreaks->textrow[i].gap;
		}

		/* Take only the largest group of gaps */
		for (maxsize = i = 0; i < ng; i++)
			if (maxsize < gapsize[i])
				maxsize = gapsize[i];
		mingap = srcregion.lcheight * word_spacing;
		if (mingap < 2)
			mingap = 2;
		if (maxsize > mingap)
			maxsize = mingap;
		ms2 = maxsize / 2;
		for (i = j = 0; i < ng; i++)
			if (gapsize[i] > ms2) {
				if (j != i) {
					gapsize[j] = gapsize[i];
					gappos[j] = gappos[i];
				}
				j++;
			}
		ng = j;

		/* Figure out total pixel expansion */
		newwidth = src->width * 1.25;
		if (newwidth > jbmp->width)
			newwidth = jbmp->width;
	} else
		newwidth = src->width;
	breakinfo_free(103, colbreaks);

	/* Starting column in destination bitmap */
	if (just == 1)
		destx0 = (jbmp->width - newwidth) / 2;
	else if (just == 2)
		destx0 = (jbmp->width - newwidth);
	else
		destx0 = 0;

	jbmpbytewidth = bmp_bytewidth(jbmp);
	srcbytewidth = bmp_bytewidth(src);

	/* Clear entire fully justified bitmap */
	memset(bmp_rowptr_from_top(jbmp, 0), 255, jbmpbytewidth * jbmp->height);

	/* Spread out source pieces to fully justify them */
	for (i = 0; i <= ng; i++) {
		int j, dx0, dx, sx0;
		unsigned char *pdst, *psrc;

		dx = i < ng ?
				(i > 0 ? gappos[i] - gappos[i - 1] : gappos[i] + 1) :
				(i > 0 ? src->width - (gappos[i - 1] + 1) : src->width);
		dx *= srcbytespp;
		sx0 = i == 0 ? 0 : (gappos[i - 1] + 1);
		dx0 = destx0 + sx0 + (i == 0 ? 0 : (newwidth - src->width) * i / ng);
		psrc = bmp_rowptr_from_top(src, 0) + sx0 * srcbytespp;
		pdst = bmp_rowptr_from_top(jbmp, 0) + dx0 * srcbytespp;
		for (j = 0; j < src->height; j++, pdst += jbmpbytewidth, psrc +=
				srcbytewidth)
			memcpy(pdst, psrc, dx);
	}
	if (gappos != NULL)
		willus_dmem_free(9, (double **) &gappos, funcname);
}

/*
 ** flags&1  : trim c1
 ** flags&2  : trim c2
 ** flags&4  : trim r1
 ** flags&8  : trim r2
 ** flags&16 : Find rowbase, font size, etc.
 **
 ** Row base is where row dist crosses 50% on r2 side.
 ** Font size is where row dist crosses 5% on other side (r1 side).
 ** Lowercase font size is where row dist crosses 50% on r1 side.
 **
 ** For 12 pt font:
 **     Single spacing is 14.66 pts (Calibri), 13.82 pts (Times), 13.81 pts (Arial)
 **     Size of cap letter is 7.7 pts (Calibri), 8.1 pts (Times), 8.7 pts (Arial)
 **     Size of small letter is 5.7 pts (Calibri), 5.6 pts (Times), 6.5 pts (Arial)
 ** Mean line spacing = 1.15 - 1.22 (~1.16)
 ** Mean cap height = 0.68
 ** Mean small letter height = 0.49
 **
 */
static void bmpregion_trim_margins(BMPREGION *region, int *colcount0,
		int *rowcount0, int flags)

{
	int i, j, n; /* ,r1,r2,dr1,dr2,dr,vtrim,vspace; */
	int *colcount, *rowcount;
	static char *funcname = "bmpregion_trim_margins";

	/* To detect a hyphen, we need to trim and calc text base row */
	if (flags & 32)
		flags |= 0x1f;
	if (colcount0 == NULL)
		willus_dmem_alloc_warn(10, (void **) &colcount,
				sizeof(int) * (region->c2 + 1), funcname, 10);
	else
		colcount = colcount0;
	if (rowcount0 == NULL)
		willus_dmem_alloc_warn(11, (void **) &rowcount,
				sizeof(int) * (region->r2 + 1), funcname, 10);
	else
		rowcount = rowcount0;
	n = region->c2 - region->c1 + 1;
	/*
	 printf("Trim:  reg=(%d,%d) - (%d,%d)\n",region->c1,region->r1,region->c2,region->r2);
	 if (region->c2+1 > cca || region->r2+1 > rca)
	 {
	 printf("A ha 0!\n");
	 exit(10);
	 }
	 */
	memset(colcount, 0, (region->c2 + 1) * sizeof(int));
	memset(rowcount, 0, (region->r2 + 1) * sizeof(int));
	for (j = region->r1; j <= region->r2; j++) {
		unsigned char *p;
		p = bmp_rowptr_from_top(region->bmp8, j) + region->c1;
		for (i = 0; i < n; i++, p++)
			if (p[0] < region->bgcolor) {
				rowcount[j]++;
				colcount[i + region->c1]++;
			}
	}
	/*
	 ** Trim excess margins
	 */
	if (flags & 1)
		trim_to(colcount, &region->c1, region->c2,
				src_left_to_right ? 2.0 : 4.0);
	if (flags & 2)
		trim_to(colcount, &region->c2, region->c1,
				src_left_to_right ? 4.0 : 2.0);
	if (colcount0 == NULL)
		willus_dmem_free(10, (double **) &colcount, funcname);
	if (flags & 4)
		trim_to(rowcount, &region->r1, region->r2, 4.0);
	if (flags & 8)
		trim_to(rowcount, &region->r2, region->r1, 4.0);
	if (flags & 16) {
		int maxcount, mc2, h2;
		double f;

		maxcount = 0;
		for (i = region->r1; i <= region->r2; i++)
			if (rowcount[i] > maxcount)
				maxcount = rowcount[i];
		mc2 = maxcount / 2;
		for (i = region->r2; i >= region->r1; i--)
			if (rowcount[i] > mc2)
				break;
		region->rowbase = i;
		for (i = region->r1; i <= region->r2; i++)
			if (rowcount[i] > mc2)
				break;
		region->h5050 = region->lcheight = region->rowbase - i + 1;
		mc2 = maxcount / 20;
		for (i = region->r1; i <= region->r2; i++)
			if (rowcount[i] > mc2)
				break;
		region->capheight = region->rowbase - i + 1;
		/*
		 ** Sanity check capheight and lcheight
		 */
		h2 = height2_calc(&rowcount[region->r1], region->r2 - region->r1 + 1);
#if (WILLUSDEBUGX & 8)
		if (region->c2-region->c1 > 1500)
		printf("reg %d x %d (%d,%d) - (%d,%d) h2=%d ch/h2=%g\n",region->c2-region->c1+1,region->r2-region->r1+1,region->c1,region->r1,region->c2,region->r2,h2,(double)region->capheight/h2);
#endif
		if (region->capheight < h2 * 0.75)
			region->capheight = h2;
		f = (double) region->lcheight / region->capheight;
		if (f < 0.55)
			region->lcheight = (int) (0.72 * region->capheight + .5);
		else if (f > 0.85)
			region->lcheight = (int) (0.72 * region->capheight + .5);
#if (WILLUSDEBUGX & 8)
		if (region->c2-region->c1 > 1500)
		printf("    lcheight final = %d\n",region->lcheight);
#endif
#if (WILLUSDEBUGX & 10)
		if (region->c2-region->c1 > 1500 && region->r2-region->r1 < 100)
		{
			static int append=0;
			FILE *f;
			int i;
			f=fopen("textrows.ep",append==0?"w":"a");
			append=1;
			for (i=region->r1;i<=region->r2;i++)
			fprintf(f,"%d %g\n",region->rowbase-i,(double)rowcount[i]/maxcount);
			fprintf(f,"//nc\n");
			fclose(f);
		}
#endif
	} else {
		region->h5050 = region->r2 - region->r1 + 1;
		region->capheight = 0.68 * (region->r2 - region->r1 + 1);
		region->lcheight = 0.5 * (region->r2 - region->r1 + 1);
		region->rowbase = region->r2;
	}
#if (WILLUSDEBUGX & 2)
	printf("trim:\n    reg->c1=%d, reg->c2=%d\n",region->c1,region->c2);
	printf("    reg->r1=%d, reg->r2=%d, reg->rowbase=%d\n\n",region->r1,region->r2,region->rowbase);
#endif
	if (rowcount0 == NULL)
		willus_dmem_free(11, (double **) &rowcount, funcname);
}

/*
 ** Does region end in a hyphen?  If so, fill in HYPHENINFO structure.
 */
static void bmpregion_hyphen_detect(BMPREGION *region)

{
	int i, j; /* ,r1,r2,dr1,dr2,dr,vtrim,vspace; */
	int width;
	int *r0, *r1, *r2, *r3;
	int rmin, rmax, rowbytes, nrmid, rsum;
	int cstart, cend, cdir;
	unsigned char *p;
	static char *funcname = "bmpregion_hyphen_detect";

#if (WILLUSDEBUGX & 16)
	static int count=0;
	char pngfile[256];
	FILE *out;

	count++;
	printf("@bmpregion_hyphen_detect count=%d\n",count);
	sprintf(pngfile,"word%04d.png",count);
	bmpregion_write(region,pngfile);
	sprintf(pngfile,"word%04d.txt",count);
	out=fopen(pngfile,"w");
	fprintf(out,"c1=%d, c2=%d, r1=%d, r2=%d\n",region->c1,region->c2,region->r1,region->r2);
	fprintf(out,"lcheight=%d\n",region->lcheight);
#endif

	region->hyphen.ch = -1;
	region->hyphen.c2 = -1;
	if (!k2_hyphen_detect)
		return;
	width = region->c2 - region->c1 + 1;
	if (width < 2)
		return;
	willus_dmem_alloc_warn(27, (void **) &r0, sizeof(int) * 4 * width, funcname,
			10);
	r1 = &r0[width];
	r2 = &r1[width];
	r3 = &r2[width];
	for (i = 0; i < width; i++)
		r0[i] = r1[i] = r2[i] = r3[i] = -1;
	rmin = region->rowbase - region->capheight - region->lcheight * .04;
	if (rmin < region->r1)
		rmin = region->r1;
	rmax = region->rowbase + region->lcheight * .04;
	if (rmax > region->r2)
		rmax = region->r2;
	rowbytes = bmp_bytewidth(region->bmp8);
	p = bmp_rowptr_from_top(region->bmp8, 0);
	nrmid = rsum = 0;
	if (src_left_to_right) {
		cstart = region->c2;
		cend = region->c1 - 1;
		cdir = -1;
	} else {
		cstart = region->c1;
		cend = region->c2 + 1;
		cdir = 1;
	}
#if (WILLUSDEBUGX & 16)
	fprintf(out,"   j     r0     r1     r2     r3\n");
#endif
	for (j = cstart; j != cend; j += cdir) {
		int r, rmid, dr, drmax;

// printf("j=%d\n",j);
		rmid = (rmin + rmax) / 2;
// printf("   rmid=%d\n",rmid);
		drmax = region->r2 + 1 - rmid > rmid - region->r1 + 1 ?
				region->r2 + 1 - rmid : rmid - region->r1 + 1;
		/* Find dark region closest to center line */
		for (dr = 0; dr < drmax; dr++) {
			if (rmid + dr <= region->r2
					&& p[(rmid + dr) * rowbytes + j] < region->bgcolor)
				break;
			if (rmid - dr >= region->r1
					&& p[(rmid - dr) * rowbytes + j] < region->bgcolor) {
				dr = -dr;
				break;
			}
		}
#if (WILLUSDEBUGX & 16)
		fprintf(out,"    dr=%d/%d, rmid+dr=%d, rmin=%d, rmax=%d, nrmid=%d\n",dr,drmax,rmid+dr,rmin,rmax,nrmid);
#endif
		/* No dark detected or mark is outside hyphen region? */
		/* Termination criterion #1 */
		if (dr >= drmax
				|| (nrmid > 2 && (double) nrmid / region->lcheight > .1
						&& (rmid + dr < rmin || rmid + dr > rmax))) {
			if (region->hyphen.ch >= 0 && dr >= drmax)
				continue;
			if (nrmid > 2 && (double) nrmid / region->lcheight > .35) {
				region->hyphen.ch = j - cdir;
				region->hyphen.r1 = rmin;
				region->hyphen.r2 = rmax;
			}
			if (dr < drmax) {
				region->hyphen.c2 = j;
				break;
			}
			continue;
		}
		if (region->hyphen.ch >= 0) {
			region->hyphen.c2 = j;
			break;
		}
		nrmid++;
		rmid += dr;
		/* Dark spot is outside expected hyphen area */
		/*
		 if (rmid<rmin || rmid>rmax)
		 {
		 if (nrmid>0)
		 break;
		 continue;
		 }
		 */
		for (r = rmid; r >= region->r1; r--)
			if (p[r * rowbytes + j] >= region->bgcolor)
				break;
		r1[j - region->c1] = r + 1;
		r0[j - region->c1] = -1;
		if (r >= region->r1) {
			for (; r >= region->r1; r--)
				if (p[r * rowbytes + j] < region->bgcolor)
					break;
			if (r >= region->r1)
				r0[j - region->c1] = r;
		}
		for (r = rmid; r <= region->r2; r++)
			if (p[r * rowbytes + j] >= region->bgcolor)
				break;
		r2[j - region->c1] = r - 1;
		r3[j - region->c1] = -1;
		if (r <= region->r2) {
			for (; r <= region->r2; r++)
				if (p[r * rowbytes + j] < region->bgcolor)
					break;
			if (r <= region->r2)
				r3[j - region->c1] = r;
		}
#if (WILLUSDEBUGX & 16)
		fprintf(out," %4d  %4d  %4d  %4d  %4d\n",j,r0[j-region->c1],r1[j-region->c1],r2[j-region->c1],r3[j-region->c1]);
#endif
		if (region->hyphen.c2 < 0
				&& (r0[j - region->c1] >= 0 || r3[j - region->c1] >= 0))
			region->hyphen.c2 = j;
		/* Termination criterion #2 */
		if (nrmid > 2 && (double) nrmid / region->lcheight > .35
				&& (r1[j - region->c1] > rmax || r2[j - region->c1] < rmin)) {
			region->hyphen.ch = j - cdir;
			region->hyphen.r1 = rmin;
			region->hyphen.r2 = rmax;
			if (region->hyphen.c2 < 0)
				region->hyphen.c2 = j;
			break;
		}
		// rc=(r1[j-region->c1]+r2[j-region->c1])/2;
		/* DQ possible hyphen if r1/r2 out of range */
		if (nrmid > 1) {
			/* Too far away from last values? */
			if ((double) (rmin - r1[j - region->c1]) / region->lcheight > .1
					|| (double) (r2[j - region->c1] - rmax) / region->lcheight
							> .1)
				break;
			if ((double) nrmid / region->lcheight > .1 && nrmid > 1) {
				if ((double) fabs(rmin - r1[j - region->c1]) / region->lcheight
						> .1
						|| (double) (rmax - r2[j - region->c1])
								/ region->lcheight > .1)
					break;
			}
		}
		if (nrmid == 1 || r1[j - region->c1] < rmin)
			rmin = r1[j - region->c1];
		if (nrmid == 1 || r2[j - region->c1] > rmax)
			rmax = r2[j - region->c1];
		if ((double) nrmid / region->lcheight > .1 && nrmid > 1) {
			double rmean;

			/* Can't be too thick */
			if ((double) (rmax - rmin) / region->lcheight > .55
					|| (double) (rmax - rmin) / region->lcheight < .08)
				break;
			/* Must be reasonably well centered above baseline */
			rmean = (double) (rmax + rmin) / 2;
			if ((double) (region->rowbase - rmean) / region->lcheight < 0.35
					|| (double) (region->rowbase - rmean) / region->lcheight
							> 0.85)
				break;
			if ((double) (region->rowbase - rmax) / region->lcheight < 0.2
					|| (double) (region->rowbase - rmin) / region->lcheight
							> 0.92)
				break;
		}
	}
#if (WILLUSDEBUGX & 16)
	fprintf(out,"   ch=%d, c2=%d, r1=%d, r2=%d\n",region->hyphen.ch,region->hyphen.c2,region->hyphen.r1,region->hyphen.r2);
	fclose(out);
#endif
	/* More sanity checks--better to miss a hyphen than falsely detect it. */
	if (region->hyphen.ch >= 0) {
		double ar;
		/* If it's only a hyphen, then it's probably actually a dash--don't detect it. */
		if (region->hyphen.c2 < 0)
			region->hyphen.ch = -1;
		/* Check aspect ratio */
		ar = (double) (region->hyphen.r2 - region->hyphen.r1) / nrmid;
		if (ar < 0.08 || ar > 0.75)
			region->hyphen.ch = -1;
	}
	willus_dmem_free(27, (double **) &r0, funcname);
#if (WILLUSDEBUGX & 16)
	if (region->hyphen.ch>=0)
	printf("\n\n   GOT HYPHEN.\n\n");
	printf("   Exiting bmpregion_hyphen_detect\n");
#endif
}

#if (defined(WILLUSDEBUGX) || defined(WILLUSDEBUG))
static void bmpregion_write(BMPREGION *region,char *filename)

{
	int i,bpp;
	WILLUSBITMAP *bmp,_bmp;

	bmp=&_bmp;
	bmp_init(bmp);
	bmp->width=region->c2-region->c1+1;
	bmp->height=region->r2-region->r1+1;
	bmp->bpp=region->bmp->bpp;
	bpp=bmp->bpp==8?1:3;
	bmp_alloc(bmp);
	for (i=0;i<256;i++)
	bmp->red[i]=bmp->green[i]=bmp->blue[i]=i;
	for (i=0;i<bmp->height;i++)
	{
		unsigned char *s,*d;
		s=bmp_rowptr_from_top(region->bmp,region->r1+i)+region->c1*bpp;
		d=bmp_rowptr_from_top(bmp,i);
		memcpy(d,s,bmp->width*bpp);
	}
	bmp_write(bmp,filename,stdout,97);
	bmp_free(bmp);
}
#endif

#if (WILLUSDEBUGX & 6)
static void breakinfo_echo(BREAKINFO *breakinfo)

{
	int i;
	printf("@breakinfo_echo...\n");
	for (i=0;i<breakinfo->n;i++)
	printf("    %2d.  r1=%4d, rowbase=%4d, r2=%4d, c1=%4d, c2=%4d\n",
			i+1,breakinfo->textrow[i].r1,
			breakinfo->textrow[i].rowbase,
			breakinfo->textrow[i].r2,
			breakinfo->textrow[i].c1,
			breakinfo->textrow[i].c2);
}
#endif

/*
 ** Calculate weighted height of a rectangular region.
 ** This weighted height is intended to be close to the height of
 ** a capital letter, or the height of the majority of the region.
 **
 */
static int height2_calc(int *rc, int n)

{
	int i, thresh, i1, h2;
	int *c;
	static char *funcname = "height2_calc";
#if (WILLUSDEBUGX & 8)
	int cmax;
#endif

	if (n <= 0)
		return (1);
	willus_dmem_alloc_warn(12, (void **) &c, sizeof(int) * n, funcname, 10);
	memcpy(c, rc, n * sizeof(int));
	sorti(c, n);
#if (WILLUSDEBUGX & 8)
	cmax=c[n-1];
#endif
	for (i = 0; i < n - 1 && c[i] == 0; i++)
		;
	thresh = c[(i + n) / 3];
	willus_dmem_free(12, (double **) &c, funcname);
	for (i = 0; i < n - 1; i++)
		if (rc[i] >= thresh)
			break;
	i1 = i;
	for (i = n - 1; i > i1; i--)
		if (rc[i] >= thresh)
			break;
#if (WILLUSDEBUGX & 8)
// printf("thresh = %g, i1=%d, i2=%d\n",(double)thresh/cmax,i1,i);
#endif
	h2 = i - i1 + 1; /* Guaranteed to be >=1 */
	return (h2);
}

static void trim_to(int *count, int *i1, int i2, double gaplen)

{
	int del, dcount, igaplen, clevel, dlevel, defect_start, last_defect;

	igaplen = (int) (gaplen * src_dpi / 72.);
	if (igaplen < 1)
		igaplen = 1;
	/* clevel=(int)(defect_size_pts*src_dpi/72./3.); */
	clevel = 0;
	dlevel = (int) (pow(defect_size_pts * src_dpi / 72., 2.) * PI / 4. + .5);
	del = i2 > (*i1) ? 1 : -1;
	defect_start = -1;
	last_defect = -1;
	dcount = 0;
	for (; (*i1) != i2; (*i1) = (*i1) + del) {
		if (count[(*i1)] <= clevel) {
			dcount = 0; /* Reset defect size */
			continue;
		}
		/* Mark found */
		if (dcount == 0) {
			if (defect_start >= 0)
				last_defect = defect_start;
			defect_start = (*i1);
		}
		dcount += count[(*i1)];
		if (dcount >= dlevel) {
			if (last_defect >= 0 && abs(defect_start - last_defect) <= igaplen)
				(*i1) = last_defect;
			else
				(*i1) = defect_start;
			return;
		}
	}
	if (defect_start < 0)
		return;
	if (last_defect < 0) {
		(*i1) = defect_start;
		return;
	}
	if (abs(defect_start - last_defect) <= igaplen)
		(*i1) = last_defect;
	else
		(*i1) = defect_start;
}

/*
 ** A region that needs its line spacing and justification analyzed.
 **
 ** The region may be wider than the max desirable region width.
 **
 ** Input:  breakinfo should be valid row-break information for the region.
 **
 ** Calls bmpregion_one_row_wrap_and_add() for each text row from the
 ** breakinfo structure that is within the region.
 **
 */
static void bmpregion_analyze_justification_and_line_spacing(BMPREGION *region,
		BREAKINFO *breakinfo, MASTERINFO *masterinfo, int *colcount,
		int *rowcount, PAGEINFO *pageinfo, int allow_text_wrapping,
		double force_scale)

{
	int i, i1, i2, ntr, mean_row_gap, maxgap, line_spacing, nls, nch;
	BMPREGION *newregion, _newregion;
	double *id, *c1, *c2, *ch, *lch, *ls;
	int *just, *indented, *short_line;
	double capheight, lcheight, fontsize;
	int textheight, ragged_right, src_line_spacing;
	static char *funcname = "bmpregion_analyze_justification_and_line_spacing";

#if (WILLUSDEBUGX & 1)
	printf("@bmpregion_analyze_justification_and_line_spacing");
	printf("    (%d,%d) - (%d,%d)\n",region->c1,region->r1,region->c2,region->r2);
	printf("    centering = %d\n",breakinfo->centered);
#endif
#if (WILLUSDEBUGX & 2)
	breakinfo_echo(breakinfo);
#endif

	/* Locate the vertical part indices in the breakinfo structure */
	newregion = &_newregion;
	breakinfo_sort_by_row_position(breakinfo);
	for (i = 0; i < breakinfo->n; i++) {
		TEXTROW *textrow;
		textrow = &breakinfo->textrow[i];
		if ((textrow->r1 + textrow->r2) / 2 >= region->r1)
			break;
	}
	if (i >= breakinfo->n)
		return;
	i1 = i;
	for (; i < breakinfo->n; i++) {
		TEXTROW *textrow;
		textrow = &breakinfo->textrow[i];
		if ((textrow->r1 + textrow->r2) / 2 > region->r2)
			break;
	}
	i2 = i - 1;
	if (i2 < i1)
		return;
	ntr = i2 - i1 + 1;
#if (WILLUSDEBUGX & 1)
	printf("    i1=%d, i2=%d, ntr=%d\n",i1,i2,ntr);
#endif

	willus_dmem_alloc_warn(13, (void **) &c1, sizeof(double) * 6 * ntr,
			funcname, 10);
	willus_dmem_alloc_warn(14, (void **) &just, sizeof(int) * 3 * ntr, funcname,
			10);
	c2 = &c1[ntr];
	ch = &c2[ntr];
	lch = &ch[ntr];
	ls = &lch[ntr];
	id = &ls[ntr];
	indented = &just[ntr];
	short_line = &indented[ntr];
	for (i = 0; i < ntr; i++)
		id[i] = i;

	/* Find baselines / font size */
	capheight = lcheight = 0.;
	maxgap = -1;
	for (nch = nls = 0, i = i1; i <= i2; i++) {
		TEXTROW *textrow;
		double ar, rh;
		int marking_flags;

		textrow = &breakinfo->textrow[i];
		c1[i - i1] = (double) textrow->c1;
		c2[i - i1] = (double) textrow->c2;
		if (i < i2 && maxgap < textrow->gap) {
			maxgap = textrow->gap;
			if (maxgap < 2)
				maxgap = 2;
		}
		if (textrow->c2 < textrow->c1)
			ar = 100.;
		else
			ar = (double) (textrow->r2 - textrow->r1 + 1)
					/ (double) (textrow->c2 - textrow->c1 + 1);
		rh = (double) (textrow->r2 - textrow->r1 + 1) / src_dpi;
		if (i < i2 && ar <= no_wrap_ar_limit
				&& rh <= no_wrap_height_limit_inches)
			ls[nls++] = breakinfo->textrow[i + 1].r1 - textrow->r1;
		if (ar <= no_wrap_ar_limit && rh <= no_wrap_height_limit_inches) {
			ch[nch] = textrow->capheight;
			lch[nch] = textrow->lcheight;
			nch++;
		}

		/* Mark region w/gray, mark rowbase also */
		marking_flags = (i == i1 ? 0 : 1) | (i == i2 ? 0 : 2);
		if (i < i2 || textrow->r2 - textrow->rowbase > 1)
			marking_flags |= 0x10;
		(*newregion) = (*region);
		newregion->r1 = textrow->r1;
		newregion->r2 = textrow->r2;
		newregion->c1 = textrow->c1;
		newregion->c2 = textrow->c2;
		newregion->rowbase = textrow->rowbase;
		mark_source_page(newregion, 5, marking_flags);
#if (WILLUSDEBUGX & 1)
		printf("   Row %2d: (%4d,%4d) - (%4d,%4d) rowbase=%4d, lch=%d, h5050=%d, rh=%d\n",i-i1+1,textrow->c1,textrow->r1,textrow->c2,textrow->r2,textrow->rowbase,textrow->lcheight,textrow->h5050,textrow->rowheight);
#endif
	}
	wrapbmp_set_maxgap(maxgap);
	if (nch < 1)
		capheight = lcheight = 2; // Err on the side of too small
	else {
		capheight = median_val(ch, nch);
		lcheight = median_val(lch, nch);
	}
// printf("capheight = %g, lcheight = %g\n",capheight,lcheight);
	bmpregion_is_centered(region, breakinfo, i1, i2, &textheight);
	/*
	 ** For 12 pt font:
	 **     Single spacing is 14.66 pts (Calibri), 13.82 pts (Times), 13.81 pts (Arial)
	 **     Size of cap letter is 7.7 pts (Calibri), 8.1 pts (Times), 8.7 pts (Arial)
	 **     Size of small letter is 5.7 pts (Calibri), 5.6 pts (Times), 6.5 pts (Arial)
	 ** Mean line spacing = 1.15 - 1.22 (~1.16)
	 ** Mean cap height = 0.68
	 ** Mean small letter height = 0.49
	 */
	fontsize = (capheight + lcheight) / 1.17;
// printf("font size = %g pts.\n",(fontsize/src_dpi)*72.);
	/*
	 ** Set line spacing for this region
	 */
	if (nls > 0)
		src_line_spacing = median_val(ls, nls);
	else
		src_line_spacing = fontsize * 1.2;
	if (vertical_line_spacing < 0
			&& src_line_spacing
					<= fabs(vertical_line_spacing) * fontsize * 1.16)
		line_spacing = src_line_spacing;
	else
		line_spacing = fabs(vertical_line_spacing) * fontsize * 1.16;
#if (WILLUSDEBUGX & 1)
	printf("   font size = %.2f pts = %d pixels\n",(fontsize/src_dpi)*72.,(int)(fontsize+.5));
	printf("   src_line_spacing = %d, line_spacing = %d\n",src_line_spacing,line_spacing);
#endif
	/*
	 if (ntr==1)
	 rheight=  (int)((breakinfo->textrow[i1].r2 - breakinfo->textrow[i1].r1)*1.25+.5);
	 else
	 rheight = (int)((double)(breakinfo->textrow[i2].rowbase - breakinfo->textrow[i1].rowbase)/(ntr-1)+.5);
	 */
	mean_row_gap = line_spacing - textheight;
	if (mean_row_gap <= 1)
		mean_row_gap = 1;

	/* Try to figure out if we have a ragged right edge */
	if (ntr < 3)
		ragged_right = 1;
	else {
		int flushcount;

		if (src_left_to_right) {
			for (flushcount = i = 0; i < ntr; i++) {
#if (WILLUSDEBUGX & 1)
				printf("    flush_factors[%d] = %g (<.5), %g in (<.1)\n",
						i,(double)(region->c2-c2[i])/textheight,(double)(region->c2-c2[i])/src_dpi);
#endif
				if ((double) (region->c2 - c2[i]) / textheight < 0.5
						&& (double) (region->c2 - c2[i]) / src_dpi < 0.1)
					flushcount++;
			}
		} else {
			for (flushcount = i = 0; i < ntr; i++) {
#if (WILLUSDEBUGX & 1)
				printf("    flush_factors[%d] = %g (<.5), %g in (<.1)\n",
						i,(double)(c1[i]-region->c1)/textheight,(double)(c1[i]-region->c1)/src_dpi);
#endif
				if ((double) (c1[i] - region->c1) / textheight < 0.5
						&& (double) (c1[i] - region->c1) / src_dpi < 0.1)
					flushcount++;
			}
		}
		ragged_right = (flushcount <= ntr / 2);
		/*
		 if (src_left_to_right)
		 {
		 sortxyd(c2,id,ntr);
		 del = region->c2 - c2[ntr-1-ntr/3];
		 sortxyd(id,c2,ntr);
		 }
		 else
		 {
		 sortxyd(c1,id,ntr);
		 del = c1[ntr/3] - region->c1;
		 sortxyd(id,c1,ntr);
		 }
		 del /= textheight;
		 printf("del=%g\n",del);
		 ragged_right = (del > 0.5);
		 */
	}
#if (WILLUSDEBUGX & 1)
	printf("ragged_right=%d\n",ragged_right);
#endif

	/* Store justification and other info line by line */
	for (i = i1; i <= i2; i++) {
		double indent1, del;
		double i1f, ilfi, i2f, ilf, ifmin, dif;
		int centered;

		TEXTROW *textrow;
		textrow = &breakinfo->textrow[i];
		i1f = (double) (c1[i - i1] - region->c1)
				/ (region->c2 - region->c1 + 1);
		i2f = (double) (region->c2 - c2[i - i1])
				/ (region->c2 - region->c1 + 1);
		ilf = src_left_to_right ? i1f : i2f;
		ilfi = ilf * (region->c2 - region->c1 + 1) / src_dpi; /* Indent in inches */
		ifmin = i1f < i2f ? i1f : i2f;
		dif = fabs(i1f - i2f);
		if (ifmin < .01)
			ifmin = 0.01;
		if (src_left_to_right)
			indent1 = (double) (c1[i - i1] - region->c1) / textheight;
		else
			indent1 = (double) (region->c2 - c2[i - i1]) / textheight;
// printf("    row %2d:  indent1=%g\n",i-i1,indent1);
		if (!breakinfo->centered) {
			indented[i - i1] = (indent1 > 0.5 && ilfi < 1.2 && ilf < .25);
			centered =
					(!indented[i - i1] && indent1 > 1.0 && dif / ifmin < 0.5);
		} else {
			centered = (dif < 0.1 || dif / ifmin < 0.5);
			indented[i - i1] = (indent1 > 0.5 && ilfi < 1.2 && ilf < .25
					&& !centered);
		}
#if (WILLUSDEBUGX & 1)
		printf("Indent %d:  %d.  indent1=%g, ilf=%g, centered=%d\n",i-i1+1,indented[i-i1],indent1,ilf,centered);
		printf("    indent1=%g, i1f=%g, i2f=%g\n",indent1,i1f,i2f);
#endif
		if (centered)
			just[i - i1] = 4;
		else {
			/*
			 ** The .01 favors left justification over right justification in
			 ** close cases.
			 */
			if (src_left_to_right)
				just[i - i1] = indented[i - i1] || (i1f < i2f + .01) ? 0 : 8;
			else
				just[i - i1] = indented[i - i1] || (i2f < i1f + .01) ? 8 : 0;
		}
		if (src_left_to_right)
			del = (double) (region->c2 - textrow->c2);
		else
			del = (double) (textrow->c1 - region->c1);
		/* Should we keep wrapping after this line? */
		if (!ragged_right)
			short_line[i - i1] = (del / textheight > 0.5);
		else
			short_line[i - i1] = (del / (region->c2 - region->c1) > 0.25);
		/* If this row is a bigger/smaller row (font) than the next row, don't wrap. */
		if (!short_line[i - i1] && i < i2) {
			TEXTROW *t1;
			t1 = &breakinfo->textrow[i + 1];
			if ((textrow->h5050 > t1->h5050 * 1.5
					|| textrow->h5050 * 1.5 < t1->h5050)
					&& (i == 0
							|| (i > 0
									&& (textrow->rowheight > t1->rowheight * 1.5
											|| textrow->rowheight * 1.5
													< t1->rowheight))))
				short_line[i - i1] = 1;
		}
		if (!ragged_right)
			just[i - i1] |= 0x40;
#if (WILLUSDEBUGX & 1)
		printf("        just[%d]=0x%02X, shortline[%d]=%d\n",i-i1,just[i-i1],i-i1,short_line[i-i1]);
		printf("        textrow->c2=%d, region->c2=%d, del=%g, textheight=%d\n",textrow->c2,region->c2,del,textheight);
#endif
		/* If short line, it should still be fully justified if it is wrapped. */
		/*
		 if (short_line[i-i1])
		 just[i-i1] = (just[i-i1]&0xf)|0x60;
		 */
	}
	/*
	 {
	 double mean1,mean2,stdev1,stdev2;
	 array_mean(c1,ntr,&mean1,&stdev1);
	 array_mean(c2,ntr,&mean2,&stdev2);
	 printf("Mean c1, c2 = %g, %g; stddevs = %g, %g\n",mean1,mean2,stdev1,stdev2);
	 printf("textheight = %d, line_spacing = %d\n",textheight,line_spacing);
	 }
	 */
	for (i = i1; i <= i2; i++) {
		TEXTROW *textrow;
		int justflags, trimflags, centered, marking_flags, gap;

#if (WILLUSDEBUGX & 1)
		aprintf("Row " ANSI_YELLOW "%d of %d" ANSI_NORMAL " (wrap=%d)\n",i-i1+1,i2-i1+1,allow_text_wrapping);
#endif
		textrow = &breakinfo->textrow[i];
		(*newregion) = (*region);
		newregion->r1 = textrow->r1;
		newregion->r2 = textrow->r2;

		/* The |3 tells it to use the user settings for left/right/center */
		justflags = just[i - i1] | 0x3;
		centered = ((justflags & 0xc) == 4);
#if (WILLUSDEBUGX & 1)
		printf("    justflags[%d]=0x%2X, centered=%d, indented=%d\n",i-i1,justflags,centered,indented[i-i1]);
#endif
		if (allow_text_wrapping) {
			/* If this line is indented or if the justification has changed, */
			/* then start a new line.                                        */
			if (centered || indented[i - i1]
					|| (i > i1
							&& (just[i - i1] & 0xc) != (just[i - i1 - 1] & 0xc))) {
#ifdef WILLUSDEBUG
				printf("wrapflush4\n");
#endif
				wrapbmp_flush(masterinfo, 0, pageinfo, 1);
			}
#ifdef WILLUSDEBUG
			printf("    c1=%d, c2=%d\n",newregion->c1,newregion->c2);
#endif
			marking_flags = 0xc | (i == i1 ? 0 : 1) | (i == i2 ? 0 : 2);
			bmpregion_one_row_wrap_and_add(newregion, breakinfo, i, i1, i2,
					masterinfo, justflags, colcount, rowcount, pageinfo,
					line_spacing, mean_row_gap, textrow->rowbase, marking_flags,
					indented[i - i1]);
			if (centered || short_line[i - i1]) {
#ifdef WILLUSDEBUG
				printf("wrapflush5\n");
#endif
				wrapbmp_flush(masterinfo, 0, pageinfo, 2);
			}
			continue;
		}
#ifdef WILLUSDEBUG
		printf("wrapflush5a\n");
#endif
		wrapbmp_flush(masterinfo, 0, pageinfo, 1);
		/* If default justifications, ignore all analysis and just center it. */
		if (dst_justify < 0 && dst_fulljustify < 0) {
			newregion->c1 = region->c1;
			newregion->c2 = region->c2;
			justflags = 0xad; /* Force centered region, no justification */
			trimflags = 0x80;
		} else
			trimflags = 0;
		/* No wrapping:  text wrap, trim flags, vert breaks, fscale, just */
		bmpregion_add(newregion, breakinfo, masterinfo, 0, trimflags, 0,
				force_scale, justflags, 5, colcount, rowcount, pageinfo, 0,
				textrow->r2 - textrow->rowbase);
		if (vertical_line_spacing < 0) {
			int gap1;
			gap1 = line_spacing - (textrow->r2 - textrow->r1 + 1);
			if (i < i2)
				gap = textrow->gap > gap1 ? gap1 : textrow->gap;
			else {
				gap = textrow->rowheight
						- (textrow->rowbase + last_rowbase_internal);
				if (gap < mean_row_gap / 2.)
					gap = mean_row_gap;
			}
		} else {
			gap = line_spacing - (textrow->r2 - textrow->r1 + 1);
			if (gap < mean_row_gap / 2.)
				gap = mean_row_gap;
		}
		if (i < i2)
			dst_add_gap_src_pixels("No-wrap line", masterinfo, gap);
		else {
			last_h5050_internal = textrow->h5050;
			beginning_gap_internal = gap;
		}
	}
	willus_dmem_free(14, (double **) &just, funcname);
	willus_dmem_free(13, (double **) &c1, funcname);
#ifdef WILLUSDEBUG
	printf("Done wrap_and_add.\n");
#endif
}

static int bmpregion_is_centered(BMPREGION *region, BREAKINFO *breakinfo,
		int i1, int i2, int *th)

{
	int j, i, cc, n1, ntr;
	int textheight;

#if (WILLUSDEBUGX & 1)
	printf("@bmpregion_is_centered:  region=(%d,%d) - (%d,%d)\n",region->c1,region->r1,region->c2,region->r2);
	printf("    nrows = %d\n",i2-i1+1);
#endif
	ntr = i2 - i1 + 1;
	for (j = 0; j < 3; j++) {
		for (n1 = textheight = 0, i = i1; i <= i2; i++) {
			TEXTROW *textrow;
			double ar, rh;

			textrow = &breakinfo->textrow[i];
			if (textrow->c2 < textrow->c1)
				ar = 100.;
			else
				ar = (double) (textrow->r2 - textrow->r1 + 1)
						/ (double) (textrow->c2 - textrow->c1 + 1);
			rh = (double) (textrow->r2 - textrow->r1 + 1) / src_dpi;
			if (j == 2 || (j >= 1 && rh <= no_wrap_height_limit_inches)
					|| (j == 0 && rh <= no_wrap_height_limit_inches
							&& ar <= no_wrap_ar_limit)) {
				textheight += textrow->rowbase - textrow->r1 + 1;
				n1++;
			}
		}
		if (n1 > 0)
			break;
	}
	textheight = (int) ((double) textheight / n1 + .5);
	if (th != NULL) {
		(*th) = textheight;
#if (WILLUSDEBUGX & 1)
		printf("    textheight assigned (%d)\n",textheight);
#endif
		return (breakinfo->centered);
	}

	/*
	 ** Does region appear to be centered?
	 */
	for (cc = 0, i = i1; i <= i2; i++) {
		double indent1, indent2;

#if (WILLUSDEBUGX & 1)
		printf("    tr[%d].c1,c2 = %d, %d\n",i,breakinfo->textrow[i].c1,breakinfo->textrow[i].c2);
#endif
		indent1 = (double) (breakinfo->textrow[i].c1 - region->c1) / textheight;
		indent2 = (double) (region->c2 - breakinfo->textrow[i].c2) / textheight;
#if (WILLUSDEBUGX & 1)
		printf("    tr[%d].indent1,2 = %g, %g\n",i,indent1,indent2);
#endif
		/* If only one line and it spans the entire region, call it centered */
		/* Sometimes this won't be the right thing to to. */
		if (i1 == i2 && indent1 < .5 && indent2 < .5) {
#if (WILLUSDEBUGX & 1)
			printf("    One line default to bigger region (%s).\n",breakinfo->centered?"not centered":"centered");
#endif
			return (1);
		}
		if (fabs(indent1 - indent2) > 1.5) {
#if (WILLUSDEBUGX & 1)
			printf("    Region not centered.\n");
#endif
			return (0);
		}
		if (indent1 > 1.0)
			cc++;
	}
#if (WILLUSDEBUGX & 1)
	printf("Region centering:  i=%d, i2=%d, cc=%d, ntr=%d\n",i,i2,cc,ntr);
#endif
	if (cc > ntr / 2) {
#if (WILLUSDEBUGX & 1)
		printf("    Region is centered (enough obviously centered lines).\n");
#endif
		return (1);
	}
#if (WILLUSDEBUGX & 1)
	printf("    Not centered (not enough obviously centered lines).\n");
#endif
	return (0);
}

/* array.c */
/*
 **
 ** Compute mean and standard deviation
 **
 */
double array_mean(double *a, int n, double *mean, double *stddev)

{
	int i;
	double sum, avg, sum_sq;

	if (n < 1)
		return (0.);
	for (sum = sum_sq = i = 0; i < n; i++)
		sum += a[i];
	avg = sum / n;
	if (mean != NULL)
		(*mean) = avg;
	if (stddev != NULL) {
		double sum_sq;

		for (sum_sq = i = 0; i < n; i++)
			sum_sq += (a[i] - avg) * (a[i] - avg);
		(*stddev) = sqrt(sum_sq / n);
	}
	return (avg);
}

/*
 ** CAUTION:  This function re-orders the x[] array!
 */
static double median_val(double *x, int n)

{
	int i1, n1;

	if (n < 4)
		return (array_mean(x, n, NULL, NULL));
	sortd(x, n);
	if (n == 4) {
		n1 = 2;
		i1 = 1;
	} else if (n == 5) {
		n1 = 3;
		i1 = 1;
	} else {
		n1 = n / 3;
		i1 = (n - n1) / 2;
	}
	return (array_mean(&x[i1], n1, NULL, NULL));
}

/*
 **
 ** Searches the region for vertical break points and stores them into
 ** the BREAKINFO structure.
 **
 ** apsize_in = averaging aperture size in inches.  Use -1 for dynamic aperture.
 **
 */
static void bmpregion_find_vertical_breaks(BMPREGION *region,
		BREAKINFO *breakinfo, int *colcount, int *rowcount, double apsize_in)

{
	static char *funcname = "bmpregion_find_vertical_breaks";
	int nr, i, brc, brcmin, dtrc, trc, aperture, aperturemax, figrow, labelrow;
	int ntr, rhmin_pix;
	BMPREGION *newregion, _newregion;
	int *rowthresh;
	double min_fig_height, max_fig_gap, max_label_height;

	min_fig_height = dst_min_figure_height_in;
	max_fig_gap = 0.16;
	max_label_height = 0.5;
	/* Trim region and populate colcount/rowcount arrays */
	bmpregion_trim_margins(region, colcount, rowcount, 0xf);
	newregion = &_newregion;
	(*newregion) = (*region);
	if (debug)
		printf("@bmpregion_find_vertical_breaks:  (%d,%d) - (%d,%d)\n",
				region->c1, region->r1, region->c2, region->r2);
	/*
	 ** brc = consecutive blank pixel rows
	 ** trc = consecutive non-blank pixel rows
	 ** dtrc = number of non blank pixel rows since last dump
	 */
	nr = region->r2 - region->r1 + 1;
	willus_dmem_alloc_warn(15, (void **) &rowthresh, sizeof(int) * nr, funcname,
			10);
	brcmin = max_vertical_gap_inches * src_dpi;
	aperturemax = (int) (src_dpi / 72. + .5);
	if (aperturemax < 2)
		aperturemax = 2;
	aperture = (int) (src_dpi * apsize_in + .5);
	/*
	 for (i=region->r1;i<=region->r2;i++)
	 printf("rowcount[%d]=%d\n",i,rowcount[i]);
	 */
	breakinfo->rhmean_pixels = 0; // Mean text row height
	ntr = 0; // Number of text rows
	/* Fill rowthresh[] array */
	for (dtrc = 0, i = region->r1; i <= region->r2; i++) {
		int ii, i1, i2, sum, pt;

		if (apsize_in < 0.) {
			aperture = (int) (dtrc / 13.7 + .5);
			if (aperture > aperturemax)
				aperture = aperturemax;
			if (aperture < 2)
				aperture = 2;
		}
		i1 = i - aperture / 2;
		i2 = i1 + aperture - 1;
		if (i1 < region->r1)
			i1 = region->r1;
		if (i2 > region->r2)
			i2 = region->r2;
		pt = (int) ((i2 - i1 + 1) * gtr_in * src_dpi + .5); /* pixel count threshold */
		if (pt < 1)
			pt = 1;
		/* Sum over row aperture */
		for (sum = 0, ii = i1; ii <= i2; sum += rowcount[ii], ii++)
			;
		/* Does row have few enough black pixels to be considered blank? */
		if ((rowthresh[i - region->r1] = 10 * sum / pt) <= 40) {
			if (dtrc > 0) {
				breakinfo->rhmean_pixels += dtrc;
				ntr++;
			}
			dtrc = 0;
		} else
			dtrc++;
	}
	if (dtrc > 0) {
		breakinfo->rhmean_pixels += dtrc;
		ntr++;
	}
	if (ntr > 0)
		breakinfo->rhmean_pixels /= ntr;
	/*
	 printf("rhmean=%d (ntr=%d)\n",breakinfo->rhmean_pixels,ntr);
	 {
	 FILE *f;
	 static int count=0;
	 f=fopen("rthresh.ep",count==0?"w":"a");
	 count++;
	 for (i=region->r1;i<=region->r2;i++)
	 nprintf(f,"%d\n",rowthresh[i-region->r1]);
	 nprintf(f,"//nc\n");
	 fclose(f);
	 }
	 */
	/* Minimum text row height required (pixels) */
	rhmin_pix = breakinfo->rhmean_pixels / 3;
	if (rhmin_pix < .04 * src_dpi)
		rhmin_pix = .04 * src_dpi;
	if (rhmin_pix > .13 * src_dpi)
		rhmin_pix = .13 * src_dpi;
	if (rhmin_pix < 1)
		rhmin_pix = 1;
	/*
	 for (rmax=region->r2;rmax>region->r1;rmax--)
	 if (rowthresh[rmax-region->r1]>10)
	 break;
	 */
	/* Look for "row" gaps in the region so that it can be broken into */
	/* multiple "rows".                                                */
	breakinfo->n = 0;
	for (labelrow = figrow = -1, dtrc = trc = brc = 0, i = region->r1;
			i <= region->r2; i++) {
		/* Does row have few enough black pixels to be considered blank? */
		if (rowthresh[i - region->r1] <= 10) {
			trc = 0;
			brc++;
			/*
			 ** Max allowed white space between rows = max_vertical_gap_inches
			 */
			if (dtrc == 0) {
				if (brc > brcmin)
					newregion->r1++;
				continue;
			}
			/*
			 ** Big enough blank gap, so add one row / line
			 */
			if (dtrc + brc >= rhmin_pix) {
				int i0, iopt;
				double region_height_inches;
				double gap_inches;

				if (dtrc < src_dpi * 0.02)
					dtrc = src_dpi * 0.02;
				if (dtrc < 2)
					dtrc = 2;
				/* Look for more optimum point */
				for (i0 = iopt = i; i <= region->r2 && i - i0 < dtrc; i++) {
					if (rowthresh[i - region->r1]
							< rowthresh[iopt - region->r1]) {
						iopt = i;
						if (rowthresh[i - region->r1] == 0)
							break;
					}
					if (rowthresh[i - region->r1] > 100)
						break;
				}
				/* If at end of region and haven't found perfect break, stay at end */
				if (i > region->r2 && rowthresh[iopt - region->r1] > 0)
					i = region->r2;
				else
					i = iopt;
				newregion->r2 = i - 1;
				region_height_inches = (double) (newregion->r2 - newregion->r1
						+ 1) / src_dpi;

				/* Could this region be a figure? */
				if (figrow < 0 && region_height_inches >= min_fig_height) {
					/* If so, set figrow and don't process it yet. */
					figrow = newregion->r1;
					labelrow = -1;
					newregion->r1 = i;
					dtrc = trc = 0;
					brc = 1;
					continue;
				}
				/* Are we processing a figure? */
				if (figrow >= 0) {
					/* Compute most recent gap */
					if (labelrow >= 0)
						gap_inches = (double) (labelrow - newregion->r1)
								/ src_dpi;
					else
						gap_inches = -1.;
					/* If gap and region height are small enough, tack them on to the figure. */
					if (region_height_inches < max_label_height
							&& gap_inches > 0. && gap_inches < max_fig_gap)
						newregion->r1 = figrow;
					else {
						/* Not small enough--dump the previous figure. */
						newregion->r2 = newregion->r1 - 1;
						newregion->r1 = figrow;
						newregion->c1 = region->c1;
						newregion->c2 = region->c2;
						bmpregion_trim_margins(newregion, colcount, rowcount,
								0x1f);
						if (newregion->r2 > newregion->r1)
							textrow_assign_bmpregion(
									&breakinfo->textrow[breakinfo->n++],
									newregion);
						if (gap_inches > 0. && gap_inches < max_fig_gap) {
							/* This new region might be a figure--set it as the new figure */
							/* and don't dump it yet.                                      */
							figrow = newregion->r2 + 1;
							labelrow = -1;
							newregion->r1 = i;
							dtrc = trc = 0;
							brc = 1;
							continue;
						} else {
							newregion->r1 = newregion->r2 + 1;
							newregion->r2 = i - 1;
						}
					}
					/* Cancel figure processing */
					figrow = -1;
					labelrow = -1;
				}
				/*
				 if (newregion->r2 >= rmax)
				 i=newregion->r2=region->r2;
				 */
				newregion->c1 = region->c1;
				newregion->c2 = region->c2;
				bmpregion_trim_margins(newregion, colcount, rowcount, 0x1f);
				if (newregion->r2 > newregion->r1)
					textrow_assign_bmpregion(
							&breakinfo->textrow[breakinfo->n++], newregion);
				newregion->r1 = i;
				dtrc = trc = 0;
				brc = 1;
			}
		} else {
			if (figrow >= 0 && labelrow < 0)
				labelrow = i;
			dtrc++;
			trc++;
			brc = 0;
		}
	}
	newregion->r2 = region->r2;
	if (dtrc > 0 && newregion->r2 - newregion->r1 + 1 > 0) {
		/* If we were processing a figure, include it. */
		if (figrow >= 0)
			newregion->r1 = figrow;
		newregion->c1 = region->c1;
		newregion->c2 = region->c2;
		bmpregion_trim_margins(newregion, colcount, rowcount, 0x1f);
		if (newregion->r2 > newregion->r1)
			textrow_assign_bmpregion(&breakinfo->textrow[breakinfo->n++],
					newregion);
	}
	/* Compute gaps between rows and row heights */
	breakinfo_compute_row_gaps(breakinfo, region->r2);
	willus_dmem_free(15, (double **) &rowthresh, funcname);
}

static void textrow_assign_bmpregion(TEXTROW *textrow, BMPREGION *region)

{
	textrow->r1 = region->r1;
	textrow->r2 = region->r2;
	textrow->c1 = region->c1;
	textrow->c2 = region->c2;
	textrow->rowbase = region->rowbase;
	textrow->lcheight = region->lcheight;
	textrow->capheight = region->capheight;
	textrow->h5050 = region->h5050;
}

static void breakinfo_compute_row_gaps(BREAKINFO *breakinfo, int r2)

{
	int i, n;

	n = breakinfo->n;
	if (n <= 0)
		return;
	breakinfo->textrow[0].rowheight = breakinfo->textrow[0].r2
			- breakinfo->textrow[0].r1;
	for (i = 0; i < n - 1; i++)
		breakinfo->textrow[i].gap = breakinfo->textrow[i + 1].r1
				- breakinfo->textrow[i].rowbase - 1;
	/*
	 breakinfo->textrow[i].rowheight = breakinfo->textrow[i+1].r1 - breakinfo->textrow[i].r1;
	 */
	for (i = 1; i < n; i++)
		breakinfo->textrow[i].rowheight = breakinfo->textrow[i].rowbase
				- breakinfo->textrow[i - 1].rowbase;
	breakinfo->textrow[n - 1].gap = r2 - breakinfo->textrow[n - 1].rowbase;
}

static void breakinfo_compute_col_gaps(BREAKINFO *breakinfo, int c2)

{
	int i, n;

	n = breakinfo->n;
	if (n <= 0)
		return;
	for (i = 0; i < n - 1; i++) {
		breakinfo->textrow[i].gap = breakinfo->textrow[i + 1].c1
				- breakinfo->textrow[i].c2 - 1;
		breakinfo->textrow[i].rowheight = breakinfo->textrow[i + 1].c1
				- breakinfo->textrow[i].c1;
	}
	breakinfo->textrow[n - 1].gap = c2 - breakinfo->textrow[n - 1].c2;
	breakinfo->textrow[n - 1].rowheight = breakinfo->textrow[n - 1].c2
			- breakinfo->textrow[n - 1].c1;
}

static void breakinfo_remove_small_col_gaps(BREAKINFO *breakinfo, int lcheight,
		double mingap)

{
	int i, j;

	if (mingap < word_spacing)
		mingap = word_spacing;
	for (i = 0; i < breakinfo->n - 1; i++) {
		double gap;

		gap = (double) breakinfo->textrow[i].gap / lcheight;
		if (gap >= mingap)
			continue;
		breakinfo->textrow[i].c2 = breakinfo->textrow[i + 1].c2;
		breakinfo->textrow[i].gap = breakinfo->textrow[i + 1].gap;
		if (breakinfo->textrow[i + 1].r1 < breakinfo->textrow[i].r1)
			breakinfo->textrow[i].r1 = breakinfo->textrow[i + 1].r1;
		if (breakinfo->textrow[i + 1].r2 > breakinfo->textrow[i].r2)
			breakinfo->textrow[i].r2 = breakinfo->textrow[i + 1].r2;
		for (j = i + 1; j < breakinfo->n - 1; j++)
			breakinfo->textrow[j] = breakinfo->textrow[j + 1];
		breakinfo->n--;
		i--;
	}
}

static void breakinfo_remove_small_rows(BREAKINFO *breakinfo, double fracrh,
		double fracgap, BMPREGION *region, int *colcount, int *rowcount)

{
	int i, j, mg, mh, mg0, mg1;
	int c1, c2, nc;
	int *rh, *gap;
	static char *funcname = "breakinfo_remove_small_rows";

#if (WILLUSDEBUGX & 2)
	printf("@breakinfo_remove_small_rows(fracrh=%g,fracgap=%g)\n",fracrh,fracgap);
#endif
	if (breakinfo->n < 2)
		return;
	c1 = region->c1;
	c2 = region->c2;
	nc = c2 - c1 + 1;
	willus_dmem_alloc_warn(16, (void **) &rh, 2 * sizeof(int) * breakinfo->n,
			funcname, 10);
	gap = &rh[breakinfo->n];
	for (i = 0; i < breakinfo->n; i++) {
		rh[i] = breakinfo->textrow[i].r2 - breakinfo->textrow[i].r1 + 1;
		if (i < breakinfo->n - 1)
			gap[i] = breakinfo->textrow[i].gap;
	}
	sorti(rh, breakinfo->n);
	sorti(gap, breakinfo->n - 1);
	mh = rh[breakinfo->n / 2];
	mh *= fracrh;
	if (mh < 1)
		mh = 1;
	mg0 = gap[(breakinfo->n - 1) / 2];
	mg = mg0 * fracgap;
	mg1 = mg0 * 0.7;
	if (mg < 1)
		mg = 1;
#if (WILLUSDEBUGX & 2)
	printf("mh = %d x %g = %d\n",rh[breakinfo->n/2],fracrh,mh);
	printf("mg = %d x %g = %d\n",gap[breakinfo->n/2],fracgap,mg);
#endif
	for (i = 0; i < breakinfo->n; i++) {
		TEXTROW *textrow;
		int trh, gs1, gs2, g1, g2, gap_is_big, row_too_small;
		double m1, m2, row_width_inches;

		textrow = &breakinfo->textrow[i];
		trh = textrow->r2 - textrow->r1 + 1;
		if (i == 0) {
			g1 = mg0 + 1;
			gs1 = mg + 1;
		} else {
			g1 = textrow->r1 - breakinfo->textrow[i - 1].r2 - 1;
			gs1 = breakinfo->textrow[i - 1].gap;
		}
		if (i == breakinfo->n - 1) {
			g2 = mg0 + 1;
			gs2 = mg + 1;
		} else {
			g2 = breakinfo->textrow[i + 1].r1 - textrow->r2 - 1;
			gs2 = breakinfo->textrow[i].gap;
		}
#if (WILLUSDEBUGX & 2)
		printf("   rowheight[%d] = %d, mh=%d, gs1=%d, gs2=%d\n",i,trh,gs1,gs2);
#endif
		gap_is_big = (trh >= mh || (gs1 >= mg && gs2 >= mg));
		/*
		 ** Is the row width small and centered?  If so, it should probably
		 ** be attached to its nearest neighbor--it's usually a fragment of
		 ** an equation or a table/figure.
		 */
		row_width_inches = (double) (textrow->c2 - textrow->c1 + 1) / src_dpi;
		m1 = fabs(textrow->c1 - c1) / nc;
		m2 = fabs(textrow->c2 - c2) / nc;
		row_too_small = m1 > 0.1 && m2 > 0.1
				&& row_width_inches < little_piece_threshold_inches
				&& (g1 <= mg1 || g2 <= mg1);
#if (WILLUSDEBUGX & 2)
		printf("       m1=%g, m2=%g, rwi=%g, g1=%d, g2=%d, mg0=%d\n",m1,m2,row_width_inches,g1,g2,mg0);
#endif
		if (gap_is_big && !row_too_small)
			continue;
#if (WILLUSDEBUGX & 2)
		printf("   row[%d] to be combined w/next row.\n",i);
#endif
		if (row_too_small) {
			if (g1 < g2)
				i--;
		} else {
			if (gs1 < gs2)
				i--;
		}
		/*
		 printf("Removing row.  nrows=%d, rh=%d, gs1=%d, gs2=%d\n",breakinfo->n,trh,gs1,gs2);
		 printf("    mh = %d, mg = %d\n",rh[breakinfo->n/2],gap[(breakinfo->n-1)/2]);
		 */
		breakinfo->textrow[i].r2 = breakinfo->textrow[i + 1].r2;
		if (breakinfo->textrow[i + 1].c2 > breakinfo->textrow[i].c2)
			breakinfo->textrow[i].c2 = breakinfo->textrow[i + 1].c2;
		if (breakinfo->textrow[i + 1].c1 < breakinfo->textrow[i].c1)
			breakinfo->textrow[i].c1 = breakinfo->textrow[i + 1].c1;
		/* Re-compute rowbase, capheight, lcheight */
		{
			BMPREGION newregion;
			newregion = (*region);
			newregion.c1 = breakinfo->textrow[i].c1;
			newregion.c2 = breakinfo->textrow[i].c2;
			newregion.r1 = breakinfo->textrow[i].r1;
			newregion.r2 = breakinfo->textrow[i].r2;
			bmpregion_trim_margins(&newregion, colcount, rowcount, 0x1f);
			newregion.c1 = breakinfo->textrow[i].c1;
			newregion.c2 = breakinfo->textrow[i].c2;
			newregion.r1 = breakinfo->textrow[i].r1;
			newregion.r2 = breakinfo->textrow[i].r2;
			textrow_assign_bmpregion(&breakinfo->textrow[i], &newregion);
		}
		for (j = i + 1; j < breakinfo->n - 1; j++)
			breakinfo->textrow[j] = breakinfo->textrow[j + 1];
		breakinfo->n--;
		i--;
	}
	willus_dmem_free(16, (double **) &rh, funcname);
}

static void breakinfo_alloc(int index, BREAKINFO *breakinfo, int nrows)

{
	static char *funcname = "breakinfo_alloc";

	willus_dmem_alloc_warn(index, (void **) &breakinfo->textrow,
			sizeof(TEXTROW) * (nrows / 2 + 2), funcname, 10);
}

static void breakinfo_free(int index, BREAKINFO *breakinfo)

{
	static char *funcname = "breakinfo_free";

	willus_dmem_free(index, (double **) &breakinfo->textrow, funcname);
}

static void breakinfo_sort_by_gap(BREAKINFO *breakinfo)

{
	int n, top, n1;
	TEXTROW *x, x0;

	x = breakinfo->textrow;
	n = breakinfo->n;
	if (n < 2)
		return;
	top = n / 2;
	n1 = n - 1;
	while (1) {
		if (top > 0) {
			top--;
			x0 = x[top];
		} else {
			x0 = x[n1];
			x[n1] = x[0];
			n1--;
			if (!n1) {
				x[0] = x0;
				return;
			}
		}
		{
			int parent, child;

			parent = top;
			child = top * 2 + 1;
			while (child <= n1) {
				if (child < n1 && x[child].gap < x[child + 1].gap)
					child++;
				if (x0.gap < x[child].gap) {
					x[parent] = x[child];
					parent = child;
					child += (parent + 1);
				} else
					break;
			}
			x[parent] = x0;
		}
	}
}

static void breakinfo_sort_by_row_position(BREAKINFO *breakinfo)

{
	int n, top, n1;
	TEXTROW *x, x0;

	x = breakinfo->textrow;
	n = breakinfo->n;
	if (n < 2)
		return;
	top = n / 2;
	n1 = n - 1;
	while (1) {
		if (top > 0) {
			top--;
			x0 = x[top];
		} else {
			x0 = x[n1];
			x[n1] = x[0];
			n1--;
			if (!n1) {
				x[0] = x0;
				return;
			}
		}
		{
			int parent, child;

			parent = top;
			child = top * 2 + 1;
			while (child <= n1) {
				if (child < n1 && x[child].r1 < x[child + 1].r1)
					child++;
				if (x0.r1 < x[child].r1) {
					x[parent] = x[child];
					parent = child;
					child += (parent + 1);
				} else
					break;
			}
			x[parent] = x0;
		}
	}
}

/*
 ** Add a vertically-contiguous rectangular region to the destination bitmap.
 ** The rectangular region may be broken up horizontally (wrapped).
 */
static void bmpregion_one_row_find_breaks(BMPREGION *region,
		BREAKINFO *breakinfo, int *colcount, int *rowcount, int add_to_dbase)

{
	int nc, i, mingap, col0, dr, thlow, thhigh;
	int *bp;
	BMPREGION *newregion, _newregion;
	static char *funcname = "bmpregion_one_row_find_breaks";

	if (debug)
		printf("@bmpregion_one_row_find_breaks(%d,%d)-(%d,%d)\n", region->c1,
				region->r1, region->c2, region->r2);
	newregion = &_newregion;
	(*newregion) = (*region);
	bmpregion_trim_margins(newregion, colcount, rowcount, 0x1f);
	region->lcheight = newregion->lcheight;
	region->capheight = newregion->capheight;
	region->rowbase = newregion->rowbase;
	region->h5050 = newregion->h5050;
	nc = newregion->c2 - newregion->c1 + 1;
	breakinfo->n = 0;
	if (nc < 6)
		return;
	/*
	 ** Look for "space-sized" gaps, i.e. gaps that would occur between words.
	 ** Use this as pixel counting aperture.
	 */
	dr = newregion->lcheight;
	mingap = dr * word_spacing * 0.8;
	if (mingap < 2)
		mingap = 2;

	/*
	 ** Find places where there are gaps (store in bp array)
	 ** Could do this more intelligently--maybe calculate a histogram?
	 */
	willus_dmem_alloc_warn(18, (void **) &bp, sizeof(int) * nc, funcname, 10);
	for (i = 0; i < nc; i++)
		bp[i] = 0;
	if (src_left_to_right) {
		for (i = newregion->c1; i <= newregion->c2; i++) {
			int i1, i2, pt, sum, ii;
			i1 = i - mingap / 2;
			i2 = i1 + mingap - 1;
			if (i1 < newregion->c1)
				i1 = newregion->c1;
			if (i2 > newregion->c2)
				i2 = newregion->c2;
			pt = (int) ((i2 - i1 + 1) * gtw_in * src_dpi + .5);
			if (pt < 1)
				pt = 1;
			for (sum = 0, ii = i1; ii <= i2; ii++, sum += colcount[ii])
				;
			bp[i - newregion->c1] = 10 * sum / pt;
		}
	} else {
		for (i = newregion->c2; i >= newregion->c1; i--) {
			int i1, i2, pt, sum, ii;
			i1 = i - mingap / 2;
			i2 = i1 + mingap - 1;
			if (i1 < newregion->c1)
				i1 = newregion->c1;
			if (i2 > newregion->c2)
				i2 = newregion->c2;
			pt = (int) ((i2 - i1 + 1) * gtw_in * src_dpi + .5);
			if (pt < 1)
				pt = 1;
			for (sum = 0, ii = i1; ii <= i2; ii++, sum += colcount[ii])
				;
			bp[i - newregion->c1] = 10 * sum / pt;
		}
	}
#if (WILLUSDEBUGX & 4)
	if (region->r1 > 3699 && region->r1<3750)
	{
		static int a=0;
		FILE *f;
		f=fopen("outbp.ep",a==0?"w":"a");
		a++;
		fprintf(f,"/sa l \"(%d,%d)-(%d,%d) lch=%d\" 2\n",region->c1,region->r1,region->c2,region->r2,region->lcheight);
		for (i=0;i<nc;i++)
		fprintf(f,"%d\n",bp[i]);
		fprintf(f,"//nc\n");
		fclose(f);
	}
#endif
	thlow = 10;
	thhigh = 50;
	/*
	 ** Break into pieces
	 */
	for (col0 = newregion->c1; col0 <= newregion->c2; col0++) {
		int copt, c0;
		BMPREGION xregion;

		xregion = (*newregion);
		xregion.c1 = col0;
		for (; col0 <= newregion->c2; col0++)
			if (bp[col0 - newregion->c1] >= thhigh)
				break;
		if (col0 > newregion->c2)
			break;
		for (col0++; col0 <= newregion->c2; col0++)
			if (bp[col0 - newregion->c1] < thlow)
				break;
		for (copt = c0 = col0; col0 <= newregion->c2 && col0 - c0 <= dr;
				col0++) {
			if (bp[col0 - newregion->c1] < bp[copt - newregion->c1])
				copt = col0;
			if (bp[col0 - newregion->c1] > thhigh)
				break;
		}
		if (copt > newregion->c2)
			copt = newregion->c2;
		xregion.c2 = copt;
		if (xregion.c2 - xregion.c1 < 2)
			continue;
		bmpregion_trim_margins(&xregion, colcount, rowcount, 0x1f);
		textrow_assign_bmpregion(&breakinfo->textrow[breakinfo->n++], &xregion);
		col0 = copt;
		if (copt == newregion->c2)
			break;
	}
	breakinfo_compute_col_gaps(breakinfo, newregion->c2);
	willus_dmem_free(18, (double **) &bp, funcname);

	/* Remove small gaps */
	{
		double median_gap;
		word_gaps_add(add_to_dbase ? breakinfo : NULL, region->lcheight,
				&median_gap);
		breakinfo_remove_small_col_gaps(breakinfo, region->lcheight,
				median_gap / 1.9);
	}
}

/*
 ** pi = preserve indentation
 */
static void bmpregion_one_row_wrap_and_add(BMPREGION *region,
		BREAKINFO *rowbreakinfo, int index, int i1, int i2,
		MASTERINFO *masterinfo, int justflags, int *colcount, int *rowcount,
		PAGEINFO *pageinfo, int line_spacing, int mean_row_gap, int rowbase,
		int marking_flags, int pi)

{
	int nc, nr, i, i0, gappix;
	double aspect_ratio, region_height;
	BREAKINFO *colbreaks, _colbreaks;
	BMPREGION *newregion, _newregion;

#if (WILLUSDEBUGX & 4)
	printf("@bmpregion_one_row_wrap_and_add, index=%d, i1=%d, i2=%d\n",index,i1,i2);
#endif
	newregion = &_newregion;
	(*newregion) = (*region);
	bmpregion_trim_margins(newregion, colcount, rowcount, 0xf);
	nc = newregion->c2 - newregion->c1 + 1;
	nr = newregion->r2 - newregion->r1 + 1;
	if (nc < 6)
		return;
	aspect_ratio = (double) nr / nc;
	region_height = (double) nr / src_dpi;
	if (aspect_ratio > no_wrap_ar_limit
			&& region_height > no_wrap_height_limit_inches) {
		newregion->r1 = region->r1;
		newregion->r2 = region->r2;
#ifdef WILLUSDEBUG
		printf("wrapflush6\n");
#endif
		wrapbmp_flush(masterinfo, 0, pageinfo, 1);
		if (index > i1)
			dst_add_gap_src_pixels("Tall region", masterinfo,
					rowbreakinfo->textrow[index - 1].gap);
		bmpregion_add(newregion, rowbreakinfo, masterinfo, 0, 0xf, 0, -1.0, 0,
				2, colcount, rowcount, pageinfo, 0xf,
				rowbreakinfo->textrow[index].r2
						- rowbreakinfo->textrow[index].rowbase);
		if (index < i2)
			gap_override_internal = rowbreakinfo->textrow[index].gap;
		return;
	}
	colbreaks = &_colbreaks;
	colbreaks->textrow = NULL;
	breakinfo_alloc(106, colbreaks, newregion->c2 - newregion->c1 + 1);
	bmpregion_one_row_find_breaks(newregion, colbreaks, colcount, rowcount, 1);
	if (pi && colbreaks->n > 0) {
		if (src_left_to_right)
			colbreaks->textrow[0].c1 = region->c1;
		else
			colbreaks->textrow[colbreaks->n - 1].c2 = region->c2;
	}
	/*
	 hs=0.;
	 for (i=0;i<colbreaks->n;i++)
	 hs += (colbreaks->textrow[i].r2-colbreaks->textrow[i].r1);
	 hs /= colbreaks->n;
	 */
	/*
	 ** Find appropriate letter height to use for word spacing
	 */
	{
		double median_gap;
		word_gaps_add(NULL, newregion->lcheight, &median_gap);
		gappix = (int) (median_gap * newregion->lcheight + .5);
	}
#if (WILLUSDEBUGX & 4)
	printf("Before small gap removal, column breaks:\n");
	breakinfo_echo(colbreaks);
#endif
#if (WILLUSDEBUGX & 4)
	printf("After small gap removal, column breaks:\n");
	breakinfo_echo(colbreaks);
#endif
	if (show_marked_source)
		for (i = 0; i < colbreaks->n; i++) {
			BMPREGION xregion;
			xregion = (*newregion);
			xregion.c1 = colbreaks->textrow[i].c1;
			xregion.c2 = colbreaks->textrow[i].c2;
			mark_source_page(&xregion, 2, marking_flags);
		}
#if (WILLUSDEBUGX & 4)
	for (i=0;i<colbreaks->n;i++)
	printf("    colbreak[%d] = %d - %d\n",i,colbreaks->textrow[i].c1,colbreaks->textrow[i].c2);
#endif
	/* Maybe skip gaps < 0.5*median_gap or collect gap/rowheight ratios and skip small gaps */
	/* (Could be thrown off by full-justified articles where some lines have big gaps.)     */
	/* Need do call a separate function that removes these gaps. */
	for (i0 = 0; i0 < colbreaks->n;) {
		int i1, i2, toolong, rw, remaining_width_pixels;
		BMPREGION reg;

		toolong = 0; /* Avoid compiler warning */
		for (i = i0; i < colbreaks->n; i++) {
			int wordgap;

			wordgap = wrapbmp_ends_in_hyphen() ? 0 : gappix;
			i1 = src_left_to_right ? i0 : colbreaks->n - 1 - i;
			i2 = src_left_to_right ? i : colbreaks->n - 1 - i0;
			rw = (colbreaks->textrow[i2].c2 - colbreaks->textrow[i1].c1 + 1);
			remaining_width_pixels = wrapbmp_remaining();
			toolong = (rw + wordgap > remaining_width_pixels);
#if (WILLUSDEBUGX & 4)
			printf("    i1=%d, i2=%d, rw=%d, rw+gap=%d, remainder=%d, toolong=%d\n",i1,i2,rw,rw+wordgap,remaining_width_pixels,toolong);
#endif
			/*
			 ** If we're too long with just one word and there is already
			 ** stuff on the queue, then flush it and re-evaluate.
			 */
			if (i == i0 && toolong && wrapbmp_width() > 0) {
#ifdef WILLUSDEBUG
				printf("wrapflush8\n");
#endif
				wrapbmp_flush(masterinfo, 1, pageinfo, 0);
				i--;
				continue;
			}
			/*
			 ** If we're not too long and we're not done yet, add another word.
			 */
			if (i < colbreaks->n - 1 && !toolong)
				continue;
			/*
			 ** Add the regions from i0 to i (or i0 to i-1)
			 */
			break;
		}
		if (i > i0 && toolong)
			i--;
		i1 = src_left_to_right ? i0 : colbreaks->n - 1 - i;
		i2 = src_left_to_right ? i : colbreaks->n - 1 - i0;
		reg = (*newregion);
		reg.c1 = colbreaks->textrow[i1].c1;
		reg.c2 = colbreaks->textrow[i2].c2;
#if (WILLUSDEBUGX & 4)
		printf("    Adding i1=%d to i2=%d\n",i1,i2);
#endif
		/* Trim the word top/bottom */
		bmpregion_trim_margins(&reg, colcount, rowcount, 0xc);
		reg.c1 = colbreaks->textrow[i1].c1;
		reg.c2 = colbreaks->textrow[i2].c2;
		reg.lcheight = newregion->lcheight;
		reg.capheight = newregion->capheight;
		reg.rowbase = newregion->rowbase;
		reg.h5050 = newregion->h5050;
		if (reg.r1 > reg.rowbase)
			reg.r1 = reg.rowbase;
		if (reg.r2 < reg.rowbase)
			reg.r2 = reg.rowbase;
		/* Add it to the existing line queue */
		wrapbmp_add(&reg, gappix, line_spacing, rowbase, mean_row_gap,
				justflags);
		if (toolong) {
#ifdef WILLUSDEBUG
			printf("wrapflush7\n");
#endif
			wrapbmp_flush(masterinfo, 1, pageinfo, 0);
		}
		i0 = i + 1;
	}
	breakinfo_free(106, colbreaks);
}

static WILLUSBITMAP _wrapbmp, *wrapbmp;
static int wrapbmp_base;
static int wrapbmp_line_spacing;
static int wrapbmp_gap;
static int wrapbmp_bgcolor;
static int wrapbmp_just;
static int wrapbmp_rhmax;
static int wrapbmp_thmax;
static int wrapbmp_maxgap = 2;
static int wrapbmp_height_extended;
static HYPHENINFO wrapbmp_hyphen;

void wrapbmp_init(void)

{
	wrapbmp = &_wrapbmp;
	bmp_init(wrapbmp);
	wrapbmp_set_color(dst_color);
	wrapbmp->width = 0;
	wrapbmp->height = 0;
	wrapbmp_base = 0;
	wrapbmp_line_spacing = -1;
	wrapbmp_gap = -1;
	wrapbmp_bgcolor = -1;
	wrapbmp_height_extended = 0;
	wrapbmp_just = 0x8f;
	wrapbmp_rhmax = -1;
	wrapbmp_thmax = -1;
	wrapbmp_hyphen.ch = -1;
	just_flushed_internal = 0;
	beginning_gap_internal = -1;
	last_h5050_internal = -1;
}

static int wrapbmp_ends_in_hyphen(void)

{
	return (wrapbmp_hyphen.ch >= 0);
}

static void wrapbmp_set_color(int is_color)

{
	if (is_color)
		wrapbmp->bpp = 24;
	else {
		int i;

		wrapbmp->bpp = 8;
		for (i = 0; i < 256; i++)
			wrapbmp->red[i] = wrapbmp->blue[i] = wrapbmp->green[i] = i;
	}
}

static void wrapbmp_free(void)

{
	bmp_free(wrapbmp);
}

static void wrapbmp_set_maxgap(int value)

{
	wrapbmp_maxgap = value;
}

static int wrapbmp_width(void)

{
	return (wrapbmp->width);
}

static int wrapbmp_remaining(void)

{
	int maxpix, w;
	maxpix = max_region_width_inches * src_dpi;
	/* Don't include hyphen if wrapbmp ends in a hyphen */
	if (wrapbmp_hyphen.ch < 0)
		w = wrapbmp->width;
	else if (src_left_to_right)
		w = wrapbmp_hyphen.c2 + 1;
	else
		w = wrapbmp->width - wrapbmp_hyphen.c2;
	return (maxpix - w);
}

/*
 ** region = bitmap region to add to line
 ** gap = horizontal pixel gap between existing region and region being added
 ** line_spacing = desired spacing between lines of text (pixels)
 ** rbase = position of baseline in region
 ** gio = gap if over--gap above top of text if it goes over line_spacing.
 */
// static int bcount=0;
static void wrapbmp_add(BMPREGION *region, int gap, int line_spacing, int rbase,
		int gio, int just_flags)

{
	WILLUSBITMAP *tmp, _tmp;
	int i, rh, th, bw, new_base, h2, bpp, width0;
// static char filename[256];

#ifdef WILLUSDEBUG
	printf("@wrapbmp_add %d x %d (w=%d).\n",region->c2-region->c1+1,region->r2-region->r1+1,wrapbmp->width);
#endif
	bmpregion_hyphen_detect(region); /* Figure out if what we're adding ends in a hyphen */
	if (wrapbmp_ends_in_hyphen())
		gap = 0;
	wrapbmp_hyphen_erase();
	just_flushed_internal = 0; // Reset "just flushed" flag
	beginning_gap_internal = -1; // Reset top-of-page or top-of-column gap
	last_h5050_internal = -1; // Reset last row font size
	if (line_spacing > wrapbmp_line_spacing)
		wrapbmp_line_spacing = line_spacing;
	if (gio > wrapbmp_gap)
		wrapbmp_gap = gio;
	wrapbmp_bgcolor = region->bgcolor;
	wrapbmp_just = just_flags;
	/*
	 printf("    c1=%d, c2=%d, r1=%d, r2=%d\n",region->c1,region->c2,region->r1,region->r2);
	 printf("    gap=%d, line_spacing=%d, rbase=%d, gio=%d\n",gap,line_spacing,rbase,gio);
	 */
	bpp = dst_color ? 3 : 1;
	rh = rbase - region->r1 + 1;
	if (rh > wrapbmp_rhmax)
		wrapbmp_rhmax = rh;
	th = rh + (region->r2 - rbase);
	if (th > wrapbmp_thmax)
		wrapbmp_thmax = th;
	/*
	 {
	 WILLUSBITMAP *bmp,_bmp;

	 bmp=&_bmp;
	 bmp_init(bmp);
	 bmp->height=region->r2-region->r1+1;
	 bmp->width=region->c2-region->c1+1;
	 bmp->bpp=bpp*8;
	 if (bpp==1)
	 for (i=0;i<256;i++)
	 bmp->red[i]=bmp->blue[i]=bmp->green[i]=i;
	 bmp_alloc(bmp);
	 bw=bmp_bytewidth(bmp);
	 memset(bmp_rowptr_from_top(bmp,0),255,bw*bmp->height);
	 for (i=region->r1;i<=region->r2;i++)
	 {
	 unsigned char *d,*s;
	 d=bmp_rowptr_from_top(bmp,i-region->r1);
	 s=bmp_rowptr_from_top(dst_color?region->bmp:region->bmp8,i)+bpp*region->c1;
	 if (i==rbase)
	 memset(d,0,bw);
	 else
	 memcpy(d,s,bw);
	 }
	 sprintf(filename,"out%05d.png",bcount++);
	 bmp_write(bmp,filename,stdout,100);
	 bmp_free(bmp);
	 }
	 */
	if (wrapbmp->width == 0) {
		/* Put appropriate gap in */
		if (last_rowbase_internal >= 0
				&& rh < wrapbmp_line_spacing - last_rowbase_internal) {
			rh = wrapbmp_line_spacing - last_rowbase_internal;
			if (rh < 2)
				rh = 2;
			th = rh + (region->r2 - rbase);
			wrapbmp_height_extended = 0;
		} else
			wrapbmp_height_extended = (last_rowbase_internal >= 0);
		wrapbmp_base = rh - 1;
		wrapbmp->height = th;
#ifdef WILLUSDEBUG
		printf("@wrapbmp_add:  bmpheight set to %d (wls=%d, lrbi=%d)\n",wrapbmp->height,wrapbmp_line_spacing,last_rowbase_internal);
#endif
		wrapbmp->width = region->c2 - region->c1 + 1;
		bmp_alloc(wrapbmp);
		bw = bmp_bytewidth(wrapbmp);
		memset(bmp_rowptr_from_top(wrapbmp, 0), 255, bw * wrapbmp->height);
		for (i = region->r1; i <= region->r2; i++) {
			unsigned char *d, *s;
			d = bmp_rowptr_from_top(wrapbmp, wrapbmp_base + (i - rbase));
			s = bmp_rowptr_from_top(dst_color ? region->bmp : region->bmp8, i)
					+ bpp * region->c1;
			memcpy(d, s, bw);
		}
#ifdef WILLUSDEBUG
		if (wrapbmp->height<=wrapbmp_base)
		{
			printf("1. SCREEECH!\n");
			printf("wrapbmp = %d x %d, base=%d\n",wrapbmp->width,wrapbmp->height,wrapbmp_base);
			exit(10);
		}
#endif
		/* Copy hyphen info from added region */
		wrapbmp_hyphen = region->hyphen;
		if (wrapbmp_ends_in_hyphen()) {
			wrapbmp_hyphen.r1 += (wrapbmp_base - rbase);
			wrapbmp_hyphen.r2 += (wrapbmp_base - rbase);
			wrapbmp_hyphen.ch -= region->c1;
			wrapbmp_hyphen.c2 -= region->c1;
		}
		return;
	}
	width0 = wrapbmp->width; /* Starting wrapbmp width */
	tmp = &_tmp;
	bmp_init(tmp);
	bmp_copy(tmp, wrapbmp);
	tmp->width += gap + region->c2 - region->c1 + 1;
	if (rh > wrapbmp_base) {
		wrapbmp_height_extended = 1;
		new_base = rh - 1;
	} else
		new_base = wrapbmp_base;
	if (region->r2 - rbase > wrapbmp->height - 1 - wrapbmp_base)
		h2 = region->r2 - rbase;
	else
		h2 = wrapbmp->height - 1 - wrapbmp_base;
	tmp->height = new_base + h2 + 1;
	bmp_alloc(tmp);
	bw = bmp_bytewidth(tmp);
	memset(bmp_rowptr_from_top(tmp, 0), 255, bw * tmp->height);
	bw = bmp_bytewidth(wrapbmp);
	/*
	 printf("3.  wbh=%d x %d, tmp=%d x %d x %d, new_base=%d, wbbase=%d\n",wrapbmp->width,wrapbmp->height,tmp->width,tmp->height,tmp->bpp,new_base,wrapbmp_base);
	 */
	for (i = 0; i < wrapbmp->height; i++) {
		unsigned char *d, *s;
		d = bmp_rowptr_from_top(tmp, i + new_base - wrapbmp_base)
				+ (src_left_to_right ? 0 : tmp->width - 1 - wrapbmp->width)
						* bpp;
		s = bmp_rowptr_from_top(wrapbmp, i);
		memcpy(d, s, bw);
	}
	bw = bpp * (region->c2 - region->c1 + 1);
	if (region->r1 + new_base - rbase < 0
			|| region->r2 + new_base - rbase > tmp->height - 1) {
		aprintf(ANSI_YELLOW "INTERNAL ERROR--TMP NOT DIMENSIONED PROPERLY.\n");
		aprintf("(%d-%d), tmp->height=%d\n" ANSI_NORMAL,
				region->r1 + new_base - rbase, region->r2 + new_base - rbase,
				tmp->height);
		exit(10);
	}
	for (i = region->r1; i <= region->r2; i++) {
		unsigned char *d, *s;

		d = bmp_rowptr_from_top(tmp, i + new_base - rbase)
				+ (src_left_to_right ? wrapbmp->width + gap : 0) * bpp;
		s = bmp_rowptr_from_top(dst_color ? region->bmp : region->bmp8, i)
				+ bpp * region->c1;
		memcpy(d, s, bw);
	}
	bmp_copy(wrapbmp, tmp);
	bmp_free(tmp);
	/* Copy region's hyphen info */
	wrapbmp_hyphen = region->hyphen;
	if (wrapbmp_ends_in_hyphen()) {
		wrapbmp_hyphen.r1 += (new_base - rbase);
		wrapbmp_hyphen.r2 += (new_base - rbase);
		if (src_left_to_right) {
			wrapbmp_hyphen.ch += width0 + gap - region->c1;
			wrapbmp_hyphen.c2 += width0 + gap - region->c1;
		} else {
			wrapbmp_hyphen.ch -= region->c1;
			wrapbmp_hyphen.c2 -= region->c1;
		}
	}
	wrapbmp_base = new_base;
#ifdef WILLUSDEBUG
	if (wrapbmp->height<=wrapbmp_base)
	{
		printf("2. SCREEECH!\n");
		printf("wrapbmp = %d x %d, base=%d\n",wrapbmp->width,wrapbmp->height,wrapbmp_base);
		exit(10);
	}
#endif
}

static void wrapbmp_flush(MASTERINFO *masterinfo, int allow_full_justification,
		PAGEINFO *pageinfo, int use_bgi)

{
	BMPREGION region;
	WILLUSBITMAP *bmp8, _bmp8;
	int gap, just, nomss, dh;
	int *colcount, *rowcount;
	static char *funcname = "wrapbmp_flush";
// char filename[256];

	if (wrapbmp->width <= 0) {
		if (use_bgi == 1 && beginning_gap_internal > 0)
			dst_add_gap_src_pixels("wrapbmp_bgi0", masterinfo,
					beginning_gap_internal);
		beginning_gap_internal = -1;
		last_h5050_internal = -1;
		if (use_bgi)
			just_flushed_internal = 1;
		return;
	}
#ifdef WILLUSDEBUG
	printf("@wrapbmp_flush()\n");
#endif
	/*
	 {
	 char filename[256];
	 int i;
	 static int bcount=0;
	 for (i=0;i<wrapbmp->height;i++)
	 {
	 unsigned char *p;
	 int j;
	 p=bmp_rowptr_from_top(wrapbmp,i);
	 for (j=0;j<wrapbmp->width;j++)
	 if (p[j]>240)
	 p[j]=192;
	 }
	 sprintf(filename,"out%05d.png",bcount++);
	 bmp_write(wrapbmp,filename,stdout,100);
	 }
	 */
	colcount = rowcount = NULL;
	willus_dmem_alloc_warn(19, (void **) &colcount,
			(wrapbmp->width + 16) * sizeof(int), funcname, 10);
	willus_dmem_alloc_warn(20, (void **) &rowcount,
			(wrapbmp->height + 16) * sizeof(int), funcname, 10);
	region.c1 = 0;
	region.c2 = wrapbmp->width - 1;
	region.r1 = 0;
	region.r2 = wrapbmp->height - 1;
	region.rowbase = wrapbmp_base;
	region.bmp = wrapbmp;
	region.bgcolor = wrapbmp_bgcolor;
#ifdef WILLUSDEBUG
	printf("Bitmap is %d x %d (baseline=%d)\n",wrapbmp->width,wrapbmp->height,wrapbmp_base);
#endif

	/* Sanity check on row spacing -- don't let it be too large. */
	nomss = wrapbmp_rhmax * 1.7; /* Nominal single-spaced height for this row */
	if (last_rowbase_internal < 0)
		dh = 0;
	else {
		dh = (int) (wrapbmp_line_spacing - last_rowbase_internal
				- 1.2 * fabs(vertical_line_spacing) * nomss + .5);
		if (vertical_line_spacing < 0.) {
			int dh1;
			if (wrapbmp_maxgap > 0)
				dh1 = region.rowbase + 1 - wrapbmp_rhmax - wrapbmp_maxgap;
			else
				dh1 = (int) (wrapbmp_line_spacing - last_rowbase_internal
						- 1.2 * nomss + .5);
			if (dh1 > dh)
				dh = dh1;
		}
	}
	if (dh > 0) {
#ifdef WILLUSDEBUG
		aprintf(ANSI_YELLOW "dh > 0 = %d" ANSI_NORMAL "\n",dh);
		printf("    wrapbmp_line_spacing=%d\n",wrapbmp_line_spacing);
		printf("    nomss = %d\n",nomss);
		printf("    vls = %g\n",vertical_line_spacing);
		printf("    lrbi=%d\n",last_rowbase_internal);
		printf("    wrapbmp_maxgap=%d\n",wrapbmp_maxgap);
		printf("    wrapbmp_rhmax=%d\n",wrapbmp_rhmax);
#endif
		region.r1 = dh;
		/*
		 if (dh>200)
		 {
		 bmp_write(wrapbmp,"out.png",stdout,100);
		 exit(10);
		 }
		 */
	}
	if (wrapbmp->bpp == 24) {
		bmp8 = &_bmp8;
		bmp_init(bmp8);
		bmp_convert_to_greyscale_ex(bmp8, wrapbmp);
		region.bmp8 = bmp8;
	} else
		region.bmp8 = wrapbmp;
	if (gap_override_internal > 0) {
		region.r1 = wrapbmp_base - wrapbmp_rhmax + 1;
		if (region.r1 < 0)
			region.r1 = 0;
		if (region.r1 > wrapbmp_base)
			region.r1 = wrapbmp_base;
		gap = gap_override_internal;
		gap_override_internal = -1;
	} else {
		if (wrapbmp_height_extended)
			gap = wrapbmp_gap;
		else
			gap = 0;
	}
#ifdef WILLUSDEBUG
	printf("wf:  gap=%d\n",gap);
#endif
	if (gap > 0)
		dst_add_gap_src_pixels("wrapbmp", masterinfo, gap);
	if (!allow_full_justification)
		just = (wrapbmp_just & 0xcf) | 0x20;
	else
		just = wrapbmp_just;
	bmpregion_add(&region, NULL, masterinfo, 0, 0, 0, -1.0, just, 2, colcount,
			rowcount, pageinfo, 0xf, wrapbmp->height - 1 - wrapbmp_base);
	if (wrapbmp->bpp == 24)
		bmp_free(bmp8);
	willus_dmem_free(20, (double **) &rowcount, funcname);
	willus_dmem_free(19, (double **) &colcount, funcname);
	wrapbmp->width = 0;
	wrapbmp->height = 0;
	wrapbmp_line_spacing = -1;
	wrapbmp_gap = -1;
	wrapbmp_rhmax = -1;
	wrapbmp_thmax = -1;
	wrapbmp_hyphen.ch = -1;
	if (use_bgi == 1 && beginning_gap_internal > 0)
		dst_add_gap_src_pixels("wrapbmp_bgi1", masterinfo,
				beginning_gap_internal);
	beginning_gap_internal = -1;
	last_h5050_internal = -1;
	if (use_bgi)
		just_flushed_internal = 1;
}

static void wrapbmp_hyphen_erase(void)

{
	WILLUSBITMAP *bmp, _bmp;
	int bw, bpp, c0, c1, c2, i;

	if (wrapbmp_hyphen.ch < 0)
		return;
#if (WILLUSDEBUGX & 16)
	printf("@hyphen_erase, bmp=%d x %d x %d\n",wrapbmp->width,wrapbmp->height,wrapbmp->bpp);
	printf("    ch=%d, c2=%d, r1=%d, r2=%d\n",wrapbmp_hyphen.ch,wrapbmp_hyphen.c2,wrapbmp_hyphen.r1,wrapbmp_hyphen.r2);
#endif
	bmp = &_bmp;
	bmp_init(bmp);
	bmp->bpp = wrapbmp->bpp;
	if (bmp->bpp == 8)
		for (i = 0; i < 256; i++)
			bmp->red[i] = bmp->blue[i] = bmp->green[i] = i;
	bmp->height = wrapbmp->height;
	if (src_left_to_right) {
		bmp->width = wrapbmp_hyphen.c2 + 1;
		c0 = 0;
		c1 = wrapbmp_hyphen.ch;
		c2 = bmp->width - 1;
	} else {
		bmp->width = wrapbmp->width - wrapbmp_hyphen.c2;
		c0 = wrapbmp_hyphen.c2;
		c1 = 0;
		c2 = wrapbmp_hyphen.ch - wrapbmp_hyphen.c2;
	}
	bmp_alloc(bmp);
	bpp = bmp->bpp == 24 ? 3 : 1;
	bw = bpp * bmp->width;
	for (i = 0; i < bmp->height; i++)
		memcpy(bmp_rowptr_from_top(bmp, i),
				bmp_rowptr_from_top(wrapbmp, i) + bpp * c0, bw);
	bw = (c2 - c1 + 1) * bpp;
	if (bw > 0)
		for (i = wrapbmp_hyphen.r1; i <= wrapbmp_hyphen.r2; i++)
			memset(bmp_rowptr_from_top(bmp, i) + bpp * c1, 255, bw);
#if (WILLUSDEBUGX & 16)
	{
		static int count=1;
		char filename[256];
		sprintf(filename,"be%04d.png",count);
		bmp_write(wrapbmp,filename,stdout,100);
		sprintf(filename,"ae%04d.png",count);
		bmp_write(bmp,filename,stdout,100);
		count++;
	}
#endif
	bmp_copy(wrapbmp, bmp);
	bmp_free(bmp);
}

/*
 ** src is only allocated if dst_color != 0
 */
static void white_margins(WILLUSBITMAP *src, WILLUSBITMAP *srcgrey)

{
	int i, n;
	BMPREGION *region, _region;

	region = &_region;
	region->bmp = srcgrey;
	get_white_margins(region);
	n = region->c1;
	for (i = 0; i < srcgrey->height; i++) {
		unsigned char *p;
		if (dst_color) {
			p = bmp_rowptr_from_top(src, i);
			memset(p, 255, n * 3);
		}
		p = bmp_rowptr_from_top(srcgrey, i);
		memset(p, 255, n);
	}
	n = srcgrey->width - 1 - region->c2;
	for (i = 0; i < srcgrey->height; i++) {
		unsigned char *p;
		if (dst_color) {
			p = bmp_rowptr_from_top(src, i) + 3 * (src->width - n);
			memset(p, 255, n * 3);
		}
		p = bmp_rowptr_from_top(srcgrey, i) + srcgrey->width - n;
		memset(p, 255, n);
	}
	n = region->r1;
	for (i = 0; i < n; i++) {
		unsigned char *p;
		if (dst_color) {
			p = bmp_rowptr_from_top(src, i);
			memset(p, 255, src->width * 3);
		}
		p = bmp_rowptr_from_top(srcgrey, i);
		memset(p, 255, srcgrey->width);
	}
	n = srcgrey->height - 1 - region->r2;
	for (i = srcgrey->height - n; i < srcgrey->height; i++) {
		unsigned char *p;
		if (dst_color) {
			p = bmp_rowptr_from_top(src, i);
			memset(p, 255, src->width * 3);
		}
		p = bmp_rowptr_from_top(srcgrey, i);
		memset(p, 255, srcgrey->width);
	}
}

static void get_white_margins(BMPREGION *region)

{
	int n;
	double defval;

	defval = 0.25;
	if (mar_left < 0.)
		mar_left = defval;
	n = (int) (0.5 + mar_left * src_dpi);
	if (n > region->bmp->width)
		n = region->bmp->width;
	region->c1 = n;
	if (mar_right < 0.)
		mar_right = defval;
	n = (int) (0.5 + mar_right * src_dpi);
	if (n > region->bmp->width)
		n = region->bmp->width;
	region->c2 = region->bmp->width - 1 - n;
	if (mar_top < 0.)
		mar_top = defval;
	n = (int) (0.5 + mar_top * src_dpi);
	if (n > region->bmp->height)
		n = region->bmp->height;
	region->r1 = n;
	if (mar_bot < 0.)
		mar_bot = defval;
	n = (int) (0.5 + mar_bot * src_dpi);
	if (n > region->bmp->height)
		n = region->bmp->height;
	region->r2 = region->bmp->height - 1 - n;
}

/*
 ** bitmap_orientation()
 **
 ** 1.0 means neutral
 **
 ** >> 1.0 means document is likely portrait (no rotation necessary)
 **    (max is 100.)
 **
 ** << 1.0 means document is likely landscape (need to rotate it)
 **    (min is 0.01)
 **
 */
static double bitmap_orientation(WILLUSBITMAP *bmp)

{
	int i, ic, wtcalc;
	double hsum, vsum, rat;

	wtcalc = -1;
	for (vsum = 0., hsum = 0., ic = 0, i = 20; i <= 85; i += 5, ic++) {
		double nv, nh;
		int wth, wtv;

#ifdef DEBUG
		printf("h %d:\n",i);
#endif
		if (ic == 0)
			wth = -1;
		else
			wth = wtcalc;
		wth = -1;
		nh = bmp_inflections_horizontal(bmp, 8, i, &wth);
#ifdef DEBUG
		{
			FILE *f;
			f=fopen("inf.ep","a");
			fprintf(f,"/ag\n");
			fclose(f);
		}
		printf("v %d:\n",i);
#endif
		if (ic == 0)
			wtv = -1;
		else
			wtv = wtcalc;
		wtv = -1;
		nv = bmp_inflections_vertical(bmp, 8, i, &wtv);
		if (ic == 0) {
			if (wtv > wth)
				wtcalc = wtv;
			else
				wtcalc = wth;
			continue;
		}
// exit(10);
		hsum += nh * i * i * i;
		vsum += nv * i * i * i;
	}
	if (vsum == 0. && hsum == 0.)
		rat = 1.0;
	else if (hsum < vsum && hsum / vsum < .01)
		rat = 100.;
	else
		rat = vsum / hsum;
	if (rat < .01)
		rat = .01;
	// printf("    page %2d:  %8.4f\n",pagenum,rat);
	// fprintf(out,"\t%8.4f",vsum/hsum);
	// fprintf(out,"\n");
	return (rat);
}

static double bmp_inflections_vertical(WILLUSBITMAP *srcgrey, int ndivisions,
		int delta, int *wthresh)

{
	int y0, y1, ny, i, nw, nisum, ni, wt, wtmax;
	double *g;
	char *funcname = "bmp_inflections_vertical";

	nw = srcgrey->width / ndivisions;
	y0 = srcgrey->height / 6;
	y1 = srcgrey->height - y0;
	ny = y1 - y0;
	willus_dmem_alloc_warn(21, (void **) &g, ny * sizeof(double), funcname, 10);
	wtmax = -1;
	for (nisum = 0, i = 0; i < 10; i++) {
		int x0, x1, nx, j;

		x0 = (srcgrey->width - nw) * (i + 2) / 13;
		x1 = x0 + nw;
		if (x1 > srcgrey->width)
			x1 = srcgrey->width;
		nx = x1 - x0;
		for (j = y0; j < y1; j++) {
			int k, rsum;
			unsigned char *p;

			p = bmp_rowptr_from_top(srcgrey, j) + x0;
			for (rsum = k = 0; k < nx; k++, p++)
				rsum += p[0];
			g[j - y0] = (double) rsum / nx;
		}
		wt = (*wthresh);
		ni = inflection_count(g, ny, delta, &wt);
		if ((*wthresh) < 0 && ni >= 3 && wt > wtmax)
			wtmax = wt;
		if (ni > nisum)
			nisum = ni;
	}
	willus_dmem_free(21, &g, funcname);
	if ((*wthresh) < 0)
		(*wthresh) = wtmax;
	return (nisum);
}

static double bmp_inflections_horizontal(WILLUSBITMAP *srcgrey, int ndivisions,
		int delta, int *wthresh)

{
	int x0, x1, nx, bw, i, nh, nisum, ni, wt, wtmax;
	double *g;
	char *funcname = "bmp_inflections_vertical";

	nh = srcgrey->height / ndivisions;
	x0 = srcgrey->width / 6;
	x1 = srcgrey->width - x0;
	nx = x1 - x0;
	bw = bmp_bytewidth(srcgrey);
	willus_dmem_alloc_warn(22, (void **) &g, nx * sizeof(double), funcname, 10);
	wtmax = -1;
	for (nisum = 0, i = 0; i < 10; i++) {
		int y0, y1, ny, j;

		y0 = (srcgrey->height - nh) * (i + 2) / 13;
		y1 = y0 + nh;
		if (y1 > srcgrey->height)
			y1 = srcgrey->height;
		ny = y1 - y0;
		for (j = x0; j < x1; j++) {
			int k, rsum;
			unsigned char *p;

			p = bmp_rowptr_from_top(srcgrey, y0) + j;
			for (rsum = k = 0; k < ny; k++, p += bw)
				rsum += p[0];
			g[j - x0] = (double) rsum / ny;
		}
		wt = (*wthresh);
		ni = inflection_count(g, nx, delta, &wt);
		if ((*wthresh) < 0 && ni >= 3 && wt > wtmax)
			wtmax = wt;
		if (ni > nisum)
			nisum = ni;
	}
	willus_dmem_free(22, &g, funcname);
	if ((*wthresh) < 0)
		(*wthresh) = wtmax;
	return (nisum);
}

static int inflection_count(double *x, int n, int delta, int *wthresh)

{
	int i, i0, ni, ww, c, ct, wt, mode;
	double meandi, meandisq, f1, f2, stdev;
	double *xs;
	static int hist[256];
	static char *funcname = "inflection_count";

	/* Find threshold white value that peaks must exceed */
	if ((*wthresh) < 0) {
		for (i = 0; i < 256; i++)
			hist[i] = 0;
		for (i = 0; i < n; i++) {
			i0 = floor(x[i]);
			if (i0 > 255)
				i0 = 255;
			hist[i0]++;
		}
		ct = n * .15;
		for (c = 0, i = 255; i >= 0; i--) {
			c += hist[i];
			if (c > ct)
				break;
		}
		wt = i - 10;
		if (wt < 192)
			wt = 192;
#ifdef DEBUG
		printf("wt=%d\n",wt);
#endif
		(*wthresh) = wt;
	} else
		wt = (*wthresh);
	ww = n / 150;
	if (ww < 1)
		ww = 1;
	willus_dmem_alloc_warn(23, (void **) &xs, sizeof(double) * n, funcname, 10);
	for (i = 0; i < n - ww; i++) {
		int j;
		for (xs[i] = 0., j = 0; j < ww; j++, xs[i] += x[i + j])
			;
		xs[i] /= ww;
	}
	meandi = meandisq = 0.;
	if (xs[0] <= wt - delta)
		mode = 1;
	else if (xs[0] >= wt)
		mode = -1;
	else
		mode = 0;
	for (i0 = 0, ni = 0, i = 1; i < n - ww; i++) {
		if (mode == 1 && xs[i] >= wt) {
			if (i0 > 0) {
				meandi += i - i0;
				meandisq += (i - i0) * (i - i0);
				ni++;
			}
			i0 = i;
			mode = -1;
			continue;
		}
		if (xs[i] <= wt - delta)
			mode = 1;
	}
	stdev = 1.0; /* Avoid compiler warning */
	if (ni > 0) {
		meandi /= ni;
		meandisq /= ni;
		stdev = sqrt(fabs(meandi * meandi - meandisq));
	}
	f1 = meandi / n;
	if (f1 > .15)
		f1 = .15;
	if (ni > 2) {
		if (stdev / meandi < .05)
			f2 = 20.;
		else
			f2 = meandi / stdev;
	} else
		f2 = 1.;
#ifdef DEBUG
	printf("    ni=%3d, f1=%8.4f, f2=%8.4f, f1*f2*ni=%8.4f\n",ni,f1,f2,f1*f2*ni);
	{
		static int count=0;
		FILE *f;
		int i;
		f=fopen("inf.ep",count==0?"w":"a");
		count++;
		fprintf(f,"/sa l \"%d\" 1\n",ni);
		for (i=0;i<n-ww;i++)
		fprintf(f,"%g\n",xs[i]);
		fprintf(f,"//nc\n");
		fclose(f);
	}
#endif /* DEBUG */
	willus_dmem_free(23, &xs, funcname);
	return (f1 * f2 * ni);
}

static void pdfboxes_init(PDFBOXES *boxes)

{
	boxes->n = boxes->na = 0;
	boxes->box = NULL;
}

static void pdfboxes_free(PDFBOXES *boxes)

{
	static char *funcname = "pdfboxes_free";
	willus_dmem_free(24, (double **) &boxes->box, funcname);
}

#ifdef COMMENT
static void pdfboxes_add_box(PDFBOXES *boxes,PDFBOX *box)

{
	static char *funcname="pdfboxes_add_box";

	if (boxes->n>=boxes->na)
	{
		int newsize;

		newsize = boxes->na < 1024 ? 2048 : boxes->na*2;
		/* Just calls willus_mem_alloc if oldsize==0 */
		willus_mem_realloc_robust_warn((void **)&boxes->box,newsize*sizeof(PDFBOX),
				boxes->na*sizeof(PDFBOX),funcname,10);
		boxes->na=newsize;
	}
	boxes->box[boxes->n++]=(*box);
}

static void pdfboxes_delete(PDFBOXES *boxes,int n)

{
	if (n>0 && n<boxes->n)
	{
		int i;
		for (i=0;i<boxes->n-n;i++)
		boxes->box[i]=boxes->box[i+n];
	}
	boxes->n -= n;
	if (boxes->n < 0)
	boxes->n = 0;
}
#endif

/*
 ** Track gaps between words so that we can tell when one is out of family.
 ** lcheight = height of a lowercase letter.
 */
static void word_gaps_add(BREAKINFO *breakinfo, int lcheight,
		double *median_gap)

{
	static int nn = 0;
	static double gap[1024];
	static char *funcname = "word_gaps_add";

	if (breakinfo != NULL && breakinfo->n > 1) {
		int i;

		for (i = 0; i < breakinfo->n - 1; i++) {
			double g;
			g = (double) breakinfo->textrow[i].gap / lcheight;
			if (g >= word_spacing) {
				gap[nn & 0x3ff] = g;
				nn++;
			}
		}
	}
	if (median_gap != NULL) {
		if (nn > 0) {
			int n;
			static double *gap_sorted;

			n = (nn > 1024) ? 1024 : nn;
			willus_dmem_alloc_warn(28, (void **) &gap_sorted,
					sizeof(double) * n, funcname, 10);
			memcpy(gap_sorted, gap, n * sizeof(double));
			sortd(gap_sorted, n);
			(*median_gap) = gap_sorted[n / 2];
			willus_dmem_free(28, &gap_sorted, funcname);
		} else
			(*median_gap) = 0.7;
	}
}

/*
 ** bmp must be grayscale! (cbmp = color, can be null)
 */
static void bmp_detect_vertical_lines(WILLUSBITMAP *bmp, WILLUSBITMAP *cbmp,
		double dpi, double minwidth_in, double maxwidth_in, double minheight_in,
		double anglemax_deg, int white_thresh)

{
	int tc, iangle, irow, icol;
	int rowstep, na, angle_sign, ccthresh;
	int pixmin, halfwidth, bytewidth;
	int bs1, nrsteps, dp;
	double anglestep;
	WILLUSBITMAP *tmp, _tmp;
	unsigned char *p0;

	if (debug)
		printf("At bmp_detect_vertical_lines...\n");
	if (!bmp_is_grayscale(bmp)) {
		printf(
				"Internal error.  bmp_detect_vertical_lines passed a non-grayscale bitmap.\n");
		exit(10);
	}
	tmp = &_tmp;
	bmp_init(tmp);
	bmp_copy(tmp, bmp);
	dp = bmp_rowptr_from_top(tmp, 0) - bmp_rowptr_from_top(bmp, 0);
	bytewidth = bmp_bytewidth(bmp);
	pixmin = (int) (minwidth_in * dpi + .5);
	if (pixmin < 1)
		pixmin = 1;
	halfwidth = pixmin / 4;
	if (halfwidth < 1)
		halfwidth = 1;
	anglestep = atan2((double) halfwidth / dpi, minheight_in);
	na = (int) ((anglemax_deg * PI / 180.) / anglestep + .5);
	if (na < 1)
		na = 1;
	rowstep = (int) (dpi / 40. + .5);
	if (rowstep < 2)
		rowstep = 2;
	nrsteps = bmp->height / rowstep;
	bs1 = bytewidth * rowstep;
	ccthresh = (int) (minheight_in * dpi / rowstep + .5);
	if (ccthresh < 2)
		ccthresh = 2;
	if (debug && verbose)
		printf(
				"    na = %d, rowstep = %d, ccthresh = %d, white_thresh = %d, nrsteps=%d\n",
				na, rowstep, ccthresh, white_thresh, nrsteps);
	/*
	 bmp_write(bmp,"out.png",stdout,97);
	 wfile_written_info("out.png",stdout);
	 */
	p0 = bmp_rowptr_from_top(bmp, 0);
	for (tc = 0; tc < 100; tc++) {
		int ccmax, ic0max, ir0max;
		double tanthmax;

		ccmax = -1;
		ic0max = ir0max = 0;
		tanthmax = 0.;
		for (iangle = 0; iangle <= na; iangle++) {
			for (angle_sign = 1; angle_sign >= -1; angle_sign -= 2) {
				double th, tanth, tanthx;
				int ic1, ic2;

				if (iangle == 0 && angle_sign == -1)
					continue;
				th = (PI / 180.) * iangle * angle_sign * fabs(anglemax_deg)
						/ na;
				tanth = tan(th);
				tanthx = tanth * rowstep;
				if (angle_sign == 1) {
					ic1 = -(int) (bmp->height * tanth + 1.);
					ic2 = bmp->width - 1;
				} else {
					ic1 = (int) (-bmp->height * tanth + 1.);
					ic2 = bmp->width - 1 + (int) (-bmp->height * tanth + 1.);
				}
// printf("iangle=%2d, angle_sign=%2d, ic1=%4d, ic2=%4d\n",iangle,angle_sign,ic1,ic2);
				for (icol = ic1; icol <= ic2; icol++) {
					unsigned char *p;
					int cc, ic0, ir0;
					p = p0;
					if (icol < 0 || icol > bmp->width - 1)
						for (irow = 0; irow < nrsteps; irow++, p += bs1) {
							int ic;
							ic = icol + irow * tanthx;
							if (ic >= 0 && ic < bmp->width)
								break;
						}
					else
						irow = 0;
					for (ir0 = ic0 = cc = 0; irow < nrsteps; irow++, p += bs1) {
						int ic;
						ic = icol + irow * tanthx;
						if (ic < 0 || ic >= bmp->width)
							break;
						if ((p[ic] < white_thresh
								|| p[ic + bytewidth] < white_thresh)
								&& (p[ic + dp] < white_thresh
										|| p[ic + bytewidth + dp] < white_thresh)) {
							if (cc == 0) {
								ic0 = ic;
								ir0 = irow * rowstep;
							}
							cc++;
							if (cc > ccmax) {
								ccmax = cc;
								tanthmax = tanth;
								ic0max = ic0;
								ir0max = ir0;
							}
						} else
							cc = 0;
					}
				}
			}
		}
		if (ccmax < ccthresh)
			break;
		if (debug)
			printf(
					"    Vert line detected:  ccmax=%d (pix=%d), tanthmax=%g, ic0max=%d, ir0max=%d\n",
					ccmax, ccmax * rowstep, tanthmax, ic0max, ir0max);
		if (!vert_line_erase(bmp, cbmp, tmp, ir0max, ic0max, tanthmax,
				minheight_in, minwidth_in, maxwidth_in, white_thresh))
			break;
	}
	/*
	 bmp_write(tmp,"outt.png",stdout,95);
	 wfile_written_info("outt.png",stdout);
	 bmp_write(bmp,"out2.png",stdout,95);
	 wfile_written_info("out2.png",stdout);
	 exit(10);
	 */
}

/*
 ** Calculate max vert line length.  Line is terminated by nw consecutive white pixels
 ** on either side.
 */
static int vert_line_erase(WILLUSBITMAP *bmp, WILLUSBITMAP *cbmp,
		WILLUSBITMAP *tmp, int row0, int col0, double tanth,
		double minheight_in, double minwidth_in, double maxwidth_in,
		int white_thresh)

{
	int lw, cc, maxdev, nw, dir, i, n;
	int *c1, *c2, *w;
	static char *funcname = "vert_line_erase";

	willus_dmem_alloc_warn(26, (void **) &c1, sizeof(int) * 3 * bmp->height,
			funcname, 10);
	c2 = &c1[bmp->height];
	w = &c2[bmp->height];
	/*
	 maxdev = (int)((double)bmp->height / minheight_in +.5);
	 if (maxdev < 3)
	 maxdev=3;
	 */
	nw = (int) ((double) src_dpi / 100. + .5);
	if (nw < 2)
		nw = 2;
	maxdev = nw;
	for (i = 0; i < bmp->height; i++)
		c1[i] = c2[i] = -1;
	n = 0;
	for (dir = -1; dir <= 1; dir += 2) {
		int del, brc;

		brc = 0;
		for (del = (dir == -1) ? 0 : 1; 1; del++) {
			int r, c;
			unsigned char *p;

			r = row0 + dir * del;
			if (r < 0 || r > bmp->height - 1)
				break;
			c = col0 + (r - row0) * tanth;
			if (c < 0 || c > bmp->width - 1)
				break;
			p = bmp_rowptr_from_top(bmp, r);
			for (i = c; i <= c + maxdev && i < bmp->width; i++)
				if (p[i] < white_thresh)
					break;
			if (i > c + maxdev || i >= bmp->width) {
				for (i = c - 1; i >= c - maxdev && i >= 0; i--)
					if (p[i] < white_thresh)
						break;
				if (i < c - maxdev || i < 0) {
					brc++;
					if (brc >= nw)
						break;
					continue;
				}
			}
			brc = 0;
			for (c = i, cc = 0; i < bmp->width; i++)
				if (p[i] < white_thresh)
					cc = 0;
				else {
					cc++;
					if (cc >= nw)
						break;
				}
			c2[r] = i - cc;
			if (c2[r] > bmp->width - 1)
				c2[r] = bmp->width - 1;
			for (cc = 0, i = c; i >= 0; i--)
				if (p[i] < white_thresh)
					cc = 0;
				else {
					cc++;
					if (cc >= nw)
						break;
				}
			c1[r] = i + cc;
			if (c1[r] < 0)
				c1[r] = 0;
			w[n++] = c2[r] - c1[r] + 1;
			c1[r] -= cc;
			if (c1[r] < 0)
				c1[r] = 0;
			c2[r] += cc;
			if (c2[r] > bmp->width - 1)
				c2[r] = bmp->width - 1;
		}
	}
	if (n > 1)
		sorti(w, n);
	if (n < 10 || n < minheight_in * src_dpi || w[n / 4] < minwidth_in * src_dpi
			|| w[3 * n / 4] > maxwidth_in * src_dpi
			|| (erase_vertical_lines == 1 && w[n - 1] > maxwidth_in * src_dpi)) {
		/* Erase area in temp bitmap */
		for (i = 0; i < bmp->height; i++) {
			unsigned char *p;
			int cmax;

			if (c1[i] < 0 || c2[i] < 0)
				continue;
			cmax = (c2[i] - c1[i]) + 1;
			p = bmp_rowptr_from_top(tmp, i) + c1[i];
			for (; cmax > 0; cmax--, p++)
				(*p) = 255;
		}
	} else {
		/* Erase line width in source bitmap */
		lw = w[3 * n / 4] + nw * 2;
		if (lw > maxwidth_in * src_dpi / 2)
			lw = maxwidth_in * src_dpi / 2;
		for (i = 0; i < bmp->height; i++) {
			unsigned char *p;
			int c0, cmin, cmax, count, white;

			if (c1[i] < 0 || c2[i] < 0)
				continue;
			c0 = col0 + (i - row0) * tanth;
			cmin = c0 - lw - 1;
			if (cmin < c1[i])
				cmin = c1[i];
			cmax = c0 + lw + 1;
			if (cmax > c2[i])
				cmax = c2[i];
			p = bmp_rowptr_from_top(bmp, i);
			c0 = (p[cmin] > p[cmax]) ? cmin : cmax;
			white = p[c0];
			if (white <= white_thresh)
				white = white_thresh + 1;
			if (white > 255)
				white = 255;
			count = (cmax - cmin) + 1;
			p = &p[cmin];
			for (; count > 0; count--, p++)
				(*p) = white;
			if (cbmp != NULL) {
				unsigned char *p0;
				p = bmp_rowptr_from_top(cbmp, i);
				p0 = p + c0 * 3;
				p = p + cmin * 3;
				count = (cmax - cmin) + 1;
				for (; count > 0; count--, p += 3) {
					p[0] = p0[0];
					p[1] = p0[1];
					p[2] = p0[2];
				}
			}
		}
	}
	willus_dmem_free(26, (double **) &c1, funcname);
	return (1);
}

/*
 ** mem_index... controls which memory allocactions get a protective margin
 ** around them.
 */
static int mem_index_min = 999;
static int mem_index_max = 999;
static void willus_dmem_alloc_warn(int index, void **ptr, int size,
		char *funcname, int exitcode)

{
	if (index >= mem_index_min && index <= mem_index_max) {
		char *ptr1;
		void *x;
		willus_mem_alloc_warn((void **) &ptr1, size + 2048, funcname, exitcode);
		ptr1 += 1024;
		x = (void *) ptr1;
		(*ptr) = x;
	} else
		willus_mem_alloc_warn(ptr, size, funcname, exitcode);
}

static void willus_dmem_free(int index, double **ptr, char *funcname)

{
	if ((*ptr) == NULL)
		return;
	if (index >= mem_index_min && index <= mem_index_max) {
		double *x;
		char *ptr1;
		x = (*ptr);
		ptr1 = (char *) x;
		ptr1 -= 1024;
		x = (double *) ptr1;
		willus_mem_free(&x, funcname);
		(*ptr) = NULL;
	} else
		willus_mem_free(ptr, funcname);
}

/* mem.c */
/*
** The reason I don't simply use malloc is because I want to allocate
** memory using type long instead of type size_t.  On some compilers,
** like gcc, these are the same, so it doesn't matter.  On other
** compilers, like Turbo C, these are different.
**
*/
static int willus_mem_alloc(double **ptr,long size,char *name)

    {
#if (defined(WIN32) && !defined(__DMC__))
    unsigned long memsize;
    memsize = (unsigned long)size;
#ifdef USEGLOBAL
    (*ptr) = (memsize==size) ? (double *)GlobalAlloc(GPTR,memsize) : NULL;
#else
    (*ptr) = (memsize==size) ? (double *)CoTaskMemAlloc(memsize) : NULL;
#endif
#else
    size_t  memsize;
    memsize=(size_t)size;
    (*ptr) =  (memsize==size) ? (double *)malloc(memsize) : NULL;
#endif
/*
{
f=fopen("mem.dat","a");
fprintf(f,"willus_mem_alloc(%d,%s)\n",size,name);
fclose(f);
}
*/
    return((*ptr)!=NULL);
    }

/*
** Prints an integer to 's' with commas separating every three digits.
** E.g. 45,399,350
** Correctly handles negative values.
*/
static void comma_print(char *s,long size)

    {
    int  i,m,neg;
    char tbuf[80];

    if (!size)
        {
        s[0]='0';
        s[1]='\0';
        return;
        }
    s[0]='\0';
    neg=0;
    if (size<0)
        {
        size=-size;
        neg=1;
        }
    for (i=0,m=size%1000;size;i++,size=(size-m)/1000,m=size%1000)
        {
        sprintf(tbuf,m==size ? "%d%s":"%03d%s",m,i>0 ? "," : "");
        strcat(tbuf,s);
        strcpy(s,tbuf);
        }
    if (neg)
        {
        strcpy(tbuf,"-");
        strcat(tbuf,s);
        strcpy(s,tbuf);
        }
    }


static void mem_warn(char *name,int size,int exitcode)

    {
    static char buf[128];

    aprintf("\n" ANSI_RED "\aCannot allocate enough memory for "
            "function %s." ANSI_NORMAL "\n",name);
    comma_print(buf,size);
    aprintf("    " ANSI_RED "(Needed %s bytes.)" ANSI_NORMAL "\n\n",buf);
    if (exitcode!=0)
        {
        aprintf("    " ANSI_RED "Program terminated." ANSI_NORMAL "\n\n");
        exit(exitcode);
        }
    }

static int willus_mem_alloc_warn(void **ptr, int size, char *name, int exitcode)

{
	int status;

	status = willus_mem_alloc((double **) ptr, (long) size, name);
	if (!status)
		mem_warn(name, size, exitcode);
	return (status);
}

static void willus_mem_free(double **ptr, char *name)

{
	if ((*ptr) != NULL) {
#if (defined(WIN32) && !defined(__DMC__))
#ifdef USEGLOBAL
		GlobalFree((void *)(*ptr));
#else
		CoTaskMemFree((void *)(*ptr));
#endif
#else
		free((void *) (*ptr));
#endif
		(*ptr) = NULL;
	}
}

static int willus_mem_realloc_robust(double **ptr,long newsize,long oldsize,char *name)

    {
#if (defined(WIN32) && !defined(__DMC__))
    unsigned long memsize;
    void *newptr;
#else
    size_t  memsize;
    void *newptr;
#endif

#if (defined(WIN32) && !defined(__DMC__))
    memsize=(unsigned long)newsize;
#else
    memsize=(size_t)newsize;
#endif
    if (memsize!=newsize)
        return(0);
    if ((*ptr)==NULL || oldsize<=0)
        return(willus_mem_alloc(ptr,newsize,name));
#if (defined(WIN32) && !defined(__DMC__))
#ifdef USEGLOBAL
    newptr = (void *)GlobalReAlloc((void *)(*ptr),memsize,GMEM_MOVEABLE);
#else
    newptr = (void *)CoTaskMemRealloc((void *)(*ptr),memsize);
#endif
#else
    newptr = realloc((void *)(*ptr),memsize);
#endif
    if (newptr==NULL && willus_mem_alloc((double **)&newptr,newsize,name))
        {
        memcpy(newptr,(*ptr),oldsize);
        willus_mem_free(ptr,name);
        }
    if (newptr==NULL)
        return(0);

    (*ptr) = newptr;
    return(1);
    }


static int willus_mem_realloc_robust_warn(void **ptr,int newsize,int oldsize,char *name,
                                int exitcode)

    {
    int status;

    status = willus_mem_realloc_robust((double **)ptr,newsize,oldsize,name);
    if (!status)
        mem_warn(name,newsize,exitcode);
    return(status);
    }

/* math.c */
static void sortd(double *x, int n)

{
	int top, n1;
	double x0;

	if (n < 2)
		return;
	top = n / 2;
	n1 = n - 1;
	while (1) {
		if (top > 0) {
			top--;
			x0 = x[top];
		} else {
			x0 = x[n1];
			x[n1] = x[0];
			n1--;
			if (!n1) {
				x[0] = x0;
				return;
			}
		}
		{
			int parent, child;

			parent = top;
			child = top * 2 + 1;
			while (child <= n1) {
				if (child < n1 && x[child] < x[child + 1])
					child++;
				if (x0 < x[child]) {
					x[parent] = x[child];
					parent = child;
					child += (parent + 1);
				} else
					break;
			}
			x[parent] = x0;
		}
	}
}

static void sorti(int *x, int n)

{
	int top, n1;
	int x0;

	if (n < 2)
		return;
	top = n / 2;
	n1 = n - 1;
	while (1) {
		if (top > 0) {
			top--;
			x0 = x[top];
		} else {
			x0 = x[n1];
			x[n1] = x[0];
			n1--;
			if (!n1) {
				x[0] = x0;
				return;
			}
		}
		{
			int parent, child;

			parent = top;
			child = top * 2 + 1;
			while (child <= n1) {
				if (child < n1 && x[child] < x[child + 1])
					child++;
				if (x0 < x[child]) {
					x[parent] = x[child];
					parent = child;
					child += (parent + 1);
				} else
					break;
			}
			x[parent] = x0;
		}
	}
}

/* bmp.c */
/*
 ** Should call bmp_set_type() right after this to set the bitmap type.
 */

#define RGBSET24(bmp,ptr,r,g,b) \
    if (bmp->type==WILLUSBITMAP_TYPE_NATIVE) \
        { \
        ptr[0]=r; \
        ptr[1]=g; \
        ptr[2]=b; \
        } \
    else \
        { \
        ptr[2]=r; \
        ptr[1]=g; \
        ptr[0]=b; \
        }

#define RGBGET(bmp,ptr,r,g,b) \
    if (bmp->bpp==8) \
        { \
        r=bmp->red[ptr[0]]; \
        g=bmp->green[ptr[0]]; \
        b=bmp->blue[ptr[0]]; \
        } \
    else if (bmp->type==WILLUSBITMAP_TYPE_NATIVE) \
        { \
        r=ptr[0]; \
        g=ptr[1]; \
        b=ptr[2]; \
        } \
    else \
        { \
        r=ptr[2]; \
        g=ptr[1]; \
        b=ptr[0]; \
        }

#define RGBGETINCPTR(bmp,ptr,r,g,b) \
    if (bmp->bpp==8) \
        { \
        r=bmp->red[ptr[0]]; \
        g=bmp->green[ptr[0]]; \
        b=bmp->blue[ptr[0]]; \
        ptr++; \
        } \
    else if (bmp->type==WILLUSBITMAP_TYPE_NATIVE) \
        { \
        r=ptr[0]; \
        g=ptr[1]; \
        b=ptr[2]; \
        ptr+=3; \
        } \
    else \
        { \
        r=ptr[2]; \
        g=ptr[1]; \
        b=ptr[0]; \
        ptr+=3; \
        }

static void bmp_init(WILLUSBITMAP *bmap)

{
	bmap->data = NULL;
	bmap->size_allocated = 0;
	bmap->type = WILLUSBITMAP_TYPE_NATIVE;
}

static int bmp_bytewidth_win32(WILLUSBITMAP *bmp)

    {
    return(((bmp->bpp==24 ? bmp->width*3 : bmp->width)+3)&(~0x3));
    }

/*
 ** The width, height, and bpp parameters of the WILLUSBITMAP structure
 ** should be set before calling this function.
 */
static int bmp_alloc(WILLUSBITMAP *bmap)

{
	int size;
	static char *funcname = "bmp_alloc";

	if (bmap->bpp != 8 && bmap->bpp != 24) {
		printf("Internal error:  call to bmp_alloc has bpp!=8 and bpp!=24!\n");
		exit(10);
	}
	/* Choose the max size even if not WIN32 to avoid memory faults */
	/* and to allow the possibility of changing the "type" of the   */
	/* bitmap without reallocating memory.                          */
	size = bmp_bytewidth_win32(bmap) * bmap->height;
	if (bmap->data != NULL && bmap->size_allocated >= size)
		return (1);
	if (bmap->data != NULL)
		willus_mem_realloc_robust_warn((void **) &bmap->data, size,
				bmap->size_allocated, funcname, 10);
	else
		willus_mem_alloc_warn((void **) &bmap->data, size, funcname, 10);
	bmap->size_allocated = size;
	return (1);
}

static void bmp_free(WILLUSBITMAP *bmap)

    {
    if (bmap->data!=NULL)
        {
        willus_mem_free((double **)&bmap->data,"bmp_free");
        bmap->data=NULL;
        bmap->size_allocated=0;
        }
    }

/*
** If 8-bit, the bitmap is filled with <r>.
** If 24-bit, it gets <r>, <g>, <b> values.
*/
static void bmp_fill(WILLUSBITMAP *bmp,int r,int g,int b)

    {
    int     y,n;

    if (bmp->bpp==8 || (r==g && r==b))
        {
        memset(bmp->data,r,bmp->size_allocated);
        return;
        }
    if (bmp->type==WILLUSBITMAP_TYPE_WIN32 && bmp->bpp==24)
        {
        y=r;
        r=b;
        b=y;
        }
    for (y=bmp->height-1;y>=0;y--)
        {
        unsigned char *p;

        p=bmp_rowptr_from_top(bmp,y);
        for (n=bmp->width-1;n>=0;n--)
            {
            (*p)=r;
            p++;
            (*p)=g;
            p++;
            (*p)=b;
            p++;
            }
        }
    }


static int bmp_copy(WILLUSBITMAP *dest, WILLUSBITMAP *src)

{
	dest->width = src->width;
	dest->height = src->height;
	dest->bpp = src->bpp;
	dest->type = src->type;
	if (!bmp_alloc(dest))
		return (0);
	memcpy(dest->data, src->data, src->height * bmp_bytewidth(src));
	memcpy(dest->red, src->red, sizeof(int) * 256);
	memcpy(dest->green, src->green, sizeof(int) * 256);
	memcpy(dest->blue, src->blue, sizeof(int) * 256);
	return (1);
}

static int bmp_bytewidth(WILLUSBITMAP *bmp) {
	return (bmp->bpp == 24 ? bmp->width * 3 : bmp->width);
}

/*
 ** row==0             ==> top row of bitmap
 ** row==bmp->height-1 ==> bottom row of bitmap
 ** (regardless of bitmap type)
 */
static unsigned char *bmp_rowptr_from_top(WILLUSBITMAP *bmp, int row)

{
	if (bmp->type == WILLUSBITMAP_TYPE_WIN32)
		return (&bmp->data[bmp_bytewidth(bmp) * (bmp->height - 1 - row)]);
	else
		return (&bmp->data[bmp_bytewidth(bmp) * row]);
}

/*
 ** Allocate more bitmap rows.
 ** ratio typically something like 1.5 or 2.0
 */
static void bmp_more_rows(WILLUSBITMAP *bmp, double ratio, int pixval)

{
	int new_height, new_bytes, bw;
	static char *funcname = "bmp_more_rows";

	new_height = (int) (bmp->height * ratio + .5);
	if (new_height <= bmp->height)
		return;
	bw = bmp_bytewidth(bmp);
	new_bytes = bw * new_height;
	if (new_bytes > bmp->size_allocated) {
		willus_mem_realloc_robust_warn((void **) &bmp->data, new_bytes,
				bmp->size_allocated, funcname, 10);
		bmp->size_allocated = new_bytes;
	}
	/* Fill in */
	memset(bmp_rowptr_from_top(bmp, bmp->height), pixval,
			(new_height - bmp->height) * bw);
	bmp->height = new_height;
}

static double resample_single(double *y,double x1,double x2)

    {
    int i,i1,i2;
    double dx,dx1,dx2,sum;

    i1=floor(x1);
    i2=floor(x2);
    if (i1==i2)
        return(y[i1]);
    dx=x2-x1;
    if (dx>1.)
        dx=1.;
    dx1= 1.-(x1-i1);
    dx2= x2-i2;
    sum=0.;
    if (dx1 > 1e-8*dx)
        sum += dx1*y[i1];
    if (dx2 > 1e-8*dx)
        sum += dx2*y[i2];
    for (i=i1+1;i<=i2-1;sum+=y[i],i++);
    return(sum/(x2-x1));
    }

/*
** Resample src[] into dst[].
** Examples:  resample_1d(dst,src,0.,5.,5) would simply copy the
**            first five elements of src[] to dst[].
**
**            resample_1d(dst,src,0.,5.,10) would work as follows:
**                dst[0] and dst[1] would get src[0].
**                dst[2] and dst[3] would get src[1].
**                and so on.
**
*/
static void resample_1d(double *dst,double *src,double x1,double x2,
                        int n)

    {
    int i;
    double new,last;

    last=x1;
    for (i=0;i<n;i++)
        {
        new=x1+(x2-x1)*(i+1)/n;
        dst[i] = resample_single(src,last,new);
        last=new;
        }
    }

static void bmp_resample_1(double *tempbmp,WILLUSBITMAP *src,double x1,double y1,
                           double x2,double y2,int newwidth,int newheight,
                           double *temprow,int color)

    {
    int row,col,x0,dx,y0,dy;

    x0=floor(x1);
    dx=ceil(x2)-x0;
    x1-=x0;
    x2-=x0;
    y0=floor(y1);
    dy=ceil(y2)-y0;
    y1-=y0;
    y2-=y0;
    if (src->type==WILLUSBITMAP_TYPE_WIN32 && color>=0)
        color=2-color;
    for (row=0;row<dy;row++)
        {
        unsigned char *p;
        p=bmp_rowptr_from_top(src,row+y0);
        if (src->bpp==8)
            {
            switch (color)
                {
                case -1:
                    for (col=0,p+=x0;col<dx;col++,p++)
                        temprow[col]=p[0];
                    break;
                case 0:
                    for (col=0,p+=x0;col<dx;col++,p++)
                        temprow[col]=src->red[p[0]];
                    break;
                case 1:
                    for (col=0,p+=x0;col<dx;col++,p++)
                        temprow[col]=src->green[p[0]];
                    break;
                case 2:
                    for (col=0,p+=x0;col<dx;col++,p++)
                        temprow[col]=src->blue[p[0]];
                    break;
                }
            }
        else
            {
            p+=color;
            for (col=0,p+=3*x0;col<dx;temprow[col]=p[0],col++,p+=3);
            }
        resample_1d(&tempbmp[row*newwidth],temprow,x1,x2,newwidth);
        }
    for (col=0;col<newwidth;col++)
        {
        double *p,*s;
        p=&tempbmp[col];
        s=&temprow[dy];
        for (row=0;row<dy;row++,p+=newwidth)
            temprow[row]=p[0];
        resample_1d(s,temprow,y1,y2,newheight);
        p=&tempbmp[col];
        for (row=0;row<newheight;row++,p+=newwidth,s++)
            p[0]=s[0];
        }
    }

/*
 ** Resample (re-size) bitmap.  The pixel positions left to right go from
 ** 0.0 to src->width (x-coord), and top to bottom go from
 ** 0.0 to src->height (y-coord).
 ** The cropped rectangle (x1,y1) to (x2,y2) is placed into
 ** the destination bitmap, which need not be allocated yet.
 **
 ** The destination bitmap will be 8-bit grayscale if the source bitmap
 ** passes the bmp_is_grayscale() function.  Otherwise it will be 24-bit.
 **
 ** Returns 0 for okay.
 **         -1 for not enough memory.
 **         -2 for bad cropping area or destination bitmap size
 */
static int bmp_resample(WILLUSBITMAP *dest, WILLUSBITMAP *src, double x1,
		double y1, double x2, double y2, int newwidth, int newheight)

{
	int gray, maxlen, colorplanes;
	double t;
	double *tempbmp;
	double *temprow;
	int color, hmax, row, col, dy;
	static char *funcname = "bmp_resample";

	/* Clip and sort x1,y1 and x2,y2 */
	if (x1 > src->width)
		x1 = src->width;
	else if (x1 < 0.)
		x1 = 0.;
	if (x2 > src->width)
		x2 = src->width;
	else if (x2 < 0.)
		x2 = 0.;
	if (y1 > src->height)
		y1 = src->height;
	else if (y1 < 0.)
		y1 = 0.;
	if (y2 > src->height)
		y2 = src->height;
	else if (y2 < 0.)
		y2 = 0.;
	if (x2 < x1) {
		t = x2;
		x2 = x1;
		x1 = t;
	}
	if (y2 < y1) {
		t = y2;
		y2 = y1;
		y1 = t;
	}
	dy = y2 - y1;
	dy += 2;
	if (x2 - x1 == 0. || y2 - y1 == 0.)
		return (-2);

	/* Allocate temp storage */
	maxlen = x2 - x1 > dy + newheight ? (int) (x2 - x1) : dy + newheight;
	maxlen += 16;
	hmax = newheight > dy ? newheight : dy;
	if (!willus_mem_alloc(&temprow, maxlen * sizeof(double), funcname))
		return (-1);
	if (!willus_mem_alloc(&tempbmp, hmax * newwidth * sizeof(double),
			funcname)) {
		willus_mem_free(&temprow, funcname);
		return (-1);
	}
	if ((gray = bmp_is_grayscale(src)) != 0) {
		int i;
		dest->bpp = 8;
		for (i = 0; i < 256; i++)
			dest->red[i] = dest->blue[i] = dest->green[i] = i;
	} else
		dest->bpp = 24;
	dest->width = newwidth;
	dest->height = newheight;
	dest->type = WILLUSBITMAP_TYPE_NATIVE;
	if (!bmp_alloc(dest)) {
		willus_mem_free(&tempbmp, funcname);
		willus_mem_free(&temprow, funcname);
		return (-1);
	}
	colorplanes = gray ? 1 : 3;
	for (color = 0; color < colorplanes; color++) {
		bmp_resample_1(tempbmp, src, x1, y1, x2, y2, newwidth, newheight,
				temprow, gray ? -1 : color);
		for (row = 0; row < newheight; row++) {
			unsigned char *p;
			double *s;
			p = bmp_rowptr_from_top(dest, row) + color;
			s = &tempbmp[row * newwidth];
			if (colorplanes == 1)
				for (col = 0; col < newwidth;
						p[0] = (int) (s[0] + .5), col++, s++, p++)
					;
			else
				for (col = 0; col < newwidth;
						p[0] = (int) (s[0] + .5), col++, s++, p += colorplanes)
					;
		}
	}
	willus_mem_free(&tempbmp, funcname);
	willus_mem_free(&temprow, funcname);
	return (0);
}

static int bmp8_greylevel_convert(int r,int g,int b)

    {
    return((int)((r*0.3+g*0.59+b*0.11)*1.002));
    }

/*
** One of dest or src can be NULL, which is the
** same as setting them equal to each other, but
** in this case, the bitmap must be 24-bit!
*/
static int bmp_is_grayscale(WILLUSBITMAP *bmp)

    {
    int i;
    if (bmp->bpp!=8)
        return(0);
    for (i=0;i<256;i++)
        if (bmp->red[i]!=i || bmp->green[i]!=i || bmp->blue[i]!=i)
            return(0);
    return(1);
    }

static void bmp_color_xform8(WILLUSBITMAP *dest,WILLUSBITMAP *src,unsigned char *newval)

    {
    int i,ir;

    if (src==NULL)
        src=dest;
    if (dest==NULL)
        dest=src;
    if (dest!=src)
        {
        dest->width = src->width;
        dest->height = src->height;
        dest->bpp = 8;
        for (i=0;i<256;i++)
            dest->red[i]=dest->green[i]=dest->blue[i]=i;
        bmp_alloc(dest);
        }
    for (ir=0;ir<src->height;ir++)
        {
        unsigned char *sp,*dp;
        sp=bmp_rowptr_from_top(src,ir);
        dp=bmp_rowptr_from_top(dest,ir);
        for (i=0;i<src->width;i++)
            dp[i]=newval[sp[i]];
        }
    }

/*
** One of dest or src can be NULL, which is the
** same as setting them equal to each other, but
** in this case, the bitmap must be 24-bit!
*/
static void bmp_color_xform(WILLUSBITMAP *dest,WILLUSBITMAP *src,unsigned char *newval)

    {
    int ir,ic;

    if (src==NULL)
        src=dest;
    if (dest==NULL)
        dest=src;
    if (bmp_is_grayscale(src))
        {
        bmp_color_xform8(dest,src,newval);
        return;
        }
    if (dest!=src)
        {
        dest->width = src->width;
        dest->height = src->height;
        dest->bpp = 24;
        bmp_alloc(dest);
        }
    for (ir=0;ir<src->height;ir++)
        {
        unsigned char *sp,*dp;
        sp=bmp_rowptr_from_top(src,ir);
        dp=bmp_rowptr_from_top(dest,ir);
        for (ic=0;ic<src->width;ic++,dp+=3)
            {
            int r,g,b;

            RGBGETINCPTR(src,sp,r,g,b);
            r=newval[r];
            g=newval[g];
            b=newval[b];
            RGBSET24(dest,dp,r,g,b);
            }
        }
    }

/*
** One of dest or src can be NULL, which is the
** same as setting them equal to each other, but
** in this case, the bitmap must be 24-bit!
** Note: contrast > 1 will increase the contrast.
**       contrast < 1 will decrease the contrast.
**       contrast of 0 will make all pixels the same value.
**       contrast of 1 will not change the image.
*/
static void bmp_contrast_adjust(WILLUSBITMAP *dest,WILLUSBITMAP *src,double contrast)

    {
    int i;
    static unsigned char newval[256];

    for (i=0;i<256;i++)
        {
        double x,y;
        int sgn,v;
        x=(i-127.5)/127.5;
        sgn = x<0 ? -1 : 1;
        if (contrast<0)
            sgn = -sgn;
        x=fabs(x);
        if (fabs(contrast)>1.5)
            y=x<.99999 ? 1-exp(fabs(contrast)*x/(x-1)) : 1.;
        else
            {
            y=fabs(contrast)*x;
            if (y>1.)
                y=1.;
            }
        y = 127.5+y*sgn*127.5;
        v = (int)(y+.5);
        if (v<0)
            v=0;
        if (v>255)
            v=255;
        newval[i] = v;
        }
    bmp_color_xform(dest,src,newval);
    }

/*
 ** Convert bitmap to grey-scale in-situ
 */
static void bmp_convert_to_greyscale_ex(WILLUSBITMAP *dst, WILLUSBITMAP *src)

{
	int oldbpr, newbpr, bpp, dp, rownum, colnum, i;

	oldbpr = bmp_bytewidth(src);
	dp = src->bpp == 8 ? 1 : 3;
	bpp = src->bpp;
	dst->bpp = 8;
	for (i = 0; i < 256; i++)
		dst->red[i] = dst->green[i] = dst->blue[i] = i;
	if (dst != src) {
		dst->width = src->width;
		dst->height = src->height;
		bmp_alloc(dst);
	}
	newbpr = bmp_bytewidth(dst);
	/* Possibly restore src->bpp to 24 so RGBGET works right (src & dst may be the same) */
	src->bpp = bpp;
	for (rownum = 0; rownum < src->height; rownum++) {
		unsigned char *oldp, *newp;
		oldp = &src->data[oldbpr * rownum];
		newp = &dst->data[newbpr * rownum];
		for (colnum = 0; colnum < src->width; colnum++, oldp += dp, newp++) {
			int r, g, b;
			RGBGET(src, oldp, r, g, b);
			(*newp) = bmp8_greylevel_convert(r, g, b);
		}
	}
	dst->bpp = 8; /* Possibly restore dst->bpp to 8 since src & dst may be the same. */
}

/*
 ** Bitmap is assumed to be grayscale
 */
static double bmp_row_by_row_stdev(WILLUSBITMAP *bmp, int ccount,
		int whitethresh, double theta_radians)

{
	int dc1, dc2, c1, c2;
	int r, n, nn, dw;
	double tanth, csum, csumsq, stdev;

	c1 = bmp->width / 15.;
	c2 = bmp->width - c1;
	dw = (int) ((c2 - c1) / ccount + .5);
	if (dw < 1)
		dw = 1;
	tanth = -tan(theta_radians);
	dc1 = (int) (tanth * bmp->width);
	if (dc1 < 0) {
		dc1 = 1 - dc1;
		dc2 = 0;
	} else {
		dc2 = -dc1 - 1;
		dc1 = 0;
	}
	dc1 += bmp->height / 15.;
	dc2 -= bmp->height / 15.;
	csum = csumsq = 0.;
	n = 0;
	for (r = dc1 + 1; r < bmp->height + dc2 - 1; r++) {
		int c, count, r0last;
		double dcount;
		unsigned char *p;

		r0last = 0;
		p = bmp_rowptr_from_top(bmp, r0last);
		for (nn = count = 0, c = c1; c < c2; c += dw) {
			int r0;

			r0 = r + tanth * c;
			if (r0 < 0 || r0 >= bmp->height)
				continue;
			if (r0 != r0last) {
				r0last = r0;
				p = bmp_rowptr_from_top(bmp, r0last);
			}
			nn++;
			if (p[c] < whitethresh)
				count++;
		}
		dcount = 100. * count / nn;
		csum += dcount;
		csumsq += dcount * dcount;
		n++;
	}
	stdev = sqrt(fabs((csum / n) * (csum / n) - csumsq / n));
	return (stdev);
}

/*
 ** y0 = 0 ==> bottom row!
 */
static void bmp_pix_vali(WILLUSBITMAP *bmp, int x0, int y0, int *r, int *g, int *b)

{
	unsigned char *p;
	int rr, gg, bb;

	p = bmp_rowptr_from_top(bmp, bmp->height - 1 - y0);
	p = &p[x0 * (bmp->bpp >> 3)];
	RGBGET(bmp, p, rr, gg, bb);
	(*r) = rr;
	(*g) = gg;
	(*b) = bb;
}

/*
 ** y0 = 0 ==> bottom row!
 */
static int bmp_grey_pix_vali(WILLUSBITMAP *bmp, int x0, int y0)

{
	unsigned char *p;
	int r, g, b;

	p = bmp_rowptr_from_top(bmp, bmp->height - 1 - y0);
	p = &p[x0 * (bmp->bpp >> 3)];
	RGBGET(bmp, p, r, g, b);
	return (bmp8_greylevel_convert(r, g, b));
}

/*
 ** Return pix value (0.0 - 255.0) in double precision given
 ** a double precision position.  Bitmap is assumed to be 8-bit greyscale.
 **
 ** x0,y0 are from bottom corner.
 ** x0=0.5, y0=0.5 would give exactly the value of the pixel
 **                in the lower left corner of the bitmap.
 */
double bmp_grey_pix_vald(WILLUSBITMAP *bmp, double x0, double y0)

{
	int ix0, iy0, ix1, iy1;
	double fx0, fx1, fy0, fy1;

	ix0 = (int) (x0 - .5);
	ix1 = ix0 + 1;
	iy0 = (int) (y0 - .5);
	iy1 = iy0 + 1;
	BOUND(ix0, 0, bmp->width - 1);
	BOUND(ix1, 0, bmp->width - 1);
	BOUND(iy0, 0, bmp->height - 1);
	BOUND(iy1, 0, bmp->height - 1);
	fx0 = 1. - fabs(ix0 + 0.5 - x0);
	if (fx0 < 0.)
		fx0 = 0.;
	fx1 = 1. - fabs(ix1 + 0.5 - x0);
	if (fx1 < 0.)
		fx1 = 0.;
	fy0 = 1. - fabs(iy0 + 0.5 - y0);
	if (fy0 < 0.)
		fy0 = 0.;
	fy1 = 1. - fabs(iy1 + 0.5 - y0);
	if (fy1 < 0.)
		fy1 = 0.;
	if ((fx0 == 0. && fx1 == 0.) || (fy0 == 0. && fy1 == 0.))
		return (-1.);
	return ((fy0
			* (fx0 * bmp_grey_pix_vali(bmp, ix0, iy0)
					+ fx1 * bmp_grey_pix_vali(bmp, ix1, iy0))
			+ fy1
					* (fx0 * bmp_grey_pix_vali(bmp, ix0, iy1)
							+ fx1 * bmp_grey_pix_vali(bmp, ix1, iy1)))
			/ ((fx0 + fx1) * (fy0 + fy1)));
}


/*
 ** Return pix values (0.0 - 255.0) in double precision given
 ** a double precision position.
 **
 ** x0,y0 are from BOTTOM CORNER.
 ** x0=0.5, y0=0.5 would give exactly the value of the pixel
 **                in the lower left corner of the bitmap.
 */
static void bmp_pix_vald(WILLUSBITMAP *bmp, double x0, double y0, double *r, double *g,
		double *b)

{
	int ix0, iy0, ix1, iy1;
	double fx0, fx1, fy0, fy1;
	int r00, r10, r01, r11;
	int g00, g10, g01, g11;
	int b00, b10, b01, b11;

	ix0 = (int) (x0 - .5);
	ix1 = ix0 + 1;
	iy0 = (int) (y0 - .5);
	iy1 = iy0 + 1;
	BOUND(ix0, 0, bmp->width - 1);
	BOUND(ix1, 0, bmp->width - 1);
	BOUND(iy0, 0, bmp->height - 1);
	BOUND(iy1, 0, bmp->height - 1);
	fx0 = 1. - fabs(ix0 + 0.5 - x0);
	if (fx0 < 0.)
		fx0 = 0.;
	fx1 = 1. - fabs(ix1 + 0.5 - x0);
	if (fx1 < 0.)
		fx1 = 0.;
	fy0 = 1. - fabs(iy0 + 0.5 - y0);
	if (fy0 < 0.)
		fy0 = 0.;
	fy1 = 1. - fabs(iy1 + 0.5 - y0);
	if (fy1 < 0.)
		fy1 = 0.;
	if ((fx0 == 0. && fx1 == 0.) || (fy0 == 0. && fy1 == 0.)) {
		(*r) = (*g) = (*b) = -1.;
		return;
	}
	bmp_pix_vali(bmp, ix0, iy0, &r00, &g00, &b00);
	bmp_pix_vali(bmp, ix1, iy0, &r10, &g10, &b10);
	bmp_pix_vali(bmp, ix0, iy1, &r01, &g01, &b01);
	bmp_pix_vali(bmp, ix1, iy1, &r11, &g11, &b11);
	(*r) = ((fy0 * (fx0 * r00 + fx1 * r10) + fy1 * (fx0 * r01 + fx1 * r11))
			/ ((fx0 + fx1) * (fy0 + fy1)));
	(*g) = ((fy0 * (fx0 * g00 + fx1 * g10) + fy1 * (fx0 * g01 + fx1 * g11))
			/ ((fx0 + fx1) * (fy0 + fy1)));
	(*b) = ((fy0 * (fx0 * b00 + fx1 * b10) + fy1 * (fx0 * b01 + fx1 * b11))
			/ ((fx0 + fx1) * (fy0 + fy1)));
}

static void bmp_rotate_fast(WILLUSBITMAP *bmp, double degrees, int expand)

{
	WILLUSBITMAP _dst, *dst;
	double th, sth, cth;
	int i, r, g, b, w, h, row, col;

	dst = &_dst;
	th = degrees * PI / 180.;
	sth = sin(th);
	cth = cos(th);
	if (expand) {
		w = (int) (fabs(bmp->width * cth) + fabs(bmp->height * sth) + .5);
		h = (int) (fabs(bmp->height * cth) + fabs(bmp->width * sth) + .5);
	} else {
		w = bmp->width;
		h = bmp->height;
	}
	dst = &_dst;
	bmp_init(dst);
	dst->width = w;
	dst->height = h;
	dst->bpp = bmp->bpp;
	if (dst->bpp == 8)
		for (i = 0; i <= 255; i++)
			dst->red[i] = dst->green[i] = dst->blue[i] = i;
	bmp_alloc(dst);
	bmp_pix_vali(bmp, 0, 0, &r, &g, &b);
	bmp_fill(dst, r, g, b);
	if (dst->bpp == 8)
		for (row = 0; row < dst->height; row++) {
			unsigned char *p;
			double x1, y1, x2, y2;

			y2 = dst->height / 2. - row;
			p = bmp_rowptr_from_top(dst, row);
			for (x2 = -dst->width / 2., col = 0; col < dst->width;
					col++, p++, x2 += 1.0) {
				double g;
				x1 = -.5 + bmp->width / 2. + x2 * cth + y2 * sth;
				y1 = -.5 + bmp->height / 2. + y2 * cth - x2 * sth;
				if (x1 < 0. || x1 >= bmp->width || y1 < 0. || y1 >= bmp->height)
					continue;
				g = bmp_grey_pix_vald(bmp, x1, y1);
				if (g >= 0.)
					p[0] = g;
			}
		}
	else
		for (row = 0; row < dst->height; row++) {
			unsigned char *p;
			double x1, y1, x2, y2;

			y2 = dst->height / 2. - row;
			p = bmp_rowptr_from_top(dst, row);
			for (x2 = -dst->width / 2., col = 0; col < dst->width; col++, p +=
					3, x2 += 1.0) {
				double rr, gg, bb;
				x1 = -.5 + bmp->width / 2. + x2 * cth + y2 * sth;
				y1 = -.5 + bmp->height / 2. + y2 * cth - x2 * sth;
				if (x1 < 0. || x1 >= bmp->width || y1 < 0. || y1 >= bmp->height)
					continue;
				bmp_pix_vald(bmp, x1, y1, &rr, &gg, &bb);
				if (rr < 0.)
					continue;
				p[0] = rr;
				p[1] = gg;
				p[2] = bb;
			}
		}
	bmp_copy(bmp, dst);
	bmp_free(dst);
}

static double bmp_autostraighten(WILLUSBITMAP *src, WILLUSBITMAP *srcgrey, int white,
		double maxdegrees, double mindegrees, int debug)

{
	int i, na, n, imax;
	double stepsize, sdmin, sdmax, rotdeg;
	double *sdev;
	static int rpc = 0;
	static char *funcname = "bmp_autostraighten";

	rpc++;
	stepsize = .5;
	na = (int) (maxdegrees / stepsize + .5);
	if (na < 1)
		na = 1;
	n = 1 + na * 2;
	sdmin = 999.;
	sdmax = -999.;
	imax = 0;
	willus_mem_alloc_warn((void **) &sdev, n * sizeof(double), funcname, 10);
	for (i = 0; i < n; i++) {
		double theta, sdev0;

		theta = (i - na) * stepsize * PI / 180.;
		sdev0 = bmp_row_by_row_stdev(srcgrey, 400, white, theta);
		if (sdmin > sdev0)
			sdmin = sdev0;
		if (sdmax < sdev0) {
			imax = i;
			sdmax = sdev0;
		}
		sdev[i] = sdev0;
	}
	if (sdmax <= 0.) {
		willus_mem_free((double **) &sdev, funcname);
		return (0.);
	}
	for (i = 0; i < n; i++)
		sdev[i] /= sdmax;
	sdmin /= sdmax;
	rotdeg = -(imax - na) * stepsize;
	if (sdmin > 0.95 || fabs(rotdeg) <= mindegrees
			|| fabs(fabs(rotdeg) - fabs(maxdegrees)) < 0.25) {
		willus_mem_free((double **) &sdev, funcname);
		return (0.);
	}
	if (imax >= 3 && imax <= n - 4) {
		double sd1min, sd2min, sdthresh;

		for (sd1min = sdev[imax - 1], i = imax - 2; i >= 0; i--)
			if (sd1min > sdev[i])
				sd1min = sdev[i];
		for (sd2min = sdev[imax + 1], i = imax + 2; i < n; i++)
			if (sd2min > sdev[i])
				sd2min = sdev[i];
		sdthresh = sd1min > sd2min ? sd1min * 1.01 : sd2min * 1.01;
		if (sdthresh < 0.9)
			sdthresh = 0.9;
		if (sdthresh < 0.95) {
			double deg1, deg2;

			for (i = imax - 1; i >= 0; i--)
				if (sdev[i] < sdthresh)
					break;
			deg1 =
					stepsize
							* ((i - na)
									+ (sdthresh - sdev[i])
											/ (sdev[i + 1] - sdev[i]));
			for (i = imax + 1; i < n - 1; i++)
				if (sdev[i] < sdthresh)
					break;
			deg2 =
					stepsize
							* ((i - na)
									- (sdthresh - sdev[i])
											/ (sdev[i - 1] - sdev[i]));
			if (deg2 - deg1 < 2.5) {
				rotdeg = -(deg1 + deg2) / 2.;
				if (debug)
					printf("/sa l \"srcpage %d, %.1f%% line\" 2\n/sa m 2 2\n"
									"%g 0\n%g 1\n//nc\n"
									"/sa l \"srcpage %d, %.1f%% line\" 2\n/sa m 2 2\n"
									"%g 0\n%g 1\n//nc\n", rpc, sdthresh * 100.,
							deg1, deg1, rpc, sdthresh * 100., deg2, deg2);
			}
		}
	}
	printf("\n(Straightening page:  rotating cc by %.2f deg.)\n", rotdeg);
	/* BMP rotation fills with pixel value at (0,0) */
	srcgrey->data[0] = 255;
	bmp_rotate_fast(srcgrey, rotdeg, 0);
	if (src != NULL) {
		src->data[0] = src->data[1] = src->data[2] = 255;
		bmp_rotate_fast(src, rotdeg, 0);
	}
	willus_mem_free((double **) &sdev, funcname);
	return (rotdeg);
}

static void bmp_flip_horizontal(WILLUSBITMAP *bmp)

{
	int i, j, bpp;

	bpp = bmp->bpp / 8;
	for (i = 0; i < bmp->height; i++) {
		unsigned char *p, *p2;

		p = bmp_rowptr_from_top(bmp, i);
		p2 = &p[(bmp->width - 1) * bpp];
		for (; p < p2; p += bpp, p2 -= bpp)
			for (j = 0; j < bpp; j++) {
				unsigned char t;
				t = p[j];
				p[j] = p2[j];
				p2[j] = t;
			}
	}
}

static void bmp_flip_vertical(WILLUSBITMAP *bmp)

{
	int i, bw, n;

	bw = bmp_bytewidth(bmp);
	n = bmp->height / 2;
	for (i = 0; i < n; i++) {
		unsigned char *p, *p2;
		int j;

		p = bmp_rowptr_from_top(bmp, i);
		p2 = bmp_rowptr_from_top(bmp, bmp->height - i - 1);
		for (j = bw; j > 0; j--, p++, p2++) {
			unsigned char t;
			t = p[0];
			p[0] = p2[0];
			p2[0] = t;
		}
	}
}

static int bmp_rotate_90(WILLUSBITMAP *bmp)

{
	WILLUSBITMAP *sbmp, _sbmp;
	int bpp, dbw, sr;

	sbmp = &_sbmp;
	bmp_init(sbmp);
	if (!bmp_copy(sbmp, bmp))
		return (0);
	bmp->width = sbmp->height;
	bmp->height = sbmp->width;
	bpp = bmp->bpp / 8;
	if (!bmp_alloc(bmp)) {
		bmp_free(sbmp);
		return (0);
	}
	dbw = (int) (bmp_rowptr_from_top(bmp, 1) - bmp_rowptr_from_top(bmp, 0));
	for (sr = 0; sr < sbmp->height; sr++) {
		unsigned char *sp, *dp;
		int j, sc;

		sp = bmp_rowptr_from_top(sbmp, sr);
		dp = bmp_rowptr_from_top(bmp, bmp->height - 1) + bpp * sr;
		for (sc = sbmp->width; sc > 0; sc--, dp -= dbw)
			for (j = 0; j < bpp; j++, sp++)
				dp[j] = sp[0];
	}
	bmp_free(sbmp);
	return (1);
}

static int bmp_rotate_270(WILLUSBITMAP *bmp)

{
	WILLUSBITMAP *sbmp, _sbmp;
	int bpp, dbw, sr;

	sbmp = &_sbmp;
	bmp_init(sbmp);
	if (!bmp_copy(sbmp, bmp))
		return (0);
	bmp->width = sbmp->height;
	bmp->height = sbmp->width;
	bpp = bmp->bpp / 8;
	if (!bmp_alloc(bmp)) {
		bmp_free(sbmp);
		return (0);
	}
	dbw = (int) (bmp_rowptr_from_top(bmp, 1) - bmp_rowptr_from_top(bmp, 0));
	for (sr = 0; sr < sbmp->height; sr++) {
		unsigned char *sp, *dp;
		int j, sc;

		sp = bmp_rowptr_from_top(sbmp, sr);
		dp = bmp_rowptr_from_top(bmp, 0) + bpp * (sbmp->height - 1 - sr);
		for (sc = sbmp->width; sc > 0; sc--, dp += dbw)
			for (j = 0; j < bpp; j++, sp++)
				dp[j] = sp[0];
	}
	bmp_free(sbmp);
	return (1);
}

/*
 ** 1 = okay, 0 = fail
 */
static int bmp_rotate_right_angle(WILLUSBITMAP *bmp, int degrees)

{
	int d;

	d = degrees % 360;
	if (d < 0)
		d += 360;
	d = (d + 45) / 90;
	if (d == 1)
		return (bmp_rotate_90(bmp));
	if (d == 2) {
		bmp_flip_horizontal(bmp);
		bmp_flip_vertical(bmp);
		return (1);
	}
	if (d == 3)
		return (bmp_rotate_270(bmp));
	return (1);
}

/* bmpmupdf.c */
static int bmpmupdf_pixmap_to_bmp(WILLUSBITMAP *bmp, fz_context *ctx,
		fz_pixmap *pixmap)

{
	unsigned char *p;
	int ncomp, i, row, col;

	bmp->width = fz_pixmap_width(ctx, pixmap);
	bmp->height = fz_pixmap_height(ctx, pixmap);
	ncomp = fz_pixmap_components(ctx, pixmap);
	/* Has to be 8-bit or RGB */
	if (ncomp != 2 && ncomp != 4)
		return (-1);
	bmp->bpp = (ncomp == 2) ? 8 : 24;
	bmp_alloc(bmp);
	if (ncomp == 2)
		for (i = 0; i < 256; i++)
			bmp->red[i] = bmp->green[i] = bmp->blue[i] = i;
	p = fz_pixmap_samples(ctx, pixmap);
	if (ncomp == 1)
		for (row = 0; row < bmp->height; row++) {
			unsigned char *dest;
			dest = bmp_rowptr_from_top(bmp, row);
			memcpy(dest, p, bmp->width);
			p += bmp->width;
		}
	else if (ncomp == 2)
		for (row = 0; row < bmp->height; row++) {
			unsigned char *dest;
			dest = bmp_rowptr_from_top(bmp, row);
			for (col = 0; col < bmp->width; col++, dest++, p += 2)
				dest[0] = p[0];
		}
	else
		for (row = 0; row < bmp->height; row++) {
			unsigned char *dest;
			dest = bmp_rowptr_from_top(bmp, row);
			for (col = 0; col < bmp->width;
					col++, dest += ncomp - 1, p += ncomp)
				memcpy(dest, p, ncomp - 1);
		}
	return (0);
}

static void handle(int wait, ddjvu_context_t *ctx)
    {
    const ddjvu_message_t *msg;

    if (!ctx)
        return;
    if (wait)
        msg = ddjvu_message_wait(ctx);
    while ((msg = ddjvu_message_peek(ctx)))
        {
        switch(msg->m_any.tag)
            {
            case DDJVU_ERROR:
                fprintf(stderr,"ddjvu: %s\n", msg->m_error.message);
                if (msg->m_error.filename)
                    fprintf(stderr,"ddjvu: '%s:%d'\n",
                      msg->m_error.filename, msg->m_error.lineno);
            exit(10);
            default:
            break;
            }
        }
    ddjvu_message_pop(ctx);
}