opencodecs 0.3.1__tar.gz → 0.5.0__tar.gz

{opencodecs-0.3.1 → opencodecs-0.5.0}/3rdparty/VENDOR.toml

@@ -59,9 +59,16 @@ multi-byte casts with byte-wise readers."""
   upstream = "bcdec.h"
   modified = true
   note = """Upstream at the pinned commit, plus one six-line comment on \
-the BC4/BC5 signed path and trailing whitespace stripped. Verified by \
-reconstruction: our file with that comment removed and trailing \
-whitespace normalized is byte-identical to upstream."""
+the BC4/BC5 signed path, trailing whitespace stripped, and one block in \
+bcdec_bc7. Before that block, reconstruction verified the rest: our file \
+with that comment removed and trailing whitespace normalized was \
+byte-identical to upstream. The block, marked "opencodecs:", sits ahead of pass 2: \
+modes without secondary indices (all but 4 and 5) skip the general \
+per-texel loop, and with two or three subsets mix all four channels in \
+16-bit lanes of one 64-bit integer. Output is bit-identical (each lane \
+holds bcdec__interpolate's exact result); BC7 decode measured 1.1 to \
+1.4x faster with MSVC, clang-cl, GCC and Apple Clang. Worth sending \
+upstream."""
 
 [[component]]
 name = "bitshuffle"
@@ -84,7 +91,10 @@ uint64 branch of bshuf_write_uint64_BE. They silence MSVC C4244; the \
 truncation is intended in all three, the value is masked to a byte \
 already. Re-derived from upstream in 2026-09 so this delta is three \
 lines that can be read, rather than a file nobody could account for. \
-Worth sending upstream."""
+And the USESSE2 guard also accepts _M_X64: MSVC never defines \
+__SSE2__, though SSE2 is part of x86-64, so MSVC builds ran the scalar \
+fallback, measured at half the speed of the SSE2 path. Both are worth \
+sending upstream."""
   [[component.file]]
   local = "3rdparty/bitshuffle/bitshuffle_core.h"
   upstream = "src/bitshuffle_core.h"
@@ -92,7 +102,8 @@ Worth sending upstream."""
   modified = true
   note = """Upstream master, except the BSHUF_VERSION macros, which \
 upstream left at 0.4.0 on master; ours say 0.5.2 to match the released \
-version the rest of this directory tracks."""
+version the rest of this directory tracks. And stdint.h is included for \
+MSVC too, as in bitshuffle_internals.h."""
   [[component.file]]
   local = "3rdparty/bitshuffle/iochain.c"
   upstream = "src/iochain.c"
@@ -108,6 +119,11 @@ version the rest of this directory tracks."""
   [[component.file]]
   local = "3rdparty/bitshuffle/bitshuffle_internals.h"
   upstream = "src/bitshuffle_internals.h"
+  modified = true
+  note = """Pristine 0.5.2 except that stdint.h is included for MSVC, \
+which has shipped it since 2010 but sets no __STDC_VERSION__ in its \
+default C mode. The hand-written fallback typedefs have no int16_t, so \
+the SSE2 path, once enabled for MSVC, did not compile."""
 
 [[component]]
 name = "cfitsio"
@@ -146,8 +162,12 @@ OC_THREAD_LOCAL, defined next to the min/max compatibility defines."""
   modified = true
   note = """Keeps the error-code return convention an earlier vendoring \
 introduced, because our binding depends on it, with upstream's \
-buffer-size guard applied on top. A blind update would break the \
-binding; port the fix, do not overwrite."""
+buffer-size guard applied on top. The three decoders also check every \
+input byte against the end of the stream (RICE_NEED_BYTE): upstream \
+checks once per block, and a run of zero bits within a block has no \
+length limit, so a damaged stream read past its buffer. See \
+docs/rice_bounds.md. A blind update would break the binding and drop \
+the checks; port the fix, do not overwrite."""
   # These three live in this directory but are opencodecs code, not
   # cfitsio's. ours = true means the drift check tracks them for
   # accidental edits but never compares them to upstream.
@@ -179,12 +199,17 @@ license = "BSD-2-Clause"
   local = "3rdparty/libspng/spng.c"
   upstream = "spng/spng.c"
   modified = true
-  note = """Carries three opencodecs changes: the grayscale-defilter \
+  note = """Carries four opencodecs changes: the grayscale-defilter \
 patch, the filter_sum_* family (one function per filter instead of a \
-switch inside the per-byte loop), and the matching filter_scanline_* \
-family. The last two are the same transformation applied to the two \
+switch inside the per-byte loop), the matching filter_scanline_* \
+family, and a libdeflate bypass for an explicit compression strategy. \
+The second and third are the same transformation applied to the two \
 halves of the encode filter path; both are branch hoisting, and both \
-produce byte-identical output to the code they replaced."""
+produce byte-identical output to the code they replaced. The fourth: \
+under SPNG_USE_LIBDEFLATE the IDAT stream is compressed in one \
+libdeflate call; setting SPNG_IMG_COMPRESSION_STRATEGY switches that \
+context back to zlib's deflate, since libdeflate has no strategy \
+setting and the option would otherwise be ignored."""
   [[component.file]]
   local = "3rdparty/libspng/spng.h"
   upstream = "spng/spng.h"

{opencodecs-0.3.1 → opencodecs-0.5.0}/3rdparty/bcdec/bcdec.h

@@ -1404,6 +1404,59 @@ BCDECDEF void bcdec_bc7(const void* compressedBlock, void* decompressedBlock, in
         }
     }
 
+    /* opencodecs: modes without secondary indices (all but 4 and 5) have
+       no rotation either, so they skip the general loop below. With two or
+       three subsets all four channels mix at once: an endpoint's channels
+       sit in the 16-bit lanes of one 64-bit integer, and as 255 * 64 + 32
+       fits in a lane, one multiply per endpoint weights every channel with
+       no carry between lanes, leaving bcdec__interpolate's exact result in
+       each. One subset keeps the per-channel form, which Clang turns into
+       NEON vector multiplies; the lanes measured 20% slower there. MSVC
+       tested the subset count, secondary indices and rotation for every
+       texel and multiplied each channel separately. Decoding 2048 x 2048
+       random blocks, or all mode 6, measured 1.1 to 1.4x faster with MSVC
+       14.41 to 14.51, clang-cl, GCC and Apple Clang. */
+    if (!indexBits2) {
+        if (numPartitions == 1) {
+            for (i = 0; i < 4; ++i) {
+                for (j = 0; j < 4; ++j) {
+                    index = indices[i][j];
+                    r = bcdec__interpolate(endpoints[0][0], endpoints[1][0], weights, index);
+                    g = bcdec__interpolate(endpoints[0][1], endpoints[1][1], weights, index);
+                    b = bcdec__interpolate(endpoints[0][2], endpoints[1][2], weights, index);
+                    a = bcdec__interpolate(endpoints[0][3], endpoints[1][3], weights, index);
+                    decompressed[j * 4 + 0] = r;
+                    decompressed[j * 4 + 1] = g;
+                    decompressed[j * 4 + 2] = b;
+                    decompressed[j * 4 + 3] = a;
+                }
+                decompressed += destinationPitch;
+            }
+        } else {
+            unsigned long long lo[3], hi[3], v;
+            int w;
+            for (k = 0; k < numPartitions; ++k) {
+                lo[k] = (unsigned long long)endpoints[k * 2][0] | ((unsigned long long)endpoints[k * 2][1] << 16) |
+                        ((unsigned long long)endpoints[k * 2][2] << 32) | ((unsigned long long)endpoints[k * 2][3] << 48);
+                hi[k] = (unsigned long long)endpoints[k * 2 + 1][0] | ((unsigned long long)endpoints[k * 2 + 1][1] << 16) |
+                        ((unsigned long long)endpoints[k * 2 + 1][2] << 32) | ((unsigned long long)endpoints[k * 2 + 1][3] << 48);
+            }
+            for (i = 0; i < 4; ++i) {
+                for (j = 0; j < 4; ++j) {
+                    partitionSet = partition_sets[numPartitions - 2][partition][i][j] & 0x03;
+                    w = weights[(int)indices[i][j]];
+                    v = (lo[partitionSet] * (unsigned)(64 - w) + hi[partitionSet] * (unsigned)w + 0x0020002000200020ULL) >> 6;
+                    decompressed[j * 4 + 0] = (unsigned char)v;
+                    decompressed[j * 4 + 1] = (unsigned char)(v >> 16);
+                    decompressed[j * 4 + 2] = (unsigned char)(v >> 32);
+                    decompressed[j * 4 + 3] = (unsigned char)(v >> 48);
+                }
+                decompressed += destinationPitch;
+            }
+        }
+        return;
+    }
+
     /* Pass #2: reading alpha indices (if any) and interpolating & rotating */
     for (i = 0; i < 4; ++i) {
         for (j = 0; j < 4; ++j) {

{opencodecs-0.3.1 → opencodecs-0.5.0}/3rdparty/bitshuffle/bitshuffle_core.c

@@ -24,7 +24,9 @@
 #define USEAVX2
 #endif
 
-#if defined(__SSE2__) || defined(NO_WARN_X86_INTRINSICS)
+/* opencodecs: or _M_X64. MSVC never defines __SSE2__, though every x86-64
+   CPU has SSE2, so MSVC builds ran the scalar fallback at half the speed. */
+#if defined(__SSE2__) || defined(_M_X64) || defined(NO_WARN_X86_INTRINSICS)
 #define USESSE2
 #endif
 

{opencodecs-0.3.1 → opencodecs-0.5.0}/3rdparty/bitshuffle/bitshuffle_core.h

@@ -31,7 +31,10 @@
 #define BITSHUFFLE_CORE_H
 
 // We assume GNU g++ defining `__cplusplus` has stdint.h
-#if (defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199900L) || defined(__cplusplus)
+/* opencodecs: and MSVC, which has shipped stdint.h since 2010 but sets no
+   __STDC_VERSION__ in its default C mode. The fallback below has no
+   int16_t, which the SSE2 byte transpose needs. */
+#if (defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199900L) || defined(__cplusplus) || defined(_MSC_VER)
 #include <stdint.h>
 #else
   typedef unsigned char       uint8_t;

{opencodecs-0.3.1 → opencodecs-0.5.0}/3rdparty/bitshuffle/bitshuffle_internals.h

@@ -14,7 +14,10 @@
 #define BITSHUFFLE_INTERNALS_H
 
 // We assume GNU g++ defining `__cplusplus` has stdint.h
-#if (defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199900L) || defined(__cplusplus)
+/* opencodecs: and MSVC, which has shipped stdint.h since 2010 but sets no
+   __STDC_VERSION__ in its default C mode. The fallback below has no
+   int16_t, which the SSE2 byte transpose needs. */
+#if (defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199900L) || defined(__cplusplus) || defined(_MSC_VER)
 #include <stdint.h>
 #else
   typedef unsigned char       uint8_t;

{opencodecs-0.3.1 → opencodecs-0.5.0}/3rdparty/cfitsio/ricecomp.c

@@ -892,6 +892,19 @@ done_outputing_bits(Buffer *buffer)
 */
 
 /*---------------------------------------------------------------------------*/
+/* Every input byte the decoders below read goes through this check
+   first (an opencodecs change). cfitsio checks for the end of the
+   input only once per block, which lets a corrupt or truncated stream
+   read past the buffer within a block: the run of leading zeros in a
+   Rice code has no length limit, so the overrun is unbounded. A valid
+   stream never reads past its last byte, so the check does not change
+   what one decodes to. */
+#define RICE_NEED_BYTE() \
+    do { \
+        if (c >= cend) \
+            return RCOMP_ERROR_EOS; \
+    } while (0)
+
 /* this routine used to be called 'rdecomp'  (WDP) */
 
 int
@@ -979,12 +992,14 @@ rdecomp_int(
     c += 4;
     cend = c + clen - 4;
 
+    RICE_NEED_BYTE();
     b = *c++;  /* bit buffer */
     nbits = 8; /* number of bits remaining in b */
     for (i = 0; i < nx;) {
         /* get the FS value from first fsbits */
         nbits -= fsbits;
         while (nbits < 0) {
+            RICE_NEED_BYTE();
             b = (b << 8) | (*c++);
             nbits += 8;
         }
@@ -1004,10 +1019,12 @@ rdecomp_int(
                 k = bbits - nbits;
                 diff = b << k;
                 for (k -= 8; k >= 0; k -= 8) {
+                    RICE_NEED_BYTE();
                     b = *c++;
                     diff |= b << k;
                 }
                 if (nbits > 0) {
+                    RICE_NEED_BYTE();
                     b = *c++;
                     diff |= b >> (-k);
                     b &= (1 << nbits) - 1;
@@ -1034,6 +1051,7 @@ rdecomp_int(
                 /* count number of leading zeros */
                 while (b == 0) {
                     nbits += 8;
+                    RICE_NEED_BYTE();
                     b = *c++;
                 }
                 nzero = nbits - nonzero_count[b];
@@ -1043,6 +1061,7 @@ rdecomp_int(
                 /* get the FS trailing bits */
                 nbits -= fs;
                 while (nbits < 0) {
+                    RICE_NEED_BYTE();
                     b = (b << 8) | (*c++);
                     nbits += 8;
                 }
@@ -1154,12 +1173,14 @@ rdecomp_short(
     c += 2;
     cend = c + clen - 2;
 
+    RICE_NEED_BYTE();
     b = *c++;  /* bit buffer */
     nbits = 8; /* number of bits remaining in b */
     for (i = 0; i < nx;) {
         /* get the FS value from first fsbits */
         nbits -= fsbits;
         while (nbits < 0) {
+            RICE_NEED_BYTE();
             b = (b << 8) | (*c++);
             nbits += 8;
         }
@@ -1179,10 +1200,12 @@ rdecomp_short(
                 k = bbits - nbits;
                 diff = b << k;
                 for (k -= 8; k >= 0; k -= 8) {
+                    RICE_NEED_BYTE();
                     b = *c++;
                     diff |= b << k;
                 }
                 if (nbits > 0) {
+                    RICE_NEED_BYTE();
                     b = *c++;
                     diff |= b >> (-k);
                     b &= (1 << nbits) - 1;
@@ -1210,6 +1233,7 @@ rdecomp_short(
                 /* count number of leading zeros */
                 while (b == 0) {
                     nbits += 8;
+                    RICE_NEED_BYTE();
                     b = *c++;
                 }
                 nzero = nbits - nonzero_count[b];
@@ -1219,6 +1243,7 @@ rdecomp_short(
                 /* get the FS trailing bits */
                 nbits -= fs;
                 while (nbits < 0) {
+                    RICE_NEED_BYTE();
                     b = (b << 8) | (*c++);
                     nbits += 8;
                 }
@@ -1325,12 +1350,14 @@ rdecomp_byte(
     c += 1;
     cend = c + clen - 1;
 
+    RICE_NEED_BYTE();
     b = *c++;  /* bit buffer */
     nbits = 8; /* number of bits remaining in b */
     for (i = 0; i < nx;) {
         /* get the FS value from first fsbits */
         nbits -= fsbits;
         while (nbits < 0) {
+            RICE_NEED_BYTE();
             b = (b << 8) | (*c++);
             nbits += 8;
         }
@@ -1350,10 +1377,12 @@ rdecomp_byte(
                 k = bbits - nbits;
                 diff = b << k;
                 for (k -= 8; k >= 0; k -= 8) {
+                    RICE_NEED_BYTE();
                     b = *c++;
                     diff |= b << k;
                 }
                 if (nbits > 0) {
+                    RICE_NEED_BYTE();
                     b = *c++;
                     diff |= b >> (-k);
                     b &= (1 << nbits) - 1;
@@ -1381,6 +1410,7 @@ rdecomp_byte(
                 /* count number of leading zeros */
                 while (b == 0) {
                     nbits += 8;
+                    RICE_NEED_BYTE();
                     b = *c++;
                 }
                 nzero = nbits - nonzero_count[b];
@@ -1390,6 +1420,7 @@ rdecomp_byte(
                 /* get the FS trailing bits */
                 nbits -= fs;
                 while (nbits < 0) {
+                    RICE_NEED_BYTE();
                     b = (b << 8) | (*c++);
                     nbits += 8;
                 }

{opencodecs-0.3.1 → opencodecs-0.5.0}/3rdparty/libspng/spng.c

@@ -358,6 +358,7 @@ struct spng_ctx
     size_t libdef_inbuf_size;
     size_t libdef_inbuf_cap;
     int libdef_level;              /* requested compression level */
+    int libdef_bypass;             /* image strategy set: use zlib */
 #endif
     unsigned char *scanline_buf, *prev_scanline_buf, *row_buf, *filtered_scanline_buf;
     unsigned char *scanline, *prev_scanline, *row, *filtered_scanline;
@@ -1264,9 +1265,16 @@ static int spng__deflate_init(spng_ctx *ctx, struct spng__zlib_options *options)
     {
         libdeflate_free_compressor(
             (struct libdeflate_compressor *)ctx->libdef_compressor);
+        ctx->libdef_compressor = NULL;
+    }
+    /* libdeflate has no strategy setting. When the caller set the image
+       strategy explicitly, IDAT goes through zlib's deflate (initialized
+       above with that strategy) so the setting is honored. */
+    if(!ctx->libdef_bypass)
+    {
+        ctx->libdef_compressor = libdeflate_alloc_compressor(ctx->libdef_level);
+        if(ctx->libdef_compressor == NULL) return SPNG_EZLIB_INIT;
     }
-    ctx->libdef_compressor = libdeflate_alloc_compressor(ctx->libdef_level);
-    if(ctx->libdef_compressor == NULL) return SPNG_EZLIB_INIT;
     if(ctx->libdef_inbuf)
     {
         spng__free(ctx, ctx->libdef_inbuf);
@@ -4685,6 +4693,8 @@ static int write_idat_bytes(spng_ctx *ctx, const void *scanline, size_t len, int
     int ret = 0;
 
 #ifdef SPNG_USE_LIBDEFLATE
+    if(!ctx->libdef_bypass)
+    {
     (void)flush;
     /* Append the scanline bytes to our libdeflate input accumulator.
        The actual compression happens in finish_idat() once we have
@@ -4707,7 +4717,8 @@ static int write_idat_bytes(spng_ctx *ctx, const void *scanline, size_t len, int
     memcpy(ctx->libdef_inbuf + ctx->libdef_inbuf_size, scanline, len);
     ctx->libdef_inbuf_size = need;
     return 0;
-#else
+    }
+#endif
     unsigned char *data = NULL;
     z_stream *zstream = &ctx->zstream;
     uint32_t idat_length = SPNG_WRITE_SIZE;
@@ -4736,7 +4747,6 @@ static int write_idat_bytes(spng_ctx *ctx, const void *scanline, size_t len, int
     if(ret != Z_OK) return SPNG_EZLIB;
 
     return 0;
-#endif
 }
 
 static int finish_idat(spng_ctx *ctx)
@@ -4746,6 +4756,8 @@ static int finish_idat(spng_ctx *ctx)
     uint32_t idat_length = SPNG_WRITE_SIZE;
 
 #ifdef SPNG_USE_LIBDEFLATE
+    if(!ctx->libdef_bypass)
+    {
     /* One-shot compress the accumulated filtered-row stream and
        splay the output across SPNG_WRITE_SIZE-sized IDAT chunks.
        Reader compatibility is identical — PNG concatenates IDATs
@@ -4817,7 +4829,8 @@ static int finish_idat(spng_ctx *ctx)
     ctx->libdef_inbuf_cap = 0;
 
     return finish_chunk(ctx);
-#else
+    }
+#endif
     z_stream *zstream = &ctx->zstream;
 
     while(ret != Z_STREAM_END)
@@ -4850,7 +4863,6 @@ static int finish_idat(spng_ctx *ctx)
     if(ret) return ret;
 
     return finish_chunk(ctx);
-#endif
 }
 
 static int encode_scanline(spng_ctx *ctx, const void *scanline, size_t len)
@@ -5533,6 +5545,9 @@ int spng_set_option(spng_ctx *ctx, enum spng_option option, int value)
         case SPNG_IMG_COMPRESSION_STRATEGY:
         {
             ctx->image_options.strategy = value;
+#ifdef SPNG_USE_LIBDEFLATE
+            ctx->libdef_bypass = 1;
+#endif
             break;
         }
         case SPNG_TEXT_COMPRESSION_LEVEL:

{opencodecs-0.3.1 → opencodecs-0.5.0}/3rdparty/oc_eer/oc_eer.h

@@ -25,9 +25,15 @@
  *   2-bit symbol (1 horz + 1 vert):  s ^= 0x03   ->  0b11
  *
  * Both constants flip exactly the MSB of each field and leave the low
- * bits alone, so the rule is width-independent and we apply it for all
- * widths. NOTE: imagecodecs applies the inversion for field widths 1 and
- * 2 but not 3 and 4; real Falcon hardware only ever emits 1 or 2, so
+ * bits alone. RELION's comment on that XOR (citing Thermo Fisher) says
+ * the field is a SIGNED 2-bit value, -2..1 (signed 1-bit for 1-bit
+ * fields). Turning a signed n-bit field into an unsigned index means
+ * adding 2^(n-1), which is flipping its top bit, at every width; so we
+ * apply that rule for all widths. Thermo Fisher's public EER format
+ * document (v3.0) defines only the tags and leaves the bitstream out of
+ * scope, so this is the only stated convention. NOTE: imagecodecs XORs
+ * each field with its WIDTH (^3, ^4), which equals the top-bit flip only
+ * at widths 1 and 2; real Falcon hardware only ever emits 1 or 2, so
  * that divergence does not affect real data. See
  * tests/test_eer.py::test_eer_subpixel_inversion_is_width_independent.
  *

{opencodecs-0.3.1 → opencodecs-0.5.0}/3rdparty/oc_giflzw/oc_giflzw.c

@@ -107,7 +107,11 @@ static int decode_inner(
         accum_bits -= code_size;
 
         if (OC_UNLIKELY(code == eoi_code)) {
-            return 0;
+            /* An end code before the frame is full is an error in
+             * libgif too (D_GIF_ERR_EOF_TOO_SOON, "Image EOF detected
+             * before image complete"). Returning success here left the
+             * rest of the caller's raster unwritten. */
+            return (out_p == out_end) ? 0 : -2;
         }
         if (OC_UNLIKELY(code == clear_code)) {
             code_size = min_code_size + 1;
@@ -125,8 +129,12 @@ static int decode_inner(
         if (OC_UNLIKELY(c >= next_code)) {
             /* "KwKwK" special case: the code refers to an entry we're
              * about to add. Emit the previous string + first byte of
-             * previous string. */
-            if (OC_UNLIKELY(prev_code < 0)) {
+             * previous string. Only next_code itself can be that entry;
+             * a larger code was never defined, and accepting it made
+             * it prev_code, so the next table entry pointed at an
+             * uninitialized slot and a later prefix walk read outside
+             * the table. libgif rejects it too (D_GIF_ERR_IMAGE_DEFECT). */
+            if (OC_UNLIKELY(prev_code < 0 || c > next_code)) {
                 return -4;
             }
             stack[sp++] = (uint8_t) first_byte[prev_code];
@@ -145,9 +153,16 @@ static int decode_inner(
         stack[sp++] = (uint8_t) c;
         uint8_t first = (uint8_t) c;
 
-        /* Bounds check + drain stack into output (reversed → forward). */
+        /* Bounds check + drain stack into output (reversed → forward).
+         * A stream that codes more pixels than the frame holds fills
+         * the frame and stops: libgif (DGifGetLine) decodes exactly
+         * width * height pixels and skips the rest of the data, so the
+         * surplus is ignored rather than failing the decode. */
         if (OC_UNLIKELY(out_p + sp > out_end)) {
-            return -3;
+            while (out_p < out_end) {
+                *out_p++ = stack[--sp];
+            }
+            return 0;
         }
         /* Reverse copy: stack[sp-1..0] → out_p[0..sp-1]. */
         for (int i = sp - 1; i >= 0; i--) {

{opencodecs-0.3.1 → opencodecs-0.5.0}/3rdparty/oc_giflzw/oc_giflzw.h

@@ -42,10 +42,11 @@ typedef struct {
  *  output: pre-allocated buffer of `output_len` bytes (= width*height).
  *
  * Return value:
- *   0 on success.
+ *   0 on success: exactly output_len pixels were written. Codes past
+ *     the last pixel are ignored, as libgif ignores them.
  *  -1 invalid min_code_size.
- *  -2 truncated input (ran out before EOI).
- *  -3 output overrun (image had more pixels than buffer).
+ *  -2 the image data ended (end of input, or the EOI code) before
+ *     output_len pixels were decoded.
  *  -4 invalid code referenced before it was defined.
  */
 int oc_giflzw_decode_blocks(