123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282 |
- // SPDX-License-Identifier: Zlib
- #include "../zlib_deflate/defutil.h"
- #include "dfltcc_util.h"
- #include "dfltcc.h"
- #include <asm/setup.h>
- #include <linux/export.h>
- #include <linux/zutil.h>
- /*
- * Compress.
- */
- int dfltcc_can_deflate(
- z_streamp strm
- )
- {
- deflate_state *state = (deflate_state *)strm->state;
- struct dfltcc_state *dfltcc_state = GET_DFLTCC_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->af.fns, DFLTCC_GDHT) ||
- !is_bit_set(dfltcc_state->af.fns, DFLTCC_CMPR) ||
- !is_bit_set(dfltcc_state->af.fmts, DFLTCC_FMT0))
- return 0;
- return 1;
- }
- EXPORT_SYMBOL(dfltcc_can_deflate);
- 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 = 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.
- */
- memmove(state->pending_buf, state->pending_out, state->pending);
- state->pending_out = state->pending_buf;
- }
- #ifdef ZLIB_DEBUG
- state->compressed_len += param->eobl;
- #endif
- }
- int dfltcc_deflate(
- z_streamp strm,
- int flush,
- block_state *result
- )
- {
- deflate_state *state = (deflate_state *)strm->state;
- struct dfltcc_state *dfltcc_state = GET_DFLTCC_STATE(state);
- struct dfltcc_param_v0 *param = &dfltcc_state->param;
- uInt masked_avail_in;
- dfltcc_cc cc;
- int need_empty_block;
- int soft_bcc;
- int no_flush;
- if (!dfltcc_can_deflate(strm))
- return 0;
- again:
- masked_avail_in = 0;
- soft_bcc = 0;
- no_flush = flush == Z_NO_FLUSH;
- /* Trailing empty block. Switch to software, except when Continuation Flag
- * is set, which means that DFLTCC has buffered some output in the
- * parameter block and needs to be called again in order to flush it.
- */
- if (flush == Z_FINISH && strm->avail_in == 0 && !param->cf) {
- if (param->bcf) {
- /* A block is still open, and the hardware does not support closing
- * blocks without adding data. Thus, close it manually.
- */
- send_eobs(strm, param);
- param->bcf = 0;
- }
- return 0;
- }
- if (strm->avail_in == 0 && !param->cf) {
- *result = need_more;
- return 1;
- }
- /* There is an open non-BFINAL block, we are not going to close it just
- * 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 (param->bcf && no_flush &&
- strm->total_in > dfltcc_state->block_threshold &&
- strm->avail_in >= dfltcc_state->dht_threshold) {
- if (param->cf) {
- /* We need to flush the DFLTCC buffer before writing the
- * End-of-block Symbol. Mask the input data and proceed as usual.
- */
- masked_avail_in += strm->avail_in;
- strm->avail_in = 0;
- no_flush = 0;
- } else {
- /* DFLTCC buffer is empty, so we can manually write the
- * End-of-block Symbol right away.
- */
- send_eobs(strm, param);
- param->bcf = 0;
- dfltcc_state->block_threshold =
- strm->total_in + dfltcc_state->block_size;
- 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 (no_flush && strm->avail_in > dfltcc_state->block_size) {
- masked_avail_in += (strm->avail_in - dfltcc_state->block_size);
- 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->bcf && !param->bhf;
- /* Translate stream to parameter block */
- param->cvt = CVT_ADLER32;
- if (!no_flush)
- /* We need to close a block. Always do this in software - when there is
- * no input data, the hardware will not nohor BCC. */
- soft_bcc = 1;
- if (flush == Z_FINISH && !param->bcf)
- /* We are about to open a BFINAL block, set Block Header Final bit
- * until the stream ends.
- */
- param->bhf = 1;
- /* DFLTCC-CMPR will write to next_out, so make sure that buffers with
- * higher precedence are empty.
- */
- Assert(state->pending == 0, "There must be no pending bytes");
- Assert(state->bi_valid < 8, "There must be less than 8 pending bits");
- param->sbb = (unsigned int)state->bi_valid;
- if (param->sbb > 0)
- *strm->next_out = (Byte)state->bi_buf;
- if (param->hl)
- param->nt = 0; /* Honor history */
- param->cv = strm->adler;
- /* When opening a block, choose a Huffman-Table Type */
- if (!param->bcf) {
- if (strm->total_in == 0 && dfltcc_state->block_threshold > 0) {
- param->htt = HTT_FIXED;
- }
- else {
- param->htt = HTT_DYNAMIC;
- dfltcc_gdht(strm);
- }
- }
- /* 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;
- } while (cc == DFLTCC_CC_AGAIN);
- /* Translate parameter block to stream */
- strm->msg = oesc_msg(dfltcc_state->msg, param->oesc);
- state->bi_valid = param->sbb;
- if (state->bi_valid == 0)
- state->bi_buf = 0; /* Avoid accessing next_out */
- else
- state->bi_buf = *strm->next_out & ((1 << state->bi_valid) - 1);
- strm->adler = param->cv;
- /* Unmask the input data */
- strm->avail_in += masked_avail_in;
- 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) {
- if (soft_bcc) {
- send_eobs(strm, param);
- param->bcf = 0;
- dfltcc_state->block_threshold =
- strm->total_in + dfltcc_state->block_size;
- } else
- param->bcf = 1;
- if (flush == Z_FINISH) {
- if (need_empty_block)
- /* Make the current deflate() call also close the stream */
- return 0;
- else {
- bi_windup(state);
- *result = finish_done;
- }
- } else {
- if (flush == Z_FULL_FLUSH)
- param->hl = 0; /* Clear history */
- *result = flush == Z_NO_FLUSH ? need_more : block_done;
- }
- } else {
- param->bcf = 1;
- *result = need_more;
- }
- if (strm->avail_in != 0 && strm->avail_out != 0)
- goto again; /* deflate() must use all input or all output */
- return 1;
- }
- EXPORT_SYMBOL(dfltcc_deflate);
|