defutil.h (e5451c8f8330e03ad3cfa16048b4daf961af434f) defutil.h (aa5b395b69b65450e008b95ec623b4fc4b175f9f)
1#ifndef DEFUTIL_H
2#define DEFUTIL_H
1
3
4#include <linux/zutil.h>
2
5
3
4#define Assert(err, str)
5#define Trace(dummy)
6#define Tracev(dummy)
7#define Tracecv(err, dummy)
8#define Tracevv(dummy)
9
10
11

--- 221 unchanged lines hidden (view full) ---

233 */
234 int bi_valid;
235 /* Number of valid bits in bi_buf. All bits above the last valid bit
236 * are always zero.
237 */
238
239} deflate_state;
240
6#define Assert(err, str)
7#define Trace(dummy)
8#define Tracev(dummy)
9#define Tracecv(err, dummy)
10#define Tracevv(dummy)
11
12
13

--- 221 unchanged lines hidden (view full) ---

235 */
236 int bi_valid;
237 /* Number of valid bits in bi_buf. All bits above the last valid bit
238 * are always zero.
239 */
240
241} deflate_state;
242
241typedef 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
250#define zlib_deflate_window_memsize(windowBits) \
244#define zlib_deflate_window_memsize(windowBits) \
245 (2 * (1 << (windowBits)) * sizeof(Byte) + PAGE_SIZE)
246#else
247#define zlib_deflate_window_memsize(windowBits) \
251 (2 * (1 << (windowBits)) * sizeof(Byte))
248 (2 * (1 << (windowBits)) * sizeof(Byte))
249#endif
252#define zlib_deflate_prev_memsize(windowBits) \
253 ((1 << (windowBits)) * sizeof(Pos))
254#define zlib_deflate_head_memsize(memLevel) \
255 ((1 << ((memLevel)+7)) * sizeof(Pos))
256#define zlib_deflate_overlay_memsize(memLevel) \
257 ((1 << ((memLevel)+6)) * (sizeof(ush)+2))
258
259/* Output a byte on the stream.

--- 28 unchanged lines hidden (view full) ---

288 * IN assertion: there is enough room in pendingBuf.
289 */
290#define put_short(s, w) { \
291 put_byte(s, (uch)((w) & 0xff)); \
292 put_byte(s, (uch)((ush)(w) >> 8)); \
293}
294
295/* ===========================================================================
250#define zlib_deflate_prev_memsize(windowBits) \
251 ((1 << (windowBits)) * sizeof(Pos))
252#define zlib_deflate_head_memsize(memLevel) \
253 ((1 << ((memLevel)+7)) * sizeof(Pos))
254#define zlib_deflate_overlay_memsize(memLevel) \
255 ((1 << ((memLevel)+6)) * (sizeof(ush)+2))
256
257/* Output a byte on the stream.

--- 28 unchanged lines hidden (view full) ---

286 * IN assertion: there is enough room in pendingBuf.
287 */
288#define put_short(s, w) { \
289 put_byte(s, (uch)((w) & 0xff)); \
290 put_byte(s, (uch)((ush)(w) >> 8)); \
291}
292
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 */
298static 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 * Flush the bit buffer, keeping at most 7 bits in it.
297 */
298static inline void bi_flush(deflate_state *s)
299{
300 if (s->bi_valid == 16) {
301 put_short(s, s->bi_buf);
302 s->bi_buf = 0;
303 s->bi_valid = 0;

--- 16 unchanged lines hidden (view full) ---

320 }
321 s->bi_buf = 0;
322 s->bi_valid = 0;
323#ifdef DEBUG_ZLIB
324 s->bits_sent = (s->bits_sent+7) & ~7;
325#endif
326}
327
312 * Flush the bit buffer, keeping at most 7 bits in it.
313 */
314static inline void bi_flush(deflate_state *s)
315{
316 if (s->bi_valid == 16) {
317 put_short(s, s->bi_buf);
318 s->bi_buf = 0;
319 s->bi_valid = 0;

--- 16 unchanged lines hidden (view full) ---

336 }
337 s->bi_buf = 0;
338 s->bi_valid = 0;
339#ifdef DEBUG_ZLIB
340 s->bits_sent = (s->bits_sent+7) & ~7;
341#endif
342}
343
344typedef 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
361static void send_bits (deflate_state *s, int value, int length);
362
363static 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
404static 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 */
419static 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 */