retronetworking
/
freeswitch
13
0
Fork 0
Code Pull Requests Releases Activity
freeswitch/libs/spandsp/tests/t42_tests.c

624 lines
20 KiB
C
Raw Blame History

/*
* SpanDSP - a series of DSP components for telephony
*
* t42_tests.c - ITU T.42 JPEG for FAX image processing
*
* Written by Steve Underwood <steveu@coppice.org>
*
* Copyright (C) 2011 Steve Underwood
*
* All rights reserved.
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License version 2, as
* published by the Free Software Foundation.
*
* 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 General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
*/
/*! \file */
/*! \page t42_tests_page T.42 tests
\section t42_tests_page_sec_1 What does it do
*/
#if defined(HAVE_CONFIG_H)
#include "config.h"
#endif
#include <stdlib.h>
#include <stdio.h>
#include <fcntl.h>
#include <unistd.h>
#include <memory.h>
#define SPANDSP_EXPOSE_INTERNAL_STRUCTURES
#include "spandsp.h"
#if defined(SPANDSP_SUPPORT_TIFF_FX) && defined(HAVE_TIF_DIR_H)
#include <tif_dir.h>
#endif
#define IN_FILE_NAME "../test-data/itu/t24/F21B400.TIF"
#define OUT_FILE_NAME "t42_tests_receive.tif"
uint8_t data5[50000000];
int data5_ptr = 0;
int plane = 0;
int bit_mask;
uint8_t colour_map[3*256];
lab_params_t lab_param;
int write_row = 0;
static __inline__ uint16_t pack_16(uint8_t *s)
{
uint16_t value;
value = ((uint16_t) s[0] << 8) | (uint16_t) s[1];
return value;
}
/*- End of function --------------------------------------------------------*/
static __inline__ uint32_t pack_32(uint8_t *s)
{
uint32_t value;
value = ((uint32_t) s[0] << 24) | ((uint32_t) s[1] << 16) | ((uint32_t) s[2] << 8) | (uint32_t) s[3];
return value;
}
/*- End of function --------------------------------------------------------*/
static int t85_row_write_handler(void *user_data, const uint8_t buf[], size_t len)
{
int i;
int j;
for (i = 0; i < len; i++)
{
for (j = 0; j < 8; j++)
{
if ((buf[i] & (0x80 >> j)))
data5[data5_ptr + 3*(8*i + j)] |= bit_mask;
else
data5[data5_ptr + 3*(8*i + j)] &= ~bit_mask;
}
}
data5_ptr += 3*8*len;
write_row++;
return 0;
}
/*- End of function --------------------------------------------------------*/
static int t85_comment_handler(void *user_data, const uint8_t buf[], size_t len)
{
if (buf)
printf("Comment (%lu): %s\n", (unsigned long int) len, buf);
else
printf("Comment (%lu): ---\n", (unsigned long int) len);
return 0;
}
/*- End of function --------------------------------------------------------*/
int main(int argc, char *argv[])
{
TIFF *tif;
uint32_t w;
uint32_t h;
tstrip_t nstrips;
uint32_t totdata;
tsize_t off;
uint8_t *data;
uint8_t *data2;
int row;
uint16_t compression;
int16_t photometric;
int16_t YCbCrSubsampleHoriz;
int16_t YCbCrSubsampleVert;
int16_t bits_per_pixel;
int16_t samples_per_pixel;
int16_t planar_config;
int bytes_per_row;
tsize_t outsize;
char *outptr;
const char *source_file;
int i;
int j;
int len;
tsize_t total_image_len;
tsize_t total_len;
int process_raw;
int result;
t85_decode_state_t t85_dec;
uint64_t start;
uint64_t end;
uint16_t *map_L;
uint16_t *map_a;
uint16_t *map_b;
uint16_t *map_z;
uint32_t jpeg_table_len;
#if 0
logging_state_t *logging;
#endif
printf("Demo of ITU/Lab library.\n");
#if 0
logging = span_log_init(NULL, SPAN_LOG_FLOW, "T.42");
#endif
#if defined(SPANDSP_SUPPORT_TIFF_FX) && defined(HAVE_TIF_DIR_H)
TIFF_FX_init();
#endif
/* The default luminant is D50 */
set_lab_illuminant(&lab_param, 96.422f, 100.000f, 82.521f);
set_lab_gamut(&lab_param, 0, 100, -85, 85, -75, 125, false);
source_file = (argc > 1) ? argv[1] : IN_FILE_NAME;
/* sRGB to ITU */
if ((tif = TIFFOpen(source_file, "r")) == NULL)
{
printf("Unable to open '%s'!\n", source_file);
return 1;
}
if (TIFFSetDirectory(tif, (tdir_t) 0) < 0)
{
printf("Unable to set directory '%s'!\n", source_file);
return 1;
}
w = 0;
TIFFGetField(tif, TIFFTAG_IMAGEWIDTH, &w);
h = 0;
TIFFGetField(tif, TIFFTAG_IMAGELENGTH, &h);
bits_per_pixel = 0;
TIFFGetField(tif, TIFFTAG_BITSPERSAMPLE, &bits_per_pixel);
samples_per_pixel = 0;
TIFFGetField(tif, TIFFTAG_SAMPLESPERPIXEL, &samples_per_pixel);
compression = 0;
TIFFGetField(tif, TIFFTAG_COMPRESSION, &compression);
photometric = 0;
TIFFGetField(tif, TIFFTAG_PHOTOMETRIC, &photometric);
YCbCrSubsampleHoriz = 0;
YCbCrSubsampleVert = 0;
TIFFGetField(tif, TIFFTAG_YCBCRSUBSAMPLING, &YCbCrSubsampleHoriz, &YCbCrSubsampleVert);
planar_config = PLANARCONFIG_CONTIG;
TIFFGetField(tif, TIFFTAG_PLANARCONFIG, &planar_config);
off = 0;
map_L = NULL;
map_a = NULL;
map_b = NULL;
map_z = NULL;
if (TIFFGetField(tif, TIFFTAG_COLORMAP, &map_L, &map_a, &map_b, &map_z))
{
#if 0
/* Sweep the colormap in the proper order */
for (i = 0; i < (1 << bits_per_pixel); i++)
{
colour_map[3*i] = (map_L[i] >> 8) & 0xFF;
colour_map[3*i + 1] = (map_a[i] >> 8) & 0xFF;
colour_map[3*i + 2] = (map_b[i] >> 8) & 0xFF;
printf("Map %3d - %5d %5d %5d\n", i, colour_map[3*i], colour_map[3*i + 1], colour_map[3*i + 2]);
}
#else
/* Sweep the colormap in the order that seems to work for l04x_02x.tif */
for (i = 0; i < (1 << bits_per_pixel); i++)
{
colour_map[i] = (map_L[i] >> 8) & 0xFF;
colour_map[256 + i] = (map_a[i] >> 8) & 0xFF;
colour_map[2*256 + i] = (map_b[i] >> 8) & 0xFF;
}
#endif
lab_params_t lab;
/* The default luminant is D50 */
set_lab_illuminant(&lab, 96.422f, 100.000f, 82.521f);
set_lab_gamut(&lab, 0, 100, -85, 85, -75, 125, false);
lab_to_srgb(&lab, colour_map, colour_map, 256);
for (i = 0; i < (1 << bits_per_pixel); i++)
printf("Map %3d - %5d %5d %5d\n", i, colour_map[3*i], colour_map[3*i + 1], colour_map[3*i + 2]);
}
else
{
printf("There is no colour map\n");
}
process_raw = false;
printf("Compression is ");
switch (compression)
{
case COMPRESSION_CCITT_T4:
printf("T.4\n");
return 0;
case COMPRESSION_CCITT_T6:
printf("T.6\n");
return 0;
case COMPRESSION_T85:
printf("T.85\n");
process_raw = true;
break;
case COMPRESSION_T43:
printf("T.43\n");
process_raw = true;
break;
case COMPRESSION_JPEG:
printf("JPEG");
if (photometric == PHOTOMETRIC_ITULAB)
{
printf(" ITULAB");
process_raw = true;
}
printf("\n");
break;
case COMPRESSION_NONE:
printf("No compression\n");
break;
default:
printf("Unexpected compression %d\n", compression);
break;
}
outsize = 0;
if (process_raw)
{
uint8_t *jpeg_table;
nstrips = TIFFNumberOfStrips(tif);
total_image_len = 0;
jpeg_table_len = 0;
if (TIFFGetField(tif, TIFFTAG_JPEGTABLES, &jpeg_table_len, &jpeg_table))
{
total_image_len += (jpeg_table_len - 4);
printf("JPEG tables %u\n", jpeg_table_len);
printf("YYY %d - %x %x %x %x\n", jpeg_table_len, jpeg_table[0], jpeg_table[1], jpeg_table[2], jpeg_table[3]);
}
for (i = 0, total_image_len = 0; i < nstrips; i++)
total_image_len += TIFFRawStripSize(tif, i);
if ((data = malloc(total_image_len)) == NULL)
{
printf("Failed to allocate buffer\n");
exit(2);
}
for (i = 0, total_len = 0; i < nstrips; i++, total_len += len)
{
if ((len = TIFFReadRawStrip(tif, i, &data[total_len], total_image_len - total_len)) < 0)
{
printf("TIFF read error.\n");
return -1;
}
}
if (jpeg_table_len > 0)
memcpy(data, jpeg_table, jpeg_table_len - 2);
if (total_len != total_image_len)
printf("Size mismatch %ld %ld\n", (long int) total_len, (long int) total_image_len);
off = total_len;
switch (compression)
{
case COMPRESSION_CCITT_T4:
break;
case COMPRESSION_CCITT_T6:
break;
case COMPRESSION_T85:
printf("T.85 image %ld bytes\n", (long int) total_len);
for (i = 0; i < 16; i++)
printf("0x%02x\n", data[i]);
t85_decode_init(&t85_dec, t85_row_write_handler, NULL);
t85_decode_set_comment_handler(&t85_dec, 1000, t85_comment_handler, NULL);
result = t85_decode_put(&t85_dec, data, total_len);
if (result == T4_DECODE_MORE_DATA)
result = t85_decode_put(&t85_dec, NULL, 0);
len = t85_decode_get_compressed_image_size(&t85_dec);
printf("Compressed image is %d bytes, %d rows\n", len/8, write_row);
t85_decode_release(&t85_dec);
return 0;
case COMPRESSION_T43:
printf("T.43 image %ld bytes\n", (long int) total_len);
if (pack_16(data) == 0xFFA8)
{
data += 2;
total_len -= 2;
for (;;)
{
if (pack_16(data) == 0xFFE1)
{
data += 2;
total_len -= 2;
len = pack_16(data);
data += len;
total_len -= len;
}
else if (pack_16(data) == 0xFFE3)
{
data += 2;
total_len -= 2;
len = pack_32(data);
data += len;
total_len -= len;
}
else
{
break;
}
}
}
bit_mask = 0x80;
t85_decode_init(&t85_dec, t85_row_write_handler, NULL);
t85_decode_set_comment_handler(&t85_dec, 1000, t85_comment_handler, NULL);
t85_dec.min_bit_planes = 1;
t85_dec.max_bit_planes = 8;
data5_ptr = 0;
result = t85_decode_put(&t85_dec, data, total_len);
len = t85_decode_get_compressed_image_size(&t85_dec);
printf("Compressed image is %d bytes, %d rows\n", len/8, write_row);
for (j = 1; j < t85_dec.bit_planes; j++)
{
bit_mask >>= 1;
data += len/8;
total_len -= len/8;
t85_decode_new_plane(&t85_dec);
data5_ptr = 0;
t85_decode_set_comment_handler(&t85_dec, 1000, t85_comment_handler, NULL);
result = t85_decode_put(&t85_dec, data, total_len);
len = t85_decode_get_compressed_image_size(&t85_dec);
printf("Compressed image is %d bytes, %d rows\n", len/8, write_row);
}
if (result == T4_DECODE_MORE_DATA)
{
printf("More\n");
result = t85_decode_put(&t85_dec, NULL, 0);
}
len = t85_decode_get_compressed_image_size(&t85_dec);
printf("Compressed image is %d bytes, %d rows\n", len/8, write_row);
t85_decode_release(&t85_dec);
for (j = 0; j < data5_ptr; j += 3)
{
i = data5[j] & 0xFF;
//printf("%d %d %d %d %d %d\n", data5_ptr, j, i, colour_map[3*i], colour_map[3*i + 1], colour_map[3*i + 2]);
data5[j] = colour_map[3*i];
data5[j + 1] = colour_map[3*i + 1];
data5[j + 2] = colour_map[3*i + 2];
}
if ((tif = TIFFOpen(OUT_FILE_NAME, "w")) == NULL)
{
printf("Unable to open '%s'!\n", OUT_FILE_NAME);
return 1;
}
TIFFSetField(tif, TIFFTAG_SUBFILETYPE, FILETYPE_PAGE);
TIFFSetField(tif, TIFFTAG_IMAGEWIDTH, w);
// libtiff requires IMAGELENGTH to be set before SAMPLESPERPIXEL,
// or StripOffsets and StripByteCounts will have SAMPLESPERPIXEL values
TIFFSetField(tif, TIFFTAG_IMAGELENGTH, h);
TIFFSetField(tif, TIFFTAG_COMPRESSION, COMPRESSION_JPEG);
TIFFSetField(tif, TIFFTAG_BITSPERSAMPLE, 8);
TIFFSetField(tif, TIFFTAG_SAMPLESPERPIXEL, 3);
TIFFSetField(tif, TIFFTAG_PLANARCONFIG, PLANARCONFIG_CONTIG);
TIFFSetField(tif, TIFFTAG_ORIENTATION, ORIENTATION_TOPLEFT);
TIFFSetField(tif, TIFFTAG_ROWSPERSTRIP, (uint32) -1);
TIFFSetField(tif, TIFFTAG_XRESOLUTION, 200.0f);
TIFFSetField(tif, TIFFTAG_YRESOLUTION, 200.0f);
TIFFSetField(tif, TIFFTAG_RESOLUTIONUNIT, RESUNIT_INCH);
TIFFSetField(tif, TIFFTAG_SOFTWARE, "spandsp");
TIFFSetField(tif, TIFFTAG_IMAGEDESCRIPTION, "Test");
TIFFSetField(tif, TIFFTAG_DATETIME, "2012/07/03 12:30:45");
TIFFSetField(tif, TIFFTAG_MAKE, "soft-switch.org");
TIFFSetField(tif, TIFFTAG_MODEL, "spandsp");
TIFFSetField(tif, TIFFTAG_HOSTCOMPUTER, "i7.coppice.org");
for (off = 0, i = 0; i < h; off += w*3, i++)
{
TIFFWriteScanline(tif, data5 + off, i, 0);
}
TIFFWriteDirectory(tif);
TIFFClose(tif);
return 0;
case COMPRESSION_JPEG:
break;
}
}
else
{
printf("Width %d, height %d, bits %d, samples %d\n", w, h, bits_per_pixel, samples_per_pixel);
bytes_per_row = (bits_per_pixel + 7)/8;
bytes_per_row *= w*samples_per_pixel;
totdata = h*bytes_per_row;
printf("total %d\n", totdata);
/* Read the image into memory. */
if ((data = malloc(totdata)) == NULL)
{
printf("Failed to allocate buffer\n");
exit(2);
}
off = 0;
for (row = 0; row < h; row++)
{
if (TIFFReadScanline(tif, data + off, row, 0) < 0)
return 1;
off += bytes_per_row;
}
printf("total %u, off %ld\n", totdata, (long int) off);
/* We now have the image in memory in RGB form */
if (photometric == PHOTOMETRIC_ITULAB)
{
printf("YYY ITULAB\n");
#if 0
if (!t42_itulab_to_itulab(logging, (tdata_t) &outptr, &outsize, data, off, w, h, 3))
{
printf("Failed to convert to ITULAB\n");
return 1;
}
#else
outptr = 0;
#endif
free(data);
data = (uint8_t *) outptr;
off = outsize;
}
else
{
start = rdtscll();
switch (photometric)
{
case PHOTOMETRIC_CIELAB:
printf("CIELAB\n");
/* The default luminant is D50 */
set_lab_illuminant(&lab_param, 96.422f, 100.000f, 82.521f);
set_lab_gamut(&lab_param, 0, 100, -128, 127, -128, 127, true);
lab_to_srgb(&lab_param, data, data, w*h);
break;
case PHOTOMETRIC_ITULAB:
/* The default luminant is D50 */
set_lab_illuminant(&lab_param, 96.422f, 100.000f, 82.521f);
set_lab_gamut(&lab_param, 0, 100, -85, 85, -75, 125, false);
break;
}
//if (!t42_srgb_to_itulab_jpeg(logging, &lab_param, (tdata_t) &outptr, &outsize, data, off, w, h, 3))
{
printf("Failed to convert to ITULAB\n");
return 1;
}
end = rdtscll();
printf("Duration %" PRIu64 "\n", end - start);
free(data);
data = (uint8_t *) outptr;
off = outsize;
}
}
TIFFClose(tif);
printf("XXX - image is %d by %d, %ld bytes\n", w, h, (long int) off);
/* We now have the image in memory in ITULAB form */
if ((tif = TIFFOpen(OUT_FILE_NAME, "w")) == NULL)
{
printf("Unable to open '%s'!\n", OUT_FILE_NAME);
return 1;
}
TIFFSetField(tif, TIFFTAG_SUBFILETYPE, FILETYPE_PAGE);
TIFFSetField(tif, TIFFTAG_IMAGEWIDTH, w);
/* libtiff requires IMAGELENGTH to be set before SAMPLESPERPIXEL,
or StripOffsets and StripByteCounts will have SAMPLESPERPIXEL values */
TIFFSetField(tif, TIFFTAG_IMAGELENGTH, h);
TIFFSetField(tif, TIFFTAG_COMPRESSION, COMPRESSION_JPEG);
TIFFSetField(tif, TIFFTAG_BITSPERSAMPLE, 8);
TIFFSetField(tif, TIFFTAG_SAMPLESPERPIXEL, 3);
TIFFSetField(tif, TIFFTAG_PLANARCONFIG, PLANARCONFIG_CONTIG);
TIFFSetField(tif, TIFFTAG_ORIENTATION, ORIENTATION_TOPLEFT);
TIFFSetField(tif, TIFFTAG_ROWSPERSTRIP, (uint32) -1);
TIFFSetField(tif, TIFFTAG_XRESOLUTION, 200.0f);
TIFFSetField(tif, TIFFTAG_YRESOLUTION, 200.0f);
TIFFSetField(tif, TIFFTAG_RESOLUTIONUNIT, RESUNIT_INCH);
TIFFSetField(tif, TIFFTAG_SOFTWARE, "spandsp");
TIFFSetField(tif, TIFFTAG_IMAGEDESCRIPTION, "Test");
TIFFSetField(tif, TIFFTAG_DATETIME, "2012/07/03 12:30:45");
TIFFSetField(tif, TIFFTAG_MAKE, "soft-switch.org");
TIFFSetField(tif, TIFFTAG_MODEL, "spandsp");
TIFFSetField(tif, TIFFTAG_HOSTCOMPUTER, "i7.coppice.org");
if (1)
{
/* Most image processors won't know what to do with the ITULAB colorspace.
So we'll be converting it to RGB for portability. */
#if 1
TIFFSetField(tif, TIFFTAG_PHOTOMETRIC, PHOTOMETRIC_RGB);
#else
TIFFSetField(tif, TIFFTAG_PHOTOMETRIC, PHOTOMETRIC_YCBCR);
#endif
if (YCbCrSubsampleHoriz || YCbCrSubsampleVert)
TIFFSetField(tif, TIFFTAG_YCBCRSUBSAMPLING, YCbCrSubsampleHoriz, YCbCrSubsampleVert);
bytes_per_row = (bits_per_pixel + 7)/8;
bytes_per_row *= w*samples_per_pixel;
totdata = h*bytes_per_row;
/* The default luminant is D50 */
set_lab_illuminant(&lab_param, 96.422f, 100.000f, 82.521f);
set_lab_gamut(&lab_param, 0, 100, -85, 85, -75, 125, false);
#if 0
start = rdtscll();
data2 = NULL;
totdata = 0;
t42_itulab_to_jpeg(logging, &lab_param, (void **) &data2, &totdata, data, off);
end = rdtscll();
printf("Duration %" PRIu64 "\n", end - start);
printf("Compressed length %d (%p)\n", totdata, data2);
if (TIFFWriteRawStrip(tif, 0, data2, totdata) < 0)
{
printf("Failed to convert from ITULAB\n");
return 1;
}
free(data);
#else
if ((data2 = malloc(totdata)) == NULL)
{
printf("Failed to allocate buffer\n");
exit(2);
}
start = rdtscll();
//if (!t42_itulab_jpeg_to_srgb(logging, &lab_param, data2, &off, data, off, &w, &h, &samples_per_pixel))
{
printf("Failed to convert from ITULAB\n");
return 1;
}
end = rdtscll();
printf("Duration %" PRIu64 "\n", end - start);
free(data);
off = 0;
bytes_per_row = (8 + 7)/8;
bytes_per_row *= (w*3);
for (row = 0; row < h; row++)
{
if (TIFFWriteScanline(tif, data2 + off, row, 0) < 0)
return 1;
off += bytes_per_row;
}
#endif
free(data2);
}
else
{
#if 1
/* If PHOTOMETRIC_ITULAB is not available the admin cannot enable color fax anyway.
This is done so that older libtiffs without it can build fine. */
TIFFSetField(tif, TIFFTAG_PHOTOMETRIC, PHOTOMETRIC_ITULAB);
#else
TIFFSetField(tif, TIFFTAG_PHOTOMETRIC, PHOTOMETRIC_YCBCR);
#endif
if (YCbCrSubsampleHoriz || YCbCrSubsampleVert)
TIFFSetField(tif, TIFFTAG_YCBCRSUBSAMPLING, YCbCrSubsampleHoriz, YCbCrSubsampleVert);
if (TIFFWriteRawStrip(tif, 0, (tdata_t) data, off) == -1)
{
printf("Write error to TIFF file\n");
return 1;
}
free(data);
}
TIFFWriteDirectory(tif);
TIFFClose(tif);
printf("Done!\n");
return 0;
}
/*- End of function --------------------------------------------------------*/
/*- End of file ------------------------------------------------------------*/
View Git Blame Copy Permalink