Lines Matching defs:in
31 * is still possible in multi-call mode by simply
35 * which is not used in the kernel. Unsupported
47 * compression options. In the decoder this means
76 * @in: Beginning of the input buffer. This may be NULL if and only
78 * @in_pos: Current position in the input buffer. This must not exceed
83 * @out_pos: Current position in the output buffer. This must not exceed
91 const uint8_t *in;
111 * in practice), so other values for dict_max don't make sense.
112 * In the kernel, dictionary sizes of 64 KiB, 128 KiB, 256 KiB,
137 * Note that if an error occurs in single-call mode (return value is not
156 * In single-call mode, xz_dec_reset() is always called in the beginning of
157 * xz_dec_run(). Thus, explicit call to xz_dec_reset() is useful only in
193 static uint8_t in[BUFSIZ];
228 b.in = in;
237 b.in_size = read(fd, in, sizeof(in));
281 msg = "Unsupported options in the .xz headers\n";
372 * could save a few bytes in code size.
406 /* Decode raw LZMA2 stream from b->in to b->out. */
434 * Return value of the next filter in the chain. We need to preserve
442 * data (in a single .xz Block). We care only about the lowest 32
456 /* Amount of already filtered data in the beginning of buf */
459 /* Total amount of data currently stored in buf */
488 * a BCJ filter in the chain. If the chain has only LZMA2, xz_dec_lzma2_run()
498 * in an x86 instruction.
617 /* Instruction slot (0, 1, or 2) in the 128-bit instruction word */
633 /* 41-bit instruction stored somewhere in the lowest 48 bits */
759 * pointers, which could be problematic in the kernel boot code, which must
830 * The BCJ filter functions are primitive in sense that they process the
831 * data in chunks of 1-16 bytes. To hide this issue, this function does
843 * filter in the chain had already returned XZ_STREAM_END.
855 * If we have more output space than what is currently pending in
858 * next filter in the chain. Apply the BCJ filter on the new data
859 * in the output buffer. If everything cannot be filtered, copy it
900 * We have unfiltered data in temp. If the output buffer isn't full
904 * A mix of filtered and unfiltered data may be left in temp; it will
1005 * number of bits of the current uncompressed offset. In some places there
1012 * and in which order. This information is used to predict the next symbol.
1020 * The symbol names are in from STATE_oldest_older_previous. REP means
1079 /* Each literal coder is divided in three sections:
1152 * Match distances greater than 127 are encoded in three pieces:
1213 * in which the dictionary variables address the actual output
1220 /* Old position in buf (before decoding more data) */
1223 /* Position in buf */
1239 * Size of the dictionary as specified in Block Header. This is used
1271 const uint8_t *in;
1356 * when the distance is in the range [4, 127].
1377 /* Position in xz_dec_lzma2_run(). */
1419 * including lzma.pos_mask are in the first 128 bytes on x86-32,
1543 memcpy(dict->buf + dict->pos, b->in + b->in_pos, copy_size);
1552 memcpy(b->out + b->out_pos, b->in + b->in_pos,
1564 * enough space in b->out. This is guaranteed because caller uses dict_limit()
1603 rc->code = (rc->code << 8) + b->in[b->in_pos++];
1630 rc->code = (rc->code << RC_SHIFT_BITS) + rc->in[rc->in_pos++];
1635 * Decode one bit. In some versions, this function has been splitted in three
1637 * an extra branch. In this particular version of the LZMA decoder, this
1639 * on x86). Using a non-splitted version results in nicer looking code too.
1793 /* Decode a match. The distance will be stored in s->lzma.rep0. */
1834 * seen matches. The distance will be stored in s->lzma.rep0.
1876 * finish the possibly pending repeat in the dictionary.
1932 * probabilities that are actually required. In the common case
1987 * As long as there is plenty of input left to be decoded in the current LZMA
2007 memcpy(s->temp.buf + s->temp.size, b->in + b->in_pos, tmp);
2022 s->rc.in = s->temp.buf;
2043 s->rc.in = b->in;
2066 memcpy(s->temp.buf, b->in + b->in_pos, in_avail);
2117 tmp = b->in[b->in_pos++];
2165 += (uint32_t)b->in[b->in_pos++] << 8;
2171 += (uint32_t)b->in[b->in_pos++] + 1;
2177 = (uint32_t)b->in[b->in_pos++] << 8;
2183 += (uint32_t)b->in[b->in_pos++] + 1;
2188 if (!lzma_props(s, b->in[b->in_pos++]))
2209 * In case the dictionary got full but we didn't fill
2326 * in code size (no effect on speed). Doing so limits the uncompressed and
2360 /* Position in dec_main() */
2374 /* Position in variable-length integers and Check fields */
2384 /* CRC32 or CRC64 value in Block or CRC32 value in Index */
2396 /* Information stored in Block Header */
2399 * Value stored in the Compressed Size field, or
2405 * Value stored in the Uncompressed Size field, or
2434 /* Position in dec_index() */
2441 /* Size of the Index in bytes */
2444 /* Number of Records (matches block.count in valid files) */
2448 * Hash calculated from the Records (matches block.hash in
2486 * Fill s->temp by copying data starting from b->in[b->in_pos]. Caller
2496 memcpy(s->temp.buf + s->temp.pos, b->in + b->in_pos, copy_size);
2509 static enum xz_ret dec_vli(struct xz_dec *s, const uint8_t *in,
2518 byte = in[*in_pos];
2543 * they don't exceed the values possibly stored in the Block Header
2546 * the CRC32 or CRC64 field was indicated in Stream Header.
2549 * the sizes possibly stored in the Block Header. Update the hash and
2623 s->crc = xz_crc32(b->in + s->in_start, in_used, s->crc);
2639 ret = dec_vli(s, b->in, &b->in_pos, b->in_size);
2652 * there were Blocks in the Stream.
2692 if (((s->crc >> s->pos) & 0xFF) != b->in[b->in_pos++])
2799 * in the chain, so we catch that with the same test.
2887 * Store the start position for the case when we are in the middle
2900 * simple. Similar approach is used in many places
2901 * in this file.
2909 * to continue decoding if working in multi-call
2925 if (b->in[b->in_pos] == 0) {
2936 = ((uint32_t)b->in[b->in_pos] + 1) * 4;
2971 if (b->in[b->in_pos++] != 0)
3012 if (b->in[b->in_pos++] != 0)
3046 * xz_dec_run() is a wrapper for dec_main() to handle some special cases in
3049 * In multi-call mode, we must return XZ_BUF_ERROR when it seems clear that we
3057 * In single-call mode, if we couldn't decode everything and no error
3062 * file is corrupt in a way that decoding it produces too big output.
3066 * be any valid uncompressed data in the output buffer unless the decoding
