| /src/external/public-domain/xz/dist/src/liblzma/common/ |
| filter_flags_decoder.c | 18 const uint8_t *in, size_t *in_pos, size_t in_size)
25 in, in_pos, in_size));
33 in, in_pos, in_size));
36 if (in_size - *in_pos < props_size)
40 filter, allocator, in + *in_pos, props_size);
42 *in_pos += props_size;
|
| vli_decoder.c | 17 const uint8_t *restrict in, size_t *restrict in_pos,
30 if (*in_pos >= in_size)
43 if (*in_pos >= in_size)
49 // can update *in_pos immediately.
50 const uint8_t byte = in[*in_pos];
51 ++*in_pos;
82 } while (*in_pos < in_size);
|
| block_buffer_decoder.c | 17 const uint8_t *in, size_t *in_pos, size_t in_size,
20 if (in_pos == NULL || (in == NULL && *in_pos != in_size)
21 || *in_pos > in_size || out_pos == NULL
34 const size_t in_start = *in_pos;
39 in, in_pos, in_size, out, out_pos, out_size,
48 assert(*in_pos == in_size
61 if (*in_pos == in_size)
68 *in_pos = in_start;
|
| filter_buffer_decoder.c | 18 const uint8_t *in, size_t *in_pos, size_t in_size,
22 if (in == NULL || in_pos == NULL || *in_pos > in_size || out == NULL
32 const size_t in_start = *in_pos;
36 lzma_ret ret = next.code(next.coder, allocator, in, in_pos, in_size,
45 assert(*in_pos == in_size || *out_pos == out_size);
47 if (*in_pos != in_size) {
69 in, in_pos, in_size,
80 *in_pos = in_start;
|
| stream_buffer_decoder.c | 18 const uint8_t *in, size_t *in_pos, size_t in_size,
22 if (in_pos == NULL || (in == NULL && *in_pos != in_size)
23 || *in_pos > in_size || out_pos == NULL
42 const size_t in_start = *in_pos;
47 in, in_pos, in_size, out, out_pos, out_size,
54 *in_pos = in_start;
60 assert(*in_pos == in_size
68 if (*in_pos == in_size)
|
| block_header_decoder.c | 68 size_t in_pos = 2;
73 NULL, in, &in_pos, in_size));
86 NULL, in, &in_pos, in_size));
95 in, &in_pos, in_size);
103 while (in_pos < in_size) {
104 if (in[in_pos++] != 0x00) {
|
| index_decoder.c | 57 const uint8_t *restrict in, size_t *restrict in_pos,
67 const size_t in_start = *in_pos;
70 while (*in_pos < in_size)
82 if (in[(*in_pos)++] != INDEX_INDICATOR)
90 in, in_pos, in_size);
120 in, in_pos, in_size);
160 if (in[(*in_pos)++] != 0x00)
168 *in_pos - in_start, coder->crc32);
175 if (*in_pos == in_size)
179 != in[(*in_pos)++])
[all...] |
| microlzma_decoder.c | 49 const uint8_t *restrict in, size_t *restrict in_pos,
56 const size_t in_start = *in_pos;
65 if (in_size - *in_pos > coder->comp_size)
66 in_size = *in_pos + (size_t)(coder->comp_size);
78 if (*in_pos >= in_size)
95 if (lzma_lzma_lclppb_decode(&options, ~in[*in_pos]))
98 ++*in_pos;
129 in, in_pos, in_size,
133 assert(coder->comp_size >= *in_pos - in_start);
134 coder->comp_size -= *in_pos - in_start
[all...] |
| alone_decoder.c | 53 const uint8_t *restrict in, size_t *restrict in_pos,
61 && (coder->sequence == SEQ_CODE || *in_pos < in_size))
64 if (lzma_lzma_lclppb_decode(&coder->options, in[*in_pos]))
68 ++*in_pos;
73 |= (size_t)(in[*in_pos]) << (coder->pos * 8);
99 ++*in_pos;
104 |= (lzma_vli)(in[*in_pos]) << (coder->pos * 8);
105 ++*in_pos;
164 allocator, in, in_pos, in_size,
|
| filter_buffer_encoder.c | 35 size_t in_pos = 0; local
36 lzma_ret ret = next.code(next.coder, allocator, in, &in_pos, in_size,
|
| index_hash.c | 174 size_t *in_pos, size_t in_size)
179 if (*in_pos >= in_size)
185 const size_t in_start = *in_pos;
188 while (*in_pos < in_size)
192 if (in[(*in_pos)++] != INDEX_INDICATOR)
200 &index_hash->pos, in, in_pos, in_size);
224 in, in_pos, in_size);
277 if (in[(*in_pos)++] != 0x00)
302 *in_pos - in_start, index_hash->crc32);
309 if (*in_pos == in_size
[all...] |
| lzip_decoder.c | 96 const uint8_t *restrict in, size_t *restrict in_pos,
109 if (*in_pos >= in_size) {
120 if (in[*in_pos] != lzip_id_string[coder->pos]) {
124 // then we won't consume the byte at *in_pos
142 ++*in_pos;
157 if (*in_pos >= in_size)
160 coder->version = in[(*in_pos)++];
178 if (*in_pos >= in_size)
181 const uint32_t ds = in[(*in_pos)++];
249 const size_t in_start = *in_pos;
[all...] |
| file_info.c | 27 /// Absolute position of in[*in_pos] in the file. All code that
28 /// modifies *in_pos also updates this. seek_to_pos() needs this
30 /// us or if we can do the seeking internally by adjusting *in_pos.
85 /// Copies data from in[*in_pos] into coder->temp until
87 /// in sync with *in_pos. Returns true if more input is needed.
90 size_t *restrict in_pos, size_t in_size)
92 coder->file_cur_pos += lzma_bufcpy(in, in_pos, in_size,
99 /// This tries to do the seeking by only modifying *in_pos, if possible.
102 /// as all the seeking can be done by adjusting *in_pos in this function.
108 size_t in_start, size_t *in_pos, size_t in_size
[all...] |
| stream_decoder_mt.c | 50 size_t in_pos; member in struct:worker_thread
71 /// This is updated from in_pos when our mutex is locked.
365 thr->progress_in = thr->in_pos;
377 if (in_filled == thr->in_pos && !(partial_update_enabled
390 if ((in_filled - thr->in_pos) > chunk_size)
391 in_filled = thr->in_pos + chunk_size;
395 thr->in, &thr->in_pos, in_filled,
412 // in_pos has changed. If thr->partial_update_started
413 // was false, it is possible that neither in_pos nor
417 thr->outbuf->decoder_in_pos = thr->in_pos;
[all...] |
| stream_decoder.c | 103 const uint8_t *restrict in, size_t *restrict in_pos,
115 lzma_bufcpy(in, in_pos, in_size, coder->buffer, &coder->pos,
162 if (*in_pos >= in_size)
167 if (in[*in_pos] == INDEX_INDICATOR) {
174 // so don't advance *in_pos.
177 in[*in_pos]);
181 lzma_bufcpy(in, in_pos, in_size, coder->buffer, &coder->pos,
260 in, in_pos, in_size, out, out_pos, out_size,
281 if (*in_pos >= in_size)
287 in, in_pos, in_size)
[all...] |
| block_decoder.c | 65 const uint8_t *restrict in, size_t *restrict in_pos,
73 const size_t in_start = *in_pos;
79 const size_t in_stop = *in_pos + (size_t)my_min(
80 in_size - *in_pos,
87 allocator, in, in_pos, in_stop,
90 const size_t in_used = *in_pos - in_start;
121 if (uncomp_done && *in_pos < in_size)
155 if (*in_pos >= in_size)
164 if (in[(*in_pos)++] != 0x00)
179 lzma_bufcpy(in, in_pos, in_size, coder->block->raw_check
[all...] |
| auto_decoder.c | 36 const uint8_t *restrict in, size_t *restrict in_pos,
44 if (*in_pos >= in_size)
57 if (in[*in_pos] == 0xFD) {
62 } else if (in[*in_pos] == 0x4C) {
87 in, in_pos, in_size,
101 if (*in_pos < in_size)
|
| block_encoder.c | 48 const uint8_t *restrict in, size_t *restrict in_pos,
55 if (LZMA_VLI_MAX - coder->uncompressed_size < in_size - *in_pos)
60 const size_t in_start = *in_pos;
64 allocator, in, in_pos, in_size,
67 const size_t in_used = *in_pos - in_start;
88 assert(*in_pos == in_size);
|
| microlzma_encoder.c | 26 const uint8_t *restrict in, size_t *restrict in_pos,
36 // Remember *in_pos so that we can set it based on how many
38 const size_t in_start = *in_pos;
56 in, in_pos, in_size, out, out_pos, out_size, action);
73 // Set *in_pos based on uncomp_size.
75 *in_pos = in_start + (size_t)(uncomp_size);
|
| /src/external/public-domain/xz/dist/tests/ |
| test_index_hash.c | 112 size_t in_pos = 0; local
119 assert_lzma_ret(lzma_vli_encode(block_count, &in_pos, buf,
126 in_pos = 0;
127 assert_lzma_ret(lzma_vli_encode(unpadded_sizes[i], &in_pos,
129 in_pos = 0;
130 assert_lzma_ret(lzma_vli_encode(uncomp_sizes[i], &in_pos,
157 size_t in_pos = 0;
190 in_pos = size_two_records + 1;
192 index_two_records, &in_pos,
196 in_pos = 0
[all...] |
| test_vli.c | 208 size_t in_pos = 0; local
210 assert_lzma_ret(lzma_vli_decode(&out, NULL, input, &in_pos,
212 assert_uint_eq(in_pos, input_len);
222 size_t in_pos = 0; local
227 &in_pos, i), LZMA_OK);
228 assert_uint_eq(in_pos, i);
232 assert_lzma_ret(lzma_vli_decode(&out, &vli_pos, input, &in_pos,
234 assert_uint_eq(in_pos, input_len);
248 size_t in_pos = 0;
252 assert_lzma_ret(lzma_vli_decode(&out, NULL, one_byte, &in_pos, 0)
[all...] |
| test_bcj_exact_size.c | 103 size_t in_pos = 0;
106 empty_bcj_lzma2, &in_pos, in_size, out, &out_pos, 0),
108 assert_uint_eq(in_pos, in_size);
|
| /src/external/mit/isl/dist/ |
| isl_multi_splice_templ.c | 19 * where A2 starts at position "in_pos" and B2 starts at position "out_pos",
39 __isl_take MULTI(BASE) *multi1, unsigned in_pos, unsigned out_pos,
50 if (FN(MULTI(BASE),check_range)(multi1, isl_dim_in, in_pos, 0) < 0)
53 multi1 = FN(MULTI(BASE),insert_dims)(multi1, isl_dim_in, in_pos, n_in2);
55 n_in1 - in_pos);
56 multi2 = FN(MULTI(BASE),insert_dims)(multi2, isl_dim_in, 0, in_pos);
|
| /src/external/public-domain/xz/dist/src/liblzma/delta/ |
| delta_encoder.c | 52 const uint8_t *restrict in, size_t *restrict in_pos,
61 const size_t in_avail = in_size - *in_pos;
69 copy_and_encode(coder, in + *in_pos, out + *out_pos,
72 *in_pos += size;
75 ret = action != LZMA_RUN && *in_pos == in_size
82 in, in_pos, in_size, out, out_pos, out_size,
|
| /src/external/public-domain/xz/dist/src/liblzma/lzma/ |
| lzma2_decoder.c | 57 const uint8_t *restrict in, size_t *restrict in_pos,
65 while (*in_pos < in_size || coder->sequence == SEQ_LZMA)
68 const uint32_t control = in[*in_pos];
69 ++*in_pos;
133 coder->uncompressed_size += (uint32_t)(in[(*in_pos)++]) << 8;
138 coder->uncompressed_size += in[(*in_pos)++] + 1U;
145 coder->compressed_size = (uint32_t)(in[(*in_pos)++]) << 8;
150 coder->compressed_size += in[(*in_pos)++] + 1U;
155 if (lzma_lzma_lclppb_decode(&coder->options, in[(*in_pos)++]))
166 const size_t in_start = *in_pos;
[all...] |
