1 Clazz.declarePackage ("JU");
\r
2 Clazz.load (["JU.Tree"], "JU.Deflate", ["JU.CRC32", "$.GZIPHeader", "$.StaticTree"], function () {
\r
3 c$ = Clazz.decorateAsClass (function () {
\r
6 this.pending_buf = null;
\r
7 this.pending_buf_size = 0;
\r
8 this.pending_out = 0;
\r
13 this.last_flush = 0;
\r
18 this.window_size = 0;
\r
25 this.hash_shift = 0;
\r
26 this.block_start = 0;
\r
27 this.match_length = 0;
\r
28 this.prev_match = 0;
\r
29 this.match_available = 0;
\r
31 this.match_start = 0;
\r
33 this.prev_length = 0;
\r
34 this.max_chain_length = 0;
\r
35 this.max_lazy_match = 0;
\r
38 this.good_match = 0;
\r
39 this.nice_match = 0;
\r
40 this.dyn_ltree = null;
\r
41 this.dyn_dtree = null;
\r
42 this.bl_tree = null;
\r
45 this.bl_desc = null;
\r
46 this.bl_count = null;
\r
52 this.lit_bufsize = 0;
\r
56 this.static_len = 0;
\r
58 this.last_eob_len = 0;
\r
61 this.gheader = null;
\r
62 Clazz.instantialize (this, arguments);
\r
64 Clazz.prepareFields (c$, function () {
\r
65 this.l_desc = new JU.Tree ();
\r
66 this.d_desc = new JU.Tree ();
\r
67 this.bl_desc = new JU.Tree ();
\r
68 this.bl_count = Clazz.newShortArray (16, 0);
\r
69 this.heap = Clazz.newIntArray (573, 0);
\r
70 this.depth = Clazz.newByteArray (573, 0);
\r
72 Clazz.makeConstructor (c$,
\r
75 this.dyn_ltree = Clazz.newShortArray (1146, 0);
\r
76 this.dyn_dtree = Clazz.newShortArray (122, 0);
\r
77 this.bl_tree = Clazz.newShortArray (78, 0);
\r
79 Clazz.defineMethod (c$, "deflateInit",
\r
81 return this.deflateInit2 (level, 15);
\r
83 Clazz.defineMethod (c$, "deflateInit2",
\r
84 function (level, bits) {
\r
85 return this.deflateInit5 (level, 8, bits, 8, 0);
\r
87 Clazz.defineMethod (c$, "deflateInit3",
\r
88 function (level, bits, memlevel) {
\r
89 return this.deflateInit5 (level, 8, bits, memlevel, 0);
\r
91 Clazz.defineMethod (c$, "lm_init",
\r
93 this.window_size = 2 * this.w_size;
\r
94 this.head[this.hash_size - 1] = 0;
\r
95 for (var i = 0; i < this.hash_size - 1; i++) {
\r
98 this.max_lazy_match = JU.Deflate.config_table[this.level].max_lazy;
\r
99 this.good_match = JU.Deflate.config_table[this.level].good_length;
\r
100 this.nice_match = JU.Deflate.config_table[this.level].nice_length;
\r
101 this.max_chain_length = JU.Deflate.config_table[this.level].max_chain;
\r
103 this.block_start = 0;
\r
104 this.lookahead = 0;
\r
105 this.match_length = this.prev_length = 2;
\r
106 this.match_available = 0;
\r
109 Clazz.defineMethod (c$, "tr_init",
\r
111 this.l_desc.dyn_tree = this.dyn_ltree;
\r
112 this.l_desc.stat_desc = JU.StaticTree.static_l_desc;
\r
113 this.d_desc.dyn_tree = this.dyn_dtree;
\r
114 this.d_desc.stat_desc = JU.StaticTree.static_d_desc;
\r
115 this.bl_desc.dyn_tree = this.bl_tree;
\r
116 this.bl_desc.stat_desc = JU.StaticTree.static_bl_desc;
\r
119 this.last_eob_len = 8;
\r
120 this.init_block ();
\r
122 Clazz.defineMethod (c$, "init_block",
\r
124 for (var i = 0; i < 286; i++) this.dyn_ltree[i * 2] = 0;
\r
126 for (var i = 0; i < 30; i++) this.dyn_dtree[i * 2] = 0;
\r
128 for (var i = 0; i < 19; i++) this.bl_tree[i * 2] = 0;
\r
130 this.dyn_ltree[512] = 1;
\r
131 this.opt_len = this.static_len = 0;
\r
132 this.last_lit = this.matches = 0;
\r
134 Clazz.defineMethod (c$, "pqdownheap",
\r
135 function (tree, k) {
\r
136 var v = this.heap[k];
\r
138 while (j <= this.heap_len) {
\r
139 if (j < this.heap_len && JU.Deflate.smaller (tree, this.heap[j + 1], this.heap[j], this.depth)) {
\r
141 }if (JU.Deflate.smaller (tree, v, this.heap[j], this.depth)) break;
\r
142 this.heap[k] = this.heap[j];
\r
148 c$.smaller = Clazz.defineMethod (c$, "smaller",
\r
149 function (tree, n, m, depth) {
\r
150 var tn2 = tree[n * 2];
\r
151 var tm2 = tree[m * 2];
\r
152 return (tn2 < tm2 || (tn2 == tm2 && depth[n] <= depth[m]));
\r
154 Clazz.defineMethod (c$, "scan_tree",
\r
155 function (tree, max_code) {
\r
159 var nextlen = tree[1];
\r
163 if (nextlen == 0) {
\r
166 }tree[(max_code + 1) * 2 + 1] = 0xffff;
\r
167 for (n = 0; n <= max_code; n++) {
\r
169 nextlen = tree[(n + 1) * 2 + 1];
\r
170 if (++count < max_count && curlen == nextlen) {
\r
172 } else if (count < min_count) {
\r
173 this.bl_tree[curlen * 2] += count;
\r
174 } else if (curlen != 0) {
\r
175 if (curlen != prevlen) this.bl_tree[curlen * 2]++;
\r
176 this.bl_tree[32]++;
\r
177 } else if (count <= 10) {
\r
178 this.bl_tree[34]++;
\r
180 this.bl_tree[36]++;
\r
183 if (nextlen == 0) {
\r
186 } else if (curlen == nextlen) {
\r
194 Clazz.defineMethod (c$, "build_bl_tree",
\r
197 this.scan_tree (this.dyn_ltree, this.l_desc.max_code);
\r
198 this.scan_tree (this.dyn_dtree, this.d_desc.max_code);
\r
199 this.bl_desc.build_tree (this);
\r
200 for (max_blindex = 18; max_blindex >= 3; max_blindex--) {
\r
201 if (this.bl_tree[JU.Tree.bl_order[max_blindex] * 2 + 1] != 0) break;
\r
203 this.opt_len += 3 * (max_blindex + 1) + 5 + 5 + 4;
\r
204 return max_blindex;
\r
206 Clazz.defineMethod (c$, "send_all_trees",
\r
207 function (lcodes, dcodes, blcodes) {
\r
209 this.send_bits (lcodes - 257, 5);
\r
210 this.send_bits (dcodes - 1, 5);
\r
211 this.send_bits (blcodes - 4, 4);
\r
212 for (rank = 0; rank < blcodes; rank++) {
\r
213 this.send_bits (this.bl_tree[JU.Tree.bl_order[rank] * 2 + 1], 3);
\r
215 this.send_tree (this.dyn_ltree, lcodes - 1);
\r
216 this.send_tree (this.dyn_dtree, dcodes - 1);
\r
218 Clazz.defineMethod (c$, "send_tree",
\r
219 function (tree, max_code) {
\r
223 var nextlen = tree[1];
\r
227 if (nextlen == 0) {
\r
230 }for (n = 0; n <= max_code; n++) {
\r
232 nextlen = tree[(n + 1) * 2 + 1];
\r
233 if (++count < max_count && curlen == nextlen) {
\r
235 } else if (count < min_count) {
\r
237 this.send_code (curlen, this.bl_tree);
\r
238 } while (--count != 0);
\r
239 } else if (curlen != 0) {
\r
240 if (curlen != prevlen) {
\r
241 this.send_code (curlen, this.bl_tree);
\r
243 }this.send_code (16, this.bl_tree);
\r
244 this.send_bits (count - 3, 2);
\r
245 } else if (count <= 10) {
\r
246 this.send_code (17, this.bl_tree);
\r
247 this.send_bits (count - 3, 3);
\r
249 this.send_code (18, this.bl_tree);
\r
250 this.send_bits (count - 11, 7);
\r
253 if (nextlen == 0) {
\r
256 } else if (curlen == nextlen) {
\r
264 Clazz.defineMethod (c$, "put_byte",
\r
265 function (p, start, len) {
\r
266 System.arraycopy (p, start, this.pending_buf, this.pending, len);
\r
267 this.pending += len;
\r
269 Clazz.defineMethod (c$, "put_byteB",
\r
272 this.pending_buf[this.pending++] = c&0xff;
\r
274 Clazz.defineMethod (c$, "put_short",
\r
276 this.put_byteB ((w));
\r
277 this.put_byteB ((w >>> 8));
\r
279 Clazz.defineMethod (c$, "putShortMSB",
\r
281 this.put_byteB ((b >> 8));
\r
282 this.put_byteB ((b));
\r
284 Clazz.defineMethod (c$, "send_code",
\r
285 function (c, tree) {
\r
287 this.send_bits ((tree[c2] & 0xffff), (tree[c2 + 1] & 0xffff));
\r
289 Clazz.defineMethod (c$, "send_bits",
\r
290 function (value, length) {
\r
292 if (this.bi_valid > 16 - len) {
\r
294 this.bi_buf |= ((val << this.bi_valid) & 0xffff);
\r
295 this.put_short (this.bi_buf);
\r
296 this.bi_buf = ((val >>> (16 - this.bi_valid)) & 0xffff);
\r
297 this.bi_valid += len - 16;
\r
299 this.bi_buf |= (((value) << this.bi_valid) & 0xffff);
\r
300 this.bi_valid += len;
\r
302 Clazz.defineMethod (c$, "_tr_align",
\r
304 this.send_bits (2, 3);
\r
305 this.send_code (256, JU.StaticTree.static_ltree);
\r
307 if (1 + this.last_eob_len + 10 - this.bi_valid < 9) {
\r
308 this.send_bits (2, 3);
\r
309 this.send_code (256, JU.StaticTree.static_ltree);
\r
311 }this.last_eob_len = 7;
\r
313 Clazz.defineMethod (c$, "_tr_tally",
\r
314 function (dist, lc) {
\r
315 this.pending_buf[this.d_buf + this.last_lit * 2] = (dist >>> 8);
\r
316 this.pending_buf[this.d_buf + this.last_lit * 2 + 1] = dist;
\r
317 this.pending_buf[this.l_buf + this.last_lit] = lc;
\r
320 this.dyn_ltree[lc * 2]++;
\r
324 this.dyn_ltree[(JU.Tree._length_code[lc] + 256 + 1) * 2]++;
\r
325 this.dyn_dtree[JU.Tree.d_code (dist) * 2]++;
\r
326 }if ((this.last_lit & 0x1fff) == 0 && this.level > 2) {
\r
327 var out_length = this.last_lit * 8;
\r
328 var in_length = this.strstart - this.block_start;
\r
330 for (dcode = 0; dcode < 30; dcode++) {
\r
331 out_length += this.dyn_dtree[dcode * 2] * (5 + JU.Tree.extra_dbits[dcode]);
\r
334 if ((this.matches < (Clazz.doubleToInt (this.last_lit / 2))) && out_length < Clazz.doubleToInt (in_length / 2)) return true;
\r
335 }return (this.last_lit == this.lit_bufsize - 1);
\r
337 Clazz.defineMethod (c$, "compress_block",
\r
338 function (ltree, dtree) {
\r
344 if (this.last_lit != 0) {
\r
346 dist = ((this.pending_buf[this.d_buf + lx * 2] << 8) & 0xff00) | (this.pending_buf[this.d_buf + lx * 2 + 1] & 0xff);
\r
347 lc = (this.pending_buf[this.l_buf + lx]) & 0xff;
\r
350 this.send_code (lc, ltree);
\r
352 code = JU.Tree._length_code[lc];
\r
353 this.send_code (code + 256 + 1, ltree);
\r
354 extra = JU.Tree.extra_lbits[code];
\r
356 lc -= JU.Tree.base_length[code];
\r
357 this.send_bits (lc, extra);
\r
359 code = JU.Tree.d_code (dist);
\r
360 this.send_code (code, dtree);
\r
361 extra = JU.Tree.extra_dbits[code];
\r
363 dist -= JU.Tree.base_dist[code];
\r
364 this.send_bits (dist, extra);
\r
365 }}} while (lx < this.last_lit);
\r
366 }this.send_code (256, ltree);
\r
367 this.last_eob_len = ltree[513];
\r
369 Clazz.defineMethod (c$, "set_data_type",
\r
372 var ascii_freq = 0;
\r
375 bin_freq += this.dyn_ltree[n * 2];
\r
379 ascii_freq += this.dyn_ltree[n * 2];
\r
383 bin_freq += this.dyn_ltree[n * 2];
\r
386 this.data_type = (bin_freq > (ascii_freq >>> 2) ? 0 : 1);
\r
388 Clazz.defineMethod (c$, "bi_flush",
\r
390 if (this.bi_valid == 16) {
\r
391 this.put_short (this.bi_buf);
\r
394 } else if (this.bi_valid >= 8) {
\r
395 this.put_byteB (this.bi_buf);
\r
396 this.bi_buf >>>= 8;
\r
397 this.bi_valid -= 8;
\r
399 Clazz.defineMethod (c$, "bi_windup",
\r
401 if (this.bi_valid > 8) {
\r
402 this.put_short (this.bi_buf);
\r
403 } else if (this.bi_valid > 0) {
\r
404 this.put_byteB (this.bi_buf);
\r
408 Clazz.defineMethod (c$, "copy_block",
\r
409 function (buf, len, header) {
\r
411 this.last_eob_len = 8;
\r
413 this.put_short (len);
\r
414 this.put_short (~len);
\r
415 }this.put_byte (this.window, buf, len);
\r
417 Clazz.defineMethod (c$, "flush_block_only",
\r
419 this._tr_flush_block (this.block_start >= 0 ? this.block_start : -1, this.strstart - this.block_start, eof);
\r
420 this.block_start = this.strstart;
\r
421 this.strm.flush_pending ();
\r
423 Clazz.defineMethod (c$, "deflate_stored",
\r
425 var max_block_size = 0xffff;
\r
427 if (max_block_size > this.pending_buf_size - 5) {
\r
428 max_block_size = this.pending_buf_size - 5;
\r
430 if (this.lookahead <= 1) {
\r
431 this.fill_window ();
\r
432 if (this.lookahead == 0 && flush == 0) return 0;
\r
433 if (this.lookahead == 0) break;
\r
434 }this.strstart += this.lookahead;
\r
435 this.lookahead = 0;
\r
436 max_start = this.block_start + max_block_size;
\r
437 if (this.strstart == 0 || this.strstart >= max_start) {
\r
438 this.lookahead = (this.strstart - max_start);
\r
439 this.strstart = max_start;
\r
440 this.flush_block_only (false);
\r
441 if (this.strm.avail_out == 0) return 0;
\r
442 }if (this.strstart - this.block_start >= this.w_size - 262) {
\r
443 this.flush_block_only (false);
\r
444 if (this.strm.avail_out == 0) return 0;
\r
446 this.flush_block_only (flush == 4);
\r
447 if (this.strm.avail_out == 0) return (flush == 4) ? 2 : 0;
\r
448 return flush == 4 ? 3 : 1;
\r
450 Clazz.defineMethod (c$, "_tr_stored_block",
\r
451 function (buf, stored_len, eof) {
\r
452 this.send_bits ((0) + (eof ? 1 : 0), 3);
\r
453 this.copy_block (buf, stored_len, true);
\r
455 Clazz.defineMethod (c$, "_tr_flush_block",
\r
456 function (buf, stored_len, eof) {
\r
459 var max_blindex = 0;
\r
460 if (this.level > 0) {
\r
461 if (this.data_type == 2) this.set_data_type ();
\r
462 this.l_desc.build_tree (this);
\r
463 this.d_desc.build_tree (this);
\r
464 max_blindex = this.build_bl_tree ();
\r
465 opt_lenb = (this.opt_len + 3 + 7) >>> 3;
\r
466 static_lenb = (this.static_len + 3 + 7) >>> 3;
\r
467 if (static_lenb <= opt_lenb) opt_lenb = static_lenb;
\r
469 opt_lenb = static_lenb = stored_len + 5;
\r
470 }if (stored_len + 4 <= opt_lenb && buf != -1) {
\r
471 this._tr_stored_block (buf, stored_len, eof);
\r
472 } else if (static_lenb == opt_lenb) {
\r
473 this.send_bits ((2) + (eof ? 1 : 0), 3);
\r
474 this.compress_block (JU.StaticTree.static_ltree, JU.StaticTree.static_dtree);
\r
476 this.send_bits ((4) + (eof ? 1 : 0), 3);
\r
477 this.send_all_trees (this.l_desc.max_code + 1, this.d_desc.max_code + 1, max_blindex + 1);
\r
478 this.compress_block (this.dyn_ltree, this.dyn_dtree);
\r
479 }this.init_block ();
\r
483 Clazz.defineMethod (c$, "fill_window",
\r
490 more = (this.window_size - this.lookahead - this.strstart);
\r
491 if (more == 0 && this.strstart == 0 && this.lookahead == 0) {
\r
492 more = this.w_size;
\r
493 } else if (more == -1) {
\r
495 } else if (this.strstart >= this.w_size + this.w_size - 262) {
\r
496 System.arraycopy (this.window, this.w_size, this.window, 0, this.w_size);
\r
497 this.match_start -= this.w_size;
\r
498 this.strstart -= this.w_size;
\r
499 this.block_start -= this.w_size;
\r
500 n = this.hash_size;
\r
503 m = (this.head[--p] & 0xffff);
\r
504 this.head[p] = (m >= this.w_size ? (m - this.w_size) : 0);
\r
505 } while (--n != 0);
\r
509 m = (this.prev[--p] & 0xffff);
\r
510 this.prev[p] = (m >= this.w_size ? (m - this.w_size) : 0);
\r
511 } while (--n != 0);
\r
512 more += this.w_size;
\r
513 }if (this.strm.avail_in == 0) return;
\r
514 n = this.strm.read_buf (this.window, this.strstart + this.lookahead, more);
\r
515 this.lookahead += n;
\r
516 if (this.lookahead >= 3) {
\r
517 this.ins_h = this.window[this.strstart] & 0xff;
\r
518 this.ins_h = (((this.ins_h) << this.hash_shift) ^ (this.window[this.strstart + 1] & 0xff)) & this.hash_mask;
\r
519 }} while (this.lookahead < 262 && this.strm.avail_in != 0);
\r
521 Clazz.defineMethod (c$, "deflate_fast",
\r
526 if (this.lookahead < 262) {
\r
527 this.fill_window ();
\r
528 if (this.lookahead < 262 && flush == 0) {
\r
530 }if (this.lookahead == 0) break;
\r
531 }if (this.lookahead >= 3) {
\r
532 this.ins_h = (((this.ins_h) << this.hash_shift) ^ (this.window[(this.strstart) + (2)] & 0xff)) & this.hash_mask;
\r
533 hash_head = (this.head[this.ins_h] & 0xffff);
\r
534 this.prev[this.strstart & this.w_mask] = this.head[this.ins_h];
\r
535 this.head[this.ins_h] = this.strstart;
\r
536 }if (hash_head != 0 && ((this.strstart - hash_head) & 0xffff) <= this.w_size - 262) {
\r
537 if (this.strategy != 2) {
\r
538 this.match_length = this.longest_match (hash_head);
\r
539 }}if (this.match_length >= 3) {
\r
540 bflush = this._tr_tally (this.strstart - this.match_start, this.match_length - 3);
\r
541 this.lookahead -= this.match_length;
\r
542 if (this.match_length <= this.max_lazy_match && this.lookahead >= 3) {
\r
543 this.match_length--;
\r
546 this.ins_h = ((this.ins_h << this.hash_shift) ^ (this.window[(this.strstart) + (2)] & 0xff)) & this.hash_mask;
\r
547 hash_head = (this.head[this.ins_h] & 0xffff);
\r
548 this.prev[this.strstart & this.w_mask] = this.head[this.ins_h];
\r
549 this.head[this.ins_h] = this.strstart;
\r
550 } while (--this.match_length != 0);
\r
553 this.strstart += this.match_length;
\r
554 this.match_length = 0;
\r
555 this.ins_h = this.window[this.strstart] & 0xff;
\r
556 this.ins_h = (((this.ins_h) << this.hash_shift) ^ (this.window[this.strstart + 1] & 0xff)) & this.hash_mask;
\r
558 bflush = this._tr_tally (0, this.window[this.strstart] & 0xff);
\r
562 this.flush_block_only (false);
\r
563 if (this.strm.avail_out == 0) return 0;
\r
565 this.flush_block_only (flush == 4);
\r
566 if (this.strm.avail_out == 0) {
\r
567 if (flush == 4) return 2;
\r
569 }return flush == 4 ? 3 : 1;
\r
571 Clazz.defineMethod (c$, "deflate_slow",
\r
576 if (this.lookahead < 262) {
\r
577 this.fill_window ();
\r
578 if (this.lookahead < 262 && flush == 0) {
\r
580 }if (this.lookahead == 0) break;
\r
581 }if (this.lookahead >= 3) {
\r
582 this.ins_h = (((this.ins_h) << this.hash_shift) ^ (this.window[(this.strstart) + (2)] & 0xff)) & this.hash_mask;
\r
583 hash_head = (this.head[this.ins_h] & 0xffff);
\r
584 this.prev[this.strstart & this.w_mask] = this.head[this.ins_h];
\r
585 this.head[this.ins_h] = this.strstart;
\r
586 }this.prev_length = this.match_length;
\r
587 this.prev_match = this.match_start;
\r
588 this.match_length = 2;
\r
589 if (hash_head != 0 && this.prev_length < this.max_lazy_match && ((this.strstart - hash_head) & 0xffff) <= this.w_size - 262) {
\r
590 if (this.strategy != 2) {
\r
591 this.match_length = this.longest_match (hash_head);
\r
592 }if (this.match_length <= 5 && (this.strategy == 1 || (this.match_length == 3 && this.strstart - this.match_start > 4096))) {
\r
593 this.match_length = 2;
\r
594 }}if (this.prev_length >= 3 && this.match_length <= this.prev_length) {
\r
595 var max_insert = this.strstart + this.lookahead - 3;
\r
596 bflush = this._tr_tally (this.strstart - 1 - this.prev_match, this.prev_length - 3);
\r
597 this.lookahead -= this.prev_length - 1;
\r
598 this.prev_length -= 2;
\r
600 if (++this.strstart <= max_insert) {
\r
601 this.ins_h = (((this.ins_h) << this.hash_shift) ^ (this.window[(this.strstart) + (2)] & 0xff)) & this.hash_mask;
\r
602 hash_head = (this.head[this.ins_h] & 0xffff);
\r
603 this.prev[this.strstart & this.w_mask] = this.head[this.ins_h];
\r
604 this.head[this.ins_h] = this.strstart;
\r
605 }} while (--this.prev_length != 0);
\r
606 this.match_available = 0;
\r
607 this.match_length = 2;
\r
610 this.flush_block_only (false);
\r
611 if (this.strm.avail_out == 0) return 0;
\r
612 }} else if (this.match_available != 0) {
\r
613 bflush = this._tr_tally (0, this.window[this.strstart - 1] & 0xff);
\r
615 this.flush_block_only (false);
\r
618 if (this.strm.avail_out == 0) return 0;
\r
620 this.match_available = 1;
\r
624 if (this.match_available != 0) {
\r
625 bflush = this._tr_tally (0, this.window[this.strstart - 1] & 0xff);
\r
626 this.match_available = 0;
\r
627 }this.flush_block_only (flush == 4);
\r
628 if (this.strm.avail_out == 0) {
\r
629 if (flush == 4) return 2;
\r
631 }return flush == 4 ? 3 : 1;
\r
633 Clazz.defineMethod (c$, "longest_match",
\r
634 function (cur_match) {
\r
635 var chain_length = this.max_chain_length;
\r
636 var scan = this.strstart;
\r
639 var best_len = this.prev_length;
\r
640 var limit = this.strstart > (this.w_size - 262) ? this.strstart - (this.w_size - 262) : 0;
\r
641 var nice_match = this.nice_match;
\r
642 var wmask = this.w_mask;
\r
643 var strend = this.strstart + 258;
\r
644 var scan_end1 = this.window[scan + best_len - 1];
\r
645 var scan_end = this.window[scan + best_len];
\r
646 if (this.prev_length >= this.good_match) {
\r
647 chain_length >>= 2;
\r
648 }if (nice_match > this.lookahead) nice_match = this.lookahead;
\r
651 if (this.window[match + best_len] != scan_end || this.window[match + best_len - 1] != scan_end1 || this.window[match] != this.window[scan] || this.window[++match] != this.window[scan + 1]) continue;
\r
655 } while (this.window[++scan] == this.window[++match] && this.window[++scan] == this.window[++match] && this.window[++scan] == this.window[++match] && this.window[++scan] == this.window[++match] && this.window[++scan] == this.window[++match] && this.window[++scan] == this.window[++match] && this.window[++scan] == this.window[++match] && this.window[++scan] == this.window[++match] && scan < strend);
\r
656 len = 258 - (strend - scan);
\r
657 scan = strend - 258;
\r
658 if (len > best_len) {
\r
659 this.match_start = cur_match;
\r
661 if (len >= nice_match) break;
\r
662 scan_end1 = this.window[scan + best_len - 1];
\r
663 scan_end = this.window[scan + best_len];
\r
664 }} while ((cur_match = (this.prev[cur_match & wmask] & 0xffff)) > limit && --chain_length != 0);
\r
665 if (best_len <= this.lookahead) return best_len;
\r
666 return this.lookahead;
\r
668 Clazz.defineMethod (c$, "deflateInit5",
\r
669 function (level, method, windowBits, memLevel, strategy) {
\r
671 this.strm.msg = null;
\r
672 if (level == -1) level = 6;
\r
673 if (windowBits < 0) {
\r
675 windowBits = -windowBits;
\r
676 } else if (windowBits > 15) {
\r
679 this.strm.checksum = new JU.CRC32 ();
\r
680 }if (memLevel < 1 || memLevel > 9 || method != 8 || windowBits < 9 || windowBits > 15 || level < 0 || level > 9 || strategy < 0 || strategy > 2) {
\r
682 }this.strm.dstate = this;
\r
684 this.w_bits = windowBits;
\r
685 this.w_size = 1 << this.w_bits;
\r
686 this.w_mask = this.w_size - 1;
\r
687 this.hash_bits = memLevel + 7;
\r
688 this.hash_size = 1 << this.hash_bits;
\r
689 this.hash_mask = this.hash_size - 1;
\r
690 this.hash_shift = (Clazz.doubleToInt ((this.hash_bits + 3 - 1) / 3));
\r
691 this.window = Clazz.newByteArray (this.w_size * 2, 0);
\r
692 this.prev = Clazz.newShortArray (this.w_size, 0);
\r
693 this.head = Clazz.newShortArray (this.hash_size, 0);
\r
694 this.lit_bufsize = 1 << (memLevel + 6);
\r
695 this.pending_buf = Clazz.newByteArray (this.lit_bufsize * 4, 0);
\r
696 this.pending_buf_size = this.lit_bufsize * 4;
\r
697 this.d_buf = Clazz.doubleToInt (this.lit_bufsize / 2);
\r
698 this.l_buf = (3) * this.lit_bufsize;
\r
699 this.level = level;
\r
700 this.strategy = strategy;
\r
701 this.method = method;
\r
702 return this.deflateReset ();
\r
703 }, "~N,~N,~N,~N,~N");
\r
704 Clazz.defineMethod (c$, "deflateReset",
\r
706 this.strm.total_in = this.strm.total_out = 0;
\r
707 this.strm.msg = null;
\r
708 this.strm.data_type = 2;
\r
710 this.pending_out = 0;
\r
711 if (this.wrap < 0) {
\r
712 this.wrap = -this.wrap;
\r
713 }this.status = (this.wrap == 0) ? 113 : 42;
\r
714 this.strm.checksum.reset ();
\r
715 this.last_flush = 0;
\r
720 Clazz.defineMethod (c$, "deflateEnd",
\r
722 if (this.status != 42 && this.status != 113 && this.status != 666) {
\r
724 }this.pending_buf = null;
\r
727 this.window = null;
\r
728 return this.status == 113 ? -3 : 0;
\r
730 Clazz.defineMethod (c$, "deflateParams",
\r
731 function (_level, _strategy) {
\r
733 if (_level == -1) {
\r
735 }if (_level < 0 || _level > 9 || _strategy < 0 || _strategy > 2) {
\r
737 }if (JU.Deflate.config_table[this.level].func != JU.Deflate.config_table[_level].func && this.strm.total_in != 0) {
\r
738 err = this.strm.deflate (1);
\r
739 }if (this.level != _level) {
\r
740 this.level = _level;
\r
741 this.max_lazy_match = JU.Deflate.config_table[this.level].max_lazy;
\r
742 this.good_match = JU.Deflate.config_table[this.level].good_length;
\r
743 this.nice_match = JU.Deflate.config_table[this.level].nice_length;
\r
744 this.max_chain_length = JU.Deflate.config_table[this.level].max_chain;
\r
745 }this.strategy = _strategy;
\r
748 Clazz.defineMethod (c$, "deflateSetDictionary",
\r
749 function (dictionary, dictLength) {
\r
750 var length = dictLength;
\r
752 if (dictionary == null || this.status != 42) return -2;
\r
753 this.strm.checksum.update (dictionary, 0, dictLength);
\r
754 if (length < 3) return 0;
\r
755 if (length > this.w_size - 262) {
\r
756 length = this.w_size - 262;
\r
757 index = dictLength - length;
\r
758 }System.arraycopy (dictionary, index, this.window, 0, length);
\r
759 this.strstart = length;
\r
760 this.block_start = length;
\r
761 this.ins_h = this.window[0] & 0xff;
\r
762 this.ins_h = (((this.ins_h) << this.hash_shift) ^ (this.window[1] & 0xff)) & this.hash_mask;
\r
763 for (var n = 0; n <= length - 3; n++) {
\r
764 this.ins_h = (((this.ins_h) << this.hash_shift) ^ (this.window[(n) + (2)] & 0xff)) & this.hash_mask;
\r
765 this.prev[n & this.w_mask] = this.head[this.ins_h];
\r
766 this.head[this.ins_h] = n;
\r
770 Clazz.defineMethod (c$, "deflate",
\r
773 if (flush > 4 || flush < 0) {
\r
775 }if (this.strm.next_out == null || (this.strm.next_in == null && this.strm.avail_in != 0) || (this.status == 666 && flush != 4)) {
\r
776 this.strm.msg = JU.Deflate.z_errmsg[4];
\r
778 }if (this.strm.avail_out == 0) {
\r
779 this.strm.msg = JU.Deflate.z_errmsg[7];
\r
781 }old_flush = this.last_flush;
\r
782 this.last_flush = flush;
\r
783 if (this.status == 42) {
\r
784 if (this.wrap == 2) {
\r
785 this.getGZIPHeader ().put (this);
\r
787 this.strm.checksum.reset ();
\r
789 var header = (8 + ((this.w_bits - 8) << 4)) << 8;
\r
790 var level_flags = ((this.level - 1) & 0xff) >> 1;
\r
791 if (level_flags > 3) level_flags = 3;
\r
792 header |= (level_flags << 6);
\r
793 if (this.strstart != 0) header |= 32;
\r
794 header += 31 - (header % 31);
\r
796 this.putShortMSB (header);
\r
797 if (this.strstart != 0) {
\r
798 var adler = this.strm.checksum.getValue ();
\r
799 this.putShortMSB ((adler >>> 16));
\r
800 this.putShortMSB ((adler & 0xffff));
\r
801 }this.strm.checksum.reset ();
\r
802 }}if (this.pending != 0) {
\r
803 this.strm.flush_pending ();
\r
804 if (this.strm.avail_out == 0) {
\r
805 this.last_flush = -1;
\r
807 }} else if (this.strm.avail_in == 0 && flush <= old_flush && flush != 4) {
\r
808 this.strm.msg = JU.Deflate.z_errmsg[7];
\r
810 }if (this.status == 666 && this.strm.avail_in != 0) {
\r
811 this.strm.msg = JU.Deflate.z_errmsg[7];
\r
813 }if (this.strm.avail_in != 0 || this.lookahead != 0 || (flush != 0 && this.status != 666)) {
\r
815 switch (JU.Deflate.config_table[this.level].func) {
\r
817 bstate = this.deflate_stored (flush);
\r
820 bstate = this.deflate_fast (flush);
\r
823 bstate = this.deflate_slow (flush);
\r
827 if (bstate == 2 || bstate == 3) {
\r
829 }if (bstate == 0 || bstate == 2) {
\r
830 if (this.strm.avail_out == 0) {
\r
831 this.last_flush = -1;
\r
833 }if (bstate == 1) {
\r
837 this._tr_stored_block (0, 0, false);
\r
839 for (var i = 0; i < this.hash_size; i++) this.head[i] = 0;
\r
841 }}this.strm.flush_pending ();
\r
842 if (this.strm.avail_out == 0) {
\r
843 this.last_flush = -1;
\r
845 }}}if (flush != 4) return 0;
\r
846 if (this.wrap <= 0) return 1;
\r
847 if (this.wrap == 2) {
\r
848 var adler = this.strm.checksum.getValue ();
\r
849 this.put_byteB ((adler & 0xff));
\r
850 this.put_byteB (((adler >> 8) & 0xff));
\r
851 this.put_byteB (((adler >> 16) & 0xff));
\r
852 this.put_byteB (((adler >> 24) & 0xff));
\r
853 this.put_byteB ((this.strm.total_in & 0xff));
\r
854 this.put_byteB (((this.strm.total_in >> 8) & 0xff));
\r
855 this.put_byteB (((this.strm.total_in >> 16) & 0xff));
\r
856 this.put_byteB (((this.strm.total_in >> 24) & 0xff));
\r
857 this.getGZIPHeader ().setCRC (adler);
\r
859 var adler = this.strm.checksum.getValue ();
\r
860 this.putShortMSB ((adler >>> 16));
\r
861 this.putShortMSB ((adler & 0xffff));
\r
862 }this.strm.flush_pending ();
\r
863 if (this.wrap > 0) this.wrap = -this.wrap;
\r
864 return this.pending != 0 ? 0 : 1;
\r
866 Clazz.defineMethod (c$, "getGZIPHeader",
\r
868 if (this.gheader == null) {
\r
869 this.gheader = new JU.GZIPHeader ();
\r
870 }return this.gheader;
\r
872 Clazz.defineMethod (c$, "getBytesRead",
\r
874 return this.strm.total_in;
\r
876 Clazz.defineMethod (c$, "getBytesWritten",
\r
878 return this.strm.total_out;
\r
880 Clazz.pu$h(self.c$);
\r
881 c$ = Clazz.decorateAsClass (function () {
\r
882 this.good_length = 0;
\r
884 this.nice_length = 0;
\r
885 this.max_chain = 0;
\r
887 Clazz.instantialize (this, arguments);
\r
888 }, JU.Deflate, "Config");
\r
889 Clazz.makeConstructor (c$,
\r
890 function (a, b, c, d, e) {
\r
891 this.good_length = a;
\r
893 this.nice_length = c;
\r
894 this.max_chain = d;
\r
896 }, "~N,~N,~N,~N,~N");
\r
898 Clazz.defineStatics (c$,
\r
899 "MAX_MEM_LEVEL", 9,
\r
900 "Z_DEFAULT_COMPRESSION", -1,
\r
902 "DEF_MEM_LEVEL", 8,
\r
906 "config_table", null);
\r
908 JU.Deflate.config_table = new Array (10);
\r
909 JU.Deflate.config_table[0] = new JU.Deflate.Config (0, 0, 0, 0, 0);
\r
910 JU.Deflate.config_table[1] = new JU.Deflate.Config (4, 4, 8, 4, 1);
\r
911 JU.Deflate.config_table[2] = new JU.Deflate.Config (4, 5, 16, 8, 1);
\r
912 JU.Deflate.config_table[3] = new JU.Deflate.Config (4, 6, 32, 32, 1);
\r
913 JU.Deflate.config_table[4] = new JU.Deflate.Config (4, 4, 16, 16, 2);
\r
914 JU.Deflate.config_table[5] = new JU.Deflate.Config (8, 16, 32, 32, 2);
\r
915 JU.Deflate.config_table[6] = new JU.Deflate.Config (8, 16, 128, 128, 2);
\r
916 JU.Deflate.config_table[7] = new JU.Deflate.Config (8, 32, 128, 256, 2);
\r
917 JU.Deflate.config_table[8] = new JU.Deflate.Config (32, 128, 258, 1024, 2);
\r
918 JU.Deflate.config_table[9] = new JU.Deflate.Config (32, 258, 258, 4096, 2);
\r
919 }Clazz.defineStatics (c$,
\r
920 "z_errmsg", Clazz.newArray (-1, ["need dictionary", "stream end", "", "file error", "stream error", "data error", "insufficient memory", "buffer error", "incompatible version", ""]),
\r
923 "FinishStarted", 2,
\r
925 "PRESET_DICT", 0x20,
\r
927 "Z_HUFFMAN_ONLY", 2,
\r
928 "Z_DEFAULT_STRATEGY", 0,
\r
930 "Z_PARTIAL_FLUSH", 1,
\r
936 "Z_STREAM_ERROR", -2,
\r
937 "Z_DATA_ERROR", -3,
\r
941 "FINISH_STATE", 666,
\r
955 "MIN_LOOKAHEAD", (262),
\r
959 "LENGTH_CODES", 29,
\r
962 "HEAP_SIZE", (573),
\r