/*
 * SpanDSP - a series of DSP components for telephony
 *
 * t43_tests.c - ITU T.43 JBIG for grey and colour FAX image processing
 *
 * Written by Steve Underwood <steveu@coppice.org>
 *
 * Copyright (C) 2011, 2013 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 t43_tests_page T.43 tests
\section t43_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/tiff-fx/l04x_02x.tif"
#define OUT_FILE_NAME   "t43_tests_receive.tif"

t43_decode_state_t t43;
t85_decode_state_t t85;

lab_params_t lab_param;

int write_row = 0;

typedef struct
{
    uint8_t *buf;
    int ptr;
} packer_t;

#if defined(SPANDSP_SUPPORT_TIFF_FX)  &&  defined(HAVE_TIF_DIR_H)
/* TIFF-FX related extensions to the tag set supported by libtiff */
static const TIFFFieldInfo tiff_fx_tiff_field_info[] =
{
    {TIFFTAG_INDEXED, 1, 1, TIFF_SHORT, FIELD_CUSTOM, false, false, (char *) "Indexed"},
    {TIFFTAG_GLOBALPARAMETERSIFD, 1, 1, TIFF_IFD8, FIELD_CUSTOM, false, false, (char *) "GlobalParametersIFD"},
    {TIFFTAG_PROFILETYPE, 1, 1, TIFF_LONG, FIELD_CUSTOM, false, false, (char *) "ProfileType"},
    {TIFFTAG_FAXPROFILE, 1, 1, TIFF_BYTE, FIELD_CUSTOM, false, false, (char *) "FaxProfile"},
    {TIFFTAG_CODINGMETHODS, 1, 1, TIFF_LONG, FIELD_CUSTOM, false, false, (char *) "CodingMethods"},
    {TIFFTAG_VERSIONYEAR, 4, 4, TIFF_BYTE, FIELD_CUSTOM, false, false, (char *) "VersionYear"},
    {TIFFTAG_MODENUMBER, 1, 1, TIFF_BYTE, FIELD_CUSTOM, false, false, (char *) "ModeNumber"},
    {TIFFTAG_DECODE, TIFF_VARIABLE, TIFF_VARIABLE, TIFF_SRATIONAL, FIELD_CUSTOM, false, true, (char *) "Decode"},
    {TIFFTAG_IMAGEBASECOLOR, TIFF_VARIABLE, TIFF_VARIABLE, TIFF_SHORT, FIELD_CUSTOM, false, true, (char *) "ImageBaseColor"},
    {TIFFTAG_T82OPTIONS, 1, 1, TIFF_LONG, FIELD_CUSTOM, false, false, (char *) "T82Options"},
    {TIFFTAG_STRIPROWCOUNTS, TIFF_VARIABLE, TIFF_VARIABLE, TIFF_LONG, FIELD_CUSTOM, false, true, (char *) "StripRowCounts"},
    {TIFFTAG_IMAGELAYER, 2, 2, TIFF_LONG, FIELD_CUSTOM, false, false, (char *) "ImageLayer"},
};

static TIFFFieldArray tifffxFieldArray;

static TIFFField tiff_fx_tiff_fields[] =
{
    { TIFFTAG_INDEXED, 1, 1, TIFF_SHORT, 0, TIFF_SETGET_UINT16, TIFF_SETGET_UNDEFINED, FIELD_CUSTOM, 1, 0, (char *) "Indexed" },
    { TIFFTAG_GLOBALPARAMETERSIFD, 1, 1, TIFF_IFD8, 0, TIFF_SETGET_IFD8, TIFF_SETGET_UNDEFINED, FIELD_CUSTOM, 0, 0, (char *) "GlobalParametersIFD", &tifffxFieldArray },
    { TIFFTAG_PROFILETYPE, 1, 1, TIFF_LONG, 0, TIFF_SETGET_UINT32, TIFF_SETGET_UNDEFINED, FIELD_CUSTOM, 1, 0, (char *) "ProfileType", NULL },
    { TIFFTAG_FAXPROFILE, 1, 1, TIFF_BYTE, 0, TIFF_SETGET_UINT8, TIFF_SETGET_UNDEFINED, FIELD_CUSTOM, 1, 0, (char *) "FaxProfile", NULL },
    { TIFFTAG_CODINGMETHODS, 1, 1, TIFF_LONG, 0, TIFF_SETGET_UINT32, TIFF_SETGET_UNDEFINED, FIELD_CUSTOM, 1, 0, (char *) "CodingMethods", NULL },
    { TIFFTAG_VERSIONYEAR, 4, 4, TIFF_BYTE, 0, TIFF_SETGET_C0_UINT8, TIFF_SETGET_UNDEFINED, FIELD_CUSTOM, 1, 0, (char *) "VersionYear", NULL },
    { TIFFTAG_MODENUMBER, 1, 1, TIFF_BYTE, 0, TIFF_SETGET_UINT8, TIFF_SETGET_UNDEFINED, FIELD_CUSTOM, 1, 0, (char *) "ModeNumber", NULL },
    { TIFFTAG_DECODE, -1, -1, TIFF_SRATIONAL, 0, TIFF_SETGET_C16_FLOAT, TIFF_SETGET_UNDEFINED, FIELD_CUSTOM, 1, 1, (char *) "Decode", NULL },
    { TIFFTAG_IMAGEBASECOLOR, -1, -1, TIFF_SHORT, 0, TIFF_SETGET_C16_UINT16, TIFF_SETGET_UNDEFINED, FIELD_CUSTOM, 1, 1, (char *) "ImageBaseColor", NULL },
    { TIFFTAG_T82OPTIONS, 1, 1, TIFF_LONG, 0, TIFF_SETGET_UINT32, TIFF_SETGET_UNDEFINED, FIELD_CUSTOM, 1, 0, (char *) "T82Options", NULL },
    { TIFFTAG_STRIPROWCOUNTS, -1, -1, TIFF_LONG, 0, TIFF_SETGET_C16_UINT32, TIFF_SETGET_UNDEFINED, FIELD_CUSTOM, 1, 1, (char *) "StripRowCounts", NULL },
    { TIFFTAG_IMAGELAYER, 2, 2, TIFF_LONG, 0, TIFF_SETGET_C0_UINT32, TIFF_SETGET_UNDEFINED, FIELD_CUSTOM, 1, 0, (char *) "ImageLayer", NULL },
};

static TIFFFieldArray tiff_fx_field_array = { tfiatOther, 0, 12, tiff_fx_tiff_fields };
#endif

typedef struct
{
    TIFF *tif;
    int pre_compressed;
    uint32_t compressed_image_len;
    uint32_t image_width;
    uint32_t image_length;
    float x_resolution;
    float y_resolution;
    uint16_t resolution_unit;
    uint16_t bits_per_sample;
    uint16_t samples_per_pixel;
    uint16_t compression;
    uint16_t photometric;
    int16_t YCbCrSubsampleHoriz;
    int16_t YCbCrSubsampleVert;
    int16_t planar_config;
    int32_t tile_width;
    int32_t tile_length;
    uint8_t *colour_map;
    float lmin;
    float lmax;
    float amin;
    float amax;
    float bmin;
    float bmax;
} meta_t;

int write_file(meta_t *meta, int page, const uint8_t buf[]);
int read_file(meta_t *meta, int page);
int read_compressed_image(meta_t *meta, uint8_t **buf);
int read_decompressed_image(meta_t *meta, uint8_t **buf);

static int row_write_handler(void *user_data, const uint8_t buf[], size_t len)
{
    packer_t *s;

    s = (packer_t *) user_data;
    memcpy(&s->buf[s->ptr], buf, len);
    s->ptr += len;
    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);
    /*endif*/
    return 0;
}
/*- End of function --------------------------------------------------------*/

static int row_read_handler(void *user_data, uint8_t row[], size_t len)
{
    packer_t *s;

    s = (packer_t *) user_data;
    memcpy(row, &s->buf[s->ptr], len);
    s->ptr += len;
    return len;
}
/*- End of function --------------------------------------------------------*/

int write_file(meta_t *meta, int page, const uint8_t buf[])
{
    TIFF *tif;
    int off;
    int i;
    time_t now;
    struct tm *tm;
    char date_buf[50 + 1];
    int bytes_per_row;
    t85_encode_state_t t85;
    t43_encode_state_t t43;
    int out_buf_len;
    int out_len;
    int chunk_len;
    uint8_t *out_buf;
    uint8_t *out_buf2;
    packer_t packer;
#if defined(SPANDSP_SUPPORT_TIFF_FX)  &&  defined(HAVE_TIF_DIR_H)
    toff_t diroff;
#endif

    tif = meta->tif;
    TIFFSetField(tif, TIFFTAG_SUBFILETYPE, FILETYPE_PAGE);
    TIFFSetField(tif, TIFFTAG_IMAGEWIDTH, meta->image_width);
    /* libtiff requires IMAGELENGTH to be set before SAMPLESPERPIXEL,
       or StripOffsets and StripByteCounts will have SAMPLESPERPIXEL values */
    TIFFSetField(tif, TIFFTAG_IMAGELENGTH, meta->image_length);
    TIFFSetField(tif, TIFFTAG_COMPRESSION, meta->compression);
    TIFFSetField(tif, TIFFTAG_BITSPERSAMPLE, meta->bits_per_sample);
    TIFFSetField(tif, TIFFTAG_SAMPLESPERPIXEL, meta->samples_per_pixel);
    TIFFSetField(tif, TIFFTAG_PLANARCONFIG, PLANARCONFIG_CONTIG);
    TIFFSetField(tif, TIFFTAG_ORIENTATION, ORIENTATION_TOPLEFT);
    TIFFSetField(tif, TIFFTAG_ROWSPERSTRIP, meta->image_length);
    TIFFSetField(tif, TIFFTAG_XRESOLUTION, meta->x_resolution);
    TIFFSetField(tif, TIFFTAG_YRESOLUTION, meta->y_resolution);
    TIFFSetField(tif, TIFFTAG_RESOLUTIONUNIT, meta->resolution_unit);
    TIFFSetField(tif, TIFFTAG_PHOTOMETRIC, meta->photometric);
    if (meta->samples_per_pixel > 1  &&  (meta->YCbCrSubsampleHoriz  ||  meta->YCbCrSubsampleVert))
        TIFFSetField(tif, TIFFTAG_YCBCRSUBSAMPLING, meta->YCbCrSubsampleHoriz, meta->YCbCrSubsampleVert);
    TIFFSetField(tif, TIFFTAG_SOFTWARE, "spandsp");
    TIFFSetField(tif, TIFFTAG_IMAGEDESCRIPTION, "Test");
    time(&now);
    tm = localtime(&now);
    sprintf(date_buf,
            "%4d/%02d/%02d %02d:%02d:%02d",
            tm->tm_year + 1900,
            tm->tm_mon + 1,
            tm->tm_mday,
            tm->tm_hour,
            tm->tm_min,
            tm->tm_sec);
    TIFFSetField(tif, TIFFTAG_DATETIME, date_buf);
    TIFFSetField(tif, TIFFTAG_MAKE, "soft-switch.org");
    TIFFSetField(tif, TIFFTAG_MODEL, "spandsp");
    TIFFSetField(tif, TIFFTAG_HOSTCOMPUTER, "i7.coppice.org");
#if defined(SPANDSP_SUPPORT_TIFF_FX)
    /* Make space for this to be filled in later */
    TIFFSetField(tif, TIFFTAG_GLOBALPARAMETERSIFD, 0);
#endif

    if (meta->pre_compressed)
    {
        if (TIFFWriteRawStrip(tif, 0, (tdata_t) buf, meta->compressed_image_len) < 0)
            printf("Error writing TIFF strip.\n");
        /*endif*/
    }
    else
    {
        switch (meta->compression)
        {
        case COMPRESSION_T85:
            packer.buf = (uint8_t *) buf;
            packer.ptr = 0;
            t85_encode_init(&t85, meta->image_width, meta->image_length, row_read_handler, &packer);
            //if (meta->compression == T4_COMPRESSION_T85_L0)
            //    t85_encode_set_options(&t85, 256, -1, -1);
            out_len = 0;
            out_buf_len = 0;
            out_buf = NULL;
            do
            {
                if (out_buf_len < out_len + 50000)
                {
                    out_buf_len += 50000;
                    if ((out_buf2 = realloc(out_buf, out_buf_len)) == NULL)
                    {
                        if (out_buf)
                            free(out_buf);
                        /*endif*/
                        return -1;
                    }
                    /*endif*/
                    out_buf = out_buf2;
                }
                /*endif*/
                chunk_len = t85_encode_get(&t85, &out_buf[out_len], 50000);
                out_len += chunk_len;
            }
            while (chunk_len > 0);
            if (TIFFWriteRawStrip(tif, 0, out_buf, out_len) < 0)
                printf("Error writing TIFF strip.\n");
            /*endif*/
            t85_encode_release(&t85);
            free(out_buf);
            break;
        case COMPRESSION_T43:
            packer.buf = (uint8_t *) buf;
            packer.ptr = 0;
            t43_encode_init(&t43, meta->image_width, meta->image_length, row_read_handler, &packer);
            out_len = 0;
            out_buf_len = 0;
            out_buf = NULL;
            do
            {
                if (out_buf_len < out_len + 50000)
                {
                    out_buf_len += 50000;
                    if ((out_buf2 = realloc(out_buf, out_buf_len)) == NULL)
                    {
                        if (out_buf)
                            free(out_buf);
                        /*endif*/
                        return -1;
                    }
                    /*endif*/
                    out_buf = out_buf2;
                }
                /*endif*/
                chunk_len = t43_encode_get(&t43, &out_buf[out_len], 50000);
                out_len += chunk_len;
            }
            while (chunk_len > 0);
            if (TIFFWriteRawStrip(tif, 0, out_buf, out_len) < 0)
                printf("Error writing TIFF strip.\n");
            /*endif*/
            t43_encode_release(&t43);
            free(out_buf);
            break;
        default:
            bytes_per_row = TIFFScanlineSize(tif);
            for (off = 0, i = 0;  i < meta->image_length;  off += bytes_per_row, i++)
            {
                if (TIFFWriteScanline(tif, (tdata_t) &buf[off], i, 0) < 0)
                    printf("Error writing TIFF scan line.\n");
                /*endif*/
            }
            /*endfor*/
            break;
        }
        /*endswitch*/
    }
    /*endif*/

    if (!TIFFWriteDirectory(tif))
        printf("Failed to write directory.\n");
    /*endif*/

#if defined(SPANDSP_SUPPORT_TIFF_FX)  &&  defined(HAVE_TIF_DIR_H)
    if (!TIFFCreateCustomDirectory(tif, &tiff_fx_field_array))
    {
        TIFFSetField(tif, TIFFTAG_PROFILETYPE, PROFILETYPE_G3_FAX);
        TIFFSetField(tif, TIFFTAG_FAXPROFILE, FAXPROFILE_F);
        TIFFSetField(tif, TIFFTAG_CODINGMETHODS, CODINGMETHODS_T4_1D | CODINGMETHODS_T4_2D | CODINGMETHODS_T6);
        TIFFSetField(tif, TIFFTAG_VERSIONYEAR, "1998");
        TIFFSetField(tif, TIFFTAG_MODENUMBER, 3);

        diroff = 0;
        if (!TIFFWriteCustomDirectory(tif, &diroff))
            printf("Failed to write custom directory.\n");

        if (!TIFFSetDirectory(tif, (tdir_t) page))
            printf("Failed to set directory.\n");
        /*endif*/
        if (!TIFFSetField(tif, TIFFTAG_GLOBALPARAMETERSIFD, diroff))
            printf("Failed to set global parameters IFD.\n");
        /*endif*/
        if (!TIFFWriteDirectory(tif))
            printf("Failed to write directory.\n");
        /*endif*/
    }
    /*endif*/
#endif
    return 0;
}
/*- End of function --------------------------------------------------------*/

int read_file(meta_t *meta, int page)
{
#if defined(SPANDSP_SUPPORT_TIFF_FX)  &&  defined(HAVE_TIF_DIR_H)
    static const char *tiff_fx_fax_profiles[] =
    {
        "???",
        "profile S",
        "profile F",
        "profile J",
        "profile C",
        "profile L",
        "profile M"
    };
    uint8_t parm8;
    uint16_t parm16;
    uint32_t parm32;
    float *fl_parms;
    char uu[10];
    char *u;
    toff_t diroff;
#endif
    TIFF *tif;
    uint16_t *map_L;
    uint16_t *map_a;
    uint16_t *map_b;
    uint16_t *map_z;
    lab_params_t lab;
    int entries;
    int i;

    tif = meta->tif;
    printf("Read %d\n", page);
    if (!TIFFSetDirectory(tif, (tdir_t) page))
    {
        printf("Unable to set TIFF directory %d!\n", page);
        return -1;
    }
    /*endif*/
    meta->image_width = 0;
    TIFFGetField(tif, TIFFTAG_IMAGEWIDTH, &meta->image_width);
    meta->image_length = 0;
    TIFFGetField(tif, TIFFTAG_IMAGELENGTH, &meta->image_length);
    meta->x_resolution = 200.0f;
    TIFFGetField(tif, TIFFTAG_XRESOLUTION, &meta->x_resolution);
    meta->y_resolution = 200.0f;
    TIFFGetField(tif, TIFFTAG_YRESOLUTION, &meta->y_resolution);
    meta->resolution_unit = RESUNIT_INCH;
    TIFFGetField(tif, TIFFTAG_RESOLUTIONUNIT, &meta->resolution_unit);
    meta->bits_per_sample = 0;
    TIFFGetField(tif, TIFFTAG_BITSPERSAMPLE, &meta->bits_per_sample);
    meta->samples_per_pixel = 0;
    TIFFGetField(tif, TIFFTAG_SAMPLESPERPIXEL, &meta->samples_per_pixel);
    meta->compression = 0;
    TIFFGetField(tif, TIFFTAG_COMPRESSION, &meta->compression);
    meta->photometric = 0;
    TIFFGetField(tif, TIFFTAG_PHOTOMETRIC, &meta->photometric);
    meta->YCbCrSubsampleHoriz = 0;
    meta->YCbCrSubsampleVert = 0;
    TIFFGetField(tif, TIFFTAG_YCBCRSUBSAMPLING, &meta->YCbCrSubsampleHoriz, &meta->YCbCrSubsampleVert);
    meta->planar_config = PLANARCONFIG_CONTIG;
    TIFFGetField(tif, TIFFTAG_PLANARCONFIG, &meta->planar_config);
    meta->tile_width = 0;
    TIFFGetField(tif, TIFFTAG_TILEWIDTH, &meta->tile_width);
    meta->tile_length = 0;
    TIFFGetField(tif, TIFFTAG_TILELENGTH, &meta->tile_length);

    switch (meta->photometric)
    {
    case PHOTOMETRIC_ITULAB:
        meta->lmin = 0.0f;
        meta->lmax = 100.0f;
        meta->amin = -21760.0f/255.0f;  // For 12 bit -348160.0f/4095.0f
        meta->amax = 21590.0f/255.0f;   // For 12 bit 347990.0f/4095.0f
        meta->bmin = -19200.0f/255.0f;  // For 12 bit -307200.0f/4095.0f
        meta->bmax = 31800.0f/255.0f;   // For 12 bit 511800.0f/4095.0f
        break;
    default:
        meta->lmin = 0.0f;
        meta->lmax = 0.0f;
        meta->amin = 0.0f;
        meta->amax = 0.0f;
        meta->bmin = 0.0f;
        meta->bmax = 0.0f;
        break;
    }
    /*endswitch*/
#if defined(SPANDSP_SUPPORT_TIFF_FX)  &&  defined(HAVE_TIF_DIR_H)
    if (TIFFGetField(tif, TIFFTAG_DECODE, &parm16, &fl_parms))
    {
        meta->lmin = fl_parms[0];
        meta->lmax = fl_parms[1];
        meta->amin = fl_parms[2];
        meta->amax = fl_parms[3];
        meta->bmin = fl_parms[4];
        meta->bmax = fl_parms[5];
        printf("Got decode tag %f %f %f %f %f %f\n", meta->lmin, meta->lmax, meta->amin, meta->amax, meta->bmin, meta->bmax);
    }
    /*endif*/
#endif

#if defined(SPANDSP_SUPPORT_TIFF_FX)  &&  defined(HAVE_TIF_DIR_H)
    printf("Trying to get global parameters\n");
    if (TIFFGetField(tif, TIFFTAG_GLOBALPARAMETERSIFD, &diroff))
    {
        printf("Got global parameters - %" PRIu64 "\n", (uint64_t) diroff);
        if (!TIFFReadCustomDirectory(tif, diroff, &tiff_fx_field_array))
        {
            printf("Failed to set global parameters IFD.\n");
        }
        else
        {
            if (TIFFGetField(tif, TIFFTAG_PROFILETYPE, &parm32))
                printf("  Profile type %u\n", parm32);
            /*endif*/
            if (TIFFGetField(tif, TIFFTAG_FAXPROFILE, &parm8))
                printf("  FAX profile %s (%u)\n", tiff_fx_fax_profiles[parm8], parm8);
            /*endif*/
            if (TIFFGetField(tif, TIFFTAG_CODINGMETHODS, &parm32))
                printf("  Coding methods 0x%x\n", parm32);
            /*endif*/
            if (TIFFGetField(tif, TIFFTAG_VERSIONYEAR, &u))
            {
                memcpy(uu, u, 4);
                uu[4] = '\0';
                printf("  Version year \"%s\"\n", uu);
            }
            /*endif*/
            if (TIFFGetField(tif, TIFFTAG_MODENUMBER, &parm8))
                printf("  Mode number %u\n", parm8);
            /*endif*/
        }
        /*endif*/
        TIFFSetDirectory(tif, (tdir_t) page);
    }
    /*endif*/

    if (TIFFGetField(tif, TIFFTAG_PROFILETYPE, &parm32))
        printf("Profile type %u\n", parm32);
    /*endif*/
    if (TIFFGetField(tif, TIFFTAG_FAXPROFILE, &parm8))
        printf("FAX profile %s (%u)\n", tiff_fx_fax_profiles[parm8], parm8);
    /*endif*/
    if (TIFFGetField(tif, TIFFTAG_CODINGMETHODS, &parm32))
        printf("Coding methods 0x%x\n", parm32);
    /*endif*/
    if (TIFFGetField(tif, TIFFTAG_VERSIONYEAR, &u))
    {
        memcpy(uu, u, 4);
        uu[4] = '\0';
        printf("Version year \"%s\"\n", uu);
    }
    /*endif*/
    if (TIFFGetField(tif, TIFFTAG_MODENUMBER, &parm8))
        printf("Mode number %u\n", parm8);
    /*endif*/
    if (TIFFGetField(tif, TIFFTAG_T82OPTIONS, &parm32))
        printf("T.82 options 0x%x\n", parm32);
    /*endif*/
#endif

    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))
    {
        entries = 1 << meta->bits_per_sample;
        if ((meta->colour_map = malloc(3*entries)))
        {
#if 0
            /* Sweep the colormap in the proper order */
            for (i = 0;  i < entries;  i++)
            {
                meta->colour_map[3*i] = (map_L[i] >> 8) & 0xFF;
                meta->colour_map[3*i + 1] = (map_a[i] >> 8) & 0xFF;
                meta->colour_map[3*i + 2] = (map_b[i] >> 8) & 0xFF;
                printf("Map %3d - %5d %5d %5d\n", i, meta->colour_map[3*i], meta->colour_map[3*i + 1], meta->colour_map[3*i + 2]);
            }
            /*endfor*/
#else
            /* Sweep the colormap in the order that seems to work for l04x_02x.tif */
            for (i = 0;  i < entries;  i++)
            {
                meta->colour_map[i] = (map_L[i] >> 8) & 0xFF;
                meta->colour_map[256 + i] = (map_a[i] >> 8) & 0xFF;
                meta->colour_map[2*256 + i] = (map_b[i] >> 8) & 0xFF;
            }
            /*endfor*/
#endif
            /* The default luminant is D50 */
            set_lab_illuminant(&lab_param, 96.422f, 100.000f,  82.521f);
            set_lab_gamut(&lab, 0, 100, -85, 85, -75, 125, false);
            lab_to_srgb(&lab, meta->colour_map, meta->colour_map, 256);
            for (i = 0;  i < entries;  i++)
                printf("Map %3d - %5d %5d %5d\n", i, meta->colour_map[3*i], meta->colour_map[3*i + 1], meta->colour_map[3*i + 2]);
            /*endfor*/
        }
        /*endif*/
    }
    /*endif*/
    meta->tif = tif;
    return 0;
}
/*- End of function --------------------------------------------------------*/

int read_compressed_image(meta_t *meta, uint8_t **buf)
{
    int i;
    int len;
    int total_len;
    int read_len;
    int num_strips;
    uint8_t *data;

    num_strips = TIFFNumberOfStrips(meta->tif);
    for (i = 0, total_len = 0;  i < num_strips;  i++)
    {
        total_len += TIFFRawStripSize(meta->tif, i);
    }
    /*endfor*/
    if ((data = malloc(total_len)) == NULL)
        return -1;
    /*endif*/
    for (i = 0, read_len = 0;  i < num_strips;  i++, read_len += len)
    {
        if ((len = TIFFReadRawStrip(meta->tif, i, &data[read_len], total_len - read_len)) < 0)
        {
            printf("TIFF read error.\n");
            free(data);
            return -1;
        }
        /*endif*/
    }
    /*endfor*/
    *buf = data;
    return total_len;
}
/*- End of function --------------------------------------------------------*/

int read_decompressed_image(meta_t *meta, uint8_t **buf)
{
    int bytes_per_row;
    int x;
    int y;
    int xx;
    int yy;
    int xxx;
    int yyy;
    int i;
    int j;
    int result;
    int total_raw;
    int total_data;
    uint8_t *raw_buf;
    uint8_t *image_buf;
    t85_decode_state_t t85;
    t43_decode_state_t t43;
    packer_t pack;
    logging_state_t *logging;
    logging_state_t logging2;
#if 0
    uint8_t *jpeg_table;
    uint32_t jpeg_table_len;
    tsize_t off;
    uint32_t w;
    uint32_t h;
#endif

    image_buf = NULL;
    total_data = 0;
    *buf = NULL;
    switch (meta->compression)
    {
    case COMPRESSION_T85:
        bytes_per_row = (meta->image_width + 7)/8;
        total_data = meta->image_length*bytes_per_row;
        printf("Total decompressed data %d, %d per row\n", total_data, bytes_per_row);

        /* Read the image into memory. */
        if ((image_buf = malloc(total_data)) == NULL)
        {
            printf("Failed to allocated image buffer\n");
            return -1;
        }
        /*endif*/
        total_raw = read_compressed_image(meta, &raw_buf);
        t85_decode_init(&t85, row_write_handler, &pack);
        t85_decode_set_comment_handler(&t85, 1000, t85_comment_handler, NULL);
        logging = t85_decode_get_logging_state(&t85);
        span_log_set_level(logging, SPAN_LOG_SHOW_SEVERITY | SPAN_LOG_SHOW_PROTOCOL | SPAN_LOG_FLOW);

        pack.buf = image_buf;
        pack.ptr = 0;

        result = t85_decode_put(&t85, raw_buf, total_raw);
        if (result == T4_DECODE_MORE_DATA)
            result = t85_decode_put(&t85, NULL, 0);
        /*endif*/
        total_data = t85_decode_get_compressed_image_size(&t85);
        printf("Compressed image is %d/%d bytes, %d rows\n", total_raw, total_data/8, write_row);
        t85_decode_release(&t85);
        free(raw_buf);
        break;
    case COMPRESSION_T43:
        bytes_per_row = meta->samples_per_pixel*meta->image_width;
        total_data = meta->image_length*bytes_per_row;
        printf("Total decompressed data %d, %d per row\n", total_data, bytes_per_row);

        total_data *= 8;
        /* Read the image into memory. */
        if ((image_buf = malloc(total_data)) == NULL)
            printf("Failed to allocated image buffer\n");
        /*endif*/

        total_raw = read_compressed_image(meta, &raw_buf);
        t43_decode_init(&t43, row_write_handler, &pack);
        t43_decode_set_comment_handler(&t43, 1000, t85_comment_handler, NULL);
        logging = t43_decode_get_logging_state(&t43);
        span_log_set_level(logging, SPAN_LOG_SHOW_SEVERITY | SPAN_LOG_SHOW_PROTOCOL | SPAN_LOG_FLOW);

        pack.buf = image_buf;
        pack.ptr = 0;

        result = t43_decode_put(&t43, raw_buf, total_raw);
        if (result == T4_DECODE_MORE_DATA)
            result = t43_decode_put(&t43, NULL, 0);
        /*endif*/
        t43_decode_release(&t43);
        free(raw_buf);

        meta->samples_per_pixel = 1;
        meta->photometric = PHOTOMETRIC_RGB;
        printf("Image %d x %d pixels\n", meta->image_width, meta->image_length);
        break;
    case COMPRESSION_JPEG:
        if (meta->photometric == PHOTOMETRIC_ITULAB)
        {
            printf(" ITULAB");

            span_log_init(&logging2, SPAN_LOG_SHOW_SEVERITY | SPAN_LOG_SHOW_PROTOCOL | SPAN_LOG_FLOW, "lab");
            bytes_per_row = TIFFScanlineSize(meta->tif);
            total_data = meta->image_length*bytes_per_row;
            printf("Total decompressed data %d, %d per row\n", total_data, bytes_per_row);

            /* Read the image into memory. */
            if ((image_buf = malloc(total_data)) == NULL)
                printf("Failed to allocated image buffer\n");
            /*endif*/
#if 0
            jpeg_table_len = 0;
            if (TIFFGetField(meta->tif, TIFFTAG_JPEGTABLES, &jpeg_table_len, &jpeg_table))
            {
                total_image_len += (jpeg_table_len - 4);
                printf("JPEG tables %u\n", jpeg_table_len);
{
int ii;
printf("YYY1 %d - ", jpeg_table_len);
for (ii = 0;  ii < jpeg_table_len;  ii++)
    printf(" %02x", jpeg_table[ii]);
printf("\n");
}
            }
            /*endif*/
#endif
            total_raw = read_compressed_image(meta, &raw_buf);
            //if (!t42_itulab_jpeg_to_srgb(&logging2, &lab_param, (tdata_t) image_buf, &off, raw_buf, total_raw, &w, &h, &samples_per_pixel))
            {
                printf("Failed to convert from ITULAB.\n");
                free(image_buf);
                return -1;
            }
            /*endif*/
            meta->photometric = PHOTOMETRIC_RGB;

#if 0
            total_len = 0;
            if (jpeg_table_len > 0)
                total_len += jpeg_table_len - 4;
            /*endif*/

printf("nstrips %d\n", nstrips);
            data2 = NULL;
            for (i = 0;  i < nstrips;  i++, total_len += len)
            {
                total_len = 0;
                if (jpeg_table_len > 0)
                    total_len += jpeg_table_len - 4;
                /*endif*/
                if ((len = TIFFReadRawStrip(tif, i, &data[total_len], total_image_len - total_len)) < 0)
                {
                    printf("TIFF read error.\n");
                    free(image_buf);
                    return -1;
                }
                /*endif*/
                if (jpeg_table_len > 0)
                {
                    memcpy(data, jpeg_table, jpeg_table_len - 2);
printf("%02x %02x %02x %02x\n", data[total_len], data[total_len + 1], data[total_len + 2], data[total_len + 3]);
                }
                /*endif*/
                totdata = meta->image_width*3000*meta->samples_per_pixel;
                data2 = realloc(data2, totdata);
                off = total_len;
                if (!t42_itulab_jpeg_to_srgb(&logging2, &lab_param, data2, &off, data, off, &w, &h, &samples_per_pixel))
                {
                    printf("Failed to convert from ITULAB.\n");
                    free(image_buf);
                    return -1;
                }
                /*endif*/
            }
            /*endfor*/
            if (data2)
                free(data2);
            /*endif*/
            //exit(2);
            if (jpeg_table_len > 0)
                memcpy(data, jpeg_table, jpeg_table_len - 2);
            /*endif*/

            if (total_len != total_image_len)
                printf("Size mismatch %d %d\n", (int) total_len, (int) total_image_len);
            /*endif*/
{
int ii;

printf("YYY2 %d - ", jpeg_table_len);
for (ii = 0;  ii < 800;  ii++)
    printf(" %02x", data[ii]);
printf("\n");
}
            off = total_len;
            len = total_len;
#endif
            break;
        }
        /* Fall through */
    default:
        if (meta->tile_width > 0)
        {
            /* The image is tiled, so we need to patch together a bunch of tiles */
            switch (meta->planar_config)
            {
            case PLANARCONFIG_CONTIG:
                bytes_per_row = TIFFScanlineSize(meta->tif);
                total_data = meta->image_length*bytes_per_row;
                printf("Total decompressed data %d, %d per row\n", total_data, bytes_per_row);

                /* Read the image into memory. */
                if ((image_buf = malloc(total_data)) == NULL)
                    printf("Failed to allocated image buffer\n");
                /*endif*/

                for (y = 0;  y < meta->image_length;  y += meta->tile_length)
                {
                    for (x = 0;  x < meta->image_width;  x += meta->tile_width)
                    {
                        uint8_t data[meta->tile_width*meta->tile_length*meta->samples_per_pixel];

                        TIFFReadTile(meta->tif, data, x, y, 0, 0);
                        yyy = meta->tile_length;
                        if (y + meta->tile_length > meta->image_length)
                            yyy = meta->image_length - y;
                        /*endif*/
                        xxx = meta->tile_width;
                        if (x + meta->tile_width > meta->image_width)
                            xxx = meta->image_width - x;
                        /*endif*/
                        for (yy = 0;  yy < yyy;  yy++)
                        {
                            for (xx = 0;  xx < xxx;  xx++)
                            {
                                for (j = 0;  j < meta->samples_per_pixel;  j++)
                                    image_buf[meta->samples_per_pixel*((y + yy)*meta->image_width + x + xx) + j] = data[meta->samples_per_pixel*(yy*meta->tile_width + xx) + j];
                                /*endfor*/
                            }
                            /*endfor*/
                        }
                        /*endfor*/
                    }
                    /*endfor*/
                }
                /*endfor*/
                break;
            case PLANARCONFIG_SEPARATE:
                bytes_per_row = TIFFScanlineSize(meta->tif);
                total_data = meta->samples_per_pixel*meta->image_length*bytes_per_row;
                printf("Total decompressed data %d, %d per row\n", total_data, bytes_per_row);

                /* Read the image into memory. */
                if ((image_buf = malloc(total_data)) == NULL)
                    printf("Failed to allocated image buffer\n");
                /*endif*/

                for (j = 0;  j < meta->samples_per_pixel;  j++)
                {
                    for (y = 0;  y < meta->image_length;  y += meta->tile_length)
                    {
                        for (x = 0;  x < meta->image_width;  x += meta->tile_width)
                        {
                            uint8_t data[meta->tile_width*meta->tile_length*meta->samples_per_pixel];

                            TIFFReadTile(meta->tif, data, x, y, 0, j);
                            yyy = meta->tile_length;
                            if (y + meta->tile_length > meta->image_length)
                                yyy = meta->image_length - y;
                            /*endif*/
                            xxx = meta->tile_width;
                            if (x + meta->tile_width > meta->image_width)
                                xxx = meta->image_width - x;
                            /*endif*/
                            for (yy = 0;  yy < yyy;  yy++)
                            {
                                for (xx = 0;  xx < xxx;  xx++)
                                {
                                    image_buf[meta->samples_per_pixel*((y + yy)*meta->image_width + x + xx) + j] = data[yy*meta->tile_width + xx];
                                }
                                /*endfor*/
                            }
                            /*endfor*/
                        }
                        /*endfor*/
                    }
                    /*endfor*/
                }
                /*endfor*/
                break;
            }
            /*endswitch*/
        }
        else
        {
            /* There is no tiling to worry about, but we might have planar issues to resolve */
            switch (meta->planar_config)
            {
            case PLANARCONFIG_CONTIG:
                bytes_per_row = TIFFScanlineSize(meta->tif);
                total_data = meta->image_length*bytes_per_row;
                printf("Total decompressed data %d, %d per row\n", total_data, bytes_per_row);

                /* Read the image into memory. */
                if ((image_buf = malloc(total_data)) == NULL)
                    printf("Failed to allocated image buffer\n");
                /*endif*/

                for (y = 0;  y < meta->image_length;  y++)
                {
                    if (TIFFReadScanline(meta->tif, &image_buf[y*bytes_per_row], y, 0) < 0)
                    {
                        free(image_buf);
                        return -1;
                    }
                    /*endif*/
                }
                /*endfor*/
                break;
            case PLANARCONFIG_SEPARATE:
                bytes_per_row = TIFFScanlineSize(meta->tif);
                total_data = meta->samples_per_pixel*meta->image_length*bytes_per_row;
                printf("Total decompressed data %d, %d per row\n", total_data, bytes_per_row);

                /* Read the image into memory. */
                if ((image_buf = malloc(total_data)) == NULL)
                    printf("Failed to allocated image buffer\n");
                /*endif*/

                for (j = 0;  j < meta->samples_per_pixel;  j++)
                {
                    uint8_t data[bytes_per_row];

                    for (y = 0;  y < meta->image_length;  y++)
                    {
                        if (TIFFReadScanline(meta->tif, data, y, j) < 0)
                        {
                            free(image_buf);
                            return -1;
                        }
                        /*endif*/
                        for (x = 0;  x < meta->image_width;  x++)
                            image_buf[meta->samples_per_pixel*(y*bytes_per_row + x) + j] = data[x];
                        /*endfor*/
                    }
                    /*endfor*/
                }
                /*endfor*/
                break;
            }
            /*endswitch*/
        }
        /*endif*/
        break;
    }
    /* Normalise bi-level images, so they are always in PHOTOMETRIC_MINISWHITE form */
    if (image_buf  &&  meta->samples_per_pixel == 1  &&  meta->bits_per_sample == 1)
    {
        if (meta->photometric != PHOTOMETRIC_MINISWHITE)
        {
            for (i = 0;  i < total_data;  i++)
                image_buf[i] = ~image_buf[i];
            /*endfor*/
            meta->photometric = PHOTOMETRIC_MINISWHITE;
        }
        /*endif*/
    }
    /*endif*/

    *buf = image_buf;
    return total_data;
}
/*- End of function --------------------------------------------------------*/

int main(int argc, char *argv[])
{
    const char *source_file;
    const char *destination_file;
    TIFF *tif;
    tstrip_t nstrips;
    uint32_t totdata;
    tsize_t off;
    uint8_t *data;
    uint8_t *data2;
    int row;
    int bytes_per_row;
    tsize_t outsize;
    char *outptr;
    int i;
    int k;
    int x;
    int y;
    uint64_t start;
    uint64_t end;
    logging_state_t logging2;
    meta_t in_meta;
    meta_t meta;
    int output_compression;
    int page_no;
#if defined(SPANDSP_SUPPORT_TIFF_FX)  &&  defined(HAVE_TIF_DIR_H)
    toff_t diroff;
#endif

    source_file = (argc > 1)  ?  argv[1]  :  IN_FILE_NAME;
    printf("Processing '%s'\n", source_file);
    destination_file = OUT_FILE_NAME;
    output_compression = (argc > 2)  ?  atoi(argv[2])  :  COMPRESSION_CCITT_T6;

#if defined(SPANDSP_SUPPORT_TIFF_FX)  &&  defined(HAVE_TIF_DIR_H)
    TIFF_FX_init();
#endif

    if ((in_meta.tif = TIFFOpen(source_file, "r")) == NULL)
    {
        printf("Unable to open '%s'!\n", source_file);
        return 1;
    }
    /*endif*/

    if ((meta.tif = TIFFOpen(destination_file, "w")) == NULL)
    {
        printf("Unable to open '%s'!\n", destination_file);
        return 1;
    }
    /*endif*/
    span_log_init(&logging2, SPAN_LOG_SHOW_SEVERITY | SPAN_LOG_SHOW_PROTOCOL | SPAN_LOG_FLOW, "lab");

    /* 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);

    outptr = NULL;
    for (page_no = 0;   ;  page_no++)
    {
        if (read_file(&in_meta, page_no) < 0)
        {
            printf("Failed to read from %s\n", source_file);
            TIFFClose(in_meta.tif);
            TIFFClose(meta.tif);
            exit(2);
        }
        /*endif*/

        tif = in_meta.tif;

        nstrips = TIFFNumberOfStrips(tif);
        if (in_meta.compression == output_compression  &&  nstrips == 1  &&  in_meta.tile_width == 0)
        {
            /* There might be no need to re-compress the image */
        }
        else
        {
            /* It looks like we need to decompress and recompress the image */
        }
        /*endif*/

        printf("Width %d, height %d, bits %d, samples %d\n", in_meta.image_width, in_meta.image_length, in_meta.bits_per_sample, in_meta.samples_per_pixel);

        totdata = read_decompressed_image(&in_meta, &data);
        off = totdata;

        bytes_per_row = TIFFScanlineSize(tif);

        printf("bits_per_sample %d, samples_per_pixel %d, w %d, h %d\n", in_meta.bits_per_sample, in_meta.samples_per_pixel, in_meta.image_width, in_meta.image_length);


        printf("total %d, off %d\n", totdata, (int) off);

        switch (in_meta.samples_per_pixel)
        {
        case 1:
            if (in_meta.bits_per_sample == 1)
            {
                printf("Bi-level\n");

                /* We have finished acquiring the image. Now we need to push it out */
                meta.pre_compressed = false;
                meta.image_width = in_meta.image_width;
                meta.image_length = in_meta.image_length;
                meta.x_resolution = in_meta.x_resolution;
                meta.y_resolution = in_meta.y_resolution;
                meta.resolution_unit = in_meta.resolution_unit;
                meta.bits_per_sample = in_meta.bits_per_sample;
                meta.samples_per_pixel = in_meta.samples_per_pixel;
                meta.compression = COMPRESSION_CCITT_T6;
                meta.photometric = PHOTOMETRIC_MINISWHITE;

                write_file(&meta, page_no, data);
            }
            else
            {
                printf("Gray scale, %d bits\n", in_meta.bits_per_sample);
                if (in_meta.bits_per_sample == 8)
                {
                    /* Nothing needs to be done */
                }
                else if (in_meta.bits_per_sample == 16)
                {
                    if ((outptr = malloc(in_meta.image_width*in_meta.image_length)) == NULL)
                        printf("Failed to allocate buffer\n");
                    /*endif*/
                    for (i = 0;  i < in_meta.image_width*in_meta.image_length;  i++)
                        outptr[i] = data[2*i];
                    /*endfor*/
                    free(data);
                    data = (uint8_t *) outptr;
                }
                else
                {
                    uint32_t bitstream;
                    int bits;
                    int j;

                    /* Deal with the messy cases where the number of bits is not a whole
                       number of bytes. */                
                    if ((outptr = malloc(in_meta.image_width*in_meta.image_length)) == NULL)
                        printf("Failed to allocate buffer\n");
                    /*endif*/
                    bitstream = 0;
                    bits = 0;
                    j = 0;
                    for (i = 0;  i < in_meta.image_width*in_meta.image_length;  i++)
                    {
                        while (bits < in_meta.bits_per_sample)
                        {
                            bitstream = (bitstream << 8) | data[j++];
                            bits += 8;
                        }
                        /*endwhile*/
                        outptr[i] = bitstream >> (bits - 8);
                        bits -= in_meta.bits_per_sample;
                    }
                    /*endfor*/
                    free(data);
                    data = (uint8_t *) outptr;
                }
                /*endif*/
                off = in_meta.samples_per_pixel*in_meta.image_width*in_meta.image_length;

                /* We have finished acquiring the image. Now we need to push it out */
                meta.pre_compressed = false;
                meta.image_width = in_meta.image_width;
                meta.image_length = in_meta.image_length;
                meta.x_resolution = in_meta.x_resolution;
                meta.y_resolution = in_meta.y_resolution;
                meta.resolution_unit = in_meta.resolution_unit;
                meta.bits_per_sample = 8;
                meta.samples_per_pixel = in_meta.samples_per_pixel;
                meta.compression = COMPRESSION_JPEG;
                meta.photometric = PHOTOMETRIC_MINISBLACK;

                write_file(&meta, page_no, data);
            }
            /*endif*/
            break;
        case 3:
            printf("Photometric is %d\n", in_meta.photometric);

            /* We now have the image in memory in RGB form */

            if (in_meta.photometric == PHOTOMETRIC_ITULAB)
            {
                printf("ITU Lab\n");
                /* We are already in the ITULAB color space */
                if ((outptr = malloc(totdata)) == NULL)
                    printf("Failed to allocate buffer\n");
                /*endif*/
                lab_to_srgb(&lab_param, (tdata_t) outptr, data, totdata/3);
                free(data);
                data = (uint8_t *) outptr;

                meta.pre_compressed = false;
                meta.image_width = in_meta.image_width;
                meta.image_length = in_meta.image_length;
                meta.x_resolution = in_meta.x_resolution;
                meta.y_resolution = in_meta.y_resolution;
                meta.resolution_unit = in_meta.resolution_unit;
                meta.bits_per_sample = 8;
                meta.samples_per_pixel = in_meta.samples_per_pixel;
                meta.compression = COMPRESSION_JPEG;
                meta.photometric = PHOTOMETRIC_RGB;
            }
            else
            {
#if 1
                start = rdtscll();
                switch (in_meta.photometric)
                {
                case PHOTOMETRIC_CIELAB:
                    printf("CIELAB\n");
                    /* Convert this to sRGB first */
                    /* 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, in_meta.image_width*in_meta.image_length);
                    break;
                case PHOTOMETRIC_RGB:
                    printf("RGB\n");
                    if (in_meta.bits_per_sample == 8)
                    {
                    }
                    else if (in_meta.bits_per_sample == 16)
                    {
                        printf("Pack %d to %d\n", totdata, in_meta.samples_per_pixel*in_meta.image_width*in_meta.image_length);
                        if ((outptr = malloc(in_meta.samples_per_pixel*in_meta.image_width*in_meta.image_length)) == NULL)
                            printf("Failed to allocate buffer\n");
                        /*endif*/
                        for (i = 0;  i < in_meta.image_width*in_meta.image_length;  i++)
                        {
                            outptr[in_meta.samples_per_pixel*i + 0] = (data[in_meta.samples_per_pixel*2*i + 1] << 4) | (data[in_meta.samples_per_pixel*2*i + 0] >> 4);
                            outptr[in_meta.samples_per_pixel*i + 1] = (data[in_meta.samples_per_pixel*2*i + 3] << 4) | (data[in_meta.samples_per_pixel*2*i + 2] >> 4);
                            outptr[in_meta.samples_per_pixel*i + 2] = (data[in_meta.samples_per_pixel*2*i + 5] << 4) | (data[in_meta.samples_per_pixel*2*i + 4] >> 4);
                        }
                        /*endfor*/
                        free(data);
                        data = (uint8_t *) outptr;
                        off = in_meta.samples_per_pixel*in_meta.image_width*in_meta.image_length;
                        in_meta.bits_per_sample = 8;
                    }
                    else
                    {
                        uint32_t bitstream;
                        int bits;
                        int j;

                        /* Deal with the messy cases where the number of bits is not a whole number of bytes. */                
                        printf("Pack %d to %d\n", totdata, in_meta.samples_per_pixel*in_meta.image_width*in_meta.image_length);
                        if ((outptr = malloc(in_meta.samples_per_pixel*in_meta.image_width*in_meta.image_length)) == NULL)
                            printf("Failed to allocate buffer\n");
                        /*endif*/
                        bitstream = 0;
                        bits = 0;
                        j = 0;
                        for (i = 0;  i < in_meta.image_width*in_meta.image_length;  i++)
                        {
                            for (k = 0;  k < in_meta.samples_per_pixel;  k++)
                            {
                                while (bits < in_meta.bits_per_sample)
                                {
                                    bitstream = (bitstream << 8) | data[j++];
                                    bits += 8;
                                }
                                /*endwhile*/
                                outptr[in_meta.samples_per_pixel*i + k] = bitstream >> (bits - 8);
                                bits -= in_meta.bits_per_sample;
                            }
                            /*endfor*/
                        }
                        /*endfor*/
                        free(data);
                        data = (uint8_t *) outptr;
                        off = in_meta.samples_per_pixel*in_meta.image_width*in_meta.image_length;
                        in_meta.bits_per_sample = 8;
                    }
                    /*endif*/
                    break;
                }
                /*endswitch*/
#if 0
                /* 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 (!t42_srgb_to_itulab_jpeg(&logging2, &lab_param, (tdata_t) &outptr, &outsize, data, off, in_meta.image_width, in_meta.image_length, 3))
                {
                    printf("Failed to convert to ITULAB (B).\n");
                    return 1;
                }
                /*endif*/
                end = rdtscll();
                printf("Duration %" PRIu64 "\n", end - start);
                free(data);
                data = (uint8_t *) outptr;
                off = outsize;
#endif
#endif
                meta.pre_compressed = false;
                meta.image_width = in_meta.image_width;
                meta.image_length = in_meta.image_length;
                meta.x_resolution = in_meta.x_resolution;
                meta.y_resolution = in_meta.y_resolution;
                meta.resolution_unit = in_meta.resolution_unit;
                meta.bits_per_sample = 8;
                meta.samples_per_pixel = in_meta.samples_per_pixel;
                meta.compression = COMPRESSION_JPEG;
                meta.photometric = PHOTOMETRIC_RGB;
            }
            /*endif*/
            write_file(&meta, page_no, data);
            break;
        case 4:
            printf("Photometric is %d\n", in_meta.photometric);

            /* We now have the image in memory in RGB form */

            if (in_meta.photometric == PHOTOMETRIC_ITULAB)
            {
                /* We are already in the ITULAB color space */
#if 0
                if (!t42_itulab_to_itulab(&logging2, (tdata_t) &outptr, &outsize, data, off, in_meta.image_width, in_meta.image_length, 3))
                {
                    printf("Failed to convert to ITULAB (C).\n");
                    return 1;
                }
                /*endif*/
#else
                outsize = 0;
#endif
                free(data);
                data = (uint8_t *) outptr;
                off = outsize;
            }
            else
            {
                start = rdtscll();
                switch (in_meta.photometric)
                {
                case PHOTOMETRIC_CIELAB:
                    printf("CIELAB\n");
                    /* TODO: This doesn't work yet */
                    /* Convert this to sRGB first */
                    /* 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, in_meta.image_width*in_meta.image_length);
                    break;
                case PHOTOMETRIC_SEPARATED:
                    for (y = 0;  y < in_meta.image_length;  y++)
                    {
                        for (x = 0;  x < in_meta.image_width;  x++)
                        {
                            k = data[(y*in_meta.image_width + x)*4 + 0] + data[(y*in_meta.image_width + x)*4 + 3];
                            if (k > 255)
                                k = 255;
                            /*endif*/
                            data[(y*in_meta.image_width + x)*3 + 0] = 255 - k;
                            k = data[(y*in_meta.image_width + x)*4 + 1] + data[(y*in_meta.image_width + x)*4 + 3];
                            if (k > 255)
                                k = 255;
                            /*endif*/
                            data[(y*in_meta.image_width + x)*3 + 1] = 255 - k;
                            k = data[(y*in_meta.image_width + x)*4 + 2] + data[(y*in_meta.image_width + x)*4 + 3];
                            if (k > 255)
                                k = 255;
                            /*endif*/
                            data[(y*in_meta.image_width + x)*3 + 2] = 255 - k;
                        }
                        /*endfor*/
                    }
                    /*endfor*/
                    off = 3*in_meta.image_width*in_meta.image_length;
                    in_meta.bits_per_sample = 8;
                    break;
                }
                /*endswitch*/

                /* 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 (!t42_srgb_to_itulab_jpeg(&logging2, &lab_param, (tdata_t) &outptr, &outsize, data, off, in_meta.image_width, in_meta.image_length, 3))
                {
                    printf("Failed to convert to ITULAB (D).\n");
                    return 1;
                }
                /*endif*/
                end = rdtscll();
                printf("Duration %" PRIu64 "\n", end - start);
                off = outsize;
                in_meta.bits_per_sample = 8;
            }
            /*endif*/
            meta.pre_compressed = false;
            meta.image_width = in_meta.image_width;
            meta.image_length = in_meta.image_length;
            meta.x_resolution = in_meta.x_resolution;
            meta.y_resolution = in_meta.y_resolution;
            meta.resolution_unit = in_meta.resolution_unit;
            meta.bits_per_sample = 8;
            meta.samples_per_pixel = 3;
            meta.compression = COMPRESSION_JPEG;
            meta.photometric = PHOTOMETRIC_RGB;

            write_file(&meta, page_no, data);
            break;
        }
        /*endswitch*/
    }
    /*endfor*/

    printf("XXX - image is %d by %d, %d bytes\n", in_meta.image_width, in_meta.image_length, (int) off);

    /* We now have the image in memory in ITULAB form */

    meta.pre_compressed = false;
    meta.compressed_image_len = off;
    meta.image_width = in_meta.image_width;
    meta.image_length = in_meta.image_length;
    meta.x_resolution = in_meta.x_resolution;
    meta.y_resolution = in_meta.y_resolution;
    meta.resolution_unit = in_meta.resolution_unit;
    meta.bits_per_sample = 8;
    meta.samples_per_pixel = 3;
    meta.compression = COMPRESSION_JPEG;
#if 1
    meta.photometric = PHOTOMETRIC_RGB;
#elif 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 PHOTOMETRIC_ITULAB is not available the admin cannot enable color fax anyway.
       This is done so that older libtiffs without it can build fine. */
    meta.photometric = PHOTOMETRIC_ITULAB;
#else
    meta.photometric = PHOTOMETRIC_YCBCR;
#endif
    meta.YCbCrSubsampleHoriz = in_meta.YCbCrSubsampleHoriz;
    meta.YCbCrSubsampleVert = in_meta.YCbCrSubsampleVert;

    if ((tif = TIFFOpen(destination_file, "w")) == NULL)
    {
        printf("Unable to open '%s'!\n", destination_file);
        return 1;
    }
    /*endif*/
    TIFFSetField(tif, TIFFTAG_SUBFILETYPE, FILETYPE_PAGE);
    TIFFSetField(tif, TIFFTAG_IMAGEWIDTH, meta.image_width);
    /* libtiff requires IMAGELENGTH to be set before SAMPLESPERPIXEL,
       or StripOffsets and StripByteCounts will have SAMPLESPERPIXEL values */
    TIFFSetField(tif, TIFFTAG_IMAGELENGTH, meta.image_length);
    TIFFSetField(tif, TIFFTAG_COMPRESSION, meta.compression);
    TIFFSetField(tif, TIFFTAG_BITSPERSAMPLE, meta.bits_per_sample);
    TIFFSetField(tif, TIFFTAG_SAMPLESPERPIXEL, meta.samples_per_pixel);
    TIFFSetField(tif, TIFFTAG_PLANARCONFIG, PLANARCONFIG_CONTIG);
    TIFFSetField(tif, TIFFTAG_ORIENTATION, ORIENTATION_TOPLEFT);
    TIFFSetField(tif, TIFFTAG_ROWSPERSTRIP, meta.image_length);
    TIFFSetField(tif, TIFFTAG_XRESOLUTION, meta.x_resolution);
    TIFFSetField(tif, TIFFTAG_YRESOLUTION, meta.y_resolution);
    TIFFSetField(tif, TIFFTAG_RESOLUTIONUNIT, meta.resolution_unit);
    TIFFSetField(tif, TIFFTAG_PHOTOMETRIC, meta.photometric);
    if (meta.samples_per_pixel > 1  &&  (meta.YCbCrSubsampleHoriz  ||  meta.YCbCrSubsampleVert))
        TIFFSetField(tif, TIFFTAG_YCBCRSUBSAMPLING, meta.YCbCrSubsampleHoriz, meta.YCbCrSubsampleVert);
    TIFFSetField(tif, TIFFTAG_SOFTWARE, "spandsp");
    TIFFSetField(tif, TIFFTAG_IMAGEDESCRIPTION, "Test");
    TIFFSetField(tif, TIFFTAG_DATETIME, "2011/02/03 12:30:45");
    TIFFSetField(tif, TIFFTAG_MAKE, "soft-switch.org");
    TIFFSetField(tif, TIFFTAG_MODEL, "spandsp");
    TIFFSetField(tif, TIFFTAG_HOSTCOMPUTER, "i7.coppice.org");
#if defined(SPANDSP_SUPPORT_TIFF_FX)  &&  defined(HAVE_TIF_DIR_H)
    /* Make space for this to be filled in later */
    TIFFSetField(tif, TIFFTAG_GLOBALPARAMETERSIFD, 0);
#endif

    if (meta.pre_compressed)
    {
        if (TIFFWriteRawStrip(tif, 0, (tdata_t) data, meta.compressed_image_len) == -1)
        {
            printf("Write error to TIFF file\n");
            return 1;
        }
        /*endif*/
        free(data);
    }
    else
    {
        if (in_meta.samples_per_pixel > 1)
        {
            bytes_per_row = ((meta.bits_per_sample + 7)/8)*meta.image_width*meta.samples_per_pixel;
            totdata = meta.image_length*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;
            if (!t42_itulab_to_JPEG(&logging2, &lab_param, (void **) &data2, &totdata, data, off))
            {
                printf("Failed to convert from ITULAB (A).\n");
                return 1;
            }
            /*endif*/
            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 (B).\n");
                return 1;
            }
            /*endif*/
            free(data);
            data = data2;
#elif 1
            if ((data2 = malloc(totdata)) == NULL)
            {
                printf("Failed to allocate buffer\n");
                exit(2);
            }
            /*endif*/
            start = rdtscll();
            //if (!t42_itulab_jpeg_to_srgb(&logging2, &lab_param, data2, &off, data, off, &meta.image_width, &meta.image_length, &meta.samples_per_pixel))
            {
                printf("Failed to convert from ITULAB.\n");
                return 1;
            }
            end = rdtscll();
            printf("Duration %" PRIu64 "\n", end - start);
            free(data);
            data = data2;
#endif
        }
        /*endif*/
        off = 0;
        bytes_per_row = ((meta.bits_per_sample + 7)/8)*meta.image_width*meta.samples_per_pixel;
        for (row = 0;  row < meta.image_length;  row++)
        {
            if (TIFFWriteScanline(tif, &data[off], row, 0) < 0)
                return 1;
            /*endif*/
            off += bytes_per_row;
        }
        /*endfor*/
        free(data);
    }
    /*endif*/

    if (!TIFFWriteDirectory(tif))
        printf("Failed to write directory.\n");
    /*endif*/

#if defined(SPANDSP_SUPPORT_TIFF_FX)  &&  defined(HAVE_TIF_DIR_H)
    if (!TIFFCreateCustomDirectory(tif, &tiff_fx_field_array))
    {
        TIFFSetField(tif, TIFFTAG_PROFILETYPE, PROFILETYPE_G3_FAX);
        TIFFSetField(tif, TIFFTAG_FAXPROFILE, FAXPROFILE_F);
        TIFFSetField(tif, TIFFTAG_CODINGMETHODS, CODINGMETHODS_T4_1D | CODINGMETHODS_T4_2D | CODINGMETHODS_T6);
        TIFFSetField(tif, TIFFTAG_VERSIONYEAR, "1998");
        TIFFSetField(tif, TIFFTAG_MODENUMBER, 3);

        diroff = 0;
        if (!TIFFWriteCustomDirectory(tif, &diroff))
            printf("Failed to write custom directory.\n");
        /*endif*/

        if (!TIFFSetDirectory(tif, (tdir_t) page_no))
            printf("Failed to set directory.\n");
        /*endif*/
        if (!TIFFSetField(tif, TIFFTAG_GLOBALPARAMETERSIFD, diroff))
            printf("Failed to set global parameters IFD.\n");
        /*endif*/
        if (!TIFFWriteDirectory(tif))
            printf("Failed to write directory.\n");
        /*endif*/
    }
    /*endif*/
#endif
    TIFFClose(tif);
    printf("Done!\n");
    return 0;
}
/*- End of function --------------------------------------------------------*/
/*- End of file ------------------------------------------------------------*/
