/*====================================================================*
 -  Copyright (C) 2001 Leptonica.  All rights reserved.
 -
 -  Redistribution and use in source and binary forms, with or without
 -  modification, are permitted provided that the following conditions
 -  are met:
 -  1. Redistributions of source code must retain the above copyright
 -     notice, this list of conditions and the following disclaimer.
 -  2. Redistributions in binary form must reproduce the above
 -     copyright notice, this list of conditions and the following
 -     disclaimer in the documentation and/or other materials
 -     provided with the distribution.
 -
 -  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 -  ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 -  LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
 -  A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL ANY
 -  CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 -  EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 -  PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
 -  PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
 -  OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
 -  NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
 -  SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 *====================================================================*/


/*!
 * \file  zlibmem.c
 * <pre>
 *
 *      zlib operations in memory, using bbuffer
 *          l_uint8   *zlibCompress()
 *          l_uint8   *zlibUncompress()
 *
 *
 *    This provides an example use of the byte buffer utility
 *    (see bbuffer.c for details of how the bbuffer works internally).
 *    We use zlib to compress and decompress a byte array from
 *    one memory buffer to another.  The standard method uses streams,
 *    but here we use the bbuffer as an expandable queue of pixels
 *    for both the reading and writing sides of each operation.
 *
 *    With memory mapping, one should be able to compress between
 *    memory buffers by using the file system to buffer everything in
 *    the background, but the bbuffer implementation is more portable.
 * </pre>
 */

#ifdef HAVE_CONFIG_H
#include <config_auto.h>
#endif  /* HAVE_CONFIG_H */

#include "allheaders.h"

/* --------------------------------------------*/
#if  HAVE_LIBZ   /* defined in environ.h */
/* --------------------------------------------*/

#include "zlib.h"

static const l_int32  L_BUF_SIZE = 32768;
static const l_int32  ZLIB_COMPRESSION_LEVEL = 6;

#ifndef  NO_CONSOLE_IO
#define  DEBUG     0
#endif  /* ~NO_CONSOLE_IO */


/*!
 * \brief   zlibCompress()
 *
 * \param[in]    datain    byte buffer with input data
 * \param[in]    nin       number of bytes of input data
 * \param[out]   pnout     number of bytes of output data
 * \return  dataout compressed data, or NULL on error
 *
 * <pre>
 * Notes:
 *      (1) We repeatedly read in and fill up an input buffer,
 *          compress the data, and read it back out.  zlib
 *          uses two byte buffers internally in the z_stream
 *          data structure.  We use the bbuffers to feed data
 *          into the fixed bufferin, and feed it out of bufferout,
 *          in the same way that a pair of streams would normally
 *          be used if the data were being read from one file
 *          and written to another.  This is done iteratively,
 *          compressing L_BUF_SIZE bytes of input data at a time.
 * </pre>
 */
l_uint8 *
zlibCompress(const l_uint8  *datain,
             size_t          nin,
             size_t         *pnout)
{
l_uint8    *dataout;
l_int32     status, success;
l_int32     flush;
size_t      nbytes;
l_uint8    *bufferin, *bufferout;
L_BBUFFER  *bbin, *bbout;
z_stream    z;

    if (!datain)
        return (l_uint8 *)ERROR_PTR("datain not defined", __func__, NULL);

        /* Set up fixed size buffers used in z_stream */
    bufferin = (l_uint8 *)LEPT_CALLOC(L_BUF_SIZE, sizeof(l_uint8));
    bufferout = (l_uint8 *)LEPT_CALLOC(L_BUF_SIZE, sizeof(l_uint8));

        /* Set up bbuffers and load bbin with the data */
    bbin = bbufferCreate(datain, nin);
    bbout = bbufferCreate(NULL, 0);

    success = TRUE;
    if (!bufferin || !bufferout || !bbin || !bbout) {
        L_ERROR("calloc fail for buffer\n", __func__);
        success = FALSE;
        goto cleanup_arrays;
    }

    z.zalloc = (alloc_func)0;
    z.zfree = (free_func)0;
    z.opaque = (voidpf)0;
    z.next_in = bufferin;
    z.avail_in = 0;
    z.next_out = bufferout;
    z.avail_out = L_BUF_SIZE;

    status = deflateInit(&z, ZLIB_COMPRESSION_LEVEL);
    if (status != Z_OK) {
        L_ERROR("deflateInit failed\n", __func__);
        success = FALSE;
        goto cleanup_arrays;
    }

    do {
        if (z.avail_in == 0) {
            z.next_in = bufferin;
            bbufferWrite(bbin, bufferin, L_BUF_SIZE, &nbytes);
#if DEBUG
            lept_stderr(" wrote %zu bytes to bufferin\n", nbytes);
#endif  /* DEBUG */
            z.avail_in = nbytes;
        }
        flush = (bbin->n) ? Z_SYNC_FLUSH : Z_FINISH;
        status = deflate(&z, flush);
#if DEBUG
        lept_stderr(" status is %d, bytesleft = %u, totalout = %zu\n",
                  status, z.avail_out, z.total_out);
#endif  /* DEBUG */
        nbytes = L_BUF_SIZE - z.avail_out;
        if (nbytes) {
            bbufferRead(bbout, bufferout, nbytes);
#if DEBUG
            lept_stderr(" read %zu bytes from bufferout\n", nbytes);
#endif  /* DEBUG */
        }
        z.next_out = bufferout;
        z.avail_out = L_BUF_SIZE;
    } while (flush != Z_FINISH);

    deflateEnd(&z);

cleanup_arrays:
    if (success) {
        dataout = bbufferDestroyAndSaveData(&bbout, pnout);
    } else {
        dataout = NULL;
        bbufferDestroy(&bbout);
    }
    bbufferDestroy(&bbin);
    LEPT_FREE(bufferin);
    LEPT_FREE(bufferout);
    return dataout;
}


/*!
 * \brief   zlibUncompress()
 *
 * \param[in]    datain    byte buffer with compressed input data
 * \param[in]    nin       number of bytes of input data
 * \param[out]   pnout     number of bytes of output data
 * \return  dataout uncompressed data, or NULL on error
 *
 * <pre>
 * Notes:
 *      (1) See zlibCompress().
 * </pre>
 */
l_uint8 *
zlibUncompress(const l_uint8  *datain,
               size_t          nin,
               size_t         *pnout)
{
l_uint8    *dataout;
l_uint8    *bufferin, *bufferout;
l_int32     status, success;
size_t      nbytes;
L_BBUFFER  *bbin, *bbout;
z_stream    z;

    if (!datain)
        return (l_uint8 *)ERROR_PTR("datain not defined", __func__, NULL);

        /* Set up fixed size buffers used in z_stream */
    bufferin = (l_uint8 *)LEPT_CALLOC(L_BUF_SIZE, sizeof(l_uint8));
    bufferout = (l_uint8 *)LEPT_CALLOC(L_BUF_SIZE, sizeof(l_uint8));

        /* Set up bbuffers and load bbin with the data */
    bbin = bbufferCreate(datain, nin);
    bbout = bbufferCreate(NULL, 0);

    success = TRUE;
    if (!bufferin || !bufferout || !bbin || !bbout) {
        L_ERROR("calloc fail for buffer\n", __func__);
        success = FALSE;
        goto cleanup_arrays;
    }

    z.zalloc = (alloc_func)0;
    z.zfree = (free_func)0;
    z.next_in = bufferin;
    z.avail_in = 0;
    z.next_out = bufferout;
    z.avail_out = L_BUF_SIZE;

    status = inflateInit(&z);
    if (status != Z_OK) {
        L_ERROR("inflateInit fail for buffer\n", __func__);
        success = FALSE;
        goto cleanup_arrays;
    }

    for ( ; ; ) {
        if (z.avail_in == 0) {
            z.next_in = bufferin;
            bbufferWrite(bbin, bufferin, L_BUF_SIZE, &nbytes);
#if DEBUG
            lept_stderr(" wrote %d bytes to bufferin\n", nbytes);
#endif  /* DEBUG */
            z.avail_in = nbytes;
        }
        if (z.avail_in == 0)
            break;
        status = inflate(&z, Z_SYNC_FLUSH);
#if DEBUG
        lept_stderr(" status is %d, bytesleft = %d, totalout = %d\n",
                status, z.avail_out, z.total_out);
#endif  /* DEBUG */
        nbytes = L_BUF_SIZE - z.avail_out;
        if (nbytes) {
            bbufferRead(bbout, bufferout, nbytes);
#if DEBUG
            lept_stderr(" read %d bytes from bufferout\n", nbytes);
#endif  /* DEBUG */
        }
        z.next_out = bufferout;
        z.avail_out = L_BUF_SIZE;
    }

    inflateEnd(&z);

cleanup_arrays:
    if (success) {
        dataout = bbufferDestroyAndSaveData(&bbout, pnout);
    } else {
        dataout = NULL;
        bbufferDestroy(&bbout);
    }
    bbufferDestroy(&bbin);
    LEPT_FREE(bufferin);
    LEPT_FREE(bufferout);
    return dataout;
}

/* --------------------------------------------*/
#endif  /* HAVE_LIBZ */
/* --------------------------------------------*/