summaryrefslogtreecommitdiff
path: root/client/glz_decode_tmpl.c
diff options
context:
space:
mode:
Diffstat (limited to 'client/glz_decode_tmpl.c')
-rw-r--r--client/glz_decode_tmpl.c335
1 files changed, 335 insertions, 0 deletions
diff --git a/client/glz_decode_tmpl.c b/client/glz_decode_tmpl.c
new file mode 100644
index 00000000..6942b73c
--- /dev/null
+++ b/client/glz_decode_tmpl.c
@@ -0,0 +1,335 @@
+/*
+ Copyright (C) 2009 Red Hat, Inc.
+
+ This program 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 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, see <http://www.gnu.org/licenses/>.
+*/
+
+// External defines: PLT, RGBX/PLTXX/ALPHA, TO_RGB32.
+// If PLT4/1 and TO_RGB32 are defined, we need CAST_PLT_DISTANCE (
+// because then the number of pixels differ from the units used in the compression)
+
+/*
+ For each output pixel type the following macros are defined:
+ OUT_PIXEL - the output pixel type
+ COPY_PIXEL(p, out) - assignes the pixel to the place pointed by out and
+ increases out. Used in RLE.
+ Need special handling because in alpha we copy only
+ the pad byte.
+ COPY_REF_PIXEL(ref, out) - copies the pixel pointed by ref to the pixel pointed by out.
+ Increases ref and out.
+ COPY_COMP_PIXEL(encoder, out) - copies pixel from the compressed buffer to the decompressed
+ buffer. Increases out.
+*/
+
+#if !defined(LZ_RGB_ALPHA)
+#define COPY_PIXEL(p, out) (*(out++) = p)
+#define COPY_REF_PIXEL(ref, out) (*(out++) = *(ref++))
+#endif
+
+// decompressing plt to plt
+#ifdef LZ_PLT
+#ifndef TO_RGB32
+#define OUT_PIXEL one_byte_pixel_t
+#define FNAME(name) glz_plt_##name
+#define COPY_COMP_PIXEL(in, out) {(out)->a = *(in++); out++;}
+#else // TO_RGB32
+#define OUT_PIXEL rgb32_pixel_t
+#define COPY_PLT_ENTRY(ent, out) {\
+ (out)->b = ent; (out)->g = (ent >> 8); (out)->r = (ent >> 16); (out)->pad = 0;}
+#ifdef PLT8
+#define FNAME(name) glz_plt8_to_rgb32_##name
+#define COPY_COMP_PIXEL(in, out, palette) { \
+ uint32_t rgb = palette->ents[*(in++)]; \
+ COPY_PLT_ENTRY(rgb, out); \
+ out++; \
+}
+#elif defined(PLT4_BE)
+#define FNAME(name) glz_plt4_be_to_rgb32_##name
+#define COPY_COMP_PIXEL(in, out, palette){ \
+ uint8_t byte = *(in++); \
+ uint32_t rgb = palette->ents[((byte >> 4) & 0x0f) % (palette->num_ents)]; \
+ COPY_PLT_ENTRY(rgb, out); \
+ out++; \
+ rgb = palette->ents[(byte & 0x0f) % (palette->num_ents)]; \
+ COPY_PLT_ENTRY(rgb, out); \
+ out++; \
+}
+#define CAST_PLT_DISTANCE(dist) (dist*2)
+#elif defined(PLT4_LE)
+#define FNAME(name) glz_plt4_le_to_rgb32_##name
+#define COPY_COMP_PIXEL(in, out, palette){ \
+ uint8_t byte = *(in++); \
+ uint32_t rgb = palette->ents[(byte & 0x0f) % (palette->num_ents)]; \
+ COPY_PLT_ENTRY(rgb, out); \
+ out++; \
+ rgb = palette->ents[((byte >> 4) & 0x0f) % (palette->num_ents)]; \
+ COPY_PLT_ENTRY(rgb, out); \
+ out++; \
+}
+#define CAST_PLT_DISTANCE(dist) (dist*2)
+#elif defined(PLT1_BE) // TODO store palette entries for direct access
+#define FNAME(name) glz_plt1_be_to_rgb32_##name
+#define COPY_COMP_PIXEL(in, out, palette){ \
+ uint8_t byte = *(in++); \
+ int i; \
+ uint32_t fore = palette->ents[1]; \
+ uint32_t back = palette->ents[0]; \
+ for (i = 7; i >= 0; i--) \
+ { \
+ if ((byte >> i) & 1) { \
+ COPY_PLT_ENTRY(fore, out); \
+ } else { \
+ COPY_PLT_ENTRY(back, out); \
+ } \
+ out++; \
+ } \
+}
+#define CAST_PLT_DISTANCE(dist) (dist*8)
+#elif defined(PLT1_LE)
+#define FNAME(name) glz_plt1_le_to_rgb32_##name
+#define COPY_COMP_PIXEL(in, out, palette){ \
+ uint8_t byte = *(in++); \
+ int i; \
+ uint32_t fore = palette->ents[1]; \
+ uint32_t back = palette->ents[0]; \
+ for (i = 0; i < 8; i++) \
+ { \
+ if ((byte >> i) & 1) { \
+ COPY_PLT_ENTRY(fore, out); \
+ } else { \
+ COPY_PLT_ENTRY(back, out); \
+ } \
+ out++; \
+ } \
+}
+#define CAST_PLT_DISTANCE(dist) (dist*8)
+#endif // PLT Type
+#endif // TO_RGB32
+#endif
+
+#ifdef LZ_RGB16
+#ifndef TO_RGB32
+#define OUT_PIXEL rgb16_pixel_t
+#define FNAME(name) glz_rgb16_##name
+#define COPY_COMP_PIXEL(in, out) {*out = (*(in++)) << 8; *out |= *(in++); out++;}
+#else
+#define OUT_PIXEL rgb32_pixel_t
+#define FNAME(name) glz_rgb16_to_rgb32_##name
+#define COPY_COMP_PIXEL(in, out) {out->r = *(in++); out->b= *(in++); \
+ out->g = (((out->r) << 6) | ((out->b) >> 2)) & ~0x07; \
+ out->g |= (out->g >> 5); \
+ out->r = ((out->r << 1) & ~0x07) | ((out->r >> 4) & 0x07) ; \
+ out->b = (out->b << 3) | ((out->b >> 2) & 0x07); \
+ out->pad = 0; \
+ out++; \
+}
+#endif
+#endif
+
+#ifdef LZ_RGB24
+#define OUT_PIXEL rgb24_pixel_t
+#define FNAME(name) glz_rgb24_##name
+#define COPY_COMP_PIXEL(in, out) { \
+ out->b = *(in++); \
+ out->g = *(in++); \
+ out->r = *(in++); \
+ out++; \
+}
+#endif
+
+#ifdef LZ_RGB32
+#define OUT_PIXEL rgb32_pixel_t
+#define FNAME(name) glz_rgb32_##name
+#define COPY_COMP_PIXEL(in, out) { \
+ out->b = *(in++); \
+ out->g = *(in++); \
+ out->r = *(in++); \
+ out->pad = 0; \
+ out++; \
+}
+#endif
+
+#ifdef LZ_RGB_ALPHA
+#define OUT_PIXEL rgb32_pixel_t
+#define FNAME(name) glz_rgb_alpha_##name
+#define COPY_PIXEL(p, out) {out->pad = p.pad; out++;}
+#define COPY_REF_PIXEL(ref, out) {out->pad = ref->pad; out++; ref++;}
+#define COPY_COMP_PIXEL(in, out) {out->pad = *(in++); out++;}
+#endif
+
+// TODO: seperate into routines that decode to dist,len. and to a routine that
+// actualy copies the data.
+
+/* returns num of bytes read from in buf.
+ size should be in PIXEL */
+static size_t FNAME(decode)(GlzDecoderWindow &window, uint8_t* in_buf,
+ uint8_t *out_buf, int size,
+ DecodedImageWinId image_win_id, Palette *plt,
+ GlzDecoderDebug &debug_calls)
+{
+ uint8_t *ip = in_buf;
+ OUT_PIXEL *out_pix_buf = (OUT_PIXEL *)out_buf;
+ OUT_PIXEL *op = out_pix_buf;
+ OUT_PIXEL *op_limit = out_pix_buf + size;
+
+ uint32_t ctrl = *(ip++);
+ int loop = true;
+
+ do {
+ if (ctrl >= MAX_COPY) { // reference (dictionary/RLE)
+ OUT_PIXEL *ref = op;
+ uint32_t len = ctrl >> 5;
+ uint8_t pixel_flag = (ctrl >> 4) & 0x01;
+ uint32_t pixel_ofs = (ctrl & 0x0f);
+ uint8_t image_flag;
+ uint32_t image_dist;
+
+ /* retrieving the referenced images, the offset of the first pixel,
+ and the match length */
+
+ uint8_t code;
+ //len--; // TODO: why do we do this?
+
+ if (len == 7) { // match length is bigger than 7
+ do {
+ code = *(ip++);
+ len += code;
+ } while (code == 255); // remaining of len
+ }
+ code = *(ip++);
+ pixel_ofs += (code << 4);
+
+ code = *(ip++);
+ image_flag = (code >> 6) & 0x03;
+ if (!pixel_flag) { // short pixel offset
+ image_dist = code & 0x3f;
+ for (int i = 0; i < image_flag; i++) {
+ code = *(ip++);
+ image_dist += (code << (6 + (8 * i)));
+ }
+ } else {
+ pixel_flag = (code >> 5) & 0x01;
+ pixel_ofs += (code & 0x1f) << 12;
+ image_dist = 0;
+ for (int i = 0; i < image_flag; i++) {
+ code = *(ip++);
+ image_dist += (code << 8 * i);
+ }
+
+
+ if (pixel_flag) { // very long pixel offset
+ code = *(ip++);
+ pixel_ofs += code << 17;
+ }
+ }
+
+#if defined(LZ_PLT) || defined(LZ_RGB_ALPHA)
+ len += 2; // length is biased by 2 (fixing bias)
+#elif defined(LZ_RGB16)
+ len += 1; // length is biased by 1 (fixing bias)
+#endif
+ if (!image_dist) {
+ pixel_ofs += 1; // offset is biased by 1 (fixing bias)
+ }
+
+#if defined(TO_RGB32)
+#if defined(PLT4_BE) || defined(PLT4_LE) || defined(PLT1_BE) || defined(PLT1_LE)
+ pixel_ofs = CAST_PLT_DISTANCE(pixel_ofs);
+ len = CAST_PLT_DISTANCE(len);
+#endif
+#endif
+
+ if (!image_dist) { // reference is inside the same image
+ ref -= pixel_ofs;
+ GLZ_ASSERT(debug_calls, ref + len <= op_limit);
+ GLZ_ASSERT(debug_calls, ref >= out_pix_buf);
+ } else {
+ ref = (OUT_PIXEL *)window.get_ref_pixel(image_win_id, image_dist,
+ pixel_ofs);
+ }
+
+ GLZ_ASSERT(debug_calls, op + len <= op_limit);
+
+ /* copying the match*/
+
+ if (ref == (op - 1)) { // run (this will never be called in PLT4/1_TO_RGB because the
+ // number of pixel copied is larger then one...
+ /* optimize copy for a run */
+ OUT_PIXEL b = *ref;
+ for (; len; --len) {
+ COPY_PIXEL(b, op);
+ GLZ_ASSERT(debug_calls, op <= op_limit);
+ }
+ } else {
+ for (; len; --len) {
+ COPY_REF_PIXEL(ref, op);
+ GLZ_ASSERT(debug_calls, op <= op_limit);
+ }
+ }
+ } else { // copy
+ ctrl++; // copy count is biased by 1
+#if defined(TO_RGB32) && (defined(PLT4_BE) || defined(PLT4_LE) || defined(PLT1_BE) || \
+ defined(PLT1_LE))
+ GLZ_ASSERT(debug_calls, op + CAST_PLT_DISTANCE(ctrl) <= op_limit);
+#else
+ GLZ_ASSERT(debug_calls, op + ctrl <= op_limit);
+#endif
+
+#if defined(TO_RGB32) && defined(LZ_PLT)
+ GLZ_ASSERT(debug_calls, plt);
+ COPY_COMP_PIXEL(ip, op, plt);
+#else
+ COPY_COMP_PIXEL(ip, op);
+#endif
+ GLZ_ASSERT(debug_calls, op <= op_limit);
+
+ for (--ctrl; ctrl; ctrl--) {
+#if defined(TO_RGB32) && defined(LZ_PLT)
+ GLZ_ASSERT(debug_calls, plt);
+ COPY_COMP_PIXEL(ip, op, plt);
+#else
+ COPY_COMP_PIXEL(ip, op);
+#endif
+ GLZ_ASSERT(debug_calls, op <= op_limit);
+ }
+ } // END REF/COPY
+
+ if (LZ_EXPECT_CONDITIONAL(op < op_limit)) {
+ ctrl = *(ip++);
+ } else {
+ loop = false;
+ }
+ } while (LZ_EXPECT_CONDITIONAL(loop));
+
+ return (ip - in_buf);
+}
+#undef LZ_PLT
+#undef PLT8
+#undef PLT4_BE
+#undef PLT4_LE
+#undef PLT1_BE
+#undef PLT1_LE
+#undef LZ_RGB16
+#undef LZ_RGB24
+#undef LZ_RGB32
+#undef LZ_RGB_ALPHA
+#undef TO_RGB32
+#undef OUT_PIXEL
+#undef FNAME
+#undef COPY_PIXEL
+#undef COPY_REF_PIXEL
+#undef COPY_COMP_PIXEL
+#undef COPY_PLT_ENTRY
+#undef CAST_PLT_DISTANCE
+
generated by cgit v1.2.3 (git 2.39.1) at 2024-12-18 16:56:40 +0000