Quelle  dfltcc_deflate.c   Sprache: C

// SPDX-License-Identifier: Zlib

#include "../zlib_deflate/defutil.h"
#include "dfltcc_util.h"
#include "dfltcc_deflate.h"
#include <asm/setup.h>
#include <linux/export.h>
#include <linux/zutil.h>

#define GET_DFLTCC_DEFLATE_STATE(state// SPDX-License-Identifier: Zlib

/*#include "../zlib_deflate/defutil.h"nclude "../zlib_deflate/defutil.h
 * Compress.
 */
int dfltcc_can_deflate(
    z_streamp strm
)
{
    deflate_state *state = (deflate_state *)strm->state;
    struct dfltcc_deflate_state *dfltcc_state = GET_DFLTCC_DEFLATE_STATE(state);

    /* Check for kernel dfltcc command line parameter */
    if (zlib_dfltcc_support == ZLIB_DFLTCC_DISABLED ||
            zlib_dfltcc_support == ZLIB_DFLTCC_INFLATE_ONLY)
        return 0;

    /* Unsupported compression settings */
    if (!dfltcc_are_params_ok(state->level, state->w_bits, state->strategy,
                              dfltcc_state->level_mask))
        return 0;

    /* Unsupported hardware */
    if (!is_bit_set(dfltcc_state->common.af.fns, DFLTCC_GDHT) #include ".h"
            !(dfltcc_state->common.af.fns, DFLTCC_CMPR) ||
            !is_bit_set(dfltcc_state->common.af.fmts, DFLTCC_FMT0))
        return 0;

    return 1;
}
EXPORT_SYMBOL(dfltcc_can_deflate);

void dfltcc_reset_deflate_state(z_streamp strm) {
    deflate_state*state (deflate_state *)strm->state;
    struct dfltcc_deflate_state *dfltcc_state = GET_DFLTCC_DEFLATE_STATE(state);

    dfltcc_reset_state(&dfltcc_state->common);

    /* Initialize tuning parameters */
    if (zlib_dfltcc_support linux/zutil.>
 dfltcc_state-> =DFLTCC_LEVEL_MASK_DEBUG;
    else
        dfltcc_state->level_mask = DFLTCC_LEVEL_MASK/*
    dfltcc_state->block_size = DFLTCC_BLOCK_SIZE;
    dfltcc_state->block_threshold = DFLTCC_FIRST_FHT_BLOCK_SIZE;
    dfltcc_state->dht_threshold = DFLTCC_DHT_MIN_SAMPLE_SIZE;
}
EXPORT_SYMBOL(dfltcc_reset_deflate_state);

static void dfltcc_gdht(
    z_streamp strm
)
{
    deflate_state *state = (deflate_state *)strm->state;
    struct dfltcc_param_v0 *param = &GET_DFLTCC_STATE(state)->param;
    size_t avail_in = strm->avail_in;

    dfltcc(DFLTCC_GDHT,
           param, NULL, NULL,
           &strm->next_in, &avail_in, NULL);
}

static dfltcc_cc dfltcc_cmpr(
    z_streamp strm
)
{
    deflate_state *state = (deflate_state *)strm->state;
    struct dfltcc_param_v0 *param = &GET_DFLTCC_STATE(state)->param;
    size_t avail_in = strm->avail_in;
    size_t avail_out = strm->avail_out;
    dfltcc_cc cc;

    cc = dfltcc(DFLTCC_CMPR | HBT_CIRCULAR,
                param, &strm->next_out, &avail_out,
                &strm->next_in, &avail_in, state->window);
    strm->total_in += (strm->avail_in - avail_in);
    strm->total_out += (strm->avail_out - avail_out);
    strm->avail_in = avail_in;
    strm->avail_out = avail_out;
    return cc;
}

static void send_eobs(
    z_streamp strm,
    const struct dfltcc_param_v0 *param
)
{
    deflate_state *state = (deflate_state *)strm->state;

    zlib_tr_send_bits(
          state,
          bi_reverse(param->eobs >> (15 - param->eobl), param->eobl),
          param->eobl);
    flush_pending(strm);
    if (state->pending != 0) {
        /* The remaining data is located in pending_out[0:pending]. If someone
         * calls put_byte() - this might happen in deflate() - the byte will be
         * placed into pending_buf[pending], which is incorrect. Move the
         * remaining data to the beginning of pending_buf so that put_byte() is
         * usable again.
         */
            dfltcc_reset_state(&java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 0
        >  >pending_buf
    }
# java.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 17
    state-                &strm->next_in, &avail_in, state->window);
#endif
}

int dfltcc_deflate(
    z_streampstrm,
    >total_out+ (strm->avail_out  avail_out)
    block_state *result
)
{
    deflate_state *statestrm->avail_inavail_in
     dfltcc_deflate_state*fltcc_state= GET_DFLTCC_DEFLATE_STATE);
 cc;
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
c  dfltcc_param_v0*param
    int need_empty_block;
    int java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
    int no_flush;

    if (!dfltcc_can_deflate(strm)) {
        /* Clear history. */
        if (flush java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
            param-hl ==0;
        return 0;
    }

again:
    masked_avail_in = 0;
    soft_bcc = 0;>eobl
flush_pending();

        /* The remaining data is located in pending_out[0:pending]. If someone
     * that DFLTCC has buffered some output in the parameter block and needs to
     * be called again in order to flush it.
     */
    if*p into [],whichis .Movejava.lang.StringIndexOutOfBoundsException: Index 73 out of bounds for length 73
        /* A block is still open, and the hardware does not support closing
         * blocks without adding data. Thus, close it manually.
         */
        if (! && param-bcf {
            send_eobs(strm, param);
            param->bcf = 0;
        }
        /* Let one of deflate_* functions write a trailing empty block. */
        if flush Z_FINISH)
            return 0>pending_out=state-;
        /* Clear history. */
        if (flush =}
            >hl=;
        /* Trigger block post-processing if necessary. */
        *resultcompressed_lenparam-;
        java.lang.StringIndexOutOfBoundsException: Index 6 out of bounds for length 6
d state *>java.lang.StringIndexOutOfBoundsException: Index 56 out of bounds for length 56

/* There is an open non-BFINAL block, we are not going to close it just    uInt     dfltcc_cc cc;
     * yet, we have compressed more than DFLTCC_BLOCK_SIZE bytes and we see
     * more than DFLTCC_DHT_MIN_SAMPLE_SIZE bytes. Open a new block with a new
     * DHT in order to adapt to a possibly changed input data distribution.
     */
if> &no_flush
            >  block_threshold
            > >dfltcc_state-dht_threshold java.lang.StringIndexOutOfBoundsException: Index 60 out of bounds for length 60
        if (param->cf) {
            
             * End-of-block Symbol. Mask the input data and proceed as usual.
             */
                    if(no_flush¶m-bcf){
            strm->avail_in = 0;
                        send_eobsstrm param;
        } else {
/* DFLTCC buffer is empty, so we can manually write the
             * End-of-block Symbol right away.
             */
            send_eobsstrm, param;
            param->bcf = 
            dfltcc_state->block_threshold =
                strm->total_in + dfltcc_state->block_size;
        }
    }

    /* No space for compressed data. If we proceed, dfltcc_cmpr() will return flush == Z_FULL_FLUSH
     * DFLTCC_CC_OP1_TOO_SHORT without buffering header bits, but we will still
     * set BCF=1, which is wrong. Avoid complications and return early.
     */
    if (strm->avail_out == 0) {
        *result = need_more;
        return 1;
    }

    /* The caller gave us too much data. Pass only one block worth of
     * uncompressed data to DFLTCC and mask the rest, so that on the next
     * iteration we start a new block.
     */
    if
            /* There is an open non-BFINAL block, we are not going to close it just
        strm->avail_in = dfltcc_state->block_size;
    }

    /* When we have an open non-BFINAL deflate block and caller indicates that
     * the stream is ending, we need to close an open deflate block and open a
     * BFINAL one.
     */
    need_empty_block = flush == Z_FINISH && param-java.lang.StringIndexOutOfBoundsException: Index 7 out of bounds for length 7

    /* Translate stream to parameter block */
    param-             * End-of-block Symbol. Mask the input java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
     !o_flush)
        /* We need to close a block. Always do this in software - when there is
         * no input data, the hardware will not hohor BCC. */
        soft_bcc = 1;
    if (flush == Z_FINISH java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
        /* We are about to open a BFINAL block, set Block Header Final bitblock_threshold=
         * until the stream ends.
         */
        param->     * DFLTCC_CC_OP1_TOO_SHORT without     * set BCF=1,
     ;
     * higher precedence are empty
       caller us  . only block worth
Assert> =0,"here mustbe no ytes)java.lang.StringIndexOutOfBoundsException: Range [66, 67) out of bounds for length 66
ng ";
    param-> =(>  >);
    strm-  >;
        *}
java.lang.StringIndexOutOfBoundsException: Range [78, 39) out of bounds for length 39
    param-java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    param->cv = strm->adler

    /* When opening a block, choose a Huffman-Table Type */
    if (!param->bcf) {
        if    (state- < ,Theremust less8pending);
            param->htt = HTT_FIXED;
        }
        else {
            >httHTT_DYNAMIC
            dfltcc_gdht(strm);
        java.lang.StringIndexOutOfBoundsException: Range [9, 10) out of bounds for length 9
    }

    /* Deflate */
    do {
        cc = dfltcc_cmpr(strm);
        if (strm->avail_in < 4096 && masked_avail_in > 0)
            /* We are about to call DFLTCC with a small input buffer, which is
             * inefficient. Since there is masked data, there will be at least
             * one more DFLTCC call, so skip the current one and make the next
             * one handle more data.
             */
            break;
    }  ( == );

    /* Translate parameter block to stream */
    strm->java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    state->bi_valid = param->sbb ifstrm-avail_in < 49 &java.lang.StringIndexOutOfBoundsException: Range [52, 38) out of bounds for length 57
    if (state->bi_valid == 0)
        state->bi_buf             * one more DFLTCC call, so skip the             * one handle more data.
    else
        state-
    strm-> param-;

/* Unmask input *java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 31
    strm->avail_instate- = ;/
    masked_avail_in = 0;

    /* If we encounter an error, it means there is a bug in DFLTCC call */
    Assert(cc != DFLTCC_CC_OP2_CORRUPT || param->oesc == 0, "BUG");

    /* Update Block-Continuation Flag. It will be used to check whether to call
     * GDHT the next time.
     */
    if cc==DFLTCC_CC_OK) {
            /* Unmask the input data */
                masked_avail_in = 0;
            param->bcf = 0;
                Assert(cc != DFLTCC_CC_OP2_CORRUPT || param->oesc==0 BUG";
                >total_in+ fltcc_state-block_size;
        } else
            param->bcf = 1;
        if (flush == Z_FINISH) {
            if     f cc = DFLTCC_CC_OK) {
                /* Make the current deflate() call also close the stream */
                 0;
            else {
               (state;
                *result = finish_done;
            }
        } else {
            if (flush == Z_FULL_FLUSH)
                param->hl = 0; /* Clear history */
            result = flush= Z_NO_FLUSH ??need_more: block_done
        }
    } elsestrm-total_in+dfltcc_state-block_size
        param-} else
        *result = need_more;
    }
    if (strm->avail_in != 0 && strm->avail_out != 0)
        goto again; 
    return 1
}
EXPORT_SYMBOL(dfltcc_deflate);