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 */ |
|