mirror of
https://github.com/opencv/opencv.git
synced 2024-12-17 02:48:01 +08:00
0de26fd78e
Zlib-ng is zlib replacement with optimizations for "next generation" systems. Its optimization may benifits image library decode and encode speed such as libpng. In our tests, if using zlib-ng and libpng combination on a x86_64 machine with AVX2, the time of `imdecode` amd `imencode` will drop 20% approximately. This patch enables zlib-ng's optimization if `CV_DISABLE_OPTIMIZATION` is OFF. Since Zlib-ng can dispatch intrinsics on the fly, port work is much easier. Related discussion: https://github.com/opencv/opencv/issues/22573
103 lines
4.0 KiB
C
103 lines
4.0 KiB
C
/* deflate_fast.c -- compress data using the fast strategy of deflation algorithm
|
|
*
|
|
* Copyright (C) 1995-2013 Jean-loup Gailly and Mark Adler
|
|
* For conditions of distribution and use, see copyright notice in zlib.h
|
|
*/
|
|
|
|
#include "zbuild.h"
|
|
#include "deflate.h"
|
|
#include "deflate_p.h"
|
|
#include "functable.h"
|
|
|
|
/* ===========================================================================
|
|
* Compress as much as possible from the input stream, return the current
|
|
* block state.
|
|
* This function does not perform lazy evaluation of matches and inserts
|
|
* new strings in the dictionary only for unmatched strings or for short
|
|
* matches. It is used only for the fast compression options.
|
|
*/
|
|
Z_INTERNAL block_state deflate_fast(deflate_state *s, int flush) {
|
|
Pos hash_head; /* head of the hash chain */
|
|
int bflush = 0; /* set if current block must be flushed */
|
|
int64_t dist;
|
|
uint32_t match_len = 0;
|
|
|
|
for (;;) {
|
|
/* Make sure that we always have enough lookahead, except
|
|
* at the end of the input file. We need STD_MAX_MATCH bytes
|
|
* for the next match, plus WANT_MIN_MATCH bytes to insert the
|
|
* string following the next match.
|
|
*/
|
|
if (s->lookahead < MIN_LOOKAHEAD) {
|
|
PREFIX(fill_window)(s);
|
|
if (UNLIKELY(s->lookahead < MIN_LOOKAHEAD && flush == Z_NO_FLUSH)) {
|
|
return need_more;
|
|
}
|
|
if (UNLIKELY(s->lookahead == 0))
|
|
break; /* flush the current block */
|
|
}
|
|
|
|
/* Insert the string window[strstart .. strstart+2] in the
|
|
* dictionary, and set hash_head to the head of the hash chain:
|
|
*/
|
|
if (s->lookahead >= WANT_MIN_MATCH) {
|
|
hash_head = functable.quick_insert_string(s, s->strstart);
|
|
dist = (int64_t)s->strstart - hash_head;
|
|
|
|
/* Find the longest match, discarding those <= prev_length.
|
|
* At this point we have always match length < WANT_MIN_MATCH
|
|
*/
|
|
if (dist <= MAX_DIST(s) && dist > 0 && hash_head != 0) {
|
|
/* To simplify the code, we prevent matches with the string
|
|
* of window index 0 (in particular we have to avoid a match
|
|
* of the string with itself at the start of the input file).
|
|
*/
|
|
match_len = functable.longest_match(s, hash_head);
|
|
/* longest_match() sets match_start */
|
|
}
|
|
}
|
|
|
|
if (match_len >= WANT_MIN_MATCH) {
|
|
check_match(s, s->strstart, s->match_start, match_len);
|
|
|
|
bflush = zng_tr_tally_dist(s, s->strstart - s->match_start, match_len - STD_MIN_MATCH);
|
|
|
|
s->lookahead -= match_len;
|
|
|
|
/* Insert new strings in the hash table only if the match length
|
|
* is not too large. This saves time but degrades compression.
|
|
*/
|
|
if (match_len <= s->max_insert_length && s->lookahead >= WANT_MIN_MATCH) {
|
|
match_len--; /* string at strstart already in table */
|
|
s->strstart++;
|
|
|
|
functable.insert_string(s, s->strstart, match_len);
|
|
s->strstart += match_len;
|
|
} else {
|
|
s->strstart += match_len;
|
|
functable.quick_insert_string(s, s->strstart + 2 - STD_MIN_MATCH);
|
|
|
|
/* If lookahead < STD_MIN_MATCH, ins_h is garbage, but it does not
|
|
* matter since it will be recomputed at next deflate call.
|
|
*/
|
|
}
|
|
match_len = 0;
|
|
} else {
|
|
/* No match, output a literal byte */
|
|
bflush = zng_tr_tally_lit(s, s->window[s->strstart]);
|
|
s->lookahead--;
|
|
s->strstart++;
|
|
}
|
|
if (UNLIKELY(bflush))
|
|
FLUSH_BLOCK(s, 0);
|
|
}
|
|
s->insert = s->strstart < (STD_MIN_MATCH - 1) ? s->strstart : (STD_MIN_MATCH - 1);
|
|
if (UNLIKELY(flush == Z_FINISH)) {
|
|
FLUSH_BLOCK(s, 1);
|
|
return finish_done;
|
|
}
|
|
if (UNLIKELY(s->sym_next))
|
|
FLUSH_BLOCK(s, 0);
|
|
return block_done;
|
|
}
|