static int read_pnm_header(deark *c, lctx *d, struct page_ctx *pg, de_int64 pos1)
{
char tokenbuf[100];
int retval = 0;
de_dbg(c, "header at %d\n", (int)pos1);
de_dbg_indent(c, 1);
de_dbg(c, "format: %s\n", pg->fmt_name);
pg->hdr_parse_pos = pos1+2; // Skip "P?"
if(!read_next_token(c, d, pg, tokenbuf, sizeof(tokenbuf))) goto done;
pg->width = de_atoi64(tokenbuf);
if(!read_next_token(c, d, pg, tokenbuf, sizeof(tokenbuf))) goto done;
pg->height = de_atoi64(tokenbuf);
de_dbg(c, "dimensions: %dx%d\n", (int)pg->width, (int)pg->height);
if(fmt_is_pbm(pg->fmt)) {
pg->maxval = 1;
}
else {
if(!read_next_token(c, d, pg, tokenbuf, sizeof(tokenbuf))) goto done;
pg->maxval = de_atoi64(tokenbuf);
de_dbg(c, "maxval: %d\n", (int)pg->maxval);
if(pg->maxval<1 || pg->maxval>65535) {
de_err(c, "Invalid maxval: %d\n", (int)pg->maxval);
goto done;
}
}
retval = 1;
done:
de_dbg_indent(c, -1);
return retval;
}
static i64 get_height(deark *c, lctx *d, i64 default_height)
{
const char *s;
s = de_get_ext_option(c, "bsave:height");
if(s) return de_atoi64(s);
return default_height;
}
// Return a width that might be overridden by user request.
static i64 get_width(deark *c, lctx *d, i64 default_width)
{
const char *s;
s = de_get_ext_option(c, "bsave:width");
if(s) return de_atoi64(s);
return default_width;
}
void de_font_bitmap_font_to_image(deark *c, struct de_bitmap_font *font1, de_finfo *fi,
unsigned int createflags)
{
struct font_render_ctx *fctx = NULL;
i64 i, j, k;
de_bitmap *img = NULL;
i64 xpos, ypos;
i64 img_leftmargin, img_topmargin;
i64 img_rightmargin, img_bottommargin;
i64 img_vpixelsperchar;
i64 img_width, img_height;
i64 num_table_rows_to_display;
i64 num_table_rows_total;
i64 last_valid_row;
struct de_bitmap_font *dfont = NULL;
i64 chars_per_row = 32;
const char *s;
struct row_info_struct *row_info = NULL;
struct col_info_struct *col_info = NULL;
int unicode_req = 0;
i64 label_stride;
i64 rownum, colnum;
i64 curpos;
unsigned int dnflags;
fctx = de_malloc(c, sizeof(struct font_render_ctx));
fctx->font = font1;
if(fctx->font->num_chars<1) goto done;
if(fctx->font->num_chars>17*65536) goto done;
if(fctx->font->nominal_width>512 || fctx->font->nominal_height>512) {
de_err(c, "Font size too big (%d"DE_CHAR_TIMES"%d). Not supported.",
(int)fctx->font->nominal_width, (int)fctx->font->nominal_height);
goto done;
}
// -1 = "no preference"
unicode_req = de_get_ext_option_bool(c, "font:tounicode", -1);
if(unicode_req==0 &&
(fctx->font->has_nonunicode_codepoints || !fctx->font->has_unicode_codepoints))
{
; // Render as nonunicode.
}
else if(fctx->font->has_unicode_codepoints &&
(unicode_req>0 || fctx->font->prefer_unicode || !fctx->font->has_nonunicode_codepoints))
{
fctx->render_as_unicode = 1;
}
s = de_get_ext_option(c, "font:charsperrow");
if(s) {
chars_per_row = de_atoi64(s);
if(chars_per_row<1) chars_per_row=1;
}
dfont = make_digit_font(c);
fctx->codepoint_tmp = de_mallocarray(c, fctx->font->num_chars, sizeof(i32));
fixup_codepoints(c, fctx);
get_min_max_codepoint(fctx);
if(fctx->num_valid_chars<1) goto done;
num_table_rows_total = fctx->max_codepoint/chars_per_row+1;
// TODO: Clean up these margin calculations, and make it more general.
if(fctx->render_as_unicode) {
img_leftmargin = dfont->nominal_width * 5 + 6;
}
else {
if(fctx->max_codepoint >= 1000)
img_leftmargin = dfont->nominal_width * 5 + 6;
else
img_leftmargin = dfont->nominal_width * 3 + 6;
}
img_topmargin = dfont->nominal_height + 6;
img_rightmargin = 1;
img_bottommargin = 1;
// Scan the characters, and record relevant information.
row_info = de_mallocarray(c, num_table_rows_total, sizeof(struct row_info_struct));
col_info = de_mallocarray(c, chars_per_row, sizeof(struct col_info_struct));
for(i=0; i<chars_per_row; i++) {
#define MIN_CHAR_CELL_WIDTH 5
col_info[i].display_width = MIN_CHAR_CELL_WIDTH;
}
for(k=0; k<fctx->font->num_chars; k++) {
i64 char_display_width;
if(fctx->codepoint_tmp[k] == DE_CODEPOINT_INVALID) continue;
if(!is_valid_char(&fctx->font->char_array[k])) continue;
rownum = fctx->codepoint_tmp[k] / chars_per_row;
colnum = fctx->codepoint_tmp[k] % chars_per_row;
if(rownum<0 || rownum>=num_table_rows_total) {
de_err(c, "internal: bad rownum");
de_fatalerror(c);
}
// Remember that there is at least one valid character in this character's row.
row_info[rownum].is_visible = 1;
// Track the maximum width of any character in this character's column.
char_display_width = (i64)(fctx->font->char_array[k].width +
(int)fctx->font->char_array[k].extraspace_l +
(int)fctx->font->char_array[k].extraspace_r);
if(char_display_width > col_info[colnum].display_width) {
col_info[colnum].display_width = char_display_width;
}
}
img_vpixelsperchar = fctx->font->nominal_height + 1;
// Figure out how many rows are used, and where to draw them.
num_table_rows_to_display = 0;
last_valid_row = -1;
curpos = img_topmargin;
for(j=0; j<num_table_rows_total; j++) {
if(!row_info[j].is_visible) continue;
// If we skipped one or more rows, leave some extra vertical space.
if(num_table_rows_to_display>0 && !row_info[j-1].is_visible) curpos+=3;
last_valid_row = j;
row_info[j].display_pos = curpos;
curpos += img_vpixelsperchar;
num_table_rows_to_display++;
}
if(num_table_rows_to_display<1) goto done;
// Figure out the positions of the columns.
curpos = img_leftmargin;
for(i=0; i<chars_per_row; i++) {
col_info[i].display_pos = curpos;
curpos += col_info[i].display_width + 1;
}
img_width = col_info[chars_per_row-1].display_pos +
col_info[chars_per_row-1].display_width + img_rightmargin;
img_height = row_info[last_valid_row].display_pos +
img_vpixelsperchar -1 + img_bottommargin;
img = de_bitmap_create(c, img_width, img_height, 1);
// Clear the image
for(j=0; j<img->height; j++) {
for(i=0; i<img->width; i++) {
de_bitmap_setpixel_gray(img, i, j, 128);
}
}
// Draw/clear the cell backgrounds
for(j=0; j<num_table_rows_total; j++) {
if(!row_info[j].is_visible) continue;
ypos = row_info[j].display_pos;
for(i=0; i<chars_per_row; i++) {
i64 ii, jj;
xpos = col_info[i].display_pos;
for(jj=0; jj<img_vpixelsperchar-1; jj++) {
for(ii=0; ii<col_info[i].display_width; ii++) {
de_bitmap_setpixel_gray(img, xpos+ii, ypos+jj, (ii/2+jj/2)%2 ? 176 : 192);
}
}
}
}
// Draw the labels in the top margin.
// TODO: Better label spacing logic.
if(fctx->font->nominal_width <= 12)
label_stride = 2;
else
label_stride = 1;
for(i=0; i<chars_per_row; i++) {
if(i%label_stride != 0) continue;
xpos = col_info[i].display_pos + col_info[i].display_width/2;
ypos = img_topmargin - 3;
dnflags = DNFLAG_HCENTER;
if(fctx->render_as_unicode) dnflags |= DNFLAG_HEX;
draw_number(c, img, dfont, i, xpos, ypos, dnflags);
}
// Draw the labels in the left margin.
for(j=0; j<num_table_rows_total; j++) {
if(!row_info[j].is_visible) continue;
xpos = img_leftmargin - 3;
ypos = row_info[j].display_pos + (img_vpixelsperchar + dfont->nominal_height + 1)/2;
dnflags = 0;
if(fctx->render_as_unicode) dnflags |= DNFLAG_HEX | DNFLAG_LEADING_ZEROES;
draw_number(c, img, dfont, j*chars_per_row, xpos, ypos, dnflags);
}
// Render the glyphs.
for(k=0; k<fctx->font->num_chars; k++) {
if(fctx->codepoint_tmp[k] == DE_CODEPOINT_INVALID) continue;
if(!is_valid_char(&fctx->font->char_array[k])) continue;
rownum = fctx->codepoint_tmp[k] / chars_per_row;
colnum = fctx->codepoint_tmp[k] % chars_per_row;
if(rownum<0 || rownum>=num_table_rows_total) {
de_err(c, "internal: bad rownum");
de_fatalerror(c);
}
xpos = col_info[colnum].display_pos;
ypos = row_info[rownum].display_pos;
de_font_paint_character_idx(c, img, fctx->font, k, xpos, ypos,
DE_STOCKCOLOR_BLACK, DE_STOCKCOLOR_WHITE, 0);
}
de_bitmap_write_to_file_finfo(img, fi, createflags);
done:
if(dfont) {
de_free(c, dfont->char_array);
de_destroy_bitmap_font(c, dfont);
}
de_bitmap_destroy(img);
de_free(c, row_info);
de_free(c, col_info);
if(fctx) {
de_free(c, fctx->codepoint_tmp);
de_free(c, fctx);
}
}
static int do_image_pgm_ppm_ascii(deark *c, lctx *d, struct page_ctx *pg, de_int64 pos1)
{
struct deark_bitmap *img = NULL;
de_int64 nsamples; // For both input and output
de_int64 pos = pos1;
de_int64 xpos, ypos, sampidx;
char samplebuf[32];
size_t samplebuf_used;
de_byte b;
if(fmt_is_ppm(pg->fmt)) nsamples=3;
else nsamples=1;
img = de_bitmap_create(c, pg->width, pg->height, (int)nsamples);
xpos=0; ypos=0;
sampidx=0;
samplebuf_used=0;
while(1) {
if(pos >= c->infile->len) break; // end of file
if(ypos==(pg->height-1) && xpos>=pg->width) break; // end of image
if(ypos>=pg->height) break;
b = de_getbyte(pos++);
if(is_pnm_whitespace(b)) {
if(samplebuf_used>0) {
de_int64 v;
de_byte v_adj;
// Completed a sample
samplebuf[samplebuf_used] = '\0'; // NUL terminate for de_atoi64()
v = de_atoi64((const char*)samplebuf);
v_adj = de_scale_n_to_255(pg->maxval, v);
samplebuf_used = 0;
if(nsamples>1) {
de_bitmap_setsample(img, xpos, ypos, sampidx, v_adj);
}
else {
de_bitmap_setpixel_gray(img, xpos, ypos, v_adj);
}
sampidx++;
if(sampidx>=nsamples) {
sampidx=0;
xpos++;
if(xpos>=pg->width) {
xpos=0;
ypos++;
}
}
}
else { // Skip extra whitespace
continue;
}
}
else {
// Non-whitespace. Save for later.
if(samplebuf_used < sizeof(samplebuf_used)-1) {
samplebuf[samplebuf_used++] = b;
}
}
}
de_bitmap_write_to_file(img, NULL, 0);
de_bitmap_destroy(img);
return 1;
}
