| /src/external/public-domain/xz/dist/src/liblzma/delta/ |
| delta_common.c | 19 lzma_delta_coder *coder = coder_ptr; local
20 lzma_next_end(&coder->next, allocator);
21 lzma_free(coder, allocator);
31 lzma_delta_coder *coder = next->coder; local
32 if (coder == NULL) {
33 coder = lzma_alloc(sizeof(lzma_delta_coder), allocator);
34 if (coder == NULL)
37 next->coder = coder;
[all...] |
| delta_decoder.c | 17 decode_buffer(lzma_delta_coder *coder, uint8_t *buffer, size_t size)
19 const size_t distance = coder->distance;
22 buffer[i] += coder->history[(distance + coder->pos) & 0xFF];
23 coder->history[coder->pos-- & 0xFF] = buffer[i];
39 lzma_delta_coder *coder = coder_ptr; local
41 assert(coder->next.code != NULL);
45 const lzma_ret ret = coder->next.code(coder->next.coder, allocator
[all...] |
| delta_encoder.c | 20 copy_and_encode(lzma_delta_coder *coder,
23 const size_t distance = coder->distance;
26 const uint8_t tmp = coder->history[
27 (distance + coder->pos) & 0xFF];
28 coder->history[coder->pos-- & 0xFF] = in[i];
37 encode_in_place(lzma_delta_coder *coder, uint8_t *buffer, size_t size)
39 const size_t distance = coder->distance;
42 const uint8_t tmp = coder->history[
43 (distance + coder->pos) & 0xFF]
56 lzma_delta_coder *coder = coder_ptr; local
100 lzma_delta_coder *coder = coder_ptr; local
[all...] |
| /src/external/public-domain/xz/dist/src/liblzma/common/ |
| alone_encoder.c | 39 lzma_alone_coder *coder = coder_ptr; local
42 switch (coder->sequence) {
44 lzma_bufcpy(coder->header, &coder->header_pos,
47 if (coder->header_pos < ALONE_HEADER_SIZE)
50 coder->sequence = SEQ_CODE;
54 return coder->next.code(coder->next.coder,
70 lzma_alone_coder *coder = coder_ptr local
83 lzma_alone_coder *coder = next->coder; local
[all...] |
| auto_decoder.c | 40 lzma_auto_coder *coder = coder_ptr; local
42 switch (coder->sequence) {
49 coder->sequence = SEQ_CODE;
59 &coder->next, allocator,
60 coder->memlimit, coder->flags));
64 &coder->next, allocator,
65 coder->memlimit, coder->flags));
68 return_if_error(lzma_alone_decoder_init(&coder->next
116 lzma_auto_coder *coder = coder_ptr; local
126 const lzma_auto_coder *coder = coder_ptr; local
138 lzma_auto_coder *coder = coder_ptr; local
[all...] |
| microlzma_encoder.c | 30 lzma_microlzma_coder *coder = coder_ptr; local
47 if (coder->lzma.set_out_limit(coder->lzma.coder,
55 const lzma_ret ret = coder->lzma.code(coder->lzma.coder, allocator,
70 out[out_start] = (uint8_t)(~coder->props);
84 lzma_microlzma_coder *coder = coder_ptr; local
85 lzma_next_end(&coder->lzma, allocator)
97 lzma_microlzma_coder *coder = next->coder; local
[all...] |
| microlzma_decoder.c | 53 lzma_microlzma_coder *coder = coder_ptr; local
65 if (in_size - *in_pos > coder->comp_size)
66 in_size = *in_pos + (size_t)(coder->comp_size);
71 if (!coder->uncomp_size_is_exact
72 && out_size - *out_pos > coder->uncomp_size)
73 out_size = *out_pos + (size_t)(coder->uncomp_size);
75 if (!coder->props_decoded) {
82 .dict_size = coder->dict_size,
90 if (coder->uncomp_size_is_exact)
91 lzma_set_ext_size(options, coder->uncomp_size)
163 lzma_microlzma_coder *coder = coder_ptr; local
178 lzma_microlzma_coder *coder = next->coder; local
[all...] |
| alone_decoder.c | 58 lzma_alone_coder *coder = coder_ptr; local
61 && (coder->sequence == SEQ_CODE || *in_pos < in_size))
62 switch (coder->sequence) {
64 if (lzma_lzma_lclppb_decode(&coder->options, in[*in_pos]))
67 coder->sequence = SEQ_DICTIONARY_SIZE;
72 coder->options.dict_size
73 |= (size_t)(in[*in_pos]) << (coder->pos * 8);
75 if (++coder->pos == 4) {
76 if (coder->picky && coder->options.dict_siz
179 lzma_alone_coder *coder = coder_ptr; local
190 lzma_alone_coder *coder = coder_ptr; local
212 lzma_alone_coder *coder = next->coder; local
[all...] |
| block_encoder.c | 52 lzma_block_coder *coder = coder_ptr; local
55 if (LZMA_VLI_MAX - coder->uncompressed_size < in_size - *in_pos)
58 switch (coder->sequence) {
63 const lzma_ret ret = coder->next.code(coder->next.coder,
70 if (COMPRESSED_SIZE_MAX - coder->compressed_size < out_used)
73 coder->compressed_size += out_used;
77 coder->uncompressed_size += in_used;
82 lzma_check_update(&coder->check, coder->block->check
141 lzma_block_coder *coder = coder_ptr; local
153 lzma_block_coder *coder = coder_ptr; local
[all...] |
| index_encoder.c | 52 lzma_index_coder *coder = coder_ptr; local
65 switch (coder->sequence) {
69 coder->sequence = SEQ_COUNT;
73 const lzma_vli count = lzma_index_block_count(coder->index);
74 ret = lzma_vli_encode(count, &coder->pos,
80 coder->pos = 0;
81 coder->sequence = SEQ_NEXT;
87 &coder->iter, LZMA_INDEX_ITER_BLOCK)) {
89 coder->pos = lzma_index_padding_size(coder->index)
[all...] |
| block_decoder.c | 69 lzma_block_coder *coder = coder_ptr; local
71 switch (coder->sequence) {
81 coder->compressed_limit - coder->compressed_size);
84 coder->uncompressed_limit - coder->uncompressed_size);
86 const lzma_ret ret = coder->next.code(coder->next.coder,
95 coder->compressed_size += in_used
205 lzma_block_coder *coder = coder_ptr; local
[all...] |
| index_decoder.c | 64 lzma_index_coder *coder = coder_ptr; local
71 switch (coder->sequence) {
85 coder->sequence = SEQ_COUNT;
89 ret = lzma_vli_decode(&coder->count, &coder->pos,
94 coder->pos = 0;
95 coder->sequence = SEQ_MEMUSAGE;
99 if (lzma_index_memusage(1, coder->count) > coder->memlimit) {
106 lzma_index_prealloc(coder->index, coder->count)
220 lzma_index_coder *coder = coder_ptr; local
231 lzma_index_coder *coder = coder_ptr; local
[all...] |
| stream_decoder.c | 86 stream_decoder_reset(lzma_stream_coder *coder, const lzma_allocator *allocator)
89 coder->index_hash = lzma_index_hash_init(coder->index_hash, allocator);
90 if (coder->index_hash == NULL)
94 coder->sequence = SEQ_STREAM_HEADER;
95 coder->pos = 0;
107 lzma_stream_coder *coder = coder_ptr; local
112 switch (coder->sequence) {
115 lzma_bufcpy(in, in_pos, in_size, coder->buffer, &coder->pos
384 lzma_stream_coder *coder = coder_ptr; local
395 const lzma_stream_coder *coder = coder_ptr; local
404 lzma_stream_coder *coder = coder_ptr; local
[all...] |
| stream_encoder.c | 61 block_encoder_init(lzma_stream_coder *coder, const lzma_allocator *allocator)
68 coder->block_options.compressed_size = LZMA_VLI_UNKNOWN;
69 coder->block_options.uncompressed_size = LZMA_VLI_UNKNOWN;
71 return_if_error(lzma_block_header_size(&coder->block_options));
74 return lzma_block_encoder_init(&coder->block_encoder, allocator,
75 &coder->block_options);
85 lzma_stream_coder *coder = coder_ptr; local
89 switch (coder->sequence) {
93 lzma_bufcpy(coder->buffer, &coder->buffer_pos
215 lzma_stream_coder *coder = coder_ptr; local
233 lzma_stream_coder *coder = coder_ptr; local
[all...] |
| common.h | 190 void *coder, const lzma_allocator *allocator,
196 /// Type of a function to free the memory allocated for the coder
198 void *coder, const lzma_allocator *allocator);
201 /// Raw coder validates and converts an array of lzma_filter structures to
223 /// Pointer to coder-specific data
224 void *coder; member in struct:lzma_next_coder_s
227 /// point to a filter coder.
231 /// We need only to detect if we are initializing a coder
239 /// Pointer to function to free lzma_next_coder.coder. This can
241 /// lzma_next_coder.coder
[all...] |
| file_info.c | 85 /// Copies data from in[*in_pos] into coder->temp until
86 /// coder->temp_pos == coder->temp_size. This also keeps coder->file_cur_pos
89 fill_temp(lzma_file_info_coder *coder, const uint8_t *restrict in,
92 coder->file_cur_pos += lzma_bufcpy(in, in_pos, in_size,
93 coder->temp, &coder->temp_pos, coder->temp_size);
94 return coder->temp_pos < coder->temp_size
256 lzma_file_info_coder *coder = coder_ptr; local
673 lzma_file_info_coder *coder = coder_ptr; local
768 lzma_file_info_coder *coder = coder_ptr; local
[all...] |
| lzip_decoder.c | 100 lzma_lzip_coder *coder = coder_ptr; local
103 switch (coder->sequence) {
108 while (coder->pos < sizeof(lzip_id_string)) {
115 return !coder->first_member
120 if (in[*in_pos] != lzip_id_string[coder->pos]) {
138 return !coder->first_member
143 ++coder->pos;
146 coder->pos = 0;
148 coder->crc32 = 0;
149 coder->uncompressed_size = 0
333 lzma_lzip_coder *coder = coder_ptr; local
351 lzma_lzip_coder *coder = coder_ptr; local
[all...] |
| /src/external/public-domain/xz/dist/src/liblzma/simple/ |
| simple_coder.c | 20 copy_or_code(lzma_simple_coder *coder, const lzma_allocator *allocator,
25 assert(!coder->end_was_reached);
27 if (coder->next.code == NULL) {
31 if (coder->is_encoder && action == LZMA_FINISH
33 coder->end_was_reached = true;
36 // Call the next coder in the chain to provide us some data.
37 const lzma_ret ret = coder->next.code(
38 coder->next.coder, allocator,
43 assert(!coder->is_encode
73 lzma_simple_coder *coder = coder_ptr; local
214 lzma_simple_coder *coder = coder_ptr; local
227 lzma_simple_coder *coder = coder_ptr; local
244 lzma_simple_coder *coder = next->coder; local
[all...] |
| x86.c | 128 lzma_simple_coder *coder = next->coder; local
129 lzma_simple_x86 *simple = coder->simple;
|
| /src/external/public-domain/xz/dist/src/liblzma/lz/ |
| lz_decoder.c | 54 lz_decoder_reset(lzma_coder *coder)
56 coder->dict.pos = LZ_DICT_INIT_POS;
57 coder->dict.full = 0;
58 coder->dict.buf[LZ_DICT_INIT_POS - 1] = '\0';
59 coder->dict.has_wrapped = false;
60 coder->dict.need_reset = false;
66 decode_buffer(lzma_coder *coder,
73 if (coder->dict.pos == coder->dict.size) {
75 coder->dict.pos = LZ_DICT_REPEAT_MAX
147 lzma_coder *coder = coder_ptr; local
203 lzma_coder *coder = coder_ptr; local
227 lzma_coder *coder = next->coder; local
[all...] |
| lz_decoder.h | 122 void *coder; member in struct:__anon388
125 lzma_ret (*code)(void *coder,
129 void (*reset)(void *coder, const void *options);
133 void (*set_uncompressed)(void *coder, lzma_vli uncompressed_size,
137 void (*end)(void *coder, const lzma_allocator *allocator);
144 .coder = NULL, \
|
| lz_encoder.c | 32 /// Next coder in the chain
80 fill_window(lzma_coder *coder, const lzma_allocator *allocator,
84 assert(coder->mf.read_pos <= coder->mf.write_pos);
87 if (coder->mf.read_pos >= coder->mf.size - coder->mf.keep_size_after)
88 move_window(&coder->mf);
93 size_t write_pos = coder->mf.write_pos;
95 if (coder->next.code == NULL)
165 lzma_coder *coder = coder_ptr; local
489 lzma_coder *coder = coder_ptr; local
512 lzma_coder *coder = coder_ptr; local
529 lzma_coder *coder = coder_ptr; local
554 lzma_coder *coder = next->coder; local
[all...] |
| lz_encoder.h | 205 void *coder; member in struct:__anon392
208 lzma_ret (*code)(void *coder,
213 void (*end)(void *coder, const lzma_allocator *allocator);
216 lzma_ret (*options_update)(void *coder, const lzma_filter *filter);
219 lzma_ret (*set_out_limit)(void *coder, uint64_t *uncomp_size,
|
| /src/external/public-domain/xz/dist/src/liblzma/lzma/ |
| lzma2_decoder.c | 60 lzma_lzma2_coder *restrict coder = coder_ptr; local
65 while (*in_pos < in_size || coder->sequence == SEQ_LZMA)
66 switch (coder->sequence) {
78 coder->need_properties = true;
79 coder->need_dictionary_reset = true;
80 } else if (coder->need_dictionary_reset) {
87 coder->uncompressed_size = (control & 0x1F) << 16;
88 coder->sequence = SEQ_UNCOMPRESSED_1;
95 coder->need_properties = false;
96 coder->next_sequence = SEQ_PROPERTIES
215 lzma_lzma2_coder *coder = coder_ptr; local
231 lzma_lzma2_coder *coder = lz->coder; local
[all...] |
| lzma2_encoder.c | 54 lzma2_header_lzma(lzma_lzma2_coder *coder)
56 assert(coder->uncompressed_size > 0);
57 assert(coder->uncompressed_size <= LZMA2_UNCOMPRESSED_MAX);
58 assert(coder->compressed_size > 0);
59 assert(coder->compressed_size <= LZMA2_CHUNK_MAX);
63 if (coder->need_properties) {
66 if (coder->need_dictionary_reset)
67 coder->buf[pos] = 0x80 + (3 << 5);
69 coder->buf[pos] = 0x80 + (2 << 5);
73 if (coder->need_state_reset
139 lzma_lzma2_coder *restrict coder = coder_ptr; local
265 lzma_lzma2_coder *coder = coder_ptr; local
275 lzma_lzma2_coder *coder = coder_ptr; local
[all...] |
