add new system file

hc

2024-02-20 102a0743326a03cd1a1202ceda21e175b7d3575c

 kernel/lib/zlib_deflate/defutil.h
..
..
@@ -1,5 +1,7 @@
1
+#ifndef DEFUTIL_H
2
+#define DEFUTIL_H
1
3
 
2
-
4
+#include <linux/zutil.h>
3
5
 
4
6
 #define Assert(err, str) 
5
7
 #define Trace(dummy) 
..
..
@@ -238,17 +240,13 @@
238
240
 
239
241
 } deflate_state;
240
242
 
241
-typedef struct deflate_workspace {
242
-    /* State memory for the deflator */
243
-    deflate_state deflate_memory;
244
-    Byte *window_memory;
245
-    Pos *prev_memory;
246
-    Pos *head_memory;
247
-    char *overlay_memory;
248
-} deflate_workspace;
249
-
243
+#ifdef CONFIG_ZLIB_DFLTCC
244
+#define zlib_deflate_window_memsize(windowBits) \
245
+	(2 * (1 << (windowBits)) * sizeof(Byte) + PAGE_SIZE)
246
+#else
250
247
 #define zlib_deflate_window_memsize(windowBits) \
251
248
 	(2 * (1 << (windowBits)) * sizeof(Byte))
249
+#endif
252
250
 #define zlib_deflate_prev_memsize(windowBits) \
253
251
 	((1 << (windowBits)) * sizeof(Pos))
254
252
 #define zlib_deflate_head_memsize(memLevel) \
..
..
@@ -293,6 +291,24 @@
293
291
 }
294
292
 
295
293
 /* ===========================================================================
294
+ * Reverse the first len bits of a code, using straightforward code (a faster
295
+ * method would use a table)
296
+ * IN assertion: 1 <= len <= 15
297
+ */
298
+static inline unsigned  bi_reverse(
299
+    unsigned code, /* the value to invert */
300
+    int len        /* its bit length */
301
+)
302
+{
303
+    register unsigned res = 0;
304
+    do {
305
+        res |= code & 1;
306
+        code >>= 1, res <<= 1;
307
+    } while (--len > 0);
308
+    return res >> 1;
309
+}
310
+
311
+/* ===========================================================================
296
312
  * Flush the bit buffer, keeping at most 7 bits in it.
297
313
  */
298
314
 static inline void bi_flush(deflate_state *s)
..
..
@@ -325,3 +341,101 @@
325
341
 #endif
326
342
 }
327
343
 
344
+typedef enum {
345
+    need_more,      /* block not completed, need more input or more output */
346
+    block_done,     /* block flush performed */
347
+    finish_started, /* finish started, need only more output at next deflate */
348
+    finish_done     /* finish done, accept no more input or output */
349
+} block_state;
350
+
351
+#define Buf_size (8 * 2*sizeof(char))
352
+/* Number of bits used within bi_buf. (bi_buf might be implemented on
353
+ * more than 16 bits on some systems.)
354
+ */
355
+
356
+/* ===========================================================================
357
+ * Send a value on a given number of bits.
358
+ * IN assertion: length <= 16 and value fits in length bits.
359
+ */
360
+#ifdef DEBUG_ZLIB
361
+static void send_bits      (deflate_state *s, int value, int length);
362
+
363
+static void send_bits(
364
+    deflate_state *s,
365
+    int value,  /* value to send */
366
+    int length  /* number of bits */
367
+)
368
+{
369
+    Tracevv((stderr," l %2d v %4x ", length, value));
370
+    Assert(length > 0 && length <= 15, "invalid length");
371
+    s->bits_sent += (ulg)length;
372
+
373
+    /* If not enough room in bi_buf, use (valid) bits from bi_buf and
374
+     * (16 - bi_valid) bits from value, leaving (width - (16-bi_valid))
375
+     * unused bits in value.
376
+     */
377
+    if (s->bi_valid > (int)Buf_size - length) {
378
+        s->bi_buf |= (value << s->bi_valid);
379
+        put_short(s, s->bi_buf);
380
+        s->bi_buf = (ush)value >> (Buf_size - s->bi_valid);
381
+        s->bi_valid += length - Buf_size;
382
+    } else {
383
+        s->bi_buf |= value << s->bi_valid;
384
+        s->bi_valid += length;
385
+    }
386
+}
387
+#else /* !DEBUG_ZLIB */
388
+
389
+#define send_bits(s, value, length) \
390
+{ int len = length;\
391
+  if (s->bi_valid > (int)Buf_size - len) {\
392
+    int val = value;\
393
+    s->bi_buf |= (val << s->bi_valid);\
394
+    put_short(s, s->bi_buf);\
395
+    s->bi_buf = (ush)val >> (Buf_size - s->bi_valid);\
396
+    s->bi_valid += len - Buf_size;\
397
+  } else {\
398
+    s->bi_buf |= (value) << s->bi_valid;\
399
+    s->bi_valid += len;\
400
+  }\
401
+}
402
+#endif /* DEBUG_ZLIB */
403
+
404
+static inline void zlib_tr_send_bits(
405
+    deflate_state *s,
406
+    int value,
407
+    int length
408
+)
409
+{
410
+    send_bits(s, value, length);
411
+}
412
+
413
+/* =========================================================================
414
+ * Flush as much pending output as possible. All deflate() output goes
415
+ * through this function so some applications may wish to modify it
416
+ * to avoid allocating a large strm->next_out buffer and copying into it.
417
+ * (See also read_buf()).
418
+ */
419
+static inline void flush_pending(
420
+	z_streamp strm
421
+)
422
+{
423
+    deflate_state *s = (deflate_state *) strm->state;
424
+    unsigned len = s->pending;
425
+
426
+    if (len > strm->avail_out) len = strm->avail_out;
427
+    if (len == 0) return;
428
+
429
+    if (strm->next_out != NULL) {
430
+	memcpy(strm->next_out, s->pending_out, len);
431
+	strm->next_out += len;
432
+    }
433
+    s->pending_out += len;
434
+    strm->total_out += len;
435
+    strm->avail_out  -= len;
436
+    s->pending -= len;
437
+    if (s->pending == 0) {
438
+        s->pending_out = s->pending_buf;
439
+    }
440
+}
441
+#endif /* DEFUTIL_H */