/*
 * This file is part of libbluray
 * Copyright (C) 2013  Petri Hintukainen <phintuka@users.sourceforge.net>
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 *
 * This library 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
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library. If not, see
 * <http://www.gnu.org/licenses/>.
 */

#if HAVE_CONFIG_H
#include "config.h"
#endif

#include "rle.h"

#include "util/logging.h"

/*
 * util
 */

static int _rle_ensure_size(RLE_ENC *p)
{
    if (BD_UNLIKELY(!p->free_elem)) {
        BD_PG_RLE_ELEM *start = rle_get(p);
        if (p->error) {
            return -1;
        }
        /* realloc to 2x */
        void *tmp = refcnt_realloc(start, p->num_elem * 2 * sizeof(BD_PG_RLE_ELEM), NULL);
        if (!tmp) {
            p->error = 1;
            return -1;
        }
        start = tmp;
        p->elem = start + p->num_elem;
        p->free_elem = p->num_elem;
        p->num_elem *= 2;
    }

    return 0;
}

/*
 * crop encoded image
 */

static int _enc_elem(RLE_ENC *p, uint16_t color, uint16_t len)
{
    if (BD_UNLIKELY(_rle_ensure_size(p) < 0)) {
        return -1;
    }

    p->elem->color = color;
    p->elem->len = len;

    p->free_elem--;
    p->elem++;

    return 0;
}

static int _enc_eol(RLE_ENC *p)
{
    return _enc_elem(p, 0, 0);
}

BD_PG_RLE_ELEM *rle_crop_object(const BD_PG_RLE_ELEM *orig, int width,
                                int crop_x, int crop_y, int crop_w, int crop_h)
{
    RLE_ENC  rle;
    int      x0 = crop_x;
    int      x1 = crop_x + crop_w; /* first pixel outside of cropped region */
    int      x, y;

    if (rle_begin(&rle) < 0) {
        return NULL;
    }

    /* skip crop_y */
    for (y = 0; y < crop_y; y++) {
        for (x = 0; x < width; x += orig->len, orig++) ;
    }

    /* crop lines */

    for (y = 0; y < crop_h; y++) {
        for (x = 0; x < width; ) {
          BD_PG_RLE_ELEM bite = *(orig++);

            if (BD_UNLIKELY(bite.len < 1)) {
                BD_DEBUG(DBG_GC | DBG_CRIT, "rle eol marker in middle of line (x=%d/%d)\n", x, width);
                continue;
            }

            /* starts outside, ends outside */
            if (x + bite.len < x0 || x >= x1) {
                x += bite.len;
                continue;
            }

            /* starts before ? */
            if (BD_UNLIKELY(x < x0)) {
                bite.len -= x0 - x;
                x = x0;
            }

            x += bite.len;

            /* ends after ? */
            if (BD_UNLIKELY(x >= x1)) {
                bite.len -= x - x1;
            }

            if (BD_UNLIKELY(_enc_elem(&rle, bite.color, bite.len) < 0)) {
                goto out;
            }
        }

        if (BD_LIKELY(!orig->len)) {
            /* skip eol marker */
            orig++;
        } else {
            BD_DEBUG(DBG_GC | DBG_CRIT, "rle eol marker missing\n");
        }

        if (BD_UNLIKELY(_enc_eol(&rle) < 0)) {
            goto out;
        }
    }

 out:
    return rle_get(&rle);
}

/*
 * compression
 */

static int _rle_grow(RLE_ENC *p)
{
    p->free_elem--;
    p->elem++;

    if (BD_UNLIKELY(_rle_ensure_size(p) < 0)) {
        return -1;
    }

    p->elem->len = 0;

    return 0;
}

int rle_add_eol(RLE_ENC *p)
{
    if (BD_LIKELY(p->elem->len)) {
        if (BD_UNLIKELY(_rle_grow(p) < 0)) {
            return -1;
        }
    }
    p->elem->color = 0;

    if (BD_UNLIKELY(_rle_grow(p) < 0)) {
        return -1;
    }
    p->elem->color = 0xffff;

    return 0;
}

int rle_add_bite(RLE_ENC *p, uint8_t color, int len)
{
    if (BD_LIKELY(color == p->elem->color)) {
        p->elem->len += len;
    } else {
        if (BD_LIKELY(p->elem->len)) {
            if (BD_UNLIKELY(_rle_grow(p) < 0)) {
                return -1;
            }
        }
        p->elem->color = color;
        p->elem->len = len;
    }

    return 0;
}

int rle_compress_chunk(RLE_ENC *p, const uint8_t *mem, unsigned width)
{
    unsigned ii;
    for (ii = 0; ii < width; ii++) {
        if (BD_UNLIKELY(rle_add_bite(p, mem[ii], 1) < 0)) {
              return -1;
        }
    }
    return 0;
}
