C++ (Cpp) write_constant_compressed_stateless Examples

Example #1

File: igzip.c Project: 01org/isa-l

static int isal_deflate_int_stateless(struct isal_zstream *stream, uint8_t * next_in,
				      const uint32_t avail_in)
{
	uint32_t crc32 = 0;
	uint32_t repeated_char_length;

#ifndef DEFLATE
	if (write_gzip_header_stateless(stream))
		return STATELESS_OVERFLOW;
#endif

	if (avail_in >= 8
	    && (*(uint64_t *) stream->next_in == 0
		|| *(uint64_t *) stream->next_in == ~(uint64_t) 0))
		repeated_char_length =
		    detect_repeated_char_length(stream->next_in, stream->avail_in);
	else
		repeated_char_length = 0;

	if (stream->avail_in == repeated_char_length) {
		if (write_constant_compressed_stateless(stream,
							stream->next_in[0],
							repeated_char_length, 1) != COMP_OK)
			return STATELESS_OVERFLOW;

#ifndef DEFLATE
		crc32 = crc32_gzip(0x0, next_in, avail_in);
#endif

		/* write_trailer_stateless is required because if flushes out the last of the output */
		if (write_trailer_stateless(stream, avail_in, crc32) != COMP_OK)
			return STATELESS_OVERFLOW;
		return COMP_OK;

	} else if (repeated_char_length >= MIN_REPEAT_LEN) {
		if (write_constant_compressed_stateless
		    (stream, stream->next_in[0], repeated_char_length, 0) != COMP_OK)
			return STATELESS_OVERFLOW;
	}

	if (write_deflate_header_unaligned_stateless(stream) != COMP_OK)
		return STATELESS_OVERFLOW;
	if (stream->avail_out < 8)
		return STATELESS_OVERFLOW;

	isal_deflate_body_stateless(stream);

	if (!stream->internal_state.has_eob)
		return STATELESS_OVERFLOW;

#ifndef DEFLATE
	crc32 = crc32_gzip(0x0, next_in, avail_in);
#endif

	if (write_trailer_stateless(stream, avail_in, crc32) != COMP_OK)
		return STATELESS_OVERFLOW;

	return COMP_OK;
}

Example #2

File: igzip.c Project: ceph/isa-l

static int isal_deflate_int_stateless(struct isal_zstream *stream)
{
	uint32_t repeat_length;
	struct isal_zstate *state = &stream->internal_state;

	if (stream->gzip_flag == IGZIP_GZIP)
		if (write_gzip_header_stateless(stream))
			return STATELESS_OVERFLOW;

	if (stream->avail_in >= 8
	    && (*(uint64_t *) stream->next_in == 0
		|| *(uint64_t *) stream->next_in == ~(uint64_t) 0)) {
		repeat_length = detect_repeated_char_length(stream->next_in, stream->avail_in);

		if (stream->avail_in == repeat_length || repeat_length >= MIN_REPEAT_LEN)
			write_constant_compressed_stateless(stream, repeat_length);
	}

	if (stream->level == 0) {
		if (state->state == ZSTATE_NEW_HDR || state->state == ZSTATE_HDR) {
			write_deflate_header_unaligned_stateless(stream);
			if (state->state == ZSTATE_NEW_HDR || state->state == ZSTATE_HDR)
				return STATELESS_OVERFLOW;

			reset_match_history(stream);
		}

		state->file_start = stream->next_in - stream->total_in;
		isal_deflate_pass(stream);

	} else if (stream->level == 1) {
		if (stream->level_buf == NULL || stream->level_buf_size < ISAL_DEF_LVL1_MIN) {
			/* Default to internal buffer if invalid size is supplied */
			stream->level_buf = state->buffer;
			stream->level_buf_size = sizeof(state->buffer);
		}

		if (state->state == ZSTATE_NEW_HDR || state->state == ZSTATE_HDR)
			reset_match_history(stream);

		state->count = 0;
		state->file_start = stream->next_in - stream->total_in;
		isal_deflate_icf_pass(stream);

	} else
		return ISAL_INVALID_LEVEL;

	if (state->state == ZSTATE_END
	    || (state->state == ZSTATE_NEW_HDR && stream->flush == FULL_FLUSH))
		return COMP_OK;
	else
		return STATELESS_OVERFLOW;
}