Function encodeLZ77

dependency/densecrf/examples/lodepng.cpp:1474–1649

LZ77-encode the data. Return value is error code. The input are raw bytes, the output is in the form of unsigned integers with codes representing for example literal bytes, or length/distance pairs. It uses a hash table technique to let it encode faster. When doing LZ77 encoding, a sliding window (of windowsize) is used, and all past bytes in that window can be used as the "dictionary". A bru

 this hash technique is one out of several ways to speed this up.
 */
static unsigned encodeLZ77(uivector* out, Hash* hash,
                           const unsigned char* in, size_t inpos, size_t insize, unsigned windowsize,
                           unsigned minmatch, unsigned nicematch, unsigned lazymatching)
{
    size_t pos;
    unsigned i, error = 0;
    /*for large window lengths, assume the user wants no compression loss. Otherwise, max hash chain length speedup.*/
    unsigned maxchainlength = windowsize >= 8192 ? windowsize : windowsize / 8;
    unsigned maxlazymatch = windowsize >= 8192 ? MAX_SUPPORTED_DEFLATE_LENGTH : 64;
    
    unsigned usezeros = 1; /*not sure if setting it to false for windowsize < 8192 is better or worse*/
    unsigned numzeros = 0;
    
    unsigned offset; /*the offset represents the distance in LZ77 terminology*/
    unsigned length;
    unsigned lazy = 0;
    unsigned lazylength = 0, lazyoffset = 0;
    unsigned hashval;
    unsigned current_offset, current_length;
    unsigned prev_offset;
    const unsigned char *lastptr, *foreptr, *backptr;
    unsigned hashpos;
    
    if(windowsize == 0 || windowsize > 32768) return 60; /*error: windowsize smaller/larger than allowed*/
    if((windowsize & (windowsize - 1)) != 0) return 90; /*error: must be power of two*/
    
    if(nicematch > MAX_SUPPORTED_DEFLATE_LENGTH) nicematch = MAX_SUPPORTED_DEFLATE_LENGTH;
    
    for(pos = inpos; pos < insize; ++pos)
    {
        size_t wpos = pos & (windowsize - 1); /*position for in 'circular' hash buffers*/
        unsigned chainlength = 0;
        
        hashval = getHash(in, insize, pos);
        
        if(usezeros && hashval == 0)
        {
            if(numzeros == 0) numzeros = countZeros(in, insize, pos);
            else if(pos + numzeros > insize || in[pos + numzeros - 1] != 0) --numzeros;
        }
        else
        {
            numzeros = 0;
        }
        
        updateHashChain(hash, wpos, hashval, numzeros);
        
        /*the length and offset found for the current position*/
        length = 0;
        offset = 0;
        
        hashpos = hash->chain[wpos];
        
        lastptr = &in[insize < pos + MAX_SUPPORTED_DEFLATE_LENGTH ? insize : pos + MAX_SUPPORTED_DEFLATE_LENGTH];
        
        /*search for the longest string*/
        prev_offset = 0;
        for(;;)