/*
 * Copyright (C) 2002 RealVNC Ltd.  All Rights Reserved.
 * Copyright (C) 2003 Sun Microsystems, Inc.
 *
 * This is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This software 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 software; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307,
 * USA.
 */

/*
 * Before including this file, you must define a number of CPP macros.
 *
 * BPP should be 8, 16 or 32 depending on the bits per pixel.
 * GET_IMAGE_INTO_BUF should be some code which gets a rectangle of pixel data
 * into the given buffer.  EXTRA_ARGS can be defined to pass any other
 * arguments needed by GET_IMAGE_INTO_BUF.
 *
 * Note that the buf argument to ZRLE_ENCODE needs to be at least one pixel
 * bigger than the largest tile of pixel data, since the ZRLE encoding
 * algorithm writes to the position one past the end of the pixel data.
 */

#include "zrleoutstream.h"
#include "zrlepalettehelper.h"
#include <assert.h>
#include "defines.h"

/* __RFB_CONCAT2 concatenates its two arguments.  __RFB_CONCAT2E does the same
   but also expands its arguments if they are macros */

#ifndef __RFB_CONCAT2E
#define __RFB_CONCAT2(a,b) a##b
#define __RFB_CONCAT2E(a,b) __RFB_CONCAT2(a,b)
#endif

#ifndef __RFB_CONCAT3E
#define __RFB_CONCAT3(a,b,c) a##b##c
#define __RFB_CONCAT3E(a,b,c) __RFB_CONCAT3(a,b,c)
#endif

#undef END_FIX
#if ZYWRLE_ENDIAN == ENDIAN_LITTLE
#  define END_FIX LE
#elif ZYWRLE_ENDIAN == ENDIAN_BIG
#  define END_FIX BE
#else
#  define END_FIX NE
#endif

#ifdef CPIXEL
#define PIXEL_T __RFB_CONCAT2E(zrle_U,BPP)
#define zrleOutStreamWRITE_PIXEL __RFB_CONCAT2E(zrleOutStreamWriteOpaque,CPIXEL)
#define ZRLE_ENCODE __RFB_CONCAT3E(zrleEncode,CPIXEL,END_FIX)
#define ZRLE_ENCODE_TILE __RFB_CONCAT3E(zrleEncodeTile,CPIXEL,END_FIX)
#define BPPOUT 24
#elif BPP==15
#define PIXEL_T __RFB_CONCAT2E(zrle_U,16)
#define zrleOutStreamWRITE_PIXEL __RFB_CONCAT2E(zrleOutStreamWriteOpaque,16)
#define ZRLE_ENCODE __RFB_CONCAT3E(zrleEncode,BPP,END_FIX)
#define ZRLE_ENCODE_TILE __RFB_CONCAT3E(zrleEncodeTile,BPP,END_FIX)
#define BPPOUT 16
#else
#define PIXEL_T __RFB_CONCAT2E(zrle_U,BPP)
#define zrleOutStreamWRITE_PIXEL __RFB_CONCAT2E(zrleOutStreamWriteOpaque,BPP)
#define ZRLE_ENCODE __RFB_CONCAT3E(zrleEncode,BPP,END_FIX)
#define ZRLE_ENCODE_TILE __RFB_CONCAT3E(zrleEncodeTile,BPP,END_FIX)
#define BPPOUT BPP
#endif

#ifndef ZRLE_ONCE
#define ZRLE_ONCE

static const int bitsPerPackedPixel[] =
{
    0, 1, 2, 2, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4
};

#endif /* ZRLE_ONCE */

void ZRLE_ENCODE_TILE (PIXEL_T* data, int w, int h, zrleOutStream* os,
                       int zywrle_level, int *zywrleBuf, void *paletteHelper);

#if BPP!=8
#define ZYWRLE_ENCODE
#include "zywrletemplate.c"
#endif

static void ZRLE_ENCODE (int x, int y, int w, int h,
                         zrleOutStream* os, void* buf
                         EXTRA_ARGS
                        )
{
    int ty;
    for (ty = y; ty < y+h; ty += rfbZRLETileHeight)
    {
        int tx, th = rfbZRLETileHeight;
        if (th > y+h-ty) th = y+h-ty;
        for (tx = x; tx < x+w; tx += rfbZRLETileWidth)
        {
            int tw = rfbZRLETileWidth;
            if (tw > x+w-tx) tw = x+w-tx;

            GET_IMAGE_INTO_BUF(tx,ty,tw,th,buf);

            if (cl->paletteHelper == NULL)
            {
                cl->paletteHelper = (void *) malloc(sizeof(zrlePaletteHelper));
            }

            ZRLE_ENCODE_TILE((PIXEL_T*)buf, tw, th, os,
                             cl->zywrleLevel, cl->zywrleBuf, cl->paletteHelper);
        }
    }
    zrleOutStreamFlush(os);
}


void ZRLE_ENCODE_TILE(PIXEL_T* data, int w, int h, zrleOutStream* os,
                      int zywrle_level, int *zywrleBuf,  void *paletteHelper)
{
    /* First find the palette and the number of runs */

    zrlePaletteHelper *ph;

    int runs = 0;
    int singlePixels = 0;

    rfbBool useRle;
    rfbBool usePalette;

    int estimatedBytes;
    int plainRleBytes;
    int i;

    PIXEL_T* ptr = data;
    PIXEL_T* end = ptr + h * w;
    *end = ~*(end-1); /* one past the end is different so the while loop ends */

    ph = (zrlePaletteHelper *) paletteHelper;
    zrlePaletteHelperInit(ph);

    while (ptr < end)
    {
        PIXEL_T pix = *ptr;
        if (*++ptr != pix)
        {
            singlePixels++;
        }
        else
        {
            while (*++ptr == pix) ;
            runs++;
        }
        zrlePaletteHelperInsert(ph, pix);
    }

    /* Solid tile is a special case */

    if (ph->size == 1)
    {
        zrleOutStreamWriteU8(os, 1);
        zrleOutStreamWRITE_PIXEL(os, ph->palette[0]);
        return;
    }

    /* Try to work out whether to use RLE and/or a palette.  We do this by
       estimating the number of bytes which will be generated and picking the
       method which results in the fewest bytes.  Of course this may not result
       in the fewest bytes after compression... */

    useRle = FALSE;
    usePalette = FALSE;

    estimatedBytes = w * h * (BPPOUT/8); /* start assuming raw */

#if BPP!=8
    if (zywrle_level > 0 && !(zywrle_level & 0x80))
        estimatedBytes >>= zywrle_level;
#endif

    plainRleBytes = ((BPPOUT/8)+1) * (runs + singlePixels);

    if (plainRleBytes < estimatedBytes)
    {
        useRle = TRUE;
        estimatedBytes = plainRleBytes;
    }

    if (ph->size < 128)
    {
        int paletteRleBytes = (BPPOUT/8) * ph->size + 2 * runs + singlePixels;

        if (paletteRleBytes < estimatedBytes)
        {
            useRle = TRUE;
            usePalette = TRUE;
            estimatedBytes = paletteRleBytes;
        }

        if (ph->size < 17)
        {
            int packedBytes = ((BPPOUT/8) * ph->size +
                               w * h * bitsPerPackedPixel[ph->size-1] / 8);

            if (packedBytes < estimatedBytes)
            {
                useRle = FALSE;
                usePalette = TRUE;
                estimatedBytes = packedBytes;
            }
        }
    }

    if (!usePalette) ph->size = 0;

    zrleOutStreamWriteU8(os, (useRle ? 128 : 0) | ph->size);

    for (i = 0; i < ph->size; i++)
    {
        zrleOutStreamWRITE_PIXEL(os, ph->palette[i]);
    }

    if (useRle)
    {

        PIXEL_T* ptr = data;
        PIXEL_T* end = ptr + w * h;
        PIXEL_T* runStart;
        PIXEL_T pix;
        while (ptr < end)
        {
            int len;
            runStart = ptr;
            pix = *ptr++;
            while (*ptr == pix && ptr < end)
                ptr++;
            len = ptr - runStart;
            if (len <= 2 && usePalette)
            {
                int index = zrlePaletteHelperLookup(ph, pix);
                if (len == 2)
                    zrleOutStreamWriteU8(os, index);
                zrleOutStreamWriteU8(os, index);
                continue;
            }
            if (usePalette)
            {
                int index = zrlePaletteHelperLookup(ph, pix);
                zrleOutStreamWriteU8(os, index | 128);
            }
            else
            {
                zrleOutStreamWRITE_PIXEL(os, pix);
            }
            len -= 1;
            while (len >= 255)
            {
                zrleOutStreamWriteU8(os, 255);
                len -= 255;
            }
            zrleOutStreamWriteU8(os, len);
        }

    }
    else
    {

        /* no RLE */

        if (usePalette)
        {
            int bppp;
            PIXEL_T* ptr = data;

            /* packed pixels */

            bppp = bitsPerPackedPixel[ph->size-1];

            for (i = 0; i < h; i++)
            {
                zrle_U8 nbits = 0;
                zrle_U8 byte = 0;

                PIXEL_T* eol = ptr + w;

                while (ptr < eol)
                {
                    PIXEL_T pix = *ptr++;
                    zrle_U8 index = zrlePaletteHelperLookup(ph, pix);
                    byte = (byte << bppp) | index;
                    nbits += bppp;
                    if (nbits >= 8)
                    {
                        zrleOutStreamWriteU8(os, byte);
                        nbits = 0;
                    }
                }
                if (nbits > 0)
                {
                    byte <<= 8 - nbits;
                    zrleOutStreamWriteU8(os, byte);
                }
            }
        }
        else
        {

            /* raw */

#if BPP!=8
            if (zywrle_level > 0 && !(zywrle_level & 0x80))
            {
                ZYWRLE_ANALYZE(data, data, w, h, w, zywrle_level, zywrleBuf);
                ZRLE_ENCODE_TILE(data, w, h, os, zywrle_level | 0x80, zywrleBuf, paletteHelper);
            }
            else
#endif
            {
#ifdef CPIXEL
                PIXEL_T *ptr;
                for (ptr = data; ptr < data+w*h; ptr++)
                    zrleOutStreamWRITE_PIXEL(os, *ptr);
#else
                zrleOutStreamWriteBytes(os, (zrle_U8 *)data, w*h*(BPP/8));
#endif
            }
        }
    }
}

#undef PIXEL_T
#undef zrleOutStreamWRITE_PIXEL
#undef ZRLE_ENCODE
#undef ZRLE_ENCODE_TILE
#undef ZYWRLE_ENCODE_TILE
#undef BPPOUT
