#include <math.h>
#endif
#include "floating_fudge.h"
-#include <jpeglib.h>
#include <tiffio.h>
#include <assert.h>
#if !defined(_SPANDSP_EXPOSE_H_)
#define _SPANDSP_EXPOSE_H_
+#include <jpeglib.h>
+
#include <spandsp/private/logging.h>
#include <spandsp/private/schedule.h>
#include <spandsp/private/bitstream.h>
/*! \brief The common group of supported image sizes. */
int mutual_image_sizes;
/*! \brief The image coding being used on the line. */
- int line_encoding;
+ int line_compression;
+ /*! \brief The image type being used on the line. */
+ int line_image_type;
+ /*! \brief The width code for the image on the line. */
+ int line_width_code;
/*! \brief The current DCS message minimum scan time code. */
uint8_t min_scan_time_code;
/*! \brief The X direction resolution of the current image, in pixels per metre. */
#define T30_DCS_BIT_RECEIVE_FAX_DOCUMENT 10
/* Bits 11, 12, 13, 14 - modem type */
+#define T30_DIS_BIT_MODEM_TYPE_1 11
+#define T30_DCS_BIT_MODEM_TYPE_1 11
+#define T30_DIS_BIT_MODEM_TYPE_2 12
+#define T30_DCS_BIT_MODEM_TYPE_2 12
+#define T30_DIS_BIT_MODEM_TYPE_3 13
+#define T30_DCS_BIT_MODEM_TYPE_3 13
+#define T30_DIS_BIT_MODEM_TYPE_4 14
+#define T30_DCS_BIT_MODEM_TYPE_4 14
#define T30_DIS_BIT_200_200_CAPABLE 15
#define T30_DCS_BIT_200_200 15
#if !defined(_SPANDSP_PRIVATE_T42_H_)
#define _SPANDSP_PRIVATE_T42_H_
+#include <setjmp.h>
+#include <jpeglib.h>
+
struct lab_params_s
{
/* Lab gamut */
t4_row_read_handler_t row_read_handler;
/*! \brief Opaque pointer passed to row_read_handler. */
void *row_read_user_data;
+ uint32_t image_width;
+ uint32_t image_length;
+ uint16_t samples_per_pixel;
+ int image_type;
+ int no_subsampling;
+ int itu_ycc;
+ int quality;
+
+ /* The X or Y direction resolution, in pixels per inch */
+ int spatial_resolution;
- lab_params_t lab_params;
+ lab_params_t lab;
+
+ uint8_t illuminant_code[4];
+ int illuminant_colour_temperature;
/*! \brief The size of the compressed image, in bytes. */
int compressed_image_size;
+ int compressed_image_ptr;
+
+ int buf_size;
+ uint8_t *compressed_buf;
+
+ FILE *out;
+#if defined(HAVE_OPEN_MEMSTREAM)
+ size_t outsize;
+#endif
+ jmp_buf escape;
+ char error_message[JMSG_LENGTH_MAX];
+ struct jpeg_compress_struct compressor;
+
+ JSAMPROW scan_line_out;
+ JSAMPROW scan_line_in;
/*! \brief Error and flow logging control */
logging_state_t logging;
void *comment_user_data;
/*! The maximum length of comment to be passed to the comment handler */
uint32_t max_comment_len;
+ uint32_t image_width;
+ uint32_t image_length;
+ uint16_t samples_per_pixel;
+ int image_type;
+ int itu_ycc;
+
+ /* The X or Y direction resolution, in pixels per inch */
+ int spatial_resolution;
+
+ lab_params_t lab;
- lab_params_t lab_params;
+ uint8_t illuminant_code[4];
+ int illuminant_colour_temperature;
/*! The contents for a COMMENT marker segment, to be added to the
image at the next opportunity. This is set to NULL when nothing is
int buf_size;
uint8_t *compressed_buf;
+ FILE *in;
+ jmp_buf escape;
+ char error_message[JMSG_LENGTH_MAX];
+ struct jpeg_decompress_struct decompressor;
+
+ /*! Flag that the data to be decoded has run out. */
+ int end_of_data;
+
+ JSAMPROW scan_line_out;
+ JSAMPROW scan_line_in;
+
/*! \brief Error and flow logging control */
logging_state_t logging;
};
struct lab_params_s lab;
struct t85_encode_state_s t85;
+ int image_type;
int bit_planes[4];
int colour_map_entries;
uint8_t colour_map[3*256];
+ uint8_t illuminant_code[4];
+ int illuminant_colour_temperature;
+
/*! The width of the full image, in pixels */
uint32_t xd;
/*! The height of the full image, in pixels */
uint32_t yd;
- int x_resolution;
- int y_resolution;
+ /* The X or Y direction resolution, in pixels per inch */
+ int spatial_resolution;
/*! \brief Error and flow logging control */
logging_state_t logging;
struct lab_params_s lab;
struct t85_decode_state_s t85;
+ int image_type;
int bit_planes[4];
uint8_t bit_plane_mask;
int current_bit_plane;
int colour_map_entries;
uint8_t colour_map[3*256];
- int x_resolution;
- int y_resolution;
+ uint8_t illuminant_code[4];
+ int illuminant_colour_temperature;
+
+ /* The X or Y direction resolution, in pixels per inch */
+ int spatial_resolution;
+ int samples_per_pixel;
uint8_t *buf;
int ptr;
/*! Image type - bilevel, gray, colour */
int image_type;
/*! \brief The compression type for output to the TIFF file. */
- int output_encoding;
+ int compression;
/*! \brief The TIFF photometric setting for the current page. */
uint16_t photo_metric;
/*! \brief The TIFF fill order setting for the current page. */
*/
typedef struct
{
+ /*! \brief The type of compression used on the wire. */
+ int compression;
+ /*! \brief The width of the current page, in pixels. */
+ uint32_t image_width;
+ /*! \brief The length of the current page, in pixels. */
+ uint32_t image_length;
/*! \brief Column-to-column (X) resolution in pixels per metre. */
int x_resolution;
/*! \brief Row-to-row (Y) resolution in pixels per metre. */
/*! \brief The size of the compressed image on the line side, in bits. */
int line_image_size;
- /*! \brief The type of compression used between the FAX machines. */
- int line_encoding;
-
- /*! \brief The width of the current page, in pixels. */
- uint32_t image_width;
- /*! \brief The length of the current page, in pixels. */
- uint32_t image_length;
-
union
{
t4_t6_decode_state_t t4_t6;
int row;
/*! \brief Width of the image in the file. */
- int image_width;
+ uint32_t image_width;
/*! \brief Length of the image in the file. */
- int image_length;
+ uint32_t image_length;
/*! \brief Column-to-column (X) resolution in pixels per metre of the image in the file. */
int image_x_resolution;
/*! \brief Row-to-row (Y) resolution in pixels per metre of the image in the file. */
int image_y_resolution;
+ /*! \brief Code for the combined X and Y resolution of the image in the file. */
+ int resolution_code;
/*! \brief Row counter used when the image is resized or dithered flat. */
int raw_row;
*/
typedef struct
{
+ /*! \brief The type of compression used on the wire. */
+ int compression;
+ /*! \brief Image type - bi-level, gray, colour, etc. */
+ int image_type;
+ /*! \brief The width code for the image on the line side. */
+ int width_code;
+
+ /*! \brief The width of the current page on the wire, in pixels. */
+ uint32_t image_width;
+ /*! \brief The length of the current page on the wire, in pixels. */
+ uint32_t image_length;
/*! \brief Column-to-column (X) resolution in pixels per metre on the wire. */
int x_resolution;
/*! \brief Row-to-row (Y) resolution in pixels per metre on the wire. */
int y_resolution;
- /*! \brief Code for the combined X and Y resolution of the image in the file. */
+ /*! \brief Code for the combined X and Y resolution on the wire. */
int resolution_code;
- /*! \brief Image type - bi-level, gray, colour, etc. */
- int image_type;
} t4_tx_metadata_t;
/*!
/*! \brief Opaque pointer passed to row_read_handler. */
void *row_handler_user_data;
- /*! \brief The type of compression used between the FAX machines. */
- int line_encoding;
-
/*! \brief When superfine and fine resolution images need to be squahed vertically
to a lower resolution, this value sets the number of source rows which
must be squashed to form each row on the wire. */
int row_squashing_ratio;
- /*! \brief The width of the current page, in pixels. */
- uint32_t image_width;
- /*! \brief The length of the current page, in pixels. */
- uint32_t image_length;
-
/*! \brief The size of the compressed image on the line side, in bits. */
int line_image_size;
t4_rx_set_vendor(&s->t4.rx, s->vendor);
t4_rx_set_model(&s->t4.rx, s->model);
- t4_rx_set_rx_encoding(&s->t4.rx, s->line_encoding);
+ t4_rx_set_rx_encoding(&s->t4.rx, s->line_compression);
t4_rx_set_x_resolution(&s->t4.rx, s->x_resolution);
t4_rx_set_y_resolution(&s->t4.rx, s->y_resolution);
/* Select the compression to use. */
use_bilevel = TRUE;
- switch (s->line_encoding)
+ switch (s->line_compression)
{
case T4_COMPRESSION_T4_1D:
/* There is nothing to set to select this encoding. */
s->x_resolution = -1;
s->y_resolution = -1;
s->current_page_resolution = 0;
- s->line_encoding = -1;
+ s->line_compression = -1;
x = -1;
if (test_ctrl_bit(dcs_frame, T30_DCS_BIT_T81_MODE)
||
if (test_ctrl_bit(dcs_frame, T30_DCS_BIT_T81_MODE))
{
if ((s->supported_compressions & T4_SUPPORT_COMPRESSION_T42_T81))
- s->line_encoding = T4_COMPRESSION_T42_T81;
+ s->line_compression = T4_COMPRESSION_T42_T81;
}
else if (test_ctrl_bit(dcs_frame, T30_DCS_BIT_T43_MODE))
{
if ((s->supported_compressions & T4_SUPPORT_COMPRESSION_T43))
- s->line_encoding = T4_COMPRESSION_T43;
+ s->line_compression = T4_COMPRESSION_T43;
}
else if (test_ctrl_bit(dcs_frame, T30_DCS_BIT_T45_MODE))
{
if ((s->supported_compressions & T4_SUPPORT_COMPRESSION_T45))
- s->line_encoding = T4_COMPRESSION_T45;
+ s->line_compression = T4_COMPRESSION_T45;
}
else if (test_ctrl_bit(dcs_frame, T30_DCS_BIT_SYCC_T81_MODE))
{
if ((s->supported_compressions & T4_SUPPORT_COMPRESSION_SYCC_T81))
- s->line_encoding = T4_COMPRESSION_SYCC_T81;
+ s->line_compression = T4_COMPRESSION_SYCC_T81;
}
}
else
test_ctrl_bit(dcs_frame, T30_DCS_BIT_T88_MODE_3))
{
if ((s->supported_compressions & T4_SUPPORT_COMPRESSION_T88))
- s->line_encoding = T4_COMPRESSION_T88;
+ s->line_compression = T4_COMPRESSION_T88;
}
if (test_ctrl_bit(dcs_frame, T30_DCS_BIT_T85_L0_MODE))
{
if ((s->supported_compressions & T4_SUPPORT_COMPRESSION_T85_L0))
- s->line_encoding = T4_COMPRESSION_T85_L0;
+ s->line_compression = T4_COMPRESSION_T85_L0;
}
else if (test_ctrl_bit(dcs_frame, T30_DCS_BIT_T85_MODE))
{
if ((s->supported_compressions & T4_SUPPORT_COMPRESSION_T85))
- s->line_encoding = T4_COMPRESSION_T85;
+ s->line_compression = T4_COMPRESSION_T85;
}
else if (test_ctrl_bit(dcs_frame, T30_DCS_BIT_T6_MODE))
{
if ((s->supported_compressions & T4_SUPPORT_COMPRESSION_T6))
- s->line_encoding = T4_COMPRESSION_T6;
+ s->line_compression = T4_COMPRESSION_T6;
}
else if (test_ctrl_bit(dcs_frame, T30_DCS_BIT_2D_MODE))
{
if ((s->supported_compressions & T4_SUPPORT_COMPRESSION_T4_2D))
- s->line_encoding = T4_COMPRESSION_T4_2D;
+ s->line_compression = T4_COMPRESSION_T4_2D;
}
else
{
if ((s->supported_compressions & T4_SUPPORT_COMPRESSION_T4_1D))
- s->line_encoding = T4_COMPRESSION_T4_1D;
+ s->line_compression = T4_COMPRESSION_T4_1D;
}
}
- if (s->line_encoding == -1)
+ if (s->line_compression == -1)
{
t30_set_status(s, T30_ERR_INCOMPATIBLE);
return -1;
}
- span_log(&s->logging, SPAN_LOG_FLOW, "Far end selected compression %s (%d)\n", t4_encoding_to_str(s->line_encoding), s->line_encoding);
+ span_log(&s->logging, SPAN_LOG_FLOW, "Far end selected compression %s (%d)\n", t4_encoding_to_str(s->line_compression), s->line_compression);
if (x < 0)
{
}
s->operation_in_progress = OPERATION_IN_PROGRESS_T4_TX;
t4_tx_get_pages_in_file(&s->t4.tx);
- t4_tx_set_tx_encoding(&s->t4.tx, s->line_encoding);
+ t4_tx_set_tx_encoding(&s->t4.tx, s->line_compression);
t4_tx_set_local_ident(&s->t4.tx, s->tx_info.ident);
t4_tx_set_header_info(&s->t4.tx, s->header_info);
if (s->use_own_tz)
/* Choose a compression scheme from amongst those mutually available */
if ((s->mutual_compressions & T4_SUPPORT_COMPRESSION_T85_L0))
- s->line_encoding = T4_COMPRESSION_T85_L0;
+ s->line_compression = T4_COMPRESSION_T85_L0;
else if ((s->mutual_compressions & T4_SUPPORT_COMPRESSION_T85))
- s->line_encoding = T4_COMPRESSION_T85;
+ s->line_compression = T4_COMPRESSION_T85;
else if ((s->mutual_compressions & T4_SUPPORT_COMPRESSION_T6))
- s->line_encoding = T4_COMPRESSION_T6;
+ s->line_compression = T4_COMPRESSION_T6;
else if ((s->mutual_compressions & T4_SUPPORT_COMPRESSION_T4_2D))
- s->line_encoding = T4_COMPRESSION_T4_2D;
+ s->line_compression = T4_COMPRESSION_T4_2D;
else
- s->line_encoding = T4_COMPRESSION_T4_1D;
+ s->line_compression = T4_COMPRESSION_T4_1D;
- span_log(&s->logging, SPAN_LOG_FLOW, "Choose compression %s (%d)\n", t4_encoding_to_str(s->line_encoding), s->line_encoding);
+ span_log(&s->logging, SPAN_LOG_FLOW, "Choose compression %s (%d)\n", t4_encoding_to_str(s->line_compression), s->line_compression);
if (s->phase_b_handler)
{
pos += 6;
unpack_16(&data[pos], 1997);
pos += 2;
- unpack_16(&data[pos], s->x_resolution);
+ unpack_16(&data[pos], s->spatial_resolution);
pos += 2;
/* JBIG coding method (0) is the only possible value here */
data[pos] = 0;
if (seg >= 6 + 10)
{
val[0] = pack_16(&data[pos + 6 + 0]);
- s->x_resolution = pack_16(&data[pos + 6 + 2]);
+ s->spatial_resolution = pack_16(&data[pos + 6 + 2]);
val[2] = data[pos + 6 + 4];
val[3] = data[pos + 6 + 5];
s->bit_planes[0] = data[pos + 6 + 6];
SPAN_LOG_FLOW,
"Version %d, resolution %.2fdpi, coding method %d, type %s (%d), bit planes %d,%d,%d,%d\n",
val[0],
- s->x_resolution/100.0f,
+ s->spatial_resolution/100.0f,
val[2],
t43_image_type_to_str(val[3]),
val[3],
bits_per_sample = 1;
samples_per_pixel = 1;
photometric = PHOTOMETRIC_MINISWHITE;
- switch (t->output_encoding)
+ switch (t->compression)
{
case T4_COMPRESSION_T4_1D:
default:
TIFFSetField(t->tiff_file, TIFFTAG_DATETIME, buf);
TIFFSetField(t->tiff_file, TIFFTAG_FAXRECVTIME, now - s->tiff.page_start_time);
- TIFFSetField(t->tiff_file, TIFFTAG_IMAGEWIDTH, s->image_width);
+ TIFFSetField(t->tiff_file, TIFFTAG_IMAGEWIDTH, s->metadata.image_width);
/* Set the total pages to 1. For any one page document we will get this
right. For multi-page documents we will need to come back and fill in
the right answer when we know it. */
/* TIFF page numbers start from zero, so the number of pages in the file
is always one greater than the highest page number in the file. */
s->tiff.pages_in_file = s->current_page + 1;
- s->image_length = 0;
- switch (s->line_encoding)
+ s->metadata.image_length = 0;
+ switch (s->metadata.compression)
{
case T4_COMPRESSION_T4_1D:
case T4_COMPRESSION_T4_2D:
}
/* Fall through */
case T4_COMPRESSION_T6:
- s->image_length = t4_t6_decode_get_image_length(&s->decoder.t4_t6);
+ s->metadata.image_length = t4_t6_decode_get_image_length(&s->decoder.t4_t6);
break;
case T4_COMPRESSION_T85:
case T4_COMPRESSION_T85_L0:
- s->image_length = t85_decode_get_image_length(&s->decoder.t85);
+ s->metadata.image_length = t85_decode_get_image_length(&s->decoder.t85);
break;
#if defined(SPANDSP_SUPPORT_T88)
case T4_COMPRESSION_T88:
break;
#endif
case T4_COMPRESSION_T42_T81:
- s->image_length = t42_decode_get_image_length(&s->decoder.t42);
+ s->metadata.image_length = t42_decode_get_image_length(&s->decoder.t42);
break;
#if defined(SPANDSP_SUPPORT_T43)
case T4_COMPRESSION_T43:
- s->image_length = t43_decode_get_image_length(&s->decoder.t43);
+ s->metadata.image_length = t43_decode_get_image_length(&s->decoder.t43);
break;
#endif
#if defined(SPANDSP_SUPPORT_T45)
break;
#endif
}
- TIFFSetField(t->tiff_file, TIFFTAG_IMAGELENGTH, s->image_length);
- TIFFSetField(t->tiff_file, TIFFTAG_ROWSPERSTRIP, s->image_length);
+ TIFFSetField(t->tiff_file, TIFFTAG_IMAGELENGTH, s->metadata.image_length);
+ TIFFSetField(t->tiff_file, TIFFTAG_ROWSPERSTRIP, s->metadata.image_length);
#if defined(SPANDSP_SUPPORT_TIFF_FX)
TIFFSetField(t->tiff_file, TIFFTAG_PROFILETYPE, PROFILETYPE_G3_FAX);
TIFFSetField(t->tiff_file, TIFFTAG_FAXPROFILE, FAXPROFILE_S);
/* We need to perform this compression here, as libtiff does not understand it. */
packer.buf = s->tiff.image_buffer;
packer.ptr = 0;
- if (t85_encode_init(&t85, s->image_width, s->image_length, row_read_handler, &packer) == NULL)
+ if (t85_encode_init(&t85, s->metadata.image_width, s->metadata.image_length, row_read_handler, &packer) == NULL)
return -1;
- //if (t->output_encoding == T4_COMPRESSION_T85_L0)
+ //if (t->compression == T4_COMPRESSION_T85_L0)
// t85_encode_set_options(&t85, 256, -1, -1);
buf = NULL;
buf_len = 0;
packer.buf = s->tiff.image_buffer;
packer.ptr = 0;
- if (t43_encode_init(&t43, s->image_width, s->image_length, row_read_handler, &packer) == NULL)
+ if (t43_encode_init(&t43, s->metadata.image_width, s->metadata.image_length, row_read_handler, &packer) == NULL)
return -1;
buf = NULL;
buf_len = 0;
if (!TIFFCheckpointDirectory(t->tiff_file))
span_log(&s->logging, SPAN_LOG_WARNING, "%s: Failed to checkpoint directory for page %d.\n", t->file, s->current_page);
/* ...and write out the image... */
- switch (t->output_encoding)
+ switch (t->compression)
{
case T4_COMPRESSION_T85:
case T4_COMPRESSION_T85_L0:
SPAN_DECLARE(int) t4_rx_put(t4_rx_state_t *s, const uint8_t buf[], size_t len)
{
s->line_image_size += 8*len;
- switch (s->line_encoding)
+ switch (s->metadata.compression)
{
case T4_COMPRESSION_T4_1D:
case T4_COMPRESSION_T4_2D:
/* Only provide for one form of coding throughout the file, even though the
coding on the wire could change between pages. */
if ((s->supported_tiff_compressions & T4_SUPPORT_COMPRESSION_T85))
- s->tiff.output_encoding = T4_COMPRESSION_T85;
+ s->tiff.compression = T4_COMPRESSION_T85;
else if ((s->supported_tiff_compressions & T4_SUPPORT_COMPRESSION_T6))
- s->tiff.output_encoding = T4_COMPRESSION_T6;
+ s->tiff.compression = T4_COMPRESSION_T6;
else if ((s->supported_tiff_compressions & T4_SUPPORT_COMPRESSION_T4_2D))
- s->tiff.output_encoding = T4_COMPRESSION_T4_2D;
+ s->tiff.compression = T4_COMPRESSION_T4_2D;
else if ((s->supported_tiff_compressions & T4_SUPPORT_COMPRESSION_T4_1D))
- s->tiff.output_encoding = T4_COMPRESSION_T4_1D;
+ s->tiff.compression = T4_COMPRESSION_T4_1D;
}
else
{
if ((s->supported_tiff_compressions & T4_SUPPORT_COMPRESSION_T42_T81))
- s->tiff.output_encoding = T4_COMPRESSION_T42_T81;
+ s->tiff.compression = T4_COMPRESSION_T42_T81;
else if ((s->supported_tiff_compressions & T4_SUPPORT_COMPRESSION_T43))
- s->tiff.output_encoding = T4_COMPRESSION_T43;
+ s->tiff.compression = T4_COMPRESSION_T43;
}
}
/*- End of function --------------------------------------------------------*/
case T4_COMPRESSION_T4_1D:
case T4_COMPRESSION_T4_2D:
case T4_COMPRESSION_T6:
- switch (s->line_encoding)
+ switch (s->metadata.compression)
{
case T4_COMPRESSION_T4_1D:
case T4_COMPRESSION_T4_2D:
case T4_COMPRESSION_T6:
break;
default:
- t4_t6_decode_init(&s->decoder.t4_t6, encoding, s->image_width, s->row_handler, s->row_handler_user_data);
+ t4_t6_decode_init(&s->decoder.t4_t6, encoding, s->metadata.image_width, s->row_handler, s->row_handler_user_data);
break;
}
- s->line_encoding = encoding;
+ s->metadata.compression = encoding;
select_tiff_compression(s, T4_IMAGE_TYPE_BILEVEL);
return t4_t6_decode_set_encoding(&s->decoder.t4_t6, encoding);
case T4_COMPRESSION_T85:
case T4_COMPRESSION_T85_L0:
- switch (s->line_encoding)
+ switch (s->metadata.compression)
{
case T4_COMPRESSION_T85:
case T4_COMPRESSION_T85_L0:
break;
}
select_tiff_compression(s, T4_IMAGE_TYPE_BILEVEL);
- s->line_encoding = encoding;
+ s->metadata.compression = encoding;
return 0;
#if defined(SPANDSP_SUPPORT_T88)
case T4_COMPRESSION_T88:
- switch (s->line_encoding)
+ switch (s->metadata.compression)
{
case T4_COMPRESSION_T88:
break;
break;
}
select_tiff_compression(s, T4_IMAGE_TYPE_BILEVEL);
- s->line_encoding = encoding;
+ s->metadata.compression = encoding;
return 0;
#endif
case T4_COMPRESSION_T42_T81:
case T4_COMPRESSION_SYCC_T81:
- switch (s->line_encoding)
+ switch (s->metadata.compression)
{
case T4_COMPRESSION_T42_T81:
case T4_COMPRESSION_SYCC_T81:
t42_decode_set_image_size_constraints(&s->decoder.t42, T4_WIDTH_1200_A3, 0);
break;
}
- s->line_encoding = encoding;
+ s->metadata.compression = encoding;
select_tiff_compression(s, T4_IMAGE_TYPE_COLOUR_8BIT);
return 0;
#if defined(SPANDSP_SUPPORT_T43)
case T4_COMPRESSION_T43:
- switch (s->line_encoding)
+ switch (s->metadata.compression)
{
case T4_COMPRESSION_T43:
break;
t43_decode_set_image_size_constraints(&s->decoder.t43, T4_WIDTH_1200_A3, 0);
break;
}
- s->line_encoding = encoding;
+ s->metadata.compression = encoding;
select_tiff_compression(s, T4_IMAGE_TYPE_COLOUR_8BIT);
return 0;
#endif
#if defined(SPANDSP_SUPPORT_T45)
case T4_COMPRESSION_T45:
- switch (s->line_encoding)
+ switch (s->metadata.compression)
{
case T4_COMPRESSION_T45:
break;
default:
break;
}
- s->line_encoding = encoding;
+ s->metadata.compression = encoding;
select_tiff_compression(s, T4_IMAGE_TYPE_COLOUR_8BIT);
return 0;
#endif
SPAN_DECLARE(void) t4_rx_set_image_width(t4_rx_state_t *s, int width)
{
- s->image_width = width;
+ s->metadata.image_width = width;
}
/*- End of function --------------------------------------------------------*/
{
s->row_handler = handler;
s->row_handler_user_data = user_data;
- switch (s->line_encoding)
+ switch (s->metadata.compression)
{
case T4_COMPRESSION_T4_1D:
case T4_COMPRESSION_T4_2D:
t->image_y_resolution = s->metadata.y_resolution;
t->x_resolution = s->metadata.x_resolution;
t->y_resolution = s->metadata.y_resolution;
- t->encoding = s->line_encoding;
- switch (s->line_encoding)
+ t->encoding = s->metadata.compression;
+ switch (s->metadata.compression)
{
case T4_COMPRESSION_T4_1D:
case T4_COMPRESSION_T4_2D:
SPAN_DECLARE(int) t4_rx_start_page(t4_rx_state_t *s)
{
- span_log(&s->logging, SPAN_LOG_FLOW, "Start rx page %d - compression %s\n", s->current_page, t4_encoding_to_str(s->line_encoding));
+ span_log(&s->logging, SPAN_LOG_FLOW, "Start rx page %d - compression %s\n", s->current_page, t4_encoding_to_str(s->metadata.compression));
- switch (s->line_encoding)
+ switch (s->metadata.compression)
{
case T4_COMPRESSION_T4_1D:
case T4_COMPRESSION_T4_2D:
case T4_COMPRESSION_T6:
- t4_t6_decode_restart(&s->decoder.t4_t6, s->image_width);
+ t4_t6_decode_restart(&s->decoder.t4_t6, s->metadata.image_width);
break;
case T4_COMPRESSION_T85:
case T4_COMPRESSION_T85_L0:
int length;
length = 0;
- switch (s->line_encoding)
+ switch (s->metadata.compression)
{
case T4_COMPRESSION_T4_1D:
case T4_COMPRESSION_T4_2D:
{
if (s->tiff.file)
tiff_rx_release(s);
- switch (s->line_encoding)
+ switch (s->metadata.compression)
{
case T4_COMPRESSION_T4_1D:
case T4_COMPRESSION_T4_2D:
#include "config.h"
#endif
-#include <stdlib.h>
#include <inttypes.h>
+#include <stdlib.h>
#include <limits.h>
#include <stdio.h>
#include <fcntl.h>
parm32 = 0;
TIFFGetField(t->tiff_file, TIFFTAG_IMAGEWIDTH, &parm32);
t->image_width =
- s->image_width = parm32;
+ s->metadata.image_width = parm32;
parm32 = 0;
TIFFGetField(t->tiff_file, TIFFTAG_IMAGELENGTH, &parm32);
t->image_length =
- s->image_length = parm32;
+ s->metadata.image_length = parm32;
x_resolution = 0.0f;
TIFFGetField(t->tiff_file, TIFFTAG_XRESOLUTION, &x_resolution);
y_resolution = 0.0f;
s->metadata.resolution_code = resolution_map[best_y_entry][best_x_entry];
- t4_tx_set_image_width(s, s->image_width);
- t4_tx_set_image_length(s, s->image_length);
+ t4_tx_set_image_width(s, s->metadata.image_width);
+ t4_tx_set_image_length(s, s->metadata.image_length);
t4_tx_set_max_2d_rows_per_1d_row(s, -s->metadata.y_resolution);
#if defined(SPANDSP_SUPPORT_TIFF_FX)
if (TIFFGetField(t->tiff_file, TIFFTAG_PROFILETYPE, &parm32))
parm32 = 0;
TIFFGetField(t->tiff_file, TIFFTAG_IMAGEWIDTH, &parm32);
- if (s->image_width != (int) parm32)
+ if (s->metadata.image_width != (int) parm32)
return 1;
x_resolution = 0.0f;
TIFFGetField(t->tiff_file, TIFFTAG_XRESOLUTION, &x_resolution);
int j;
s = (t4_tx_state_t *) user_data;
- if (s->tiff.row >= s->image_length)
+ if (s->tiff.row >= s->metadata.image_length)
return 0;
memcpy(buf, &s->tiff.image_buffer[s->tiff.row*len], len);
s->tiff.row++;
/* If this is a bi-level image which has more vertical resolution than the
far end will accept, we need to squash it down to size. */
- for (i = 1; i < s->row_squashing_ratio && s->tiff.row < s->image_length; i++)
+ for (i = 1; i < s->row_squashing_ratio && s->tiff.row < s->metadata.image_length; i++)
{
- for (j = 0; j < s->image_width/8; j++)
+ for (j = 0; j < s->metadata.image_width/8; j++)
buf[j] |= s->tiff.image_buffer[s->tiff.row*len + j];
s->tiff.row++;
}
if ((raw_data = malloc(biggest)) == NULL)
return -1;
- s->tiff.image_size = s->image_length*((s->image_width + 7)/8);
+ s->tiff.image_size = s->metadata.image_length*((s->metadata.image_width + 7)/8);
if (s->tiff.image_size >= s->tiff.image_buffer_size)
{
if ((t = realloc(s->tiff.image_buffer, s->tiff.image_size)) == NULL)
result = t85_decode_put(&t85, NULL, 0);
len = t85_decode_get_compressed_image_size(&t85);
- span_log(&s->logging, SPAN_LOG_WARNING, "Compressed image is %d bytes, %d rows\n", len/8, s->image_length);
+ span_log(&s->logging, SPAN_LOG_WARNING, "Compressed image is %d bytes, %d rows\n", len/8, s->metadata.image_length);
t85_decode_release(&t85);
free(raw_data);
return 0;
logging = t43_decode_get_logging_state(&t43);
span_log_set_level(logging, SPAN_LOG_SHOW_SEVERITY | SPAN_LOG_SHOW_PROTOCOL | SPAN_LOG_FLOW);
- image_size = 3*s->image_length*s->image_width;
+ image_size = 3*s->metadata.image_length*s->metadata.image_width;
if ((*buf = malloc(image_size)) == NULL)
return -1;
if (total_len != total_image_len)
span_log(&s->logging, SPAN_LOG_FLOW, "Size mismatch %d %d\n", (int) total_len, (int) total_image_len);
- image_size = 3*s->image_length*s->image_width;
+ image_size = 3*s->metadata.image_length*s->metadata.image_width;
if ((*buf = malloc(image_size)) == NULL)
return -1;
/* Decode the whole image into a buffer */
/* Let libtiff handle the decompression */
- s->tiff.image_size = s->image_length*TIFFScanlineSize(s->tiff.tiff_file);
+ s->tiff.image_size = s->metadata.image_length*TIFFScanlineSize(s->tiff.tiff_file);
if (s->tiff.image_size >= s->tiff.image_buffer_size)
{
if ((t = realloc(s->tiff.image_buffer, s->tiff.image_size)) == NULL)
{
/* We need to dither this image down to pure black and white, possibly resizing it
along the way. */
- if ((translator = image_translate_init(NULL, T4_IMAGE_TYPE_BILEVEL, 1728, -1, s->tiff.image_type, s->image_width, s->image_length, row_read, s)) == NULL)
+ if ((translator = image_translate_init(NULL, T4_IMAGE_TYPE_BILEVEL, 1728, -1, s->tiff.image_type, s->metadata.image_width, s->metadata.image_length, row_read, s)) == NULL)
return -1;
- s->image_width = image_translate_get_output_width(translator);
- s->image_length = image_translate_get_output_length(translator);
+ s->metadata.image_width = image_translate_get_output_width(translator);
+ s->metadata.image_length = image_translate_get_output_length(translator);
s->metadata.x_resolution = T4_X_RESOLUTION_R8;
s->metadata.y_resolution = T4_Y_RESOLUTION_FINE;
s->metadata.resolution_code = T4_RESOLUTION_R8_FINE;
- s->tiff.image_size = (s->image_width*s->image_length + 7)/8;
+ s->tiff.image_size = (s->metadata.image_width*s->metadata.image_length + 7)/8;
if (s->tiff.image_size >= s->tiff.image_buffer_size)
{
if ((t = realloc(s->tiff.image_buffer, s->tiff.image_size)) == NULL)
break;
}
total_len = 0;
- for (i = 0; i < s->image_length; i++)
- total_len += image_translate_row(translator, &s->tiff.image_buffer[total_len], s->image_width/8);
+ for (i = 0; i < s->metadata.image_length; i++)
+ total_len += image_translate_row(translator, &s->tiff.image_buffer[total_len], s->metadata.image_width/8);
image_translate_free(translator);
}
else
}
}
s->tiff.row = 0;
- return s->image_length;
+ return s->metadata.image_length;
}
/*- End of function --------------------------------------------------------*/
static int set_row_read_handler(t4_tx_state_t *s, t4_row_read_handler_t handler, void *user_data)
{
- switch (s->line_encoding)
+ switch (s->metadata.compression)
{
case T4_COMPRESSION_T4_1D:
case T4_COMPRESSION_T4_2D:
case T4_COMPRESSION_T4_1D:
case T4_COMPRESSION_T4_2D:
case T4_COMPRESSION_T6:
- switch (s->line_encoding)
+ switch (s->metadata.compression)
{
case T4_COMPRESSION_T4_1D:
case T4_COMPRESSION_T4_2D:
case T4_COMPRESSION_T6:
break;
default:
- t4_t6_encode_init(&s->encoder.t4_t6, encoding, s->image_width, s->row_handler, s->row_handler_user_data);
+ t4_t6_encode_init(&s->encoder.t4_t6, encoding, s->metadata.image_width, s->row_handler, s->row_handler_user_data);
t4_t6_encode_set_max_2d_rows_per_1d_row(&s->encoder.t4_t6, -s->metadata.y_resolution);
break;
}
- s->line_encoding = encoding;
+ s->metadata.compression = encoding;
if (t4_t6_encode_set_encoding(&s->encoder.t4_t6, encoding))
return -1;
- return s->line_encoding;
+ return s->metadata.compression;
case T4_COMPRESSION_T85:
case T4_COMPRESSION_T85_L0:
- switch (s->line_encoding)
+ switch (s->metadata.compression)
{
case T4_COMPRESSION_T85:
case T4_COMPRESSION_T85_L0:
break;
default:
- t85_encode_init(&s->encoder.t85, s->image_width, s->image_length, s->row_handler, s->row_handler_user_data);
+ t85_encode_init(&s->encoder.t85, s->metadata.image_width, s->metadata.image_length, s->row_handler, s->row_handler_user_data);
break;
}
- s->line_encoding = encoding;
- return s->line_encoding;
+ s->metadata.compression = encoding;
+ return s->metadata.compression;
#if defined(SPANDSP_SUPPORT_T88)
case T4_COMPRESSION_T88:
- switch (s->line_encoding)
+ switch (s->metadata.compression)
{
case T4_COMPRESSION_T88:
break;
default:
break;
}
- s->line_encoding = encoding;
- return s->line_encoding;
+ s->metadata.compression = encoding;
+ return s->metadata.compression;
#endif
case T4_COMPRESSION_T42_T81:
case T4_COMPRESSION_SYCC_T81:
- switch (s->line_encoding)
+ switch (s->metadata.compression)
{
case T4_COMPRESSION_T42_T81:
case T4_COMPRESSION_SYCC_T81:
break;
default:
- t42_encode_init(&s->encoder.t42, s->image_width, s->image_length, s->row_handler, s->row_handler_user_data);
+ t42_encode_init(&s->encoder.t42, s->metadata.image_width, s->metadata.image_length, s->row_handler, s->row_handler_user_data);
break;
}
- s->line_encoding = encoding;
- return s->line_encoding;
+ s->metadata.compression = encoding;
+ return s->metadata.compression;
#if defined(SPANDSP_SUPPORT_T43)
case T4_COMPRESSION_T43:
- switch (s->line_encoding)
+ switch (s->metadata.compression)
{
case T4_COMPRESSION_T43:
break;
default:
- t43_encode_init(&s->encoder.t43, s->image_width, s->image_length, s->row_handler, s->row_handler_user_data);
+ t43_encode_init(&s->encoder.t43, s->metadata.image_width, s->metadata.image_length, s->row_handler, s->row_handler_user_data);
break;
}
- s->line_encoding = encoding;
- return s->line_encoding;
+ s->metadata.compression = encoding;
+ return s->metadata.compression;
#endif
#if defined(SPANDSP_SUPPORT_T45)
case T4_COMPRESSION_T45:
- switch (s->line_encoding)
+ switch (s->metadata.compression)
{
case T4_COMPRESSION_T45:
break;
default:
break;
}
- s->line_encoding = encoding;
- return s->line_encoding;
+ s->metadata.compression = encoding;
+ return s->metadata.compression;
#endif
}
}
SPAN_DECLARE(void) t4_tx_set_min_bits_per_row(t4_tx_state_t *s, int bits)
{
- switch (s->line_encoding)
+ switch (s->metadata.compression)
{
case T4_COMPRESSION_T4_1D:
case T4_COMPRESSION_T4_2D:
SPAN_DECLARE(void) t4_tx_set_image_width(t4_tx_state_t *s, int image_width)
{
- s->image_width = image_width;
- switch (s->line_encoding)
+ s->metadata.image_width = image_width;
+ switch (s->metadata.compression)
{
case T4_COMPRESSION_T4_1D:
case T4_COMPRESSION_T4_2D:
static void t4_tx_set_image_length(t4_tx_state_t *s, int image_length)
{
- s->image_length = image_length;
- switch (s->line_encoding)
+ s->metadata.image_length = image_length;
+ switch (s->metadata.compression)
{
case T4_COMPRESSION_T85:
case T4_COMPRESSION_T85_L0:
SPAN_DECLARE(void) t4_tx_set_max_2d_rows_per_1d_row(t4_tx_state_t *s, int max)
{
- switch (s->line_encoding)
+ switch (s->metadata.compression)
{
case T4_COMPRESSION_T4_1D:
case T4_COMPRESSION_T4_2D:
SPAN_DECLARE(int) t4_tx_get_image_width(t4_tx_state_t *s)
{
- return s->image_width;
+ return s->metadata.image_width;
}
/*- End of function --------------------------------------------------------*/
t->x_resolution = s->metadata.x_resolution;
t->y_resolution = s->metadata.y_resolution/s->row_squashing_ratio;
- t->encoding = s->line_encoding;
- switch (s->line_encoding)
+ t->encoding = s->metadata.compression;
+ switch (s->metadata.compression)
{
case T4_COMPRESSION_T4_1D:
case T4_COMPRESSION_T4_2D:
SPAN_DECLARE(int) t4_tx_image_complete(t4_tx_state_t *s)
{
- switch (s->line_encoding)
+ switch (s->metadata.compression)
{
case T4_COMPRESSION_T4_1D:
case T4_COMPRESSION_T4_2D:
SPAN_DECLARE(int) t4_tx_get(t4_tx_state_t *s, uint8_t buf[], size_t max_len)
{
- switch (s->line_encoding)
+ switch (s->metadata.compression)
{
case T4_COMPRESSION_T4_1D:
case T4_COMPRESSION_T4_2D:
SPAN_DECLARE(int) t4_tx_start_page(t4_tx_state_t *s)
{
- span_log(&s->logging, SPAN_LOG_FLOW, "Start tx page %d - compression %s\n", s->current_page, t4_encoding_to_str(s->line_encoding));
+ span_log(&s->logging, SPAN_LOG_FLOW, "Start tx page %d - compression %s\n", s->current_page, t4_encoding_to_str(s->metadata.compression));
if (s->current_page > s->stop_page)
return -1;
if (s->tiff.file)
}
else
{
- s->image_length = UINT32_MAX;
+ s->metadata.image_length = UINT32_MAX;
}
- switch (s->line_encoding)
+ switch (s->metadata.compression)
{
case T4_COMPRESSION_T4_1D:
case T4_COMPRESSION_T4_2D:
case T4_COMPRESSION_T6:
- t4_t6_encode_restart(&s->encoder.t4_t6, s->image_width);
+ t4_t6_encode_restart(&s->encoder.t4_t6, s->metadata.image_width);
break;
case T4_COMPRESSION_T85:
case T4_COMPRESSION_T85_L0:
- t85_encode_restart(&s->encoder.t85, s->image_width, s->image_length);
+ t85_encode_restart(&s->encoder.t85, s->metadata.image_width, s->metadata.image_length);
break;
#if defined(SPANDSP_SUPPORT_T88)
case T4_COMPRESSION_T88:
#endif
case T4_COMPRESSION_T42_T81:
case T4_COMPRESSION_SYCC_T81:
- t42_encode_restart(&s->encoder.t42, s->image_width, s->image_length);
+ t42_encode_restart(&s->encoder.t42, s->metadata.image_width, s->metadata.image_length);
break;
#if defined(SPANDSP_SUPPORT_T43)
case T4_COMPRESSION_T43:
- t43_encode_restart(&s->encoder.t43, s->image_width, s->image_length);
+ t43_encode_restart(&s->encoder.t43, s->metadata.image_width, s->metadata.image_length);
break;
#endif
#if defined(SPANDSP_SUPPORT_T45)
s->current_page =
s->start_page = (start_page >= 0) ? start_page : 0;
s->stop_page = (stop_page >= 0) ? stop_page : INT_MAX;
- s->line_encoding = T4_COMPRESSION_NONE;
+ s->metadata.compression = T4_COMPRESSION_NONE;
s->row_handler = tiff_row_read_handler;
s->row_handler_user_data = (void *) s;
free(s->colour_map);
s->colour_map = NULL;
}
- switch (s->line_encoding)
+ switch (s->metadata.compression)
{
case T4_COMPRESSION_T4_1D:
case T4_COMPRESSION_T4_2D:
projects / thirdparty / freeswitch.git / commitdiff
