1 extern {
BrotliAllocate( m : &mut [MemoryManager], n : usize ) -> *mut std::os::raw::c_void2 fn BrotliAllocate(
3 m : &mut [MemoryManager], n : usize
4 ) -> *mut std::os::raw::c_void;
BrotliEstimateBitCostsForLiterals( pos : usize, len : usize, mask : usize, data : & [u8], cost : &mut [f32 ])5 fn BrotliEstimateBitCostsForLiterals(
6 pos : usize,
7 len : usize,
8 mask : usize,
9 data : & [u8],
10 cost : &mut [f32
11 ]);
BrotliFindAllStaticDictionaryMatches( dictionary : & [BrotliEncoderDictionary], data : & [u8], min_length : usize, max_length : usize, matches : &mut [u32 ]) -> i3212 fn BrotliFindAllStaticDictionaryMatches(
13 dictionary : & [BrotliEncoderDictionary],
14 data : & [u8],
15 min_length : usize,
16 max_length : usize,
17 matches : &mut [u32
18 ]) -> i32;
BrotliFree( m : &mut [MemoryManager], p : &mut [std::os::raw::c_void ])19 fn BrotliFree(
20 m : &mut [MemoryManager], p : &mut [std::os::raw::c_void
21 ]);
log2(__x : f64) -> f6422 fn log2(__x : f64) -> f64;
memcpy( __dest : &mut [std::os::raw::c_void], __src : & [std::os::raw::c_void], __n : usize ) -> *mut std::os::raw::c_void23 fn memcpy(
24 __dest : &mut [std::os::raw::c_void],
25 __src : & [std::os::raw::c_void],
26 __n : usize
27 ) -> *mut std::os::raw::c_void;
memset( __s : &mut [std::os::raw::c_void], __c : i32, __n : usize ) -> *mut std::os::raw::c_void28 fn memset(
29 __s : &mut [std::os::raw::c_void], __c : i32, __n : usize
30 ) -> *mut std::os::raw::c_void;
31 }
32
33 static mut kLog2Table
34 : *const f32
35 = 0.0000000000000000f32 ;
36
37 static kDictNumBits : i32 = 15i32;
38
39 static kDictHashMul32 : u32 = 0x1e35a7bdu32;
40
41 static mut kStaticDictionaryBuckets
42 : *const u16
43 = 1i32 ;
44
45
46
47 pub struct DictWord {
48 pub len : u8,
49 pub transform : u8,
50 pub idx : u16,
51 }
52
53 static mut kStaticDictionaryWords
54 : *const DictWord
55 = 0i32 ;
56
57 static mut kInsBase : *mut u32 = 0i32 ;
58
59 static mut kInsExtra : *mut u32 = 0i32 ;
60
61 static mut kCopyBase : *mut u32 = 2i32 ;
62
63 static mut kCopyExtra : *mut u32 = 0i32 ;
64
65
ctzll(mut x : usize) -> usize66 pub fn ctzll(mut x : usize) -> usize {
67 let mut count : u8 = 0i32 as (u8);
68 while x & 0usize != 0 {
69 count = (count as (i32) + 1i32) as (u8);
70 x = x >> 1i32;
71 }
72 count as (usize)
73 }
74
75 static kInvalidMatch : u32 = 0xfffffffu32;
76
77 static kCutoffTransformsCount : u32 = 10u32;
78
79 static kCutoffTransforms
80 : usize
81 = 0x71b520ausize << 32i32 | 0xda2d3200u32 as (usize);
82
83 static kHashMul32 : u32 = 0x1e35a7bdu32;
84
85 static kHashMul64
86 : usize
87 = 0x1e35a7bdusize << 32i32 | 0x1e35a7bdusize;
88
89 static kHashMul64Long
90 : usize
91 = 0x1fe35a7bu32 as (usize) << 32i32 | 0xd3579bd3u32 as (usize);
92
93 static kInfinity : f32 = 1.7e38f32;
94
95 static mut kDistanceCacheIndex : *const u32 = 0i32 ;
96
97 static mut kDistanceCacheOffset
98 : *const i32
99 = 0i32 ;
100
101
102
103 pub struct Struct1 {
104 pub cost : f32,
105 pub next : u32,
106 pub shortcut : u32,
107 }
108
109
110
111 pub struct ZopfliNode {
112 pub length : u32,
113 pub distance : u32,
114 pub dcode_insert_length : u32,
115 pub u : Struct1,
116 }
117
118
BrotliInitZopfliNodes( mut array : &mut [ZopfliNode], mut length : usize )119 pub fn BrotliInitZopfliNodes(
120 mut array : &mut [ZopfliNode], mut length : usize
121 ) {
122 let mut stub : ZopfliNode;
123 let mut i : usize;
124 stub.length = 1u32;
125 stub.distance = 0u32;
126 stub.dcode_insert_length = 0u32;
127 stub.u.cost = kInfinity;
128 i = 0usize;
129 while i < length {
130 array[(i as (usize)) ]= stub;
131 i = i.wrapping_add(1 as (usize));
132 }
133 }
134
135
136 #[repr(i32)]
137 pub enum BrotliEncoderMode {
138 BROTLI_MODE_GENERIC = 0i32,
139 BROTLI_MODE_TEXT = 1i32,
140 BROTLI_MODE_FONT = 2i32,
141 }
142
143
144
145 pub struct BrotliHasherParams {
146 pub type_ : i32,
147 pub bucket_bits : i32,
148 pub block_bits : i32,
149 pub hash_len : i32,
150 pub num_last_distances_to_check : i32,
151 }
152
153
154
155 pub struct BrotliDistanceParams {
156 pub distance_postfix_bits : u32,
157 pub num_direct_distance_codes : u32,
158 pub alphabet_size : u32,
159 pub max_distance : usize,
160 }
161
162
163
164 pub struct BrotliDictionary {
165 pub size_bits_by_length : *mut u8,
166 pub offsets_by_length : *mut u32,
167 pub data_size : usize,
168 pub data : *const u8,
169 }
170
171
172
173 pub struct BrotliEncoderDictionary {
174 pub words : *const BrotliDictionary,
175 pub cutoffTransformsCount : u32,
176 pub cutoffTransforms : usize,
177 pub hash_table : *const u16,
178 pub buckets : *const u16,
179 pub dict_words : *const DictWord,
180 }
181
182
183
184 pub struct BrotliEncoderParams {
185 pub mode : BrotliEncoderMode,
186 pub quality : i32,
187 pub lgwin : i32,
188 pub lgblock : i32,
189 pub size_hint : usize,
190 pub disable_literal_context_modeling : i32,
191 pub large_window : i32,
192 pub hasher : BrotliHasherParams,
193 pub dist : BrotliDistanceParams,
194 pub dictionary : BrotliEncoderDictionary,
195 }
196
197
198
199 pub struct Command {
200 pub insert_len_ : u32,
201 pub copy_len_ : u32,
202 pub dist_extra_ : u32,
203 pub cmd_prefix_ : u16,
204 pub dist_prefix_ : u16,
205 }
206
ZopfliNodeCopyLength( mut xself : & ZopfliNode ) -> u32207 fn ZopfliNodeCopyLength(
208 mut xself : & ZopfliNode
209 ) -> u32 {
210 (*xself).length & 0x1ffffffu32
211 }
212
ZopfliNodeCopyDistance( mut xself : & ZopfliNode ) -> u32213 fn ZopfliNodeCopyDistance(
214 mut xself : & ZopfliNode
215 ) -> u32 {
216 (*xself).distance
217 }
218
ZopfliNodeLengthCode( mut xself : & ZopfliNode ) -> u32219 fn ZopfliNodeLengthCode(
220 mut xself : & ZopfliNode
221 ) -> u32 {
222 let modifier : u32 = (*xself).length >> 25i32;
223 ZopfliNodeCopyLength(xself).wrapping_add(9u32).wrapping_sub(
224 modifier
225 )
226 }
227
brotli_min_size_t( mut a : usize, mut b : usize ) -> usize228 fn brotli_min_size_t(
229 mut a : usize, mut b : usize
230 ) -> usize {
231 if a < b { a } else { b }
232 }
233
ZopfliNodeDistanceCode( mut xself : & ZopfliNode ) -> u32234 fn ZopfliNodeDistanceCode(
235 mut xself : & ZopfliNode
236 ) -> u32 {
237 let short_code : u32 = (*xself).dcode_insert_length >> 27i32;
238 if short_code == 0u32 {
239 ZopfliNodeCopyDistance(xself).wrapping_add(
240 16u32
241 ).wrapping_sub(
242 1u32
243 )
244 } else {
245 short_code.wrapping_sub(1u32)
246 }
247 }
248
Log2FloorNonZero(mut n : usize) -> u32249 fn Log2FloorNonZero(mut n : usize) -> u32 {
250 let mut result : u32 = 0u32;
251 while {
252 n = n >> 1i32;
253 n
254 } != 0 {
255 result = result.wrapping_add(1 as (u32));
256 }
257 result
258 }
259
PrefixEncodeCopyDistance( mut distance_code : usize, mut num_direct_codes : usize, mut postfix_bits : usize, mut code : &mut [u16], mut extra_bits : &mut [u32 ])260 fn PrefixEncodeCopyDistance(
261 mut distance_code : usize,
262 mut num_direct_codes : usize,
263 mut postfix_bits : usize,
264 mut code : &mut [u16],
265 mut extra_bits : &mut [u32
266 ]) { if distance_code < (16usize).wrapping_add(
267 num_direct_codes
268 ) {
269 *code = distance_code as (u16);
270 *extra_bits = 0u32;
271 } else {
272 let mut dist
273 : usize
274 = (1usize << postfix_bits.wrapping_add(
275 2u32 as (usize)
276 )).wrapping_add(
277 distance_code.wrapping_sub(16usize).wrapping_sub(
278 num_direct_codes
279 )
280 );
281 let mut bucket
282 : usize
283 = Log2FloorNonZero(dist).wrapping_sub(1u32) as (usize);
284 let mut postfix_mask
285 : usize
286 = (1u32 << postfix_bits).wrapping_sub(1u32) as (usize);
287 let mut postfix : usize = dist & postfix_mask;
288 let mut prefix : usize = dist >> bucket & 1usize;
289 let mut offset
290 : usize
291 = (2usize).wrapping_add(prefix) << bucket;
292 let mut nbits : usize = bucket.wrapping_sub(postfix_bits);
293 *code = (nbits << 10i32 | (16usize).wrapping_add(
294 num_direct_codes
295 ).wrapping_add(
296 (2usize).wrapping_mul(
297 nbits.wrapping_sub(1usize)
298 ).wrapping_add(
299 prefix
300 ) << postfix_bits
301 ).wrapping_add(
302 postfix
303 )) as (u16);
304 *extra_bits = (dist.wrapping_sub(offset) >> postfix_bits) as (u32);
305 }
306 }
307
GetInsertLengthCode( mut insertlen : usize ) -> u16308 fn GetInsertLengthCode(
309 mut insertlen : usize
310 ) -> u16 {
311 if insertlen < 6usize {
312 insertlen as (u16)
313 } else if insertlen < 130usize {
314 let mut nbits
315 : u32
316 = Log2FloorNonZero(
317 insertlen.wrapping_sub(2usize)
318 ).wrapping_sub(
319 1u32
320 );
321 ((nbits << 1i32) as (usize)).wrapping_add(
322 insertlen.wrapping_sub(2usize) >> nbits
323 ).wrapping_add(
324 2usize
325 ) as (u16)
326 } else if insertlen < 2114usize {
327 Log2FloorNonZero(
328 insertlen.wrapping_sub(66usize)
329 ).wrapping_add(
330 10u32
331 ) as (u16)
332 } else if insertlen < 6210usize {
333 21u32 as (u16)
334 } else if insertlen < 22594usize {
335 22u32 as (u16)
336 } else {
337 23u32 as (u16)
338 }
339 }
340
GetCopyLengthCode(mut copylen : usize) -> u16341 fn GetCopyLengthCode(mut copylen : usize) -> u16 {
342 if copylen < 10usize {
343 copylen.wrapping_sub(2usize) as (u16)
344 } else if copylen < 134usize {
345 let mut nbits
346 : u32
347 = Log2FloorNonZero(
348 copylen.wrapping_sub(6usize)
349 ).wrapping_sub(
350 1u32
351 );
352 ((nbits << 1i32) as (usize)).wrapping_add(
353 copylen.wrapping_sub(6usize) >> nbits
354 ).wrapping_add(
355 4usize
356 ) as (u16)
357 } else if copylen < 2118usize {
358 Log2FloorNonZero(
359 copylen.wrapping_sub(70usize)
360 ).wrapping_add(
361 12u32
362 ) as (u16)
363 } else {
364 23u32 as (u16)
365 }
366 }
367
CombineLengthCodes( mut inscode : u16, mut copycode : u16, mut use_last_distance : i32 ) -> u16368 fn CombineLengthCodes(
369 mut inscode : u16, mut copycode : u16, mut use_last_distance : i32
370 ) -> u16 {
371 let mut bits64
372 : u16
373 = (copycode as (u32) & 0x7u32 | (inscode as (u32) & 0x7u32) << 3i32) as (u16);
374 if use_last_distance != 0 && (inscode as (i32) < 8i32) && (copycode as (i32) < 16i32) {
375 if copycode as (i32) < 8i32 {
376 bits64 as (i32)
377 } else {
378 bits64 as (i32) | 64i32
379 } as (u16)
380 } else {
381 let mut offset
382 : i32
383 = 2i32 * ((copycode as (i32) >> 3i32) + 3i32 * (inscode as (i32) >> 3i32));
384 offset = (offset << 5i32) + 0x40i32 + (0x520d40i32 >> offset & 0xc0i32);
385 (offset as (u16) as (i32) | bits64 as (i32)) as (u16)
386 }
387 }
388
GetLengthCode( mut insertlen : usize, mut copylen : usize, mut use_last_distance : i32, mut code : &mut [u16 ])389 fn GetLengthCode(
390 mut insertlen : usize,
391 mut copylen : usize,
392 mut use_last_distance : i32,
393 mut code : &mut [u16
394 ]) {
395 let mut inscode : u16 = GetInsertLengthCode(insertlen);
396 let mut copycode : u16 = GetCopyLengthCode(copylen);
397 *code = CombineLengthCodes(inscode,copycode,use_last_distance);
398 }
399
InitCommand( mut xself : &mut Command, mut dist : & [BrotliDistanceParams], mut insertlen : usize, mut copylen : usize, mut copylen_code_delta : i32, mut distance_code : usize )400 fn InitCommand(
401 mut xself : &mut Command,
402 mut dist : & [BrotliDistanceParams],
403 mut insertlen : usize,
404 mut copylen : usize,
405 mut copylen_code_delta : i32,
406 mut distance_code : usize
407 ) {
408 let mut delta : u32 = copylen_code_delta as (i8) as (u8) as (u32);
409 (*xself).insert_len_ = insertlen as (u32);
410 (*xself).copy_len_ = (copylen | (delta << 25i32) as (usize)) as (u32);
411 PrefixEncodeCopyDistance(
412 distance_code,
413 (*dist).num_direct_distance_codes as (usize),
414 (*dist).distance_postfix_bits as (usize),
415 &mut (*xself).dist_prefix_ ,
416 &mut (*xself).dist_extra_
417 );
418 GetLengthCode(
419 insertlen,
420 (copylen as (i32) + copylen_code_delta) as (usize),
421 if !!((*xself).dist_prefix_ as (i32) & 0x3ffi32 == 0i32) {
422 1i32
423 } else {
424 0i32
425 },
426 &mut (*xself).cmd_prefix_
427 );
428 }
429
430
BrotliZopfliCreateCommands( num_bytes : usize, block_start : usize, max_backward_limit : usize, mut nodes : & [ZopfliNode], mut dist_cache : &mut [i32], mut last_insert_len : &mut [usize], mut params : & [BrotliEncoderParams], mut commands : &mut [Command], mut num_literals : &mut [usize ])431 pub fn BrotliZopfliCreateCommands(
432 num_bytes : usize,
433 block_start : usize,
434 max_backward_limit : usize,
435 mut nodes : & [ZopfliNode],
436 mut dist_cache : &mut [i32],
437 mut last_insert_len : &mut [usize],
438 mut params : & [BrotliEncoderParams],
439 mut commands : &mut [Command],
440 mut num_literals : &mut [usize
441 ]) {
442 let mut pos : usize = 0usize;
443 let mut offset : u32 = (nodes[(0usize)]).u.next;
444 let mut i : usize;
445 let mut gap : usize = 0usize;
446 i = 0usize;
447 while offset != !(0u32) {
448 {
449 let mut next
450 : *const ZopfliNode
451 = &nodes[(
452 pos.wrapping_add(offset as (usize)) as (usize)
453 ) ];
454 let mut copy_length
455 : usize
456 = ZopfliNodeCopyLength(next) as (usize);
457 let mut insert_length
458 : usize
459 = ((*next).dcode_insert_length & 0x7ffffffu32) as (usize);
460 pos = pos.wrapping_add(insert_length);
461 offset = (*next).u.next;
462 if i == 0usize {
463 insert_length = insert_length.wrapping_add(*last_insert_len);
464 *last_insert_len = 0usize;
465 }
466 {
467 let mut distance : usize = ZopfliNodeCopyDistance(next) as (usize);
468 let mut len_code : usize = ZopfliNodeLengthCode(next) as (usize);
469 let mut max_distance
470 : usize
471 = brotli_min_size_t(
472 block_start.wrapping_add(pos),
473 max_backward_limit
474 );
475 let mut is_dictionary
476 : i32
477 = if !!(distance > max_distance.wrapping_add(gap)) {
478 1i32
479 } else {
480 0i32
481 };
482 let mut dist_code
483 : usize
484 = ZopfliNodeDistanceCode(next) as (usize);
485 InitCommand(
486 &mut commands[(i as (usize)) ],
487 &(*params).dist ,
488 insert_length,
489 copy_length,
490 len_code as (i32) - copy_length as (i32),
491 dist_code
492 );
493 if is_dictionary == 0 && (dist_code > 0usize) {
494 dist_cache[(3usize) ]= dist_cache[(
495 2usize
496 )];
497 dist_cache[(2usize) ]= dist_cache[(
498 1usize
499 )];
500 dist_cache[(1usize) ]= dist_cache[(
501 0usize
502 )];
503 dist_cache[(0usize) ]= distance as (i32);
504 }
505 }
506 *num_literals = (*num_literals).wrapping_add(insert_length);
507 pos = pos.wrapping_add(copy_length);
508 }
509 i = i.wrapping_add(1 as (usize));
510 }
511 *last_insert_len = (*last_insert_len).wrapping_add(
512 num_bytes.wrapping_sub(pos)
513 );
514 }
515
516
517
518 pub struct MemoryManager {
519 pub alloc_func : fn(*mut std::os::raw::c_void, usize) -> *mut std::os::raw::c_void,
520 pub free_func : fn(*mut std::os::raw::c_void, *mut std::os::raw::c_void),
521 pub opaque : *mut std::os::raw::c_void,
522 }
523
MaxZopfliLen( mut params : & [BrotliEncoderParams ]) -> usize524 fn MaxZopfliLen(
525 mut params : & [BrotliEncoderParams
526 ]) -> usize {
527 (if (*params).quality <= 10i32 {
528 150i32
529 } else {
530 325i32
531 }) as (usize)
532 }
533
534
535
536 pub struct ZopfliCostModel {
537 pub cost_cmd_ : *mut f32,
538 pub cost_dist_ : *mut f32,
539 pub distance_histogram_size : u32,
540 pub literal_costs_ : *mut f32,
541 pub min_cost_cmd_ : f32,
542 pub num_bytes_ : usize,
543 }
544
545
546
547 pub struct PosData {
548 pub pos : usize,
549 pub distance_cache : *mut i32,
550 pub costdiff : f32,
551 pub cost : f32,
552 }
553
554
555
556 pub struct StartPosQueue {
557 pub q_ : *mut PosData,
558 pub idx_ : usize,
559 }
560
561
562
563 pub struct BackwardMatch {
564 pub distance : u32,
565 pub length_and_code : u32,
566 }
567
StoreLookaheadH10() -> usize568 fn StoreLookaheadH10() -> usize { 128usize }
569
InitZopfliCostModel( mut m : &mut [MemoryManager], mut xself : &mut ZopfliCostModel, mut dist : & [BrotliDistanceParams], mut num_bytes : usize )570 fn InitZopfliCostModel(
571 mut m : &mut [MemoryManager],
572 mut xself : &mut ZopfliCostModel,
573 mut dist : & [BrotliDistanceParams],
574 mut num_bytes : usize
575 ) {
576 let mut distance_histogram_size : u32 = (*dist).alphabet_size;
577 if distance_histogram_size > 544u32 {
578 distance_histogram_size = 544u32;
579 }
580 (*xself).num_bytes_ = num_bytes;
581 (*xself).literal_costs_ = if num_bytes.wrapping_add(
582 2usize
583 ) > 0usize {
584 BrotliAllocate(
585 m,
586 num_bytes.wrapping_add(2usize).wrapping_mul(
587 std::mem::size_of::<f32>()
588 )
589 )
590 } else {
591 0i32
592 };
593 (*xself).cost_dist_ = if (*dist).alphabet_size > 0u32 {
594 BrotliAllocate(
595 m,
596 ((*dist).alphabet_size as (usize)).wrapping_mul(
597 std::mem::size_of::<f32>()
598 )
599 )
600 } else {
601 0i32
602 };
603 (*xself).distance_histogram_size = distance_histogram_size;
604 if !(0i32 == 0) { }
605 }
606
FastLog2(mut v : usize) -> f64607 fn FastLog2(mut v : usize) -> f64 {
608 if v < std::mem::size_of::<*const f32>().wrapping_div(
609 std::mem::size_of::<f32>()
610 ) {
611 return kLog2Table[(v as (usize)) ]as (f64);
612 }
613 log2(v as (f64))
614 }
615
ZopfliCostModelSetFromLiteralCosts( mut xself : &mut ZopfliCostModel, mut position : usize, mut ringbuffer : & [u8], mut ringbuffer_mask : usize )616 fn ZopfliCostModelSetFromLiteralCosts(
617 mut xself : &mut ZopfliCostModel,
618 mut position : usize,
619 mut ringbuffer : & [u8],
620 mut ringbuffer_mask : usize
621 ) {
622 let mut literal_costs : *mut f32 = (*xself).literal_costs_;
623 let mut literal_carry : f32 = 0.0f64 as (f32);
624 let mut cost_dist : *mut f32 = (*xself).cost_dist_;
625 let mut cost_cmd : *mut f32 = (*xself).cost_cmd_;
626 let mut num_bytes : usize = (*xself).num_bytes_;
627 let mut i : usize;
628 BrotliEstimateBitCostsForLiterals(
629 position,
630 num_bytes,
631 ringbuffer_mask,
632 ringbuffer,
633 &mut literal_costs[(1usize) ]
634 );
635 literal_costs[(0usize) ]= 0.0f64 as (f32);
636 i = 0usize;
637 while i < num_bytes {
638 {
639 literal_carry = literal_carry + literal_costs[(
640 i.wrapping_add(1usize) as (usize)
641 )];
642 literal_costs[(
643 i.wrapping_add(1usize) as (usize)
644 ) ]= literal_costs[(i as (usize)) ]+ literal_carry;
645 literal_carry = literal_carry - (literal_costs[(
646 i.wrapping_add(1usize) as (usize)
647 ) ]- literal_costs[(i as (usize))]);
648 }
649 i = i.wrapping_add(1 as (usize));
650 }
651 i = 0usize;
652 while i < 704usize {
653 {
654 cost_cmd[(i as (usize)) ]= FastLog2(
655 (11u32).wrapping_add(
656 i as (u32)
657 ) as (usize)
658 ) as (f32);
659 }
660 i = i.wrapping_add(1 as (usize));
661 }
662 i = 0usize;
663 while i < (*xself).distance_histogram_size as (usize) {
664 {
665 cost_dist[(i as (usize)) ]= FastLog2(
666 (20u32).wrapping_add(
667 i as (u32)
668 ) as (usize)
669 ) as (f32);
670 }
671 i = i.wrapping_add(1 as (usize));
672 }
673 (*xself).min_cost_cmd_ = FastLog2(11usize) as (f32);
674 }
675
InitStartPosQueue(mut xself : &mut StartPosQueue)676 fn InitStartPosQueue(mut xself : &mut StartPosQueue) {
677 (*xself).idx_ = 0usize;
678 }
679
BrotliUnalignedRead64( mut p : & [std::os::raw::c_void ]) -> usize680 fn BrotliUnalignedRead64(
681 mut p : & [std::os::raw::c_void
682 ]) -> usize {
683 *(p )
684 }
685
FindMatchLengthWithLimit( mut s1 : & [u8], mut s2 : & [u8], mut limit : usize ) -> usize686 fn FindMatchLengthWithLimit(
687 mut s1 : & [u8], mut s2 : & [u8], mut limit : usize
688 ) -> usize {
689 let mut matched : usize = 0usize;
690 let mut limit2
691 : usize
692 = (limit >> 3i32).wrapping_add(1usize);
693 while {
694 limit2 = limit2.wrapping_sub(1 as (usize));
695 limit2
696 } != 0 {
697 if BrotliUnalignedRead64(
698 s2
699 ) == BrotliUnalignedRead64(
700 s1[(matched as (usize)) ..]
701 ) {
702 s2 = s2[(8usize)..];
703 matched = matched.wrapping_add(8usize);
704 } else {
705 let mut x
706 : usize
707 = BrotliUnalignedRead64(
708 s2
709 ) ^ BrotliUnalignedRead64(
710 s1[(matched as (usize)) ..]
711 );
712 let mut matching_bits : usize = ctzll(x) as (usize);
713 matched = matched.wrapping_add(matching_bits >> 3i32);
714 return matched;
715 }
716 }
717 limit = (limit & 7usize).wrapping_add(1usize);
718 while {
719 limit = limit.wrapping_sub(1 as (usize));
720 limit
721 } != 0 {
722 if s1[(matched as (usize)) ]as (i32) == *s2 as (i32) {
723 s2 = s2[(1 as (usize))..];
724 matched = matched.wrapping_add(1 as (usize));
725 } else {
726 return matched;
727 }
728 }
729 matched
730 }
731
InitBackwardMatch( mut xself : &mut BackwardMatch, mut dist : usize, mut len : usize )732 fn InitBackwardMatch(
733 mut xself : &mut BackwardMatch, mut dist : usize, mut len : usize
734 ) {
735 (*xself).distance = dist as (u32);
736 (*xself).length_and_code = (len << 5i32) as (u32);
737 }
738
739
740
741 pub struct H10 {
742 pub window_mask_ : usize,
743 pub buckets_ : *mut u32,
744 pub invalid_pos_ : u32,
745 }
746
BrotliUnalignedRead32( mut p : & [std::os::raw::c_void ]) -> u32747 fn BrotliUnalignedRead32(
748 mut p : & [std::os::raw::c_void
749 ]) -> u32 {
750 *(p )
751 }
752
HashBytesH10(mut data : & [u8]) -> u32753 fn HashBytesH10(mut data : & [u8]) -> u32 {
754 let mut h
755 : u32
756 = BrotliUnalignedRead32(
757 data
758 ).wrapping_mul(
759 kHashMul32
760 );
761 h >> 32i32 - 17i32
762 }
763
ForestH10(mut xself : &mut H10) -> *mut u32764 fn ForestH10(mut xself : &mut H10) -> *mut u32 {
765 &mut xself[(1usize) ]
766 }
767
LeftChildIndexH10( mut xself : &mut H10, pos : usize ) -> usize768 fn LeftChildIndexH10(
769 mut xself : &mut H10, pos : usize
770 ) -> usize {
771 (2usize).wrapping_mul(pos & (*xself).window_mask_)
772 }
773
RightChildIndexH10( mut xself : &mut H10, pos : usize ) -> usize774 fn RightChildIndexH10(
775 mut xself : &mut H10, pos : usize
776 ) -> usize {
777 (2usize).wrapping_mul(
778 pos & (*xself).window_mask_
779 ).wrapping_add(
780 1usize
781 )
782 }
783
StoreAndFindMatchesH10( mut xself : &mut H10, data : & [u8], cur_ix : usize, ring_buffer_mask : usize, max_length : usize, max_backward : usize, best_len : &mut [usize], mut matches : &mut [BackwardMatch ]) -> *mut BackwardMatch784 fn StoreAndFindMatchesH10(
785 mut xself : &mut H10,
786 data : & [u8],
787 cur_ix : usize,
788 ring_buffer_mask : usize,
789 max_length : usize,
790 max_backward : usize,
791 best_len : &mut [usize],
792 mut matches : &mut [BackwardMatch
793 ]) -> *mut BackwardMatch {
794 let cur_ix_masked : usize = cur_ix & ring_buffer_mask;
795 let max_comp_len
796 : usize
797 = brotli_min_size_t(max_length,128usize);
798 let should_reroot_tree
799 : i32
800 = if !!(max_length >= 128usize) { 1i32 } else { 0i32 };
801 let key
802 : u32
803 = HashBytesH10(
804 &data[(cur_ix_masked as (usize)) ]
805 );
806 let mut forest : *mut u32 = ForestH10(xself);
807 let mut prev_ix
808 : usize
809 = *(*xself).buckets_[(key as (usize)) ..]as (usize);
810 let mut node_left : usize = LeftChildIndexH10(xself,cur_ix);
811 let mut node_right : usize = RightChildIndexH10(xself,cur_ix);
812 let mut best_len_left : usize = 0usize;
813 let mut best_len_right : usize = 0usize;
814 let mut depth_remaining : usize;
815 if should_reroot_tree != 0 {
816 *(*xself).buckets_[(key as (usize)) ..]= cur_ix as (u32);
817 }
818 depth_remaining = 64usize;
819 'break16: loop {
820 {
821 let backward : usize = cur_ix.wrapping_sub(prev_ix);
822 let prev_ix_masked : usize = prev_ix & ring_buffer_mask;
823 if backward == 0usize || backward > max_backward || depth_remaining == 0usize {
824 if should_reroot_tree != 0 {
825 forest[(node_left as (usize)) ]= (*xself).invalid_pos_;
826 forest[(node_right as (usize)) ]= (*xself).invalid_pos_;
827 }
828 break 'break16;
829 }
830 {
831 let cur_len
832 : usize
833 = brotli_min_size_t(best_len_left,best_len_right);
834 let mut len : usize;
835 len = cur_len.wrapping_add(
836 FindMatchLengthWithLimit(
837 &data[(
838 cur_ix_masked.wrapping_add(cur_len) as (usize)
839 ) ],
840 &data[(
841 prev_ix_masked.wrapping_add(cur_len) as (usize)
842 ) ],
843 max_length.wrapping_sub(cur_len)
844 )
845 );
846 if !matches.is_null() && (len > *best_len) {
847 *best_len = len;
848 InitBackwardMatch(
849 {
850 let _old = matches;
851 matches = matches[(1 as (usize))..];
852 _old
853 },
854 backward,
855 len
856 );
857 }
858 if len >= max_comp_len {
859 if should_reroot_tree != 0 {
860 forest[(node_left as (usize)) ]= forest[(
861 LeftChildIndexH10(
862 xself,
863 prev_ix
864 ) as (usize)
865 )];
866 forest[(node_right as (usize)) ]= forest[(
867 RightChildIndexH10(
868 xself,
869 prev_ix
870 ) as (usize)
871 )];
872 }
873 break 'break16;
874 }
875 if data[(
876 cur_ix_masked.wrapping_add(len) as (usize)
877 ) ]as (i32) > data[(
878 prev_ix_masked.wrapping_add(len) as (usize)
879 ) ]as (i32) {
880 best_len_left = len;
881 if should_reroot_tree != 0 {
882 forest[(node_left as (usize)) ]= prev_ix as (u32);
883 }
884 node_left = RightChildIndexH10(xself,prev_ix);
885 prev_ix = forest[(node_left as (usize)) ]as (usize);
886 } else {
887 best_len_right = len;
888 if should_reroot_tree != 0 {
889 forest[(node_right as (usize)) ]= prev_ix as (u32);
890 }
891 node_right = LeftChildIndexH10(xself,prev_ix);
892 prev_ix = forest[(node_right as (usize)) ]as (usize);
893 }
894 }
895 }
896 depth_remaining = depth_remaining.wrapping_sub(1 as (usize));
897 }
898 matches
899 }
900
901
902
903 pub struct Struct18 {
904 pub params : BrotliHasherParams,
905 pub is_prepared_ : i32,
906 pub dict_num_lookups : usize,
907 pub dict_num_matches : usize,
908 }
909
GetHasherCommon( mut handle : &mut [u8 ]) -> *mut Struct18910 fn GetHasherCommon(
911 mut handle : &mut [u8
912 ]) -> *mut Struct18 {
913 handle
914 }
915
SelfH10(mut handle : &mut [u8]) -> *mut H10916 fn SelfH10(mut handle : &mut [u8]) -> *mut H10 {
917 &mut *GetHasherCommon(handle).offset(
918 1i32 as (isize)
919 )
920 }
921
brotli_max_size_t( mut a : usize, mut b : usize ) -> usize922 fn brotli_max_size_t(
923 mut a : usize, mut b : usize
924 ) -> usize {
925 if a > b { a } else { b }
926 }
927
InitDictionaryBackwardMatch( mut xself : &mut BackwardMatch, mut dist : usize, mut len : usize, mut len_code : usize )928 fn InitDictionaryBackwardMatch(
929 mut xself : &mut BackwardMatch,
930 mut dist : usize,
931 mut len : usize,
932 mut len_code : usize
933 ) {
934 (*xself).distance = dist as (u32);
935 (*xself).length_and_code = (len << 5i32 | if len == len_code {
936 0usize
937 } else {
938 len_code
939 }) as (u32);
940 }
941
FindAllMatchesH10( mut handle : &mut [u8], mut dictionary : & [BrotliEncoderDictionary], mut data : & [u8], ring_buffer_mask : usize, cur_ix : usize, max_length : usize, max_backward : usize, gap : usize, mut params : & [BrotliEncoderParams], mut matches : &mut [BackwardMatch ]) -> usize942 fn FindAllMatchesH10(
943 mut handle : &mut [u8],
944 mut dictionary : & [BrotliEncoderDictionary],
945 mut data : & [u8],
946 ring_buffer_mask : usize,
947 cur_ix : usize,
948 max_length : usize,
949 max_backward : usize,
950 gap : usize,
951 mut params : & [BrotliEncoderParams],
952 mut matches : &mut [BackwardMatch
953 ]) -> usize {
954 let orig_matches : *mut BackwardMatch = matches;
955 let cur_ix_masked : usize = cur_ix & ring_buffer_mask;
956 let mut best_len : usize = 1usize;
957 let short_match_max_backward
958 : usize
959 = (if (*params).quality != 11i32 {
960 16i32
961 } else {
962 64i32
963 }) as (usize);
964 let mut stop
965 : usize
966 = cur_ix.wrapping_sub(short_match_max_backward);
967 let mut dict_matches : *mut u32;
968 let mut i : usize;
969 if cur_ix < short_match_max_backward {
970 stop = 0usize;
971 }
972 i = cur_ix.wrapping_sub(1usize);
973 'break14: while i > stop && (best_len <= 2usize) {
974 'continue15: loop {
975 {
976 let mut prev_ix : usize = i;
977 let backward : usize = cur_ix.wrapping_sub(prev_ix);
978 if backward > max_backward {
979 break 'break14;
980 }
981 prev_ix = prev_ix & ring_buffer_mask;
982 if data[(cur_ix_masked as (usize)) ]as (i32) != data[(
983 prev_ix as (usize)
984 ) ]as (i32) || data[(
985 cur_ix_masked.wrapping_add(
986 1usize
987 ) as (usize)
988 ) ]as (i32) != data[(
989 prev_ix.wrapping_add(
990 1usize
991 ) as (usize)
992 ) ]as (i32) {
993 break 'continue15;
994 }
995 {
996 let len
997 : usize
998 = FindMatchLengthWithLimit(
999 &data[(prev_ix as (usize)) ],
1000 &data[(cur_ix_masked as (usize)) ],
1001 max_length
1002 );
1003 if len > best_len {
1004 best_len = len;
1005 InitBackwardMatch(
1006 {
1007 let _old = matches;
1008 matches = matches[(1 as (usize))..];
1009 _old
1010 },
1011 backward,
1012 len
1013 );
1014 }
1015 }
1016 }
1017 break;
1018 }
1019 i = i.wrapping_sub(1 as (usize));
1020 }
1021 if best_len < max_length {
1022 matches = StoreAndFindMatchesH10(
1023 SelfH10(handle),
1024 data,
1025 cur_ix,
1026 ring_buffer_mask,
1027 max_length,
1028 max_backward,
1029 &mut best_len ,
1030 matches
1031 );
1032 }
1033 i = 0usize;
1034 while i <= 37usize {
1035 {
1036 dict_matches[(i as (usize)) ]= kInvalidMatch;
1037 }
1038 i = i.wrapping_add(1 as (usize));
1039 }
1040 {
1041 let mut minlen
1042 : usize
1043 = brotli_max_size_t(
1044 4usize,
1045 best_len.wrapping_add(1usize)
1046 );
1047 if BrotliFindAllStaticDictionaryMatches(
1048 dictionary,
1049 &data[(cur_ix_masked as (usize)) ],
1050 minlen,
1051 max_length,
1052 &mut dict_matches[(0usize) ]
1053 ) != 0 {
1054 let mut maxlen
1055 : usize
1056 = brotli_min_size_t(37usize,max_length);
1057 let mut l : usize;
1058 l = minlen;
1059 while l <= maxlen {
1060 {
1061 let mut dict_id : u32 = dict_matches[(l as (usize))];
1062 if dict_id < kInvalidMatch {
1063 let mut distance
1064 : usize
1065 = max_backward.wrapping_add(gap).wrapping_add(
1066 (dict_id >> 5i32) as (usize)
1067 ).wrapping_add(
1068 1usize
1069 );
1070 if distance <= (*params).dist.max_distance {
1071 InitDictionaryBackwardMatch(
1072 {
1073 let _old = matches;
1074 matches = matches[(1 as (usize))..];
1075 _old
1076 },
1077 distance,
1078 l,
1079 (dict_id & 31u32) as (usize)
1080 );
1081 }
1082 }
1083 }
1084 l = l.wrapping_add(1 as (usize));
1085 }
1086 }
1087 }
1088 ((matches as (isize)).wrapping_sub(
1089 orig_matches as (isize)
1090 ) / std::mem::size_of::<*mut BackwardMatch>(
1091 ) as (isize)) as (usize)
1092 }
1093
BackwardMatchLength( mut xself : & BackwardMatch ) -> usize1094 fn BackwardMatchLength(
1095 mut xself : & BackwardMatch
1096 ) -> usize {
1097 ((*xself).length_and_code >> 5i32) as (usize)
1098 }
1099
MaxZopfliCandidates( mut params : & [BrotliEncoderParams ]) -> usize1100 fn MaxZopfliCandidates(
1101 mut params : & [BrotliEncoderParams
1102 ]) -> usize {
1103 (if (*params).quality <= 10i32 { 1i32 } else { 5i32 }) as (usize)
1104 }
1105
ComputeDistanceShortcut( block_start : usize, pos : usize, max_backward : usize, gap : usize, mut nodes : & [ZopfliNode ]) -> u321106 fn ComputeDistanceShortcut(
1107 block_start : usize,
1108 pos : usize,
1109 max_backward : usize,
1110 gap : usize,
1111 mut nodes : & [ZopfliNode
1112 ]) -> u32 {
1113 let clen
1114 : usize
1115 = ZopfliNodeCopyLength(
1116 &nodes[(pos as (usize)) ]
1117 ) as (usize);
1118 let ilen
1119 : usize
1120 = ((nodes[(
1121 pos as (usize)
1122 )]).dcode_insert_length & 0x7ffffffu32) as (usize);
1123 let dist
1124 : usize
1125 = ZopfliNodeCopyDistance(
1126 &nodes[(pos as (usize)) ]
1127 ) as (usize);
1128 if pos == 0usize {
1129 0u32
1130 } else if dist.wrapping_add(clen) <= block_start.wrapping_add(
1131 pos
1132 ).wrapping_add(
1133 gap
1134 ) && (dist <= max_backward.wrapping_add(
1135 gap
1136 )) && (ZopfliNodeDistanceCode(
1137 &nodes[(
1138 pos as (usize)
1139 ) ]
1140 ) > 0u32) {
1141 pos as (u32)
1142 } else {
1143 (nodes[(
1144 pos.wrapping_sub(clen).wrapping_sub(ilen) as (usize)
1145 )]).u.shortcut
1146 }
1147 }
1148
ZopfliCostModelGetLiteralCosts( mut xself : & ZopfliCostModel, mut from : usize, mut to : usize ) -> f321149 fn ZopfliCostModelGetLiteralCosts(
1150 mut xself : & ZopfliCostModel, mut from : usize, mut to : usize
1151 ) -> f32 {
1152 *(*xself).literal_costs_[(
1153 to as (usize)
1154 ) ..]- *(*xself).literal_costs_[(from as (usize))
1155
1156 ..]}fn ComputeDistanceCache(
1157 pos : usize,
1158 mut starting_dist_cache : & [i32],
1159 mut nodes : & [ZopfliNode],
1160 mut dist_cache : &mut [i32
1161 ]) {
1162 let mut idx : i32 = 0i32;
1163 let mut p
1164 : usize
1165 = (nodes[(pos as (usize))]).u.shortcut as (usize);
1166 while idx < 4i32 && (p > 0usize) {
1167 let ilen
1168 : usize
1169 = ((nodes[(
1170 p as (usize)
1171 )]).dcode_insert_length & 0x7ffffffu32) as (usize);
1172 let clen
1173 : usize
1174 = ZopfliNodeCopyLength(
1175 &nodes[(p as (usize)) ]
1176 ) as (usize);
1177 let dist
1178 : usize
1179 = ZopfliNodeCopyDistance(
1180 &nodes[(p as (usize)) ]
1181 ) as (usize);
1182 dist_cache[(
1183 {
1184 let _old = idx;
1185 idx = idx + 1;
1186 _old
1187 } as (usize)
1188 ) ]= dist as (i32);
1189 p = (nodes[(
1190 p.wrapping_sub(clen).wrapping_sub(ilen) as (usize)
1191 )]).u.shortcut as (usize);
1192 }
1193 while idx < 4i32 {
1194 {
1195 dist_cache[(idx as (usize)) ]= *{
1196 let _old = starting_dist_cache;
1197 starting_dist_cache = starting_dist_cache[(
1198 1 as (usize)
1199 )..];
1200 _old
1201 };
1202 }
1203 idx = idx + 1;
1204 }
1205 }
1206
StartPosQueueSize( mut xself : & StartPosQueue ) -> usize1207 fn StartPosQueueSize(
1208 mut xself : & StartPosQueue
1209 ) -> usize {
1210 brotli_min_size_t((*xself).idx_,8usize)
1211 }
1212
StartPosQueuePush( mut xself : &mut StartPosQueue, mut posdata : & [PosData ])1213 fn StartPosQueuePush(
1214 mut xself : &mut StartPosQueue, mut posdata : & [PosData
1215 ]) {
1216 let mut offset
1217 : usize
1218 = !{
1219 let _old = (*xself).idx_;
1220 (*xself).idx_ = (*xself).idx_.wrapping_add(1 as (usize));
1221 _old
1222 } & 7usize;
1223 let mut len
1224 : usize
1225 = StartPosQueueSize(xself );
1226 let mut i : usize;
1227 let mut q : *mut PosData = (*xself).q_;
1228 q[(offset as (usize)) ]= *posdata;
1229 i = 1usize;
1230 while i < len {
1231 {
1232 if (q[(
1233 (offset & 7usize) as (usize)
1234 )]).costdiff > (q[(
1235 (offset.wrapping_add(
1236 1usize
1237 ) & 7usize) as (usize)
1238 )]).costdiff {
1239 let mut __brotli_swap_tmp
1240 : PosData
1241 = q[((offset & 7usize) as (usize))];
1242 q[((offset & 7usize) as (usize)) ]= q[(
1243 (offset.wrapping_add(
1244 1usize
1245 ) & 7usize) as (usize)
1246 )];
1247 q[(
1248 (offset.wrapping_add(1usize) & 7usize) as (usize)
1249 ) ]= __brotli_swap_tmp;
1250 }
1251 offset = offset.wrapping_add(1 as (usize));
1252 }
1253 i = i.wrapping_add(1 as (usize));
1254 }
1255 }
1256
EvaluateNode( block_start : usize, pos : usize, max_backward_limit : usize, gap : usize, mut starting_dist_cache : & [i32], mut model : & [ZopfliCostModel], mut queue : &mut [StartPosQueue], mut nodes : &mut [ZopfliNode ])1257 fn EvaluateNode(
1258 block_start : usize,
1259 pos : usize,
1260 max_backward_limit : usize,
1261 gap : usize,
1262 mut starting_dist_cache : & [i32],
1263 mut model : & [ZopfliCostModel],
1264 mut queue : &mut [StartPosQueue],
1265 mut nodes : &mut [ZopfliNode
1266 ]) {
1267 let mut node_cost : f32 = (nodes[(pos as (usize))]).u.cost;
1268 (nodes[(
1269 pos as (usize)
1270 )]).u.shortcut = ComputeDistanceShortcut(
1271 block_start,
1272 pos,
1273 max_backward_limit,
1274 gap,
1275 nodes
1276 );
1277 if node_cost <= ZopfliCostModelGetLiteralCosts(
1278 model,
1279 0usize,
1280 pos
1281 ) {
1282 let mut posdata : PosData;
1283 posdata.pos = pos;
1284 posdata.cost = node_cost;
1285 posdata.costdiff = node_cost - ZopfliCostModelGetLiteralCosts(
1286 model,
1287 0usize,
1288 pos
1289 );
1290 ComputeDistanceCache(
1291 pos,
1292 starting_dist_cache,
1293 nodes ,
1294 posdata.distance_cache
1295 );
1296 StartPosQueuePush(
1297 queue,
1298 &mut posdata
1299 );
1300 }
1301 }
1302
StartPosQueueAt( mut xself : & StartPosQueue, mut k : usize ) -> *const PosData1303 fn StartPosQueueAt(
1304 mut xself : & StartPosQueue, mut k : usize
1305 ) -> *const PosData {
1306 &mut *(*xself).q_[(
1307 (k.wrapping_sub((*xself).idx_) & 7usize) as (usize)
1308 ) ..]
1309 }
1310
ZopfliCostModelGetMinCostCmd( mut xself : & ZopfliCostModel ) -> f321311 fn ZopfliCostModelGetMinCostCmd(
1312 mut xself : & ZopfliCostModel
1313 ) -> f32 {
1314 (*xself).min_cost_cmd_
1315 }
1316
ComputeMinimumCopyLength( start_cost : f32, mut nodes : & [ZopfliNode], num_bytes : usize, pos : usize ) -> usize1317 fn ComputeMinimumCopyLength(
1318 start_cost : f32,
1319 mut nodes : & [ZopfliNode],
1320 num_bytes : usize,
1321 pos : usize
1322 ) -> usize {
1323 let mut min_cost : f32 = start_cost;
1324 let mut len : usize = 2usize;
1325 let mut next_len_bucket : usize = 4usize;
1326 let mut next_len_offset : usize = 10usize;
1327 while pos.wrapping_add(len) <= num_bytes && ((nodes[(
1328 pos.wrapping_add(len) as (usize)
1329 )]).u.cost <= min_cost) {
1330 len = len.wrapping_add(1 as (usize));
1331 if len == next_len_offset {
1332 min_cost = min_cost + 1.0f32;
1333 next_len_offset = next_len_offset.wrapping_add(next_len_bucket);
1334 next_len_bucket = next_len_bucket.wrapping_mul(2usize);
1335 }
1336 }
1337 len
1338 }
1339
GetInsertExtra(mut inscode : u16) -> u321340 fn GetInsertExtra(mut inscode : u16) -> u32 {
1341 kInsExtra[(inscode as (usize))
1342
1343 ]}fn ZopfliCostModelGetDistanceCost(
1344 mut xself : & ZopfliCostModel, mut distcode : usize
1345 ) -> f32 {
1346 *(*xself).cost_dist_[(distcode as (usize))
1347
GetCopyExtra(mut copycode : u16) -> u321348 ..]}fn GetCopyExtra(mut copycode : u16) -> u32 {
1349 kCopyExtra[(copycode as (usize))
1350
1351 ]}fn ZopfliCostModelGetCommandCost(
1352 mut xself : & ZopfliCostModel, mut cmdcode : u16
1353 ) -> f32 {
1354 *(*xself).cost_cmd_[(cmdcode as (usize))
1355
UpdateZopfliNode( mut nodes : &mut [ZopfliNode], mut pos : usize, mut start_pos : usize, mut len : usize, mut len_code : usize, mut dist : usize, mut short_code : usize, mut cost : f32 )1356 ..]}fn UpdateZopfliNode(
1357 mut nodes : &mut [ZopfliNode],
1358 mut pos : usize,
1359 mut start_pos : usize,
1360 mut len : usize,
1361 mut len_code : usize,
1362 mut dist : usize,
1363 mut short_code : usize,
1364 mut cost : f32
1365 ) {
1366 let mut next
1367 : *mut ZopfliNode
1368 = &mut nodes[(
1369 pos.wrapping_add(len) as (usize)
1370 ) ];
1371 (*next).length = (len | len.wrapping_add(
1372 9u32 as (usize)
1373 ).wrapping_sub(
1374 len_code
1375 ) << 25i32) as (u32);
1376 (*next).distance = dist as (u32);
1377 (*next).dcode_insert_length = (short_code << 27i32 | pos.wrapping_sub(
1378 start_pos
1379 )) as (u32);
1380 (*next).u.cost = cost;
1381 }
1382
BackwardMatchLengthCode( mut xself : & BackwardMatch ) -> usize1383 fn BackwardMatchLengthCode(
1384 mut xself : & BackwardMatch
1385 ) -> usize {
1386 let mut code
1387 : usize
1388 = ((*xself).length_and_code & 31u32) as (usize);
1389 if code != 0 { code } else { BackwardMatchLength(xself) }
1390 }
1391
UpdateNodes( num_bytes : usize, block_start : usize, pos : usize, mut ringbuffer : & [u8], ringbuffer_mask : usize, mut params : & [BrotliEncoderParams], max_backward_limit : usize, mut starting_dist_cache : & [i32], num_matches : usize, mut matches : & [BackwardMatch], mut model : & [ZopfliCostModel], mut queue : &mut [StartPosQueue], mut nodes : &mut [ZopfliNode ]) -> usize1392 fn UpdateNodes(
1393 num_bytes : usize,
1394 block_start : usize,
1395 pos : usize,
1396 mut ringbuffer : & [u8],
1397 ringbuffer_mask : usize,
1398 mut params : & [BrotliEncoderParams],
1399 max_backward_limit : usize,
1400 mut starting_dist_cache : & [i32],
1401 num_matches : usize,
1402 mut matches : & [BackwardMatch],
1403 mut model : & [ZopfliCostModel],
1404 mut queue : &mut [StartPosQueue],
1405 mut nodes : &mut [ZopfliNode
1406 ]) -> usize {
1407 let cur_ix : usize = block_start.wrapping_add(pos);
1408 let cur_ix_masked : usize = cur_ix & ringbuffer_mask;
1409 let max_distance
1410 : usize
1411 = brotli_min_size_t(cur_ix,max_backward_limit);
1412 let max_len : usize = num_bytes.wrapping_sub(pos);
1413 let max_zopfli_len : usize = MaxZopfliLen(params);
1414 let max_iters : usize = MaxZopfliCandidates(params);
1415 let mut min_len : usize;
1416 let mut result : usize = 0usize;
1417 let mut k : usize;
1418 let mut gap : usize = 0usize;
1419 EvaluateNode(
1420 block_start,
1421 pos,
1422 max_backward_limit,
1423 gap,
1424 starting_dist_cache,
1425 model,
1426 queue,
1427 nodes
1428 );
1429 {
1430 let mut posdata
1431 : *const PosData
1432 = StartPosQueueAt(queue ,0usize);
1433 let mut min_cost
1434 : f32
1435 = (*posdata).cost + ZopfliCostModelGetMinCostCmd(
1436 model
1437 ) + ZopfliCostModelGetLiteralCosts(model,(*posdata).pos,pos);
1438 min_len = ComputeMinimumCopyLength(
1439 min_cost,
1440 nodes ,
1441 num_bytes,
1442 pos
1443 );
1444 }
1445 k = 0usize;
1446 while k < max_iters && (k < StartPosQueueSize(
1447 queue
1448 )) {
1449 'continue28: loop {
1450 {
1451 let mut posdata
1452 : *const PosData
1453 = StartPosQueueAt(queue ,k);
1454 let start : usize = (*posdata).pos;
1455 let inscode : u16 = GetInsertLengthCode(pos.wrapping_sub(start));
1456 let start_costdiff : f32 = (*posdata).costdiff;
1457 let base_cost
1458 : f32
1459 = start_costdiff + GetInsertExtra(
1460 inscode
1461 ) as (f32) + ZopfliCostModelGetLiteralCosts(
1462 model,
1463 0usize,
1464 pos
1465 );
1466 let mut best_len : usize = min_len.wrapping_sub(1usize);
1467 let mut j : usize = 0usize;
1468 'break29: while j < 16usize && (best_len < max_len) {
1469 'continue30: loop {
1470 {
1471 let idx
1472 : usize
1473 = kDistanceCacheIndex[(j as (usize)) ]as (usize);
1474 let backward
1475 : usize
1476 = (*(*posdata).distance_cache[(
1477 idx as (usize)
1478 ) ..]+ kDistanceCacheOffset[(j as (usize)) ])as (usize);
1479 let mut prev_ix : usize = cur_ix.wrapping_sub(backward);
1480 let mut len : usize = 0usize;
1481 let mut continuation
1482 : u8
1483 = ringbuffer[(
1484 cur_ix_masked.wrapping_add(best_len) as (usize)
1485 )];
1486 if cur_ix_masked.wrapping_add(best_len) > ringbuffer_mask {
1487 break 'break29;
1488 }
1489 if backward > max_distance.wrapping_add(gap) {
1490 break 'continue30;
1491 }
1492 if backward <= max_distance {
1493 if prev_ix >= cur_ix {
1494 break 'continue30;
1495 }
1496 prev_ix = prev_ix & ringbuffer_mask;
1497 if prev_ix.wrapping_add(
1498 best_len
1499 ) > ringbuffer_mask || continuation as (i32) != ringbuffer[(
1500 prev_ix.wrapping_add(
1501 best_len
1502 ) as (usize)
1503 ) ]as (i32) {
1504 break 'continue30;
1505 }
1506 len = FindMatchLengthWithLimit(
1507 &ringbuffer[(prev_ix as (usize)) ],
1508 &ringbuffer[(
1509 cur_ix_masked as (usize)
1510 ) ],
1511 max_len
1512 );
1513 } else {
1514 break 'continue30;
1515 }
1516 {
1517 let dist_cost
1518 : f32
1519 = base_cost + ZopfliCostModelGetDistanceCost(model,j);
1520 let mut l : usize;
1521 l = best_len.wrapping_add(1usize);
1522 while l <= len {
1523 {
1524 let copycode : u16 = GetCopyLengthCode(l);
1525 let cmdcode
1526 : u16
1527 = CombineLengthCodes(
1528 inscode,
1529 copycode,
1530 (j == 0usize) as (i32)
1531 );
1532 let cost
1533 : f32
1534 = (if cmdcode as (i32) < 128i32 {
1535 base_cost
1536 } else {
1537 dist_cost
1538 }) + GetCopyExtra(
1539 copycode
1540 ) as (f32) + ZopfliCostModelGetCommandCost(
1541 model,
1542 cmdcode
1543 );
1544 if cost < (nodes[(
1545 pos.wrapping_add(l) as (usize)
1546 )]).u.cost {
1547 UpdateZopfliNode(
1548 nodes,
1549 pos,
1550 start,
1551 l,
1552 l,
1553 backward,
1554 j.wrapping_add(1usize),
1555 cost
1556 );
1557 result = brotli_max_size_t(result,l);
1558 }
1559 best_len = l;
1560 }
1561 l = l.wrapping_add(1 as (usize));
1562 }
1563 }
1564 }
1565 break;
1566 }
1567 j = j.wrapping_add(1 as (usize));
1568 }
1569 if k >= 2usize {
1570 break 'continue28;
1571 }
1572 {
1573 let mut len : usize = min_len;
1574 j = 0usize;
1575 while j < num_matches {
1576 {
1577 let mut match_ : BackwardMatch = matches[(j as (usize))];
1578 let mut dist : usize = match_.distance as (usize);
1579 let mut is_dictionary_match
1580 : i32
1581 = if !!(dist > max_distance.wrapping_add(gap)) {
1582 1i32
1583 } else {
1584 0i32
1585 };
1586 let mut dist_code
1587 : usize
1588 = dist.wrapping_add(16usize).wrapping_sub(
1589 1usize
1590 );
1591 let mut dist_symbol : u16;
1592 let mut distextra : u32;
1593 let mut distnumextra : u32;
1594 let mut dist_cost : f32;
1595 let mut max_match_len : usize;
1596 PrefixEncodeCopyDistance(
1597 dist_code,
1598 (*params).dist.num_direct_distance_codes as (usize),
1599 (*params).dist.distance_postfix_bits as (usize),
1600 &mut dist_symbol ,
1601 &mut distextra
1602 );
1603 distnumextra = (dist_symbol as (i32) >> 10i32) as (u32);
1604 dist_cost = base_cost + distnumextra as (f32) + ZopfliCostModelGetDistanceCost(
1605 model,
1606 (dist_symbol as (i32) & 0x3ffi32) as (usize)
1607 );
1608 max_match_len = BackwardMatchLength(
1609 &mut match_
1610 );
1611 if len < max_match_len && (is_dictionary_match != 0 || max_match_len > max_zopfli_len) {
1612 len = max_match_len;
1613 }
1614 while len <= max_match_len {
1615 {
1616 let len_code
1617 : usize
1618 = if is_dictionary_match != 0 {
1619 BackwardMatchLengthCode(
1620 &mut match_
1621 )
1622 } else {
1623 len
1624 };
1625 let copycode : u16 = GetCopyLengthCode(len_code);
1626 let cmdcode : u16 = CombineLengthCodes(inscode,copycode,0i32);
1627 let cost
1628 : f32
1629 = dist_cost + GetCopyExtra(
1630 copycode
1631 ) as (f32) + ZopfliCostModelGetCommandCost(
1632 model,
1633 cmdcode
1634 );
1635 if cost < (nodes[(
1636 pos.wrapping_add(len) as (usize)
1637 )]).u.cost {
1638 UpdateZopfliNode(
1639 nodes,
1640 pos,
1641 start,
1642 len,
1643 len_code,
1644 dist,
1645 0usize,
1646 cost
1647 );
1648 result = brotli_max_size_t(result,len);
1649 }
1650 }
1651 len = len.wrapping_add(1 as (usize));
1652 }
1653 }
1654 j = j.wrapping_add(1 as (usize));
1655 }
1656 }
1657 }
1658 break;
1659 }
1660 k = k.wrapping_add(1 as (usize));
1661 }
1662 result
1663 }
1664
StoreH10( mut handle : &mut [u8], mut data : & [u8], mask : usize, ix : usize )1665 fn StoreH10(
1666 mut handle : &mut [u8],
1667 mut data : & [u8],
1668 mask : usize,
1669 ix : usize
1670 ) {
1671 let mut xself : *mut H10 = SelfH10(handle);
1672 let max_backward
1673 : usize
1674 = (*xself).window_mask_.wrapping_sub(16usize).wrapping_add(
1675 1usize
1676 );
1677 StoreAndFindMatchesH10(
1678 xself,
1679 data,
1680 ix,
1681 mask,
1682 128usize,
1683 max_backward,
1684 0i32 ,
1685 0i32
1686 );
1687 }
1688
StoreRangeH10( mut handle : &mut [u8], mut data : & [u8], mask : usize, ix_start : usize, ix_end : usize )1689 fn StoreRangeH10(
1690 mut handle : &mut [u8],
1691 mut data : & [u8],
1692 mask : usize,
1693 ix_start : usize,
1694 ix_end : usize
1695 ) {
1696 let mut i : usize = ix_start;
1697 let mut j : usize = ix_start;
1698 if ix_start.wrapping_add(63usize) <= ix_end {
1699 i = ix_end.wrapping_sub(63usize);
1700 }
1701 if ix_start.wrapping_add(512usize) <= i {
1702 while j < i {
1703 {
1704 StoreH10(handle,data,mask,j);
1705 }
1706 j = j.wrapping_add(8usize);
1707 }
1708 }
1709 while i < ix_end {
1710 {
1711 StoreH10(handle,data,mask,i);
1712 }
1713 i = i.wrapping_add(1 as (usize));
1714 }
1715 }
1716
HashTypeLengthH10() -> usize1717 fn HashTypeLengthH10() -> usize { 4usize }
1718
CleanupZopfliCostModel( mut m : &mut [MemoryManager], mut xself : &mut ZopfliCostModel )1719 fn CleanupZopfliCostModel(
1720 mut m : &mut [MemoryManager], mut xself : &mut ZopfliCostModel
1721 ) {
1722 {
1723 BrotliFree(
1724 m,
1725 (*xself).literal_costs_
1726 );
1727 (*xself).literal_costs_ = 0i32 ;
1728 }
1729 {
1730 BrotliFree(m,(*xself).cost_dist_ );
1731 (*xself).cost_dist_ = 0i32 ;
1732 }
1733 }
1734
ZopfliNodeCommandLength( mut xself : & ZopfliNode ) -> u321735 fn ZopfliNodeCommandLength(
1736 mut xself : & ZopfliNode
1737 ) -> u32 {
1738 ZopfliNodeCopyLength(xself).wrapping_add(
1739 (*xself).dcode_insert_length & 0x7ffffffu32
1740 )
1741 }
1742
ComputeShortestPathFromNodes( mut num_bytes : usize, mut nodes : &mut [ZopfliNode ]) -> usize1743 fn ComputeShortestPathFromNodes(
1744 mut num_bytes : usize, mut nodes : &mut [ZopfliNode
1745 ]) -> usize {
1746 let mut index : usize = num_bytes;
1747 let mut num_commands : usize = 0usize;
1748 while (nodes[(
1749 index as (usize)
1750 )]).dcode_insert_length & 0x7ffffffu32 == 0u32 && ((nodes[(
1751 index as (usize)
1752 )]).length == 1u32) {
1753 index = index.wrapping_sub(1 as (usize));
1754 }
1755 (nodes[(index as (usize))]).u.next = !(0u32);
1756 while index != 0usize {
1757 let mut len
1758 : usize
1759 = ZopfliNodeCommandLength(
1760 &mut nodes[(
1761 index as (usize)
1762 ) ]
1763 ) as (usize);
1764 index = index.wrapping_sub(len);
1765 (nodes[(index as (usize))]).u.next = len as (u32);
1766 num_commands = num_commands.wrapping_add(1 as (usize));
1767 }
1768 num_commands
1769 }
1770
1771
BrotliZopfliComputeShortestPath( mut m : &mut [MemoryManager], mut num_bytes : usize, mut position : usize, mut ringbuffer : & [u8], mut ringbuffer_mask : usize, mut params : & [BrotliEncoderParams], max_backward_limit : usize, mut dist_cache : & [i32], mut hasher : &mut [u8], mut nodes : &mut [ZopfliNode ]) -> usize1772 pub fn BrotliZopfliComputeShortestPath(
1773 mut m : &mut [MemoryManager],
1774 mut num_bytes : usize,
1775 mut position : usize,
1776 mut ringbuffer : & [u8],
1777 mut ringbuffer_mask : usize,
1778 mut params : & [BrotliEncoderParams],
1779 max_backward_limit : usize,
1780 mut dist_cache : & [i32],
1781 mut hasher : &mut [u8],
1782 mut nodes : &mut [ZopfliNode
1783 ]) -> usize {
1784 let max_zopfli_len : usize = MaxZopfliLen(params);
1785 let mut model : ZopfliCostModel;
1786 let mut queue : StartPosQueue;
1787 let mut matches : *mut BackwardMatch;
1788 let store_end
1789 : usize
1790 = if num_bytes >= StoreLookaheadH10() {
1791 position.wrapping_add(num_bytes).wrapping_sub(
1792 StoreLookaheadH10()
1793 ).wrapping_add(
1794 1usize
1795 )
1796 } else {
1797 position
1798 };
1799 let mut i : usize;
1800 let mut gap : usize = 0usize;
1801 let mut lz_matches_offset : usize = 0usize;
1802 (nodes[(0usize)]).length = 0u32;
1803 (nodes[(0usize)]).u.cost = 0i32 as (f32);
1804 InitZopfliCostModel(
1805 m,
1806 &mut model ,
1807 &(*params).dist ,
1808 num_bytes
1809 );
1810 if !(0i32 == 0) {
1811 return 0usize;
1812 }
1813 ZopfliCostModelSetFromLiteralCosts(
1814 &mut model ,
1815 position,
1816 ringbuffer,
1817 ringbuffer_mask
1818 );
1819 InitStartPosQueue(&mut queue );
1820 i = 0usize;
1821 while i.wrapping_add(HashTypeLengthH10()).wrapping_sub(
1822 1usize
1823 ) < num_bytes {
1824 {
1825 let pos : usize = position.wrapping_add(i);
1826 let max_distance
1827 : usize
1828 = brotli_min_size_t(pos,max_backward_limit);
1829 let mut skip : usize;
1830 let mut num_matches
1831 : usize
1832 = FindAllMatchesH10(
1833 hasher,
1834 &(*params).dictionary ,
1835 ringbuffer,
1836 ringbuffer_mask,
1837 pos,
1838 num_bytes.wrapping_sub(i),
1839 max_distance,
1840 gap,
1841 params,
1842 &mut matches[(
1843 lz_matches_offset as (usize)
1844 ) ]
1845 );
1846 if num_matches > 0usize && (BackwardMatchLength(
1847 &mut matches[(
1848 num_matches.wrapping_sub(
1849 1usize
1850 ) as (usize)
1851 ) ]
1852 ) > max_zopfli_len) {
1853 matches[(0usize) ]= matches[(
1854 num_matches.wrapping_sub(
1855 1usize
1856 ) as (usize)
1857 )];
1858 num_matches = 1usize;
1859 }
1860 skip = UpdateNodes(
1861 num_bytes,
1862 position,
1863 i,
1864 ringbuffer,
1865 ringbuffer_mask,
1866 params,
1867 max_backward_limit,
1868 dist_cache,
1869 num_matches,
1870 matches ,
1871 &mut model ,
1872 &mut queue ,
1873 nodes
1874 );
1875 if skip < 16384usize {
1876 skip = 0usize;
1877 }
1878 if num_matches == 1usize && (BackwardMatchLength(
1879 &mut matches[(
1880 0usize
1881 ) ]
1882 ) > max_zopfli_len) {
1883 skip = brotli_max_size_t(
1884 BackwardMatchLength(
1885 &mut matches[(
1886 0usize
1887 ) ]
1888 ),
1889 skip
1890 );
1891 }
1892 if skip > 1usize {
1893 StoreRangeH10(
1894 hasher,
1895 ringbuffer,
1896 ringbuffer_mask,
1897 pos.wrapping_add(1usize),
1898 brotli_min_size_t(pos.wrapping_add(skip),store_end)
1899 );
1900 skip = skip.wrapping_sub(1 as (usize));
1901 while skip != 0 {
1902 i = i.wrapping_add(1 as (usize));
1903 if i.wrapping_add(HashTypeLengthH10()).wrapping_sub(
1904 1usize
1905 ) >= num_bytes {
1906 break;
1907 }
1908 EvaluateNode(
1909 position,
1910 i,
1911 max_backward_limit,
1912 gap,
1913 dist_cache,
1914 &mut model ,
1915 &mut queue ,
1916 nodes
1917 );
1918 skip = skip.wrapping_sub(1 as (usize));
1919 }
1920 }
1921 }
1922 i = i.wrapping_add(1 as (usize));
1923 }
1924 CleanupZopfliCostModel(m,&mut model );
1925 ComputeShortestPathFromNodes(num_bytes,nodes)
1926 }
1927
1928
BrotliCreateZopfliBackwardReferences( mut m : &mut [MemoryManager], mut num_bytes : usize, mut position : usize, mut ringbuffer : & [u8], mut ringbuffer_mask : usize, mut params : & [BrotliEncoderParams], mut hasher : &mut [u8], mut dist_cache : &mut [i32], mut last_insert_len : &mut [usize], mut commands : &mut [Command], mut num_commands : &mut [usize], mut num_literals : &mut [usize ])1929 pub fn BrotliCreateZopfliBackwardReferences(
1930 mut m : &mut [MemoryManager],
1931 mut num_bytes : usize,
1932 mut position : usize,
1933 mut ringbuffer : & [u8],
1934 mut ringbuffer_mask : usize,
1935 mut params : & [BrotliEncoderParams],
1936 mut hasher : &mut [u8],
1937 mut dist_cache : &mut [i32],
1938 mut last_insert_len : &mut [usize],
1939 mut commands : &mut [Command],
1940 mut num_commands : &mut [usize],
1941 mut num_literals : &mut [usize
1942 ]) {
1943 let max_backward_limit
1944 : usize
1945 = (1usize << (*params).lgwin).wrapping_sub(
1946 16usize
1947 );
1948 let mut nodes : *mut ZopfliNode;
1949 nodes = if num_bytes.wrapping_add(
1950 1usize
1951 ) > 0usize {
1952 BrotliAllocate(
1953 m,
1954 num_bytes.wrapping_add(1usize).wrapping_mul(
1955 std::mem::size_of::<ZopfliNode>()
1956 )
1957 )
1958 } else {
1959 0i32
1960 };
1961 if !(0i32 == 0) {
1962 return;
1963 }
1964 BrotliInitZopfliNodes(
1965 nodes,
1966 num_bytes.wrapping_add(1usize)
1967 );
1968 *num_commands = (*num_commands).wrapping_add(
1969 BrotliZopfliComputeShortestPath(
1970 m,
1971 num_bytes,
1972 position,
1973 ringbuffer,
1974 ringbuffer_mask,
1975 params,
1976 max_backward_limit,
1977 dist_cache ,
1978 hasher,
1979 nodes
1980 )
1981 );
1982 if !(0i32 == 0) {
1983 return;
1984 }
1985 BrotliZopfliCreateCommands(
1986 num_bytes,
1987 position,
1988 max_backward_limit,
1989 nodes ,
1990 dist_cache,
1991 last_insert_len,
1992 params,
1993 commands,
1994 num_literals
1995 );
1996 {
1997 BrotliFree(m,nodes );
1998 nodes = 0i32 ;
1999 }
2000 }
2001
CommandCopyLen(mut xself : & Command) -> u322002 fn CommandCopyLen(mut xself : & Command) -> u32 {
2003 (*xself).copy_len_ & 0x1ffffffu32
2004 }
2005
SetCost( mut histogram : & [u32], mut histogram_size : usize, mut literal_histogram : i32, mut cost : &mut [f32 ])2006 fn SetCost(
2007 mut histogram : & [u32],
2008 mut histogram_size : usize,
2009 mut literal_histogram : i32,
2010 mut cost : &mut [f32
2011 ]) {
2012 let mut sum : usize = 0usize;
2013 let mut missing_symbol_sum : usize;
2014 let mut log2sum : f32;
2015 let mut missing_symbol_cost : f32;
2016 let mut i : usize;
2017 i = 0usize;
2018 while i < histogram_size {
2019 {
2020 sum = sum.wrapping_add(histogram[(i as (usize)) ]as (usize));
2021 }
2022 i = i.wrapping_add(1 as (usize));
2023 }
2024 log2sum = FastLog2(sum) as (f32);
2025 missing_symbol_sum = sum;
2026 if literal_histogram == 0 {
2027 i = 0usize;
2028 while i < histogram_size {
2029 {
2030 if histogram[(i as (usize)) ]== 0u32 {
2031 missing_symbol_sum = missing_symbol_sum.wrapping_add(1 as (usize));
2032 }
2033 }
2034 i = i.wrapping_add(1 as (usize));
2035 }
2036 }
2037 missing_symbol_cost = FastLog2(
2038 missing_symbol_sum
2039 ) as (f32) + 2i32 as (f32);
2040 i = 0usize;
2041 while i < histogram_size {
2042 'continue56: loop {
2043 {
2044 if histogram[(i as (usize)) ]== 0u32 {
2045 cost[(i as (usize)) ]= missing_symbol_cost;
2046 break 'continue56;
2047 }
2048 cost[(i as (usize)) ]= log2sum - FastLog2(
2049 histogram[(
2050 i as (usize)
2051 ) ]as (usize)
2052 ) as (f32);
2053 if cost[(i as (usize)) ]< 1i32 as (f32) {
2054 cost[(i as (usize)) ]= 1i32 as (f32);
2055 }
2056 }
2057 break;
2058 }
2059 i = i.wrapping_add(1 as (usize));
2060 }
2061 }
2062
brotli_min_float( mut a : f32, mut b : f32 ) -> f322063 fn brotli_min_float(
2064 mut a : f32, mut b : f32
2065 ) -> f32 {
2066 if a < b { a } else { b }
2067 }
2068
ZopfliCostModelSetFromCommands( mut xself : &mut ZopfliCostModel, mut position : usize, mut ringbuffer : & [u8], mut ringbuffer_mask : usize, mut commands : & [Command], mut num_commands : usize, mut last_insert_len : usize )2069 fn ZopfliCostModelSetFromCommands(
2070 mut xself : &mut ZopfliCostModel,
2071 mut position : usize,
2072 mut ringbuffer : & [u8],
2073 mut ringbuffer_mask : usize,
2074 mut commands : & [Command],
2075 mut num_commands : usize,
2076 mut last_insert_len : usize
2077 ) {
2078 let mut histogram_literal : *mut u32;
2079 let mut histogram_cmd : *mut u32;
2080 let mut histogram_dist : *mut u32;
2081 let mut cost_literal : *mut f32;
2082 let mut pos : usize = position.wrapping_sub(last_insert_len);
2083 let mut min_cost_cmd : f32 = kInfinity;
2084 let mut i : usize;
2085 let mut cost_cmd : *mut f32 = (*xself).cost_cmd_;
2086 memset(
2087 histogram_literal ,
2088 0i32,
2089 std::mem::size_of::<*mut u32>()
2090 );
2091 memset(
2092 histogram_cmd ,
2093 0i32,
2094 std::mem::size_of::<*mut u32>()
2095 );
2096 memset(
2097 histogram_dist ,
2098 0i32,
2099 std::mem::size_of::<*mut u32>()
2100 );
2101 i = 0usize;
2102 while i < num_commands {
2103 {
2104 let mut inslength
2105 : usize
2106 = (commands[(i as (usize))]).insert_len_ as (usize);
2107 let mut copylength
2108 : usize
2109 = CommandCopyLen(
2110 &commands[(i as (usize)) ]
2111 ) as (usize);
2112 let mut distcode
2113 : usize
2114 = ((commands[(
2115 i as (usize)
2116 )]).dist_prefix_ as (i32) & 0x3ffi32) as (usize);
2117 let mut cmdcode
2118 : usize
2119 = (commands[(i as (usize))]).cmd_prefix_ as (usize);
2120 let mut j : usize;
2121 {
2122 let _rhs = 1;
2123 let _lhs = &mut histogram_cmd[(cmdcode as (usize))];
2124 *_lhs = (*_lhs).wrapping_add(_rhs as (u32));
2125 }
2126 if cmdcode >= 128usize {
2127 let _rhs = 1;
2128 let _lhs = &mut histogram_dist[(distcode as (usize))];
2129 *_lhs = (*_lhs).wrapping_add(_rhs as (u32));
2130 }
2131 j = 0usize;
2132 while j < inslength {
2133 {
2134 let _rhs = 1;
2135 let _lhs
2136 = &mut histogram_literal[(
2137 ringbuffer[(
2138 (pos.wrapping_add(j) & ringbuffer_mask) as (usize)
2139 ) ]as (usize)
2140 )];
2141 *_lhs = (*_lhs).wrapping_add(_rhs as (u32));
2142 }
2143 j = j.wrapping_add(1 as (usize));
2144 }
2145 pos = pos.wrapping_add(inslength.wrapping_add(copylength));
2146 }
2147 i = i.wrapping_add(1 as (usize));
2148 }
2149 SetCost(
2150 histogram_literal ,
2151 256usize,
2152 1i32,
2153 cost_literal
2154 );
2155 SetCost(
2156 histogram_cmd ,
2157 704usize,
2158 0i32,
2159 cost_cmd
2160 );
2161 SetCost(
2162 histogram_dist ,
2163 (*xself).distance_histogram_size as (usize),
2164 0i32,
2165 (*xself).cost_dist_
2166 );
2167 i = 0usize;
2168 while i < 704usize {
2169 {
2170 min_cost_cmd = brotli_min_float(
2171 min_cost_cmd,
2172 cost_cmd[(i as (usize))]);
2173 }
2174 i = i.wrapping_add(1 as (usize));
2175 }
2176 (*xself).min_cost_cmd_ = min_cost_cmd;
2177 {
2178 let mut literal_costs : *mut f32 = (*xself).literal_costs_;
2179 let mut literal_carry : f32 = 0.0f64 as (f32);
2180 let mut num_bytes : usize = (*xself).num_bytes_;
2181 literal_costs[(0usize) ]= 0.0f64 as (f32);
2182 i = 0usize;
2183 while i < num_bytes {
2184 {
2185 literal_carry = literal_carry + cost_literal[(
2186 ringbuffer[(
2187 (position.wrapping_add(
2188 i
2189 ) & ringbuffer_mask) as (usize)
2190 ) ]as (usize)
2191 )];
2192 literal_costs[(
2193 i.wrapping_add(1usize) as (usize)
2194 ) ]= literal_costs[(i as (usize)) ]+ literal_carry;
2195 literal_carry = literal_carry - (literal_costs[(
2196 i.wrapping_add(1usize) as (usize)
2197 ) ]- literal_costs[(i as (usize))]);
2198 }
2199 i = i.wrapping_add(1 as (usize));
2200 }
2201 }
2202 }
2203
ZopfliIterate( mut num_bytes : usize, mut position : usize, mut ringbuffer : & [u8], mut ringbuffer_mask : usize, mut params : & [BrotliEncoderParams], max_backward_limit : usize, gap : usize, mut dist_cache : & [i32], mut model : & [ZopfliCostModel], mut num_matches : & [u32], mut matches : & [BackwardMatch], mut nodes : &mut [ZopfliNode ]) -> usize2204 fn ZopfliIterate(
2205 mut num_bytes : usize,
2206 mut position : usize,
2207 mut ringbuffer : & [u8],
2208 mut ringbuffer_mask : usize,
2209 mut params : & [BrotliEncoderParams],
2210 max_backward_limit : usize,
2211 gap : usize,
2212 mut dist_cache : & [i32],
2213 mut model : & [ZopfliCostModel],
2214 mut num_matches : & [u32],
2215 mut matches : & [BackwardMatch],
2216 mut nodes : &mut [ZopfliNode
2217 ]) -> usize {
2218 let max_zopfli_len : usize = MaxZopfliLen(params);
2219 let mut queue : StartPosQueue;
2220 let mut cur_match_pos : usize = 0usize;
2221 let mut i : usize;
2222 (nodes[(0usize)]).length = 0u32;
2223 (nodes[(0usize)]).u.cost = 0i32 as (f32);
2224 InitStartPosQueue(&mut queue );
2225 i = 0usize;
2226 while i.wrapping_add(3usize) < num_bytes {
2227 {
2228 let mut skip
2229 : usize
2230 = UpdateNodes(
2231 num_bytes,
2232 position,
2233 i,
2234 ringbuffer,
2235 ringbuffer_mask,
2236 params,
2237 max_backward_limit,
2238 dist_cache,
2239 num_matches[(i as (usize)) ]as (usize),
2240 &matches[(
2241 cur_match_pos as (usize)
2242 ) ],
2243 model,
2244 &mut queue ,
2245 nodes
2246 );
2247 if skip < 16384usize {
2248 skip = 0usize;
2249 }
2250 cur_match_pos = cur_match_pos.wrapping_add(
2251 num_matches[(i as (usize)) ]as (usize)
2252 );
2253 if num_matches[(
2254 i as (usize)
2255 ) ]== 1u32 && (BackwardMatchLength(
2256 &matches[(
2257 cur_match_pos.wrapping_sub(
2258 1usize
2259 ) as (usize)
2260 ) ]
2261 ) > max_zopfli_len) {
2262 skip = brotli_max_size_t(
2263 BackwardMatchLength(
2264 &matches[(
2265 cur_match_pos.wrapping_sub(1usize) as (usize)
2266 ) ]
2267 ),
2268 skip
2269 );
2270 }
2271 if skip > 1usize {
2272 skip = skip.wrapping_sub(1 as (usize));
2273 while skip != 0 {
2274 i = i.wrapping_add(1 as (usize));
2275 if i.wrapping_add(3usize) >= num_bytes {
2276 break;
2277 }
2278 EvaluateNode(
2279 position,
2280 i,
2281 max_backward_limit,
2282 gap,
2283 dist_cache,
2284 model,
2285 &mut queue ,
2286 nodes
2287 );
2288 cur_match_pos = cur_match_pos.wrapping_add(
2289 num_matches[(i as (usize)) ]as (usize)
2290 );
2291 skip = skip.wrapping_sub(1 as (usize));
2292 }
2293 }
2294 }
2295 i = i.wrapping_add(1 as (usize));
2296 }
2297 ComputeShortestPathFromNodes(num_bytes,nodes)
2298 }
2299
2300
BrotliCreateHqZopfliBackwardReferences( mut m : &mut [MemoryManager], mut num_bytes : usize, mut position : usize, mut ringbuffer : & [u8], mut ringbuffer_mask : usize, mut params : & [BrotliEncoderParams], mut hasher : &mut [u8], mut dist_cache : &mut [i32], mut last_insert_len : &mut [usize], mut commands : &mut [Command], mut num_commands : &mut [usize], mut num_literals : &mut [usize ])2301 pub fn BrotliCreateHqZopfliBackwardReferences(
2302 mut m : &mut [MemoryManager],
2303 mut num_bytes : usize,
2304 mut position : usize,
2305 mut ringbuffer : & [u8],
2306 mut ringbuffer_mask : usize,
2307 mut params : & [BrotliEncoderParams],
2308 mut hasher : &mut [u8],
2309 mut dist_cache : &mut [i32],
2310 mut last_insert_len : &mut [usize],
2311 mut commands : &mut [Command],
2312 mut num_commands : &mut [usize],
2313 mut num_literals : &mut [usize
2314 ]) {
2315 let max_backward_limit
2316 : usize
2317 = (1usize << (*params).lgwin).wrapping_sub(
2318 16usize
2319 );
2320 let mut num_matches
2321 : *mut u32
2322 = if num_bytes > 0usize {
2323 BrotliAllocate(
2324 m,
2325 num_bytes.wrapping_mul(std::mem::size_of::<u32>())
2326 )
2327 } else {
2328 0i32
2329 };
2330 let mut matches_size
2331 : usize
2332 = (4usize).wrapping_mul(num_bytes);
2333 let store_end
2334 : usize
2335 = if num_bytes >= StoreLookaheadH10() {
2336 position.wrapping_add(num_bytes).wrapping_sub(
2337 StoreLookaheadH10()
2338 ).wrapping_add(
2339 1usize
2340 )
2341 } else {
2342 position
2343 };
2344 let mut cur_match_pos : usize = 0usize;
2345 let mut i : usize;
2346 let mut orig_num_literals : usize;
2347 let mut orig_last_insert_len : usize;
2348 let mut orig_dist_cache : *mut i32;
2349 let mut orig_num_commands : usize;
2350 let mut model : ZopfliCostModel;
2351 let mut nodes : *mut ZopfliNode;
2352 let mut matches
2353 : *mut BackwardMatch
2354 = if matches_size > 0usize {
2355 BrotliAllocate(
2356 m,
2357 matches_size.wrapping_mul(std::mem::size_of::<BackwardMatch>())
2358 )
2359 } else {
2360 0i32
2361 };
2362 let mut gap : usize = 0usize;
2363 let mut shadow_matches : usize = 0usize;
2364 if !(0i32 == 0) {
2365 return;
2366 }
2367 i = 0usize;
2368 while i.wrapping_add(HashTypeLengthH10()).wrapping_sub(
2369 1usize
2370 ) < num_bytes {
2371 {
2372 let pos : usize = position.wrapping_add(i);
2373 let mut max_distance
2374 : usize
2375 = brotli_min_size_t(pos,max_backward_limit);
2376 let mut max_length : usize = num_bytes.wrapping_sub(i);
2377 let mut num_found_matches : usize;
2378 let mut cur_match_end : usize;
2379 let mut j : usize;
2380 {
2381 if matches_size < cur_match_pos.wrapping_add(
2382 128usize
2383 ).wrapping_add(
2384 shadow_matches
2385 ) {
2386 let mut _new_size
2387 : usize
2388 = if matches_size == 0usize {
2389 cur_match_pos.wrapping_add(128usize).wrapping_add(
2390 shadow_matches
2391 )
2392 } else {
2393 matches_size
2394 };
2395 let mut new_array : *mut BackwardMatch;
2396 while _new_size < cur_match_pos.wrapping_add(
2397 128usize
2398 ).wrapping_add(
2399 shadow_matches
2400 ) {
2401 _new_size = _new_size.wrapping_mul(2usize);
2402 }
2403 new_array = if _new_size > 0usize {
2404 BrotliAllocate(
2405 m,
2406 _new_size.wrapping_mul(std::mem::size_of::<BackwardMatch>())
2407 )
2408 } else {
2409 0i32
2410 };
2411 if !!(0i32 == 0) && (matches_size != 0usize) {
2412 memcpy(
2413 new_array ,
2414 matches ,
2415 matches_size.wrapping_mul(std::mem::size_of::<BackwardMatch>())
2416 );
2417 }
2418 {
2419 BrotliFree(m,matches );
2420 matches = 0i32 ;
2421 }
2422 matches = new_array;
2423 matches_size = _new_size;
2424 }
2425 }
2426 if !(0i32 == 0) {
2427 return;
2428 }
2429 num_found_matches = FindAllMatchesH10(
2430 hasher,
2431 &(*params).dictionary ,
2432 ringbuffer,
2433 ringbuffer_mask,
2434 pos,
2435 max_length,
2436 max_distance,
2437 gap,
2438 params,
2439 &mut matches[(
2440 cur_match_pos.wrapping_add(shadow_matches) as (usize)
2441 ) ]
2442 );
2443 cur_match_end = cur_match_pos.wrapping_add(num_found_matches);
2444 j = cur_match_pos;
2445 while j.wrapping_add(1usize) < cur_match_end {
2446 { }
2447 j = j.wrapping_add(1 as (usize));
2448 }
2449 num_matches[(i as (usize)) ]= num_found_matches as (u32);
2450 if num_found_matches > 0usize {
2451 let match_len
2452 : usize
2453 = BackwardMatchLength(
2454 &mut matches[(
2455 cur_match_end.wrapping_sub(1usize) as (usize)
2456 ) ]
2457 );
2458 if match_len > 325usize {
2459 let skip : usize = match_len.wrapping_sub(1usize);
2460 matches[(
2461 {
2462 let _old = cur_match_pos;
2463 cur_match_pos = cur_match_pos.wrapping_add(1 as (usize));
2464 _old
2465 } as (usize)
2466 ) ]= matches[(
2467 cur_match_end.wrapping_sub(1usize) as (usize)
2468 )];
2469 num_matches[(i as (usize)) ]= 1u32;
2470 StoreRangeH10(
2471 hasher,
2472 ringbuffer,
2473 ringbuffer_mask,
2474 pos.wrapping_add(1usize),
2475 brotli_min_size_t(pos.wrapping_add(match_len),store_end)
2476 );
2477 memset(
2478 &mut num_matches[(
2479 i.wrapping_add(1usize) as (usize)
2480 ) ] ,
2481 0i32,
2482 skip.wrapping_mul(std::mem::size_of::<u32>())
2483 );
2484 i = i.wrapping_add(skip);
2485 } else {
2486 cur_match_pos = cur_match_end;
2487 }
2488 }
2489 }
2490 i = i.wrapping_add(1 as (usize));
2491 }
2492 orig_num_literals = *num_literals;
2493 orig_last_insert_len = *last_insert_len;
2494 memcpy(
2495 orig_dist_cache ,
2496 dist_cache ,
2497 (4usize).wrapping_mul(std::mem::size_of::<i32>())
2498 );
2499 orig_num_commands = *num_commands;
2500 nodes = if num_bytes.wrapping_add(
2501 1usize
2502 ) > 0usize {
2503 BrotliAllocate(
2504 m,
2505 num_bytes.wrapping_add(1usize).wrapping_mul(
2506 std::mem::size_of::<ZopfliNode>()
2507 )
2508 )
2509 } else {
2510 0i32
2511 };
2512 if !(0i32 == 0) {
2513 return;
2514 }
2515 InitZopfliCostModel(
2516 m,
2517 &mut model ,
2518 &(*params).dist ,
2519 num_bytes
2520 );
2521 if !(0i32 == 0) {
2522 return;
2523 }
2524 i = 0usize;
2525 while i < 2usize {
2526 {
2527 BrotliInitZopfliNodes(
2528 nodes,
2529 num_bytes.wrapping_add(1usize)
2530 );
2531 if i == 0usize {
2532 ZopfliCostModelSetFromLiteralCosts(
2533 &mut model ,
2534 position,
2535 ringbuffer,
2536 ringbuffer_mask
2537 );
2538 } else {
2539 ZopfliCostModelSetFromCommands(
2540 &mut model ,
2541 position,
2542 ringbuffer,
2543 ringbuffer_mask,
2544 commands ,
2545 (*num_commands).wrapping_sub(orig_num_commands),
2546 orig_last_insert_len
2547 );
2548 }
2549 *num_commands = orig_num_commands;
2550 *num_literals = orig_num_literals;
2551 *last_insert_len = orig_last_insert_len;
2552 memcpy(
2553 dist_cache ,
2554 orig_dist_cache ,
2555 (4usize).wrapping_mul(std::mem::size_of::<i32>())
2556 );
2557 *num_commands = (*num_commands).wrapping_add(
2558 ZopfliIterate(
2559 num_bytes,
2560 position,
2561 ringbuffer,
2562 ringbuffer_mask,
2563 params,
2564 max_backward_limit,
2565 gap,
2566 dist_cache ,
2567 &mut model ,
2568 num_matches ,
2569 matches ,
2570 nodes
2571 )
2572 );
2573 BrotliZopfliCreateCommands(
2574 num_bytes,
2575 position,
2576 max_backward_limit,
2577 nodes ,
2578 dist_cache,
2579 last_insert_len,
2580 params,
2581 commands,
2582 num_literals
2583 );
2584 }
2585 i = i.wrapping_add(1 as (usize));
2586 }
2587 CleanupZopfliCostModel(m,&mut model );
2588 {
2589 BrotliFree(m,nodes );
2590 nodes = 0i32 ;
2591 }
2592 {
2593 BrotliFree(m,matches );
2594 matches = 0i32 ;
2595 }
2596 {
2597 BrotliFree(m,num_matches );
2598 num_matches = 0i32 ;
2599 }
2600 }
2601