Subversion Repositories Games.Descent

/*

 * Portions of this file are copyright Rebirth contributors and licensed as

 * described in COPYING.txt.

 * Portions of this file are copyright Parallax Software and licensed

 * according to the Parallax license below.

 * See COPYING.txt for license details.

THE COMPUTER CODE CONTAINED HEREIN IS THE SOLE PROPERTY OF PARALLAX

SOFTWARE CORPORATION ("PARALLAX").  PARALLAX, IN DISTRIBUTING THE CODE TO

END-USERS, AND SUBJECT TO ALL OF THE TERMS AND CONDITIONS HEREIN, GRANTS A

ROYALTY-FREE, PERPETUAL LICENSE TO SUCH END-USERS FOR USE BY SUCH END-USERS

IN USING, DISPLAYING,  AND CREATING DERIVATIVE WORKS THEREOF, SO LONG AS

SUCH USE, DISPLAY OR CREATION IS FOR NON-COMMERCIAL, ROYALTY OR REVENUE

FREE PURPOSES.  IN NO EVENT SHALL THE END-USER USE THE COMPUTER CODE

CONTAINED HEREIN FOR REVENUE-BEARING PURPOSES.  THE END-USER UNDERSTANDS

AND AGREES TO THE TERMS HEREIN AND ACCEPTS THE SAME BY USE OF THIS FILE.

COPYRIGHT 1993-1998 PARALLAX SOFTWARE CORPORATION.  ALL RIGHTS RESERVED.

*/

/*

 *

 * Protypes for rle functions.

 *

 */

#pragma once

#include "pstypes.h"

#include "gr.h"

#include <cstdint>

#include "dxxsconf.h"

#include "dsx-ns.h"

#include "compiler-poison.h"

#include <iterator>

struct rle_position_t

{

        const uint8_t *src;

        uint8_t *dst;

};

static inline const uint8_t *end(const grs_bitmap &b)

{

        return &b.bm_data[b.bm_h * b.bm_w];

}

static inline uint8_t *end(grs_bitmap &b)

{

        return &b.get_bitmap_data()[b.bm_h * b.bm_w];

}

template <typename T1, typename T2>

static inline rle_position_t rle_end(const T1 &src, T2 &dst)

{

        return {end(src), end(dst)};

}

namespace dcx {

uint8_t *gr_rle_decode(const uint8_t *sb, uint8_t *db, rle_position_t e);

int gr_bitmap_rle_compress(grs_bitmap &bmp);

#if !DXX_USE_OGL

void gr_rle_expand_scanline_masked(uint8_t *dest, const uint8_t *src, int x1, int x2);

#endif

void gr_rle_expand_scanline(uint8_t *dest, const uint8_t *src, int x1, int x2);

grs_bitmap *_rle_expand_texture(const grs_bitmap &bmp);

static inline const grs_bitmap *rle_expand_texture(const grs_bitmap &bmp) __attribute_warn_unused_result;

static inline const grs_bitmap *rle_expand_texture(const grs_bitmap &bmp)

{

        if (bmp.get_flag_mask(BM_FLAG_RLE))

                return _rle_expand_texture(bmp);

        return &bmp;

}

void rle_cache_close();

void rle_cache_flush();

void rle_swap_0_255(grs_bitmap &bmp);

void rle_remap(grs_bitmap &bmp, std::array<color_palette_index, 256> &colormap);

#if !DXX_USE_OGL

#define gr_rle_expand_scanline_generic(C,D,DX,DY,S,X1,X2) gr_rle_expand_scanline_generic(D,DX,DY,S,X1,X2)

void gr_rle_expand_scanline_generic(grs_canvas &, grs_bitmap &dest, int dx, int dy, const ubyte *src, int x1, int x2 );

#endif

class bm_rle_expand_range

{

        uint8_t *iter_dbits;

        uint8_t *const end_dbits;

public:

        bm_rle_expand_range(uint8_t *const i, uint8_t *const e) :

                iter_dbits(i), end_dbits(e)

        {

        }

        template <std::size_t N>

                bm_rle_expand_range(std::array<uint8_t, N> &a) :

                        iter_dbits(a.data()), end_dbits(std::next(iter_dbits, N))

        {

        }

        uint8_t *get_begin_dbits() const

        {

                return iter_dbits;

        }

        uint8_t *get_end_dbits() const

        {

                return end_dbits;

        }

        void consume_dbits(const unsigned w)

        {

                iter_dbits += w;

        }

};

class bm_rle_src_stride

{

        /* Width of an individual element of the table of row lengths.  This

         * is sizeof(uint8_t) if the bitmap is not RLE_BIG, or is

         * sizeof(uint16_t) otherwise.

         */

        const unsigned src_bit_stride_size;

        /* Bitmask used for filtering the table load.  To minimize

         * branching, the code always loads two bytes from the table of row

         * lengths.  If the bitmap is not RLE_BIG, then `src_bit_load_mask`

         * will be 0xff and will be used to mask out the high byte from the

         * load.  Otherwise, `src_bit_load_mask` will be 0xffff and the mask

         * operation will leave the loaded value unchanged.

         */

        const unsigned src_bit_load_mask;

protected:

        /* Pointer to the table of row lengths.  The table is uint8_t[] if

         * the bitmap is not RLE_BIG, or is uint16_t[] otherwise.  The table

         * is not required to be aligned.

         */

        const uint8_t *ptr_src_bit_lengths;

        /* Pointer to the table of RLE-encoded bitmap elements.

         */

        const uint8_t *src_bits;

public:

        bm_rle_src_stride(const grs_bitmap &src, const unsigned rle_big) :

                /* Jump threading should collapse the separate ?: uses */

                src_bit_stride_size(rle_big ? sizeof(uint16_t) : sizeof(uint8_t)),

                src_bit_load_mask(rle_big ? 0xffff : 0xff),

                ptr_src_bit_lengths(&src.bm_data[4]),

                src_bits(&ptr_src_bit_lengths[rle_big ? src.bm_h * 2 : src.bm_h])

        {

        }

        void advance_src_bits();

};

class bm_rle_expand : bm_rle_src_stride

{

        /* Pointer to the first byte that is not part of the table of row

         * lengths.  When `ptr_src_bit_lengths` == `end_src_bit_lengths`, no

         * further rows are available.

         */

        const uint8_t *const end_src_bit_lengths;

        /* Pointer to the first byte that is not part of the bitmap data.

         * When `end_src_bm` == `src_bits`, no further bitmap elements are

         * available.

         */

        const uint8_t *const end_src_bm;

public:

        enum step_result

        {

                /* A row decoded successfully.  Act on the decoded buffer as

                 * necessary, then call this class again.

                 *

                 * This result is returned even if the returned row is the last

                 * row.  The first call after the last row will return

                 * src_exhausted, which is the trigger to stop calling the

                 * class.

                 */

                again,

                /* The source was exhausted before any work was done.  No data

                 * is available.  No further calls should be made with this

                 * source.

                 */

                src_exhausted,

                /* The destination was exhausted before decoding completed.  The

                 * source is left at the beginning of the row which failed to

                 * decode.  The caller may try again with a larger destination

                 * buffer or may abandon the attempt.  Further calls with the

                 * same source and destination will continue to return

                 * `dst_exhausted`.

                 */

                dst_exhausted,

        };

        bm_rle_expand(const grs_bitmap &src) :

                bm_rle_src_stride(src, src.get_flag_mask(BM_FLAG_RLE_BIG)),

                end_src_bit_lengths(src_bits),

                end_src_bm(end(src))

        {

        }

        template <typename T>

                /* Decode one row of the bitmap, then return control to the

                 * caller.  If the return value is `again`, then the caller

                 * should perform any per-row processing, then call step()

                 * again.  If the return value is not `again`, then the

                 * destination buffer is undefined and the caller should not

                 * access it or call step().

                 *

                 * `const T &` to ensure that t is only modified by the caller

                 * and that the caller does not accidentally provide an

                 * implementation of `get_begin_dbits` that moves the

                 * destination pointer.

                 */

                step_result step(const T &t)

                {

                        /* Poison the memory first, so that it is undefined even if

                         * the source is exhausted.

                         */

                        const auto b = t.get_begin_dbits();

                        const auto e = t.get_end_dbits();

                        DXX_MAKE_MEM_UNDEFINED(b, e);

                        /* Check for source exhaustion, so that empty bitmaps are

                         * not read at all.  This allows callers to treat

                         * src_exhausted as a definitive end-of-record with no data

                         * available.

                         */

                        if (ptr_src_bit_lengths == end_src_bit_lengths)

                                return src_exhausted;

                        return step_internal(b, e);

                }

        template <typename T>

                /* Decode until source or destination is exhausted.  The

                 * destination position is updated automatically as each row is

                 * decoded.  There is no opportunity for callers to perform

                 * per-row processing.  Callers should call step() directly if

                 * per-row processing is required.

                 *

                 * `T &&` since some callers may not care about the state of `t`

                 * afterward; `T &&` lets them pass an anonymous temporary.

                 */

                bool loop(const unsigned bm_w, T &&t)

                {

                        for (;;)

                        {

                                switch (step(t))

                                {

                                        case again:

                                                /* Step succeeded.  Notify `t` to update its

                                                 * dbits position, then loop around.

                                                 */

                                                t.consume_dbits(bm_w);

                                                break;

                                        case src_exhausted:

                                                /* Success: source buffer exhausted and no error

                                                 * conditions detected.

                                                 */

                                                return true;

                                        case dst_exhausted:

                                                /* Failure: destination buffer too small to hold

                                                 * expanded source.

                                                 */

                                                return false;

                                }

                        }

                }

private:

        step_result step_internal(uint8_t *begin_dbits, uint8_t *end_dbits);

};

}