liblzma/simple/simple_coder.c

21 copy_or_code(lzma_simple_coder *coder, const lzma_allocator *allocator,
26 	assert(!coder->end_was_reached);
28 	if (coder->next.code == NULL) {
32 		if (coder->is_encoder && action == LZMA_FINISH
34 			coder->end_was_reached = true;
37 		// Call the next coder in the chain to provide us some data.
38 		const lzma_ret ret = coder->next.code(
39 				coder->next.coder, allocator,
44 			assert(!coder->is_encoder
46 			coder->end_was_reached = true;
58 call_filter(lzma_simple_coder *coder, uint8_t *buffer, size_t size)
60 	const size_t filtered = coder->filter(coder->simple,
61 			coder->now_pos, coder->is_encoder,
63 	coder->now_pos += filtered;
74 	lzma_simple_coder *coder = coder_ptr;
84 	// Flush already filtered data from coder->buffer[] to out[].
85 	if (coder->pos < coder->filtered) {
86 		lzma_bufcpy(coder->buffer, &coder->pos, coder->filtered,
91 		if (coder->pos < coder->filtered)
94 		if (coder->end_was_reached) {
95 			assert(coder->filtered == coder->size);
101 	coder->filtered = 0;
103 	assert(!coder->end_was_reached);
106 	// in coder->buffer[], flush coder->buffer[] to out[], and copy/code
111 	const size_t buf_avail = coder->size - coder->pos;
117 		// Flush data from coder->buffer[] to out[], but don't reset
118 		// coder->pos and coder->size yet. This way the coder can be
121 		memcpy(out + *out_pos, coder->buffer + coder->pos, buf_avail);
126 			const lzma_ret ret = copy_or_code(coder, allocator,
137 				coder, out + out_start, size);
140 		assert(unfiltered <= coder->allocated / 2);
142 		// Now we can update coder->pos and coder->size, because
143 		// the next coder in the chain (if any) was successful.
144 		coder->pos = 0;
145 		coder->size = unfiltered;
147 		if (coder->end_was_reached) {
150 			coder->size = 0;
154 			// coder->buffer[] and rewind *out_pos appropriately.
156 			memcpy(coder->buffer, out + *out_pos, unfiltered);
158 	} else if (coder->pos > 0) {
159 		memmove(coder->buffer, coder->buffer + coder->pos, buf_avail);
160 		coder->size -= coder->pos;
161 		coder->pos = 0;
164 	assert(coder->pos == 0);
166 	// If coder->buffer[] isn't empty, try to fill it by copying/decoding
167 	// more data. Then filter coder->buffer[] and copy the successfully
169 	// unfiltered data will be left to coder->buffer[].
170 	if (coder->size > 0) {
172 			const lzma_ret ret = copy_or_code(coder, allocator,
174 					coder->buffer, &coder->size,
175 					coder->allocated, action);
181 		coder->filtered = call_filter(
182 				coder, coder->buffer, coder->size);
184 		// Everything is considered to be filtered if coder->buffer[]
186 		if (coder->end_was_reached)
187 			coder->filtered = coder->size;
190 		lzma_bufcpy(coder->buffer, &coder->pos, coder->filtered,
195 	if (coder->end_was_reached && coder->pos == coder->size)
205 	lzma_simple_coder *coder = coder_ptr;
206 	lzma_next_end(&coder->next, allocator);
207 	lzma_free(coder->simple, allocator);
208 	lzma_free(coder, allocator);
218 	lzma_simple_coder *coder = coder_ptr;
222 			&coder->next, allocator, reversed_filters + 1);
235 	lzma_simple_coder *coder = next->coder;
236 	if (coder == NULL) {
240 		// more data in coder->buffer[] if it can be filled completely.
241 		coder = lzma_alloc(sizeof(lzma_simple_coder)
243 		if (coder == NULL)
246 		next->coder = coder;
251 		coder->next = LZMA_NEXT_CODER_INIT;
252 		coder->filter = filter;
253 		coder->allocated = 2 * unfiltered_max;
257 			coder->simple = lzma_alloc(simple_size, allocator);
258 			if (coder->simple == NULL)
261 			coder->simple = NULL;
267 		coder->now_pos = simple->start_offset;
268 		if (coder->now_pos & (alignment - 1))
271 		coder->now_pos = 0;
275 	coder->is_encoder = is_encoder;
276 	coder->end_was_reached = false;
277 	coder->pos = 0;
278 	coder->filtered = 0;
279 	coder->size = 0;
281 	return lzma_next_filter_init(&coder->next, allocator, filters + 1);