mirrors/zint
2
0
Fork 0
mirror of https://github.com/zint/zint synced 2024-11-16 20:57:25 +13:00
Code Issues Actions Packages Projects Releases Wiki Activity
master
zint/backend/tif.c
gitlost 5e2044ff2e CODE128: reduce extended latch cut-off from 5 to 4 for better 
encodation in certain cases (and no pessimizations found so far),
  props lyngklip (BWIPP);
  fix extended char latching when exactly 3 extended chars at end;
  count code set C (not digits) in loop deciding when to
  shift/latch to extended for better estimate
AZTEC: return warning if ECC < 5% (due to bit-stuffing when version
  given); return error if > 22 layers (Zint 26) for Reader
  Initialisation symbol requested for better error message
AZTEC/HANXIN/QRCODE: consolidate different ECC data size tables
  into one indexed by ECC
DBAR_EXP: check for reduced length <= 77 up front for better error
  message
HANXIN: use `malloc()` rather than `z_alloca()` for large binary
  array
QRCODE: `ecc_level` now 0-based (not 1-based)
MICROQR: consolidate different version end routines into one
  `microqr_end()` and use new `microqr_data` table to simplify code
MICROPDF417: use table for max codewords per column
library: centralize all error messages using new `errtxt()`,
  `errtxtf()`, `errtxt_adj()` funcs that protect `symbol->errtxt`
  from overflow, & try to make error messages more consistent
  thru-out, adding more feedback info to many, & use positional
  args "%n$" in prep for l10n (maybe);
  `is_sane/is_sane_lookup()` -> `not_sane/not_sane_lookup()`,
  returning 1-based position (zero on failure) instead of bool;
  `long` ints -> plain `int` (except those dealing with `ftell()`,
  `fread()` etc) as depend on int being 32-bits already
GUI: in "grpDATF.ui" use "PlainText" rather than "RichText" for
  tracker ratio examples as height of text messing up sometimes
manual: clarify Codablock-F length maximum & add examples
docs: README: pandoc 3.5, Ubuntu 24.04
CMake: use "-Wpedantic" for Clang only as GNU complains about
  `errtxtf()` positional args "%n$"
2024-10-27 21:33:33 +00:00

612 lines
23 KiB
C
Raw Permalink Blame History

/* tif.c - Aldus Tagged Image File Format support */
/*
libzint - the open source barcode library
Copyright (C) 2016-2024 Robin Stuart <rstuart114@gmail.com>
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions
are met:
1. Redistributions of source code must retain the above copyright
notice, this list of conditions and the following disclaimer.
2. Redistributions in binary form must reproduce the above copyright
notice, this list of conditions and the following disclaimer in the
documentation and/or other materials provided with the distribution.
3. Neither the name of the project nor the names of its contributors
may be used to endorse or promote products derived from this software
without specific prior written permission.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE
FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
SUCH DAMAGE.
*/
/* SPDX-License-Identifier: BSD-3-Clause */
#include <assert.h>
#include <errno.h>
#include <math.h>
#include <stdio.h>
#include "common.h"
#include "filemem.h"
#include "output.h"
#include "tif.h"
#include "tif_lzw.h"
/* PhotometricInterpretation */
#define TIF_PMI_WHITEISZERO 0
#define TIF_PMI_BLACKISZERO 1
#define TIF_PMI_RGB 2
#define TIF_PMI_PALETTE_COLOR 3
#define TIF_PMI_SEPARATED 5 /* CMYK */
/* Compression */
#define TIF_NO_COMPRESSION 1
#define TIF_LZW 5
static void to_color_map(const unsigned char rgb[4], tiff_color_t *color_map_entry) {
color_map_entry->red = (rgb[0] << 8) | rgb[0];
color_map_entry->green = (rgb[1] << 8) | rgb[1];
color_map_entry->blue = (rgb[2] << 8) | rgb[2];
}
static void to_cmyk(const char *colour, unsigned char *cmyk) {
int cyan, magenta, yellow, black;
unsigned char alpha;
(void) out_colour_get_cmyk(colour, &cyan, &magenta, &yellow, &black, &alpha);
cmyk[0] = (unsigned char) roundf(cyan * 0xFF / 100.0f);
cmyk[1] = (unsigned char) roundf(magenta * 0xFF / 100.0f);
cmyk[2] = (unsigned char) roundf(yellow * 0xFF / 100.0f);
cmyk[3] = (unsigned char) roundf(black * 0xFF / 100.0f);
cmyk[4] = alpha;
}
/* TIFF Revision 6.0 https://www.adobe.io/content/dam/udp/en/open/standards/tiff/TIFF6.pdf */
INTERNAL int tif_pixel_plot(struct zint_symbol *symbol, const unsigned char *pixelbuf) {
unsigned char fg[4], bg[4];
int i;
int pmi; /* PhotometricInterpretation */
int rows_per_strip, strip_count;
int rows_last_strip;
int bytes_per_strip;
uint16_t bits_per_sample;
int samples_per_pixel;
int pixels_per_sample;
unsigned char map[128];
tiff_color_t color_map[256] = {{0}};
unsigned char palette[32][5];
int color_map_size = 0;
int extra_samples = 0;
size_t free_memory;
int row, column, strip;
int strip_row;
unsigned int bytes_put;
long total_bytes_put;
struct filemem fm;
struct filemem *const fmp = &fm;
const unsigned char *pb;
int compression = TIF_NO_COMPRESSION;
tif_lzw_state lzw_state;
long file_pos;
const int output_to_stdout = symbol->output_options & BARCODE_STDOUT;
uint32_t *strip_offset;
uint32_t *strip_bytes;
unsigned char *strip_buf;
tiff_header_t header;
uint16_t entries = 0;
tiff_tag_t tags[20];
uint32_t offset = 0;
int update_offsets[20];
int offsets = 0;
int ifd_size;
uint32_t temp32;
uint16_t temp16;
(void) out_colour_get_rgb(symbol->fgcolour, &fg[0], &fg[1], &fg[2], &fg[3]);
(void) out_colour_get_rgb(symbol->bgcolour, &bg[0], &bg[1], &bg[2], &bg[3]);
if (symbol->symbology == BARCODE_ULTRA) {
static const unsigned char ultra_chars[8] = { 'W', 'C', 'B', 'M', 'R', 'Y', 'G', 'K' };
if (symbol->output_options & CMYK_COLOUR) {
static const unsigned char ultra_cmyks[8][4] = {
{ 0, 0, 0, 0 }, /* White */
{ 0xFF, 0, 0, 0 }, /* Cyan */
{ 0xFF, 0xFF, 0, 0 }, /* Blue */
{ 0, 0xFF, 0, 0 }, /* Magenta */
{ 0, 0xFF, 0xFF, 0 }, /* Red */
{ 0, 0, 0xFF, 0 }, /* Yellow */
{ 0xFF, 0, 0xFF, 0 }, /* Green */
{ 0, 0, 0, 0xFF }, /* Black */
};
for (i = 0; i < 8; i++) {
map[ultra_chars[i]] = i;
memcpy(palette[i], ultra_cmyks[i], 4);
palette[i][4] = fg[3];
}
map['0'] = 8;
to_cmyk(symbol->bgcolour, palette[8]);
map['1'] = 9;
to_cmyk(symbol->fgcolour, palette[9]);
pmi = TIF_PMI_SEPARATED;
bits_per_sample = 8;
if (fg[3] == 0xff && bg[3] == 0xff) { /* If no alpha */
samples_per_pixel = 4;
} else {
samples_per_pixel = 5;
extra_samples = 1; /* Associated alpha */
}
pixels_per_sample = 1;
} else {
static const unsigned char ultra_rgbs[8][3] = {
{ 0xff, 0xff, 0xff, }, /* White */
{ 0, 0xff, 0xff, }, /* Cyan */
{ 0, 0, 0xff, }, /* Blue */
{ 0xff, 0, 0xff, }, /* Magenta */
{ 0xff, 0, 0, }, /* Red */
{ 0xff, 0xff, 0, }, /* Yellow */
{ 0, 0xff, 0, }, /* Green */
{ 0, 0, 0, }, /* Black */
};
for (i = 0; i < 8; i++) {
map[ultra_chars[i]] = i;
memcpy(palette[i], ultra_rgbs[i], 3);
palette[i][3] = fg[3];
}
map['0'] = 8;
memcpy(palette[8], bg, 4);
map['1'] = 9;
memcpy(palette[9], fg, 4);
if (fg[3] == 0xff && bg[3] == 0xff) { /* If no alpha */
pmi = TIF_PMI_PALETTE_COLOR;
for (i = 0; i < 10; i++) {
to_color_map(palette[i], &color_map[i]);
}
bits_per_sample = 4;
samples_per_pixel = 1;
pixels_per_sample = 2;
color_map_size = 16; /* 2**BitsPerSample */
} else {
pmi = TIF_PMI_RGB;
bits_per_sample = 8;
samples_per_pixel = 4;
pixels_per_sample = 1;
extra_samples = 1; /* Associated alpha */
}
}
} else { /* fg/bg only */
if (symbol->output_options & CMYK_COLOUR) {
map['0'] = 0;
to_cmyk(symbol->bgcolour, palette[0]);
map['1'] = 1;
to_cmyk(symbol->fgcolour, palette[1]);
pmi = TIF_PMI_SEPARATED;
bits_per_sample = 8;
if (fg[3] == 0xff && bg[3] == 0xff) { /* If no alpha */
samples_per_pixel = 4;
} else {
samples_per_pixel = 5;
extra_samples = 1; /* Associated alpha */
}
pixels_per_sample = 1;
} else if (bg[0] == 0xff && bg[1] == 0xff && bg[2] == 0xff && bg[3] == 0xff
&& fg[0] == 0 && fg[1] == 0 && fg[2] == 0 && fg[3] == 0xff) {
map['0'] = 0;
map['1'] = 1;
pmi = TIF_PMI_WHITEISZERO;
bits_per_sample = 1;
samples_per_pixel = 1;
pixels_per_sample = 8;
} else if (bg[0] == 0 && bg[1] == 0 && bg[2] == 0 && bg[3] == 0xff
&& fg[0] == 0xff && fg[1] == 0xff && fg[2] == 0xff && fg[3] == 0xff) {
map['0'] = 0;
map['1'] = 1;
pmi = TIF_PMI_BLACKISZERO;
bits_per_sample = 1;
samples_per_pixel = 1;
pixels_per_sample = 8;
} else {
map['0'] = 0;
memcpy(palette[0], bg, 4);
map['1'] = 1;
memcpy(palette[1], fg, 4);
pmi = TIF_PMI_PALETTE_COLOR;
for (i = 0; i < 2; i++) {
to_color_map(palette[i], &color_map[i]);
}
if (fg[3] == 0xff && bg[3] == 0xff) { /* If no alpha */
bits_per_sample = 4;
samples_per_pixel = 1;
pixels_per_sample = 2;
color_map_size = 16; /* 2**BitsPerSample */
} else {
bits_per_sample = 8;
samples_per_pixel = 2;
pixels_per_sample = 1;
color_map_size = 256; /* 2**BitsPerSample */
extra_samples = 1; /* Associated alpha */
}
}
}
/* TIFF Rev 6 Section 7 p.27 "Set RowsPerStrip such that the size of each strip is about 8K bytes...
* Note that extremely wide high resolution images may have rows larger than 8K bytes; in this case,
* RowsPerStrip should be 1, and the strip will be larger than 8K." */
rows_per_strip = (8192 * pixels_per_sample) / (symbol->bitmap_width * samples_per_pixel);
if (rows_per_strip == 0) {
rows_per_strip = 1;
}
/* Suppresses clang-tidy clang-analyzer-core.VLASize warning */
assert(symbol->bitmap_height > 0);
if (rows_per_strip >= symbol->bitmap_height) {
strip_count = 1;
rows_per_strip = rows_last_strip = symbol->bitmap_height;
} else {
strip_count = symbol->bitmap_height / rows_per_strip;
rows_last_strip = symbol->bitmap_height % rows_per_strip;
if (rows_last_strip != 0) {
strip_count++;
}
if (rows_per_strip > symbol->bitmap_height) {
rows_per_strip = rows_last_strip = symbol->bitmap_height;
}
}
assert(strip_count > 0); /* Suppress clang-analyzer-core.UndefinedBinaryOperatorResult */
if (symbol->debug & ZINT_DEBUG_PRINT) {
printf("TIFF (%dx%d) Strip Count %d, Rows Per Strip %d, Pixels Per Sample %d, Samples Per Pixel %d, PMI %d\n",
symbol->bitmap_width, symbol->bitmap_height, strip_count, rows_per_strip, pixels_per_sample,
samples_per_pixel, pmi);
}
bytes_per_strip = rows_per_strip * ((symbol->bitmap_width + pixels_per_sample - 1) / pixels_per_sample)
* samples_per_pixel;
strip_offset = (uint32_t *) z_alloca(sizeof(uint32_t) * strip_count);
strip_bytes = (uint32_t *) z_alloca(sizeof(uint32_t) * strip_count);
strip_buf = (unsigned char *) z_alloca(bytes_per_strip + 1);
free_memory = sizeof(tiff_header_t);
for (i = 0; i < strip_count; i++) {
strip_offset[i] = (uint32_t) free_memory;
if (i != (strip_count - 1)) {
strip_bytes[i] = bytes_per_strip;
} else {
if (rows_last_strip) {
strip_bytes[i] = rows_last_strip
* ((symbol->bitmap_width + pixels_per_sample - 1) / pixels_per_sample)
* samples_per_pixel;
} else {
strip_bytes[i] = bytes_per_strip;
}
}
free_memory += strip_bytes[i];
}
if (free_memory & 1) {
free_memory++; /* IFD must be on word boundary */
}
if (free_memory > 0xffff0000) {
return errtxt(ZINT_ERROR_MEMORY, symbol, 670, "TIF output file size too big");
}
/* Open output file in binary mode */
if (!fm_open(fmp, symbol, "wb")) {
return errtxtf(ZINT_ERROR_FILE_ACCESS, symbol, 672, "Could not open TIF output file (%1$d: %2$s)", fmp->err,
strerror(fmp->err));
}
if (!output_to_stdout) {
compression = TIF_LZW;
tif_lzw_init(&lzw_state);
}
/* Header */
out_le_u16(header.byte_order, 0x4949); /* "II" little-endian */
out_le_u16(header.identity, 42);
out_le_u32(header.offset, free_memory);
fm_write(&header, sizeof(tiff_header_t), 1, fmp);
total_bytes_put = sizeof(tiff_header_t);
/* Pixel data */
pb = pixelbuf;
strip = 0;
strip_row = 0;
bytes_put = 0;
for (row = 0; row < symbol->bitmap_height; row++) {
if (samples_per_pixel == 1) {
if (bits_per_sample == 1) { /* WHITEISZERO or BLACKISZERO */
for (column = 0; column < symbol->bitmap_width; column += 8) {
unsigned char byte = 0;
for (i = 0; i < 8 && column + i < symbol->bitmap_width; i++, pb++) {
byte |= map[*pb] << (7 - i);
}
strip_buf[bytes_put++] = byte;
}
} else { /* bits_per_sample == 4, PALETTE_COLOR with no alpha */
for (column = 0; column < symbol->bitmap_width; column += 2) {
unsigned char byte = map[*pb++] << 4;
if (column + 1 < symbol->bitmap_width) {
byte |= map[*pb++];
}
strip_buf[bytes_put++] = byte;
}
}
} else if (samples_per_pixel == 2) { /* PALETTE_COLOR with alpha */
for (column = 0; column < symbol->bitmap_width; column++) {
const int idx = map[*pb++];
strip_buf[bytes_put++] = idx;
strip_buf[bytes_put++] = palette[idx][3];
}
} else { /* samples_per_pixel >= 4, RGB with alpha (4) or CMYK with (5) or without (4) alpha */
for (column = 0; column < symbol->bitmap_width; column++) {
const int idx = map[*pb++];
memcpy(&strip_buf[bytes_put], &palette[idx], samples_per_pixel);
bytes_put += samples_per_pixel;
}
}
strip_row++;
if (strip_row == rows_per_strip || (strip == strip_count - 1 && strip_row == rows_last_strip)) {
/* End of strip */
if (compression == TIF_LZW) {
file_pos = fm_tell(fmp);
if (!tif_lzw_encode(&lzw_state, fmp, strip_buf, bytes_put)) { /* Only fails if can't malloc */
tif_lzw_cleanup(&lzw_state);
(void) fm_close(fmp, symbol);
return errtxt(ZINT_ERROR_MEMORY, symbol, 673, "Insufficient memory for TIF LZW hash table");
}
bytes_put = fm_tell(fmp) - file_pos;
if (bytes_put != strip_bytes[strip]) {
const int diff = bytes_put - strip_bytes[strip];
strip_bytes[strip] = bytes_put;
for (i = strip + 1; i < strip_count; i++) {
strip_offset[i] += diff;
}
}
} else {
fm_write(strip_buf, 1, bytes_put, fmp);
}
strip++;
total_bytes_put += bytes_put;
bytes_put = 0;
strip_row = 0;
/* Suppress clang-analyzer-core.UndefinedBinaryOperatorResult */
assert(strip < strip_count || row + 1 == symbol->bitmap_height);
}
}
if (total_bytes_put & 1) {
fm_putc(0, fmp); /* IFD must be on word boundary */
total_bytes_put++;
}
if (compression == TIF_LZW) {
tif_lzw_cleanup(&lzw_state);
file_pos = fm_tell(fmp);
fm_seek(fmp, 4, SEEK_SET);
free_memory = file_pos;
temp32 = (uint32_t) free_memory;
/* Shouldn't happen as `free_memory` checked above to be <= 0xffff0000 & should only decrease */
if (free_memory != temp32 || (long) free_memory != file_pos) {
(void) fm_close(fmp, symbol);
return errtxt(ZINT_ERROR_MEMORY, symbol, 982, "TIF output file size too big");
}
out_le_u32(temp32, temp32);
fm_write(&temp32, 4, 1, fmp);
fm_seek(fmp, file_pos, SEEK_SET);
}
/* Image File Directory */
out_le_u16(tags[entries].tag, 0x0100); /* ImageWidth */
out_le_u16(tags[entries].type, 3); /* SHORT */
out_le_u32(tags[entries].count, 1);
out_le_u32(tags[entries++].offset, symbol->bitmap_width);
out_le_u16(tags[entries].tag, 0x0101); /* ImageLength - number of rows */
out_le_u16(tags[entries].type, 3); /* SHORT */
out_le_u32(tags[entries].count, 1);
out_le_u32(tags[entries++].offset, symbol->bitmap_height);
if (samples_per_pixel != 1 || bits_per_sample != 1) {
out_le_u16(tags[entries].tag, 0x0102); /* BitsPerSample */
out_le_u16(tags[entries].type, 3); /* SHORT */
out_le_u32(tags[entries].count, samples_per_pixel);
if (samples_per_pixel == 1) {
out_le_u32(tags[entries++].offset, bits_per_sample);
} else if (samples_per_pixel == 2) { /* 2 SHORTS fit into LONG offset so packed into offset */
out_le_u32(tags[entries++].offset, (bits_per_sample << 16) | bits_per_sample);
} else {
update_offsets[offsets++] = entries;
tags[entries++].offset = (uint32_t) free_memory;
free_memory += samples_per_pixel * 2;
}
}
out_le_u16(tags[entries].tag, 0x0103); /* Compression */
out_le_u16(tags[entries].type, 3); /* SHORT */
out_le_u32(tags[entries].count, 1);
out_le_u32(tags[entries++].offset, compression);
out_le_u16(tags[entries].tag, 0x0106); /* PhotometricInterpretation */
out_le_u16(tags[entries].type, 3); /* SHORT */
out_le_u32(tags[entries].count, 1);
out_le_u32(tags[entries++].offset, pmi);
out_le_u16(tags[entries].tag, 0x0111); /* StripOffsets */
out_le_u16(tags[entries].type, 4); /* LONG */
out_le_u32(tags[entries].count, strip_count);
if (strip_count == 1) {
out_le_u32(tags[entries++].offset, strip_offset[0]);
} else {
update_offsets[offsets++] = entries;
tags[entries++].offset = (uint32_t) free_memory;
free_memory += strip_count * 4;
}
if (samples_per_pixel > 1) {
out_le_u16(tags[entries].tag, 0x0115); /* SamplesPerPixel */
out_le_u16(tags[entries].type, 3); /* SHORT */
out_le_u32(tags[entries].count, 1);
out_le_u32(tags[entries++].offset, samples_per_pixel);
}
out_le_u16(tags[entries].tag, 0x0116); /* RowsPerStrip */
out_le_u16(tags[entries].type, 4); /* LONG */
out_le_u32(tags[entries].count, 1);
out_le_u32(tags[entries++].offset, rows_per_strip);
out_le_u16(tags[entries].tag, 0x0117); /* StripByteCounts */
out_le_u16(tags[entries].type, 4); /* LONG */
out_le_u32(tags[entries].count, strip_count);
if (strip_count == 1) {
out_le_u32(tags[entries++].offset, strip_bytes[0]);
} else {
update_offsets[offsets++] = entries;
tags[entries++].offset = (uint32_t) free_memory;
free_memory += strip_count * 4;
}
out_le_u16(tags[entries].tag, 0x011a); /* XResolution */
out_le_u16(tags[entries].type, 5); /* RATIONAL */
out_le_u32(tags[entries].count, 1);
update_offsets[offsets++] = entries;
tags[entries++].offset = (uint32_t) free_memory;
free_memory += 8;
out_le_u16(tags[entries].tag, 0x011b); /* YResolution */
out_le_u16(tags[entries].type, 5); /* RATIONAL */
out_le_u32(tags[entries].count, 1);
update_offsets[offsets++] = entries;
tags[entries++].offset = (uint32_t) free_memory;
free_memory += 8;
out_le_u16(tags[entries].tag, 0x0128); /* ResolutionUnit */
out_le_u16(tags[entries].type, 3); /* SHORT */
out_le_u32(tags[entries].count, 1);
if (symbol->dpmm) {
out_le_u32(tags[entries++].offset, 3); /* Centimetres */
} else {
out_le_u32(tags[entries++].offset, 2); /* Inches */
}
if (color_map_size) {
out_le_u16(tags[entries].tag, 0x0140); /* ColorMap */
out_le_u16(tags[entries].type, 3); /* SHORT */
out_le_u32(tags[entries].count, color_map_size * 3);
update_offsets[offsets++] = entries;
tags[entries++].offset = (uint32_t) free_memory;
/* free_memory += color_map_size * 3 * 2; Unnecessary as long as last use */
}
if (extra_samples) {
out_le_u16(tags[entries].tag, 0x0152); /* ExtraSamples */
out_le_u16(tags[entries].type, 3); /* SHORT */
out_le_u32(tags[entries].count, 1);
out_le_u32(tags[entries++].offset, extra_samples);
}
ifd_size = sizeof(entries) + sizeof(tiff_tag_t) * entries + sizeof(offset);
for (i = 0; i < offsets; i++) {
out_le_u32(tags[update_offsets[i]].offset, tags[update_offsets[i]].offset + ifd_size);
}
out_le_u16(temp16, entries);
fm_write(&temp16, sizeof(entries), 1, fmp);
fm_write(&tags, sizeof(tiff_tag_t), entries, fmp);
out_le_u32(offset, offset);
fm_write(&offset, sizeof(offset), 1, fmp);
total_bytes_put += ifd_size;
if (samples_per_pixel > 2) {
out_le_u16(bits_per_sample, bits_per_sample);
for (i = 0; i < samples_per_pixel; i++) {
fm_write(&bits_per_sample, sizeof(bits_per_sample), 1, fmp);
}
total_bytes_put += sizeof(bits_per_sample) * samples_per_pixel;
}
if (strip_count != 1) {
/* Strip offsets */
for (i = 0; i < strip_count; i++) {
out_le_u32(temp32, strip_offset[i]);
fm_write(&temp32, 4, 1, fmp);
}
/* Strip byte lengths */
for (i = 0; i < strip_count; i++) {
out_le_u32(temp32, strip_bytes[i]);
fm_write(&temp32, 4, 1, fmp);
}
total_bytes_put += strip_count * 8;
}
/* XResolution */
out_le_u32(temp32, symbol->dpmm ? symbol->dpmm : 72);
fm_write(&temp32, 4, 1, fmp);
out_le_u32(temp32, symbol->dpmm ? 10 /*cm*/ : 1);
fm_write(&temp32, 4, 1, fmp);
total_bytes_put += 8;
/* YResolution */
out_le_u32(temp32, symbol->dpmm ? symbol->dpmm : 72);
fm_write(&temp32, 4, 1, fmp);
out_le_u32(temp32, symbol->dpmm ? 10 /*cm*/ : 1);
fm_write(&temp32, 4, 1, fmp);
total_bytes_put += 8;
if (color_map_size) {
for (i = 0; i < color_map_size; i++) {
fm_write(&color_map[i].red, 2, 1, fmp);
}
for (i = 0; i < color_map_size; i++) {
fm_write(&color_map[i].green, 2, 1, fmp);
}
for (i = 0; i < color_map_size; i++) {
fm_write(&color_map[i].blue, 2, 1, fmp);
}
total_bytes_put += 6 * color_map_size;
}
if (fm_error(fmp)) {
errtxtf(0, symbol, 679, "Incomplete write of TIF output (%1$d: %2$s)", fmp->err, strerror(fmp->err));
(void) fm_close(fmp, symbol);
return ZINT_ERROR_FILE_WRITE;
}
if (!output_to_stdout) {
if (fm_tell(fmp) != total_bytes_put) {
(void) fm_close(fmp, symbol);
return errtxt(ZINT_ERROR_FILE_WRITE, symbol, 674, "Failed to write all TIF output");
}
}
if (!fm_close(fmp, symbol)) {
return errtxtf(ZINT_ERROR_FILE_WRITE, symbol, 981, "Failure on closing TIF output file (%1$d: %2$s)",
fmp->err, strerror(fmp->err));
}
return 0;
}
/* vim: set ts=4 sw=4 et : */
Reference in New Issue View Git Blame Copy Permalink