libmspack 0.0.5 → 0.10.1.2

data/ext/libmspack/mspack/mszipd.c

@@ -20,9 +20,9 @@
 #define BITS_VAR zip
 #define BITS_ORDER_LSB
 #define BITS_LSB_TABLE
-#define READ_BYTES do {		\
-    READ_IF_NEEDED;		\
-    INJECT_BITS(*i_ptr++, 8);	\
+#define READ_BYTES do {         \
+    READ_IF_NEEDED;             \
+    INJECT_BITS(*i_ptr++, 8);   \
 } while (0)
 #include <readbits.h>
 
@@ -34,13 +34,13 @@
 #define HUFF_ERROR          return INF_ERR_HUFFSYM
 #include <readhuff.h>
 
-#define FLUSH_IF_NEEDED do {				\
-    if (zip->window_posn == MSZIP_FRAME_SIZE) {		\
-	if (zip->flush_window(zip, MSZIP_FRAME_SIZE)) {	\
-	    return INF_ERR_FLUSH;			\
-	}						\
-	zip->window_posn = 0;				\
-    }							\
+#define FLUSH_IF_NEEDED do {                            \
+    if (zip->window_posn == MSZIP_FRAME_SIZE) {         \
+        if (zip->flush_window(zip, MSZIP_FRAME_SIZE)) { \
+            return INF_ERR_FLUSH;                       \
+        }                                               \
+        zip->window_posn = 0;                           \
+    }                                                   \
 } while (0)
 
 /* match lengths for literal codes 257.. 285 */
@@ -181,14 +181,14 @@ static int inflate(struct mszipd_stream *zip) {
 
       /* read 4 bytes of data, emptying the bit-buffer if necessary */
       for (i = 0; (bits_left >= 8); i++) {
-	if (i == 4) return INF_ERR_BITBUF;
-	lens_buf[i] = PEEK_BITS(8);
-	REMOVE_BITS(8);
+        if (i == 4) return INF_ERR_BITBUF;
+        lens_buf[i] = PEEK_BITS(8);
+        REMOVE_BITS(8);
       }
       if (bits_left != 0) return INF_ERR_BITBUF;
       while (i < 4) {
-	READ_IF_NEEDED;
-	lens_buf[i++] = *i_ptr++;
+        READ_IF_NEEDED;
+        lens_buf[i++] = *i_ptr++;
       }
 
       /* get the length and its complement */
@@ -198,18 +198,18 @@ static int inflate(struct mszipd_stream *zip) {
 
       /* read and copy the uncompressed data into the window */
       while (length > 0) {
-	READ_IF_NEEDED;
-
-	this_run = length;
-	if (this_run > (unsigned int)(i_end - i_ptr)) this_run = i_end - i_ptr;
-	if (this_run > (MSZIP_FRAME_SIZE - zip->window_posn))
-	  this_run = MSZIP_FRAME_SIZE - zip->window_posn;
-
-	zip->sys->copy(i_ptr, &zip->window[zip->window_posn], this_run);
-	zip->window_posn += this_run;
-	i_ptr    += this_run;
-	length   -= this_run;
-	FLUSH_IF_NEEDED;
+        READ_IF_NEEDED;
+
+        this_run = length;
+        if (this_run > (unsigned int)(i_end - i_ptr)) this_run = i_end - i_ptr;
+        if (this_run > (MSZIP_FRAME_SIZE - zip->window_posn))
+          this_run = MSZIP_FRAME_SIZE - zip->window_posn;
+
+        zip->sys->copy(i_ptr, &zip->window[zip->window_posn], this_run);
+        zip->window_posn += this_run;
+        i_ptr    += this_run;
+        length   -= this_run;
+        FLUSH_IF_NEEDED;
       }
     }
     else if ((block_type == 1) || (block_type == 2)) {
@@ -217,92 +217,92 @@ static int inflate(struct mszipd_stream *zip) {
       unsigned int match_posn, code;
 
       if (block_type == 1) {
-	/* block with fixed Huffman codes */
-	i = 0;
-	while (i < 144) zip->LITERAL_len[i++] = 8;
-	while (i < 256) zip->LITERAL_len[i++] = 9;
-	while (i < 280) zip->LITERAL_len[i++] = 7;
-	while (i < 288) zip->LITERAL_len[i++] = 8;
-	for (i = 0; i < 32; i++) zip->DISTANCE_len[i] = 5;
+        /* block with fixed Huffman codes */
+        i = 0;
+        while (i < 144) zip->LITERAL_len[i++] = 8;
+        while (i < 256) zip->LITERAL_len[i++] = 9;
+        while (i < 280) zip->LITERAL_len[i++] = 7;
+        while (i < 288) zip->LITERAL_len[i++] = 8;
+        for (i = 0; i < 32; i++) zip->DISTANCE_len[i] = 5;
       }
       else {
-	/* block with dynamic Huffman codes */
-	STORE_BITS;
-	if ((i = zip_read_lens(zip))) return i;
-	RESTORE_BITS;
+        /* block with dynamic Huffman codes */
+        STORE_BITS;
+        if ((i = zip_read_lens(zip))) return i;
+        RESTORE_BITS;
       }
 
       /* now huffman lengths are read for either kind of block, 
        * create huffman decoding tables */
       if (make_decode_table(MSZIP_LITERAL_MAXSYMBOLS, MSZIP_LITERAL_TABLEBITS,
-			    &zip->LITERAL_len[0], &zip->LITERAL_table[0]))
+                            &zip->LITERAL_len[0], &zip->LITERAL_table[0]))
       {
-	return INF_ERR_LITERALTBL;
+        return INF_ERR_LITERALTBL;
       }
 
       if (make_decode_table(MSZIP_DISTANCE_MAXSYMBOLS,MSZIP_DISTANCE_TABLEBITS,
-			    &zip->DISTANCE_len[0], &zip->DISTANCE_table[0]))
+                            &zip->DISTANCE_len[0], &zip->DISTANCE_table[0]))
       {
-	return INF_ERR_DISTANCETBL;
+        return INF_ERR_DISTANCETBL;
       }
 
       /* decode forever until end of block code */
       for (;;) {
-	READ_HUFFSYM(LITERAL, code);
-	if (code < 256) {
-	  zip->window[zip->window_posn++] = (unsigned char) code;
-	  FLUSH_IF_NEEDED;
-	}
-	else if (code == 256) {
-	  /* END OF BLOCK CODE: loop break point */
-	  break;
-	}
-	else {
-	  code -= 257; /* codes 257-285 are matches */
-	  if (code >= 29) return INF_ERR_LITCODE; /* codes 286-287 are illegal */
-	  READ_BITS_T(length, lit_extrabits[code]);
-	  length += lit_lengths[code];
-
-	  READ_HUFFSYM(DISTANCE, code);
-	  if (code > 30) return INF_ERR_DISTCODE;
-	  READ_BITS_T(distance, dist_extrabits[code]);
-	  distance += dist_offsets[code];
-
-	  /* match position is window position minus distance. If distance
-	   * is more than window position numerically, it must 'wrap
-	   * around' the frame size. */ 
-	  match_posn = ((distance > zip->window_posn) ? MSZIP_FRAME_SIZE : 0)
-	    + zip->window_posn - distance;
-
-	  /* copy match */
-	  if (length < 12) {
-	    /* short match, use slower loop but no loop setup code */
-	    while (length--) {
-	      zip->window[zip->window_posn++] = zip->window[match_posn++];
-	      match_posn &= MSZIP_FRAME_SIZE - 1;
-	      FLUSH_IF_NEEDED;
-	    }
-	  }
-	  else {
-	    /* longer match, use faster loop but with setup expense */
-	    unsigned char *runsrc, *rundest;
-	    do {
-	      this_run = length;
-	      if ((match_posn + this_run) > MSZIP_FRAME_SIZE)
-		this_run = MSZIP_FRAME_SIZE - match_posn;
-	      if ((zip->window_posn + this_run) > MSZIP_FRAME_SIZE)
-		this_run = MSZIP_FRAME_SIZE - zip->window_posn;
-
-	      rundest = &zip->window[zip->window_posn]; zip->window_posn += this_run;
-	      runsrc  = &zip->window[match_posn];  match_posn  += this_run;
-	      length -= this_run;
-	      while (this_run--) *rundest++ = *runsrc++;
-	      if (match_posn == MSZIP_FRAME_SIZE) match_posn = 0;
-	      FLUSH_IF_NEEDED;
-	    } while (length > 0);
-	  }
-
-	} /* else (code >= 257) */
+        READ_HUFFSYM(LITERAL, code);
+        if (code < 256) {
+          zip->window[zip->window_posn++] = (unsigned char) code;
+          FLUSH_IF_NEEDED;
+        }
+        else if (code == 256) {
+          /* END OF BLOCK CODE: loop break point */
+          break;
+        }
+        else {
+          code -= 257; /* codes 257-285 are matches */
+          if (code >= 29) return INF_ERR_LITCODE; /* codes 286-287 are illegal */
+          READ_BITS_T(length, lit_extrabits[code]);
+          length += lit_lengths[code];
+
+          READ_HUFFSYM(DISTANCE, code);
+          if (code >= 30) return INF_ERR_DISTCODE;
+          READ_BITS_T(distance, dist_extrabits[code]);
+          distance += dist_offsets[code];
+
+          /* match position is window position minus distance. If distance
+           * is more than window position numerically, it must 'wrap
+           * around' the frame size. */ 
+          match_posn = ((distance > zip->window_posn) ? MSZIP_FRAME_SIZE : 0)
+            + zip->window_posn - distance;
+
+          /* copy match */
+          if (length < 12) {
+            /* short match, use slower loop but no loop setup code */
+            while (length--) {
+              zip->window[zip->window_posn++] = zip->window[match_posn++];
+              match_posn &= MSZIP_FRAME_SIZE - 1;
+              FLUSH_IF_NEEDED;
+            }
+          }
+          else {
+            /* longer match, use faster loop but with setup expense */
+            unsigned char *runsrc, *rundest;
+            do {
+              this_run = length;
+              if ((match_posn + this_run) > MSZIP_FRAME_SIZE)
+                this_run = MSZIP_FRAME_SIZE - match_posn;
+              if ((zip->window_posn + this_run) > MSZIP_FRAME_SIZE)
+                this_run = MSZIP_FRAME_SIZE - zip->window_posn;
+
+              rundest = &zip->window[zip->window_posn]; zip->window_posn += this_run;
+              runsrc  = &zip->window[match_posn];  match_posn  += this_run;
+              length -= this_run;
+              while (this_run--) *rundest++ = *runsrc++;
+              if (match_posn == MSZIP_FRAME_SIZE) match_posn = 0;
+              FLUSH_IF_NEEDED;
+            } while (length > 0);
+          }
+
+        } /* else (code >= 257) */
 
       } /* for(;;) -- break point at 'code == 256' */
     }
@@ -328,7 +328,7 @@ static int inflate(struct mszipd_stream *zip) {
  * is flushed, an error is raised.
  */  
 static int mszipd_flush_window(struct mszipd_stream *zip,
-			       unsigned int data_flushed)
+                               unsigned int data_flushed)
 {
   zip->bytes_output += data_flushed;
   if (zip->bytes_output > MSZIP_FRAME_SIZE) {
@@ -340,17 +340,18 @@ static int mszipd_flush_window(struct mszipd_stream *zip,
 }
 
 struct mszipd_stream *mszipd_init(struct mspack_system *system,
-				  struct mspack_file *input,
-				  struct mspack_file *output,
-				  int input_buffer_size,
-				  int repair_mode)
+                                  struct mspack_file *input,
+                                  struct mspack_file *output,
+                                  int input_buffer_size,
+                                  int repair_mode)
 {
   struct mszipd_stream *zip;
 
   if (!system) return NULL;
 
+  /* round up input buffer size to multiple of two */
   input_buffer_size = (input_buffer_size + 1) & -2;
-  if (!input_buffer_size) return NULL;
+  if (input_buffer_size < 2) return NULL;
 
   /* allocate decompression state */
   if (!(zip = (struct mszipd_stream *) system->alloc(system, sizeof(struct mszipd_stream)))) {
@@ -426,19 +427,19 @@ int mszipd_decompress(struct mszipd_stream *zip, off_t out_bytes) {
     if ((error = inflate(zip))) {
       D(("inflate error %d", error))
       if (zip->repair_mode) {
-	/* recover partially-inflated buffers */
-	if (zip->bytes_output == 0 && zip->window_posn > 0) {
-	  zip->flush_window(zip, zip->window_posn);
-	}
-	zip->sys->message(NULL, "MSZIP error, %u bytes of data lost.",
-			  MSZIP_FRAME_SIZE - zip->bytes_output);
-	for (i = zip->bytes_output; i < MSZIP_FRAME_SIZE; i++) {
-	  zip->window[i] = '\0';
-	}
-	zip->bytes_output = MSZIP_FRAME_SIZE;
+        /* recover partially-inflated buffers */
+        if (zip->bytes_output == 0 && zip->window_posn > 0) {
+          zip->flush_window(zip, zip->window_posn);
+        }
+        zip->sys->message(NULL, "MSZIP error, %u bytes of data lost.",
+                          MSZIP_FRAME_SIZE - zip->bytes_output);
+        for (i = zip->bytes_output; i < MSZIP_FRAME_SIZE; i++) {
+          zip->window[i] = '\0';
+        }
+        zip->bytes_output = MSZIP_FRAME_SIZE;
       }
       else {
-	return zip->error = (error > 0) ? error : MSPACK_ERR_DECRUNCH;
+        return zip->error = (error > 0) ? error : MSPACK_ERR_DECRUNCH;
       }
     }
     zip->o_ptr = &zip->window[0];
@@ -475,31 +476,31 @@ int mszipd_decompress_kwaj(struct mszipd_stream *zip) {
 
     /* unpack blocks until block_len == 0 */
     for (;;) {
-	RESTORE_BITS;
-
-	/* align to bytestream, read block_len */
-	i = bits_left & 7; REMOVE_BITS(i);
-	READ_BITS(block_len, 8);
-	READ_BITS(i, 8); block_len |= i << 8;
-
-	if (block_len == 0) break;
-
-	/* read "CK" header */
-	READ_BITS(i, 8); if (i != 'C') return MSPACK_ERR_DATAFORMAT;
-	READ_BITS(i, 8); if (i != 'K') return MSPACK_ERR_DATAFORMAT;
-
-	/* inflate block */
-	zip->window_posn = 0;
-	zip->bytes_output = 0;
-	STORE_BITS;
-	if ((error = inflate(zip))) {
-	    D(("inflate error %d", error))
-	    return zip->error = (error > 0) ? error : MSPACK_ERR_DECRUNCH;
-	}
-
-	/* write inflated block */
-	if (zip->sys->write(zip->output, &zip->window[0], zip->bytes_output)
-	    != zip->bytes_output) return zip->error = MSPACK_ERR_WRITE;
+        RESTORE_BITS;
+
+        /* align to bytestream, read block_len */
+        i = bits_left & 7; REMOVE_BITS(i);
+        READ_BITS(block_len, 8);
+        READ_BITS(i, 8); block_len |= i << 8;
+
+        if (block_len == 0) break;
+
+        /* read "CK" header */
+        READ_BITS(i, 8); if (i != 'C') return MSPACK_ERR_DATAFORMAT;
+        READ_BITS(i, 8); if (i != 'K') return MSPACK_ERR_DATAFORMAT;
+
+        /* inflate block */
+        zip->window_posn = 0;
+        zip->bytes_output = 0;
+        STORE_BITS;
+        if ((error = inflate(zip))) {
+            D(("inflate error %d", error))
+            return zip->error = (error > 0) ? error : MSPACK_ERR_DECRUNCH;
+        }
+
+        /* write inflated block */
+        if (zip->sys->write(zip->output, &zip->window[0], zip->bytes_output)
+            != zip->bytes_output) return zip->error = MSPACK_ERR_WRITE;
     }
     return MSPACK_ERR_OK;
 }

data/ext/libmspack/mspack/oab.h

@@ -27,6 +27,7 @@ struct msoab_compressor_p {
 struct msoab_decompressor_p {
   struct msoab_decompressor base;
   struct mspack_system *system;
+  int buf_size;
   /* todo */
 };
 

data/ext/libmspack/mspack/oabd.c

@@ -29,10 +29,15 @@
 
 /* prototypes */
 static int oabd_decompress(struct msoab_decompressor *self, const char *input,
-			   const char *output);
+                           const char *output);
 static int oabd_decompress_incremental(struct msoab_decompressor *self,
-				       const char *input, const char *base,
-				       const char *output);
+                                       const char *input, const char *base,
+                                       const char *output);
+static int oabd_param(struct msoab_decompressor *base, int param, int value);
+static int copy_fh(struct mspack_system *sys, struct mspack_file *infh,
+                   struct mspack_file *outfh, size_t bytes_to_copy,
+                   unsigned char *buf, int buf_size);
+
 
 struct msoab_decompressor *
   mspack_create_oab_decompressor(struct mspack_system *sys)
@@ -45,7 +50,9 @@ struct msoab_decompressor *
   if ((self = (struct msoab_decompressor_p *) sys->alloc(sys, sizeof(struct msoab_decompressor_p)))) {
     self->base.decompress             = &oabd_decompress;
     self->base.decompress_incremental = &oabd_decompress_incremental;
+    self->base.set_param              = &oabd_param;
     self->system                      = sys;
+    self->buf_size                    = 4096;
   }
   return (struct msoab_decompressor *) self;
 }
@@ -94,7 +101,7 @@ static int oabd_sys_write (struct mspack_file *base_file, void *buf, int size)
 }
 
 static int oabd_decompress(struct msoab_decompressor *_self, const char *input,
-			   const char *output)
+                           const char *output)
 {
   struct msoab_decompressor_p *self = (struct msoab_decompressor_p *) _self;
   struct mspack_system *sys;
@@ -132,17 +139,13 @@ static int oabd_decompress(struct msoab_decompressor *_self, const char *input,
   block_max   = EndGetI32(&hdrbuf[oabhead_BlockMax]);
   target_size = EndGetI32(&hdrbuf[oabhead_TargetSize]);
 
-  /* We use it for reading block headers too */
-  if (block_max < oabblk_SIZEOF)
-    block_max = oabblk_SIZEOF;
-
   outfh = sys->open(sys, output, MSPACK_SYS_OPEN_WRITE);
   if (!outfh) {
     ret = MSPACK_ERR_OPEN;
     goto out;
   }
 
-  buf = sys->alloc(sys, block_max);
+  buf = sys->alloc(sys, self->buf_size);
   if (!buf) {
     ret = MSPACK_ERR_NOMEMORY;
     goto out;
@@ -178,79 +181,59 @@ static int oabd_decompress(struct msoab_decompressor *_self, const char *input,
     if (!blk_flags) {
       /* Uncompressed block */
       if (blk_dsize != blk_csize) {
-	ret = MSPACK_ERR_DATAFORMAT;
-	goto out;
-      }
-      if (sys->read(infh, buf, blk_dsize) != (int)blk_dsize) {
-	ret = MSPACK_ERR_READ;
-	goto out;
-      }
-      if (sys->write(outfh, buf, blk_dsize) != (int)blk_dsize) {
-	ret = MSPACK_ERR_WRITE;
-	goto out;
+        ret = MSPACK_ERR_DATAFORMAT;
+        goto out;
       }
+      ret = copy_fh(sys, infh, outfh, blk_dsize, buf, self->buf_size);
+      if (ret) goto out;
     } else {
       /* LZX compressed block */
       window_bits = 17;
 
       while (window_bits < 25 && (1U << window_bits) < blk_dsize)
-	window_bits++;
+        window_bits++;
 
       in_ofh.available = blk_csize;
       out_ofh.crc = 0xffffffff;
 
       lzx = lzxd_init(&oabd_sys, (void *)&in_ofh, (void *)&out_ofh, window_bits,
-		      0, 4096, blk_dsize, 1);
+                      0, self->buf_size, blk_dsize, 1);
       if (!lzx) {
-	ret = MSPACK_ERR_NOMEMORY;
-	goto out;
+        ret = MSPACK_ERR_NOMEMORY;
+        goto out;
       }
 
       ret = lzxd_decompress(lzx, blk_dsize);
       if (ret != MSPACK_ERR_OK)
-	goto out;
+        goto out;
 
       lzxd_free(lzx);
       lzx = NULL;
 
       /* Consume any trailing padding bytes before the next block */
-      while (in_ofh.available) {
-	int count = block_max;
-	if ((size_t)count > in_ofh.available)
-	  count = in_ofh.available;
-
-	count = sys->read(infh, buf, count);
-	if (count < 0) {
-	  ret = MSPACK_ERR_READ;
-	  goto out;
-	}
-	in_ofh.available -= count;
-      }
+      ret = copy_fh(sys, infh, NULL, in_ofh.available, buf, self->buf_size);
+      if (ret) goto out;
 
       if (out_ofh.crc != blk_crc) {
-	ret = MSPACK_ERR_CHECKSUM;
-	goto out;
+        ret = MSPACK_ERR_CHECKSUM;
+        goto out;
       }
     }
     target_size -= blk_dsize;
   }
 
  out:
-  if (lzx)
-    lzxd_free(lzx);
-  if (buf)
-    sys->free(buf);
-  if (outfh)
-    sys->close(outfh);
-  if (infh)
-    sys->close(infh);
+  if (lzx) lzxd_free(lzx);
+  if (outfh) sys->close(outfh);
+  if (infh) sys->close(infh);
+  sys->free(buf);
 
   return ret;
 }
 
 static int oabd_decompress_incremental(struct msoab_decompressor *_self,
-				       const char *input, const char *base,
-				       const char *output)
+                                       const char *input, const char *base,
+                                       const char *output)
 {
   struct msoab_decompressor_p *self = (struct msoab_decompressor_p *) _self;
   struct mspack_system *sys;
@@ -305,7 +288,7 @@ static int oabd_decompress_incremental(struct msoab_decompressor *_self,
     goto out;
   }
 
-  buf = sys->alloc(sys, block_max);
+  buf = sys->alloc(sys, self->buf_size);
   if (!buf) {
     ret = MSPACK_ERR_NOMEMORY;
     goto out;
@@ -334,7 +317,7 @@ static int oabd_decompress_incremental(struct msoab_decompressor *_self,
     blk_crc   = EndGetI32(&buf[patchblk_CRC]);
 
     if (blk_dsize > block_max || blk_dsize > target_size ||
-	blk_ssize > block_max) {
+        blk_ssize > block_max) {
       ret = MSPACK_ERR_DATAFORMAT;
       goto out;
     }
@@ -351,7 +334,7 @@ static int oabd_decompress_incremental(struct msoab_decompressor *_self,
     out_ofh.crc = 0xffffffff;
 
     lzx = lzxd_init(&oabd_sys, (void *)&in_ofh, (void *)&out_ofh, window_bits,
-		    0, 4096, blk_dsize, 1);
+                    0, 4096, blk_dsize, 1);
     if (!lzx) {
       ret = MSPACK_ERR_NOMEMORY;
       goto out;
@@ -368,18 +351,8 @@ static int oabd_decompress_incremental(struct msoab_decompressor *_self,
     lzx = NULL;
 
     /* Consume any trailing padding bytes before the next block */
-    while (in_ofh.available) {
-      int count = block_max;
-      if ((size_t)count > in_ofh.available)
-	count = in_ofh.available;
-
-      count = sys->read(infh, buf, count);
-      if (count < 0) {
-	ret = MSPACK_ERR_READ;
-	goto out;
-      }
-      in_ofh.available -= count;
-    }
+    ret = copy_fh(sys, infh, NULL, in_ofh.available, buf, self->buf_size);
+    if (ret) goto out;
 
     if (out_ofh.crc != blk_crc) {
       ret = MSPACK_ERR_CHECKSUM;
@@ -390,16 +363,41 @@ static int oabd_decompress_incremental(struct msoab_decompressor *_self,
   }
 
  out:
-  if (lzx)
-    lzxd_free(lzx);
-  if (buf)
-    sys->free(buf);
-  if (outfh)
-    sys->close(outfh);
-  if (basefh)
-    sys->close(basefh);
-  if (infh)
-    sys->close(infh);
+  if (lzx) lzxd_free(lzx);
+  if (outfh) sys->close(outfh);
+  if (basefh) sys->close(basefh);
+  if (infh) sys->close(infh);
+  sys->free(buf);
 
   return ret;
 }
+
+static int copy_fh(struct mspack_system *sys, struct mspack_file *infh,
+                   struct mspack_file *outfh, size_t bytes_to_copy,
+                   unsigned char *buf, int buf_size)
+{
+    while (bytes_to_copy) {
+        int run = buf_size;
+        if ((size_t) run > bytes_to_copy) {
+            run = (int) bytes_to_copy;
+        }
+        if (sys->read(infh, buf, run) != run) {
+            return MSPACK_ERR_READ;
+        }
+        if (outfh && sys->write(outfh, buf, run) != run) {
+            return MSPACK_ERR_WRITE;
+        }
+        bytes_to_copy -= run;
+    }
+    return MSPACK_ERR_OK;
+}
+
+static int oabd_param(struct msoab_decompressor *base, int param, int value) {
+    struct msoab_decompressor_p *self = (struct msoab_decompressor_p *) base;
+    if (self && param == MSOABD_PARAM_DECOMPBUF && value >= 16) {
+        /* must be at least 16 bytes (patchblk_SIZEOF, oabblk_SIZEOF) */
+        self->buf_size = value;
+        return MSPACK_ERR_OK;
+    }
+    return MSPACK_ERR_ARGS;
+}

data/ext/libmspack/mspack/qtm.h

@@ -90,10 +90,10 @@ struct qtmd_stream {
  * - input_buffer_size is the number of bytes to use to store bitstream data.
  */
 extern struct qtmd_stream *qtmd_init(struct mspack_system *system,
-				     struct mspack_file *input,
-				     struct mspack_file *output,
-				     int window_bits,
-				     int input_buffer_size);
+                                     struct mspack_file *input,
+                                     struct mspack_file *output,
+                                     int window_bits,
+                                     int input_buffer_size);
 
 /* decompresses, or decompresses more of, a Quantum stream.
  *