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";
366 * could save a few bytes in code size.
400 /* Decode raw LZMA2 stream from b->in to b->out. */
428 * Return value of the next filter in the chain. We need to preserve
436 * data (in a single .xz Block). We care only about the lowest 32
450 /* Amount of already filtered data in the beginning of buf */
453 /* Total amount of data currently stored in buf */
482 * a BCJ filter in the chain. If the chain has only LZMA2, xz_dec_lzma2_run()
492 * in an x86 instruction.
611 /* Instruction slot (0, 1, or 2) in the 128-bit instruction word */
627 /* 41-bit instruction stored somewhere in the lowest 48 bits */
753 * pointers, which could be problematic in the kernel boot code, which must
824 * The BCJ filter functions are primitive in sense that they process the
825 * data in chunks of 1-16 bytes. To hide this issue, this function does
837 * filter in the chain had already returned XZ_STREAM_END.
849 * If we have more output space than what is currently pending in
852 * next filter in the chain. Apply the BCJ filter on the new data
853 * in the output buffer. If everything cannot be filtered, copy it
894 * We have unfiltered data in temp. If the output buffer isn't full
898 * A mix of filtered and unfiltered data may be left in temp; it will
999 * number of bits of the current uncompressed offset. In some places there
1006 * and in which order. This information is used to predict the next symbol.
1014 * The symbol names are in from STATE_oldest_older_previous. REP means
1073 /* Each literal coder is divided in three sections:
1146 * Match distances greater than 127 are encoded in three pieces:
1207 * in which the dictionary variables address the actual output
1214 /* Old position in buf (before decoding more data) */
1217 /* Position in buf */
1233 * Size of the dictionary as specified in Block Header. This is used
1265 const uint8_t *in;
1350 * when the distance is in the range [4, 127].
1371 /* Position in xz_dec_lzma2_run(). */
1413 * including lzma.pos_mask are in the first 128 bytes on x86-32,
1537 memcpy(dict->buf + dict->pos, b->in + b->in_pos, copy_size);
1546 memcpy(b->out + b->out_pos, b->in + b->in_pos,
1558 * enough space in b->out. This is guaranteed because caller uses dict_limit()
1597 rc->code = (rc->code << 8) + b->in[b->in_pos++];
1624 rc->code = (rc->code << RC_SHIFT_BITS) + rc->in[rc->in_pos++];
1629 * Decode one bit. In some versions, this function has been splitted in three
1631 * an extra branch. In this particular version of the LZMA decoder, this
1633 * on x86). Using a non-splitted version results in nicer looking code too.
1787 /* Decode a match. The distance will be stored in s->lzma.rep0. */
1828 * seen matches. The distance will be stored in s->lzma.rep0.
1870 * finish the possibly pending repeat in the dictionary.
1926 * probabilities that are actually required. In the common case
1981 * As long as there is plenty of input left to be decoded in the current LZMA
2001 memcpy(s->temp.buf + s->temp.size, b->in + b->in_pos, tmp);
2016 s->rc.in = s->temp.buf;
2037 s->rc.in = b->in;
2060 memcpy(s->temp.buf, b->in + b->in_pos, in_avail);
2111 tmp = b->in[b->in_pos++];
2159 += (uint32_t)b->in[b->in_pos++] << 8;
2165 += (uint32_t)b->in[b->in_pos++] + 1;
2171 = (uint32_t)b->in[b->in_pos++] << 8;
2177 += (uint32_t)b->in[b->in_pos++] + 1;
2182 if (!lzma_props(s, b->in[b->in_pos++]))
2203 * In case the dictionary got full but we didn't fill
2319 * in code size (no effect on speed). Doing so limits the uncompressed and
2353 /* Position in dec_main() */
2367 /* Position in variable-length integers and Check fields */
2377 /* CRC32 or CRC64 value in Block or CRC32 value in Index */
2389 /* Information stored in Block Header */
2392 * Value stored in the Compressed Size field, or
2398 * Value stored in the Uncompressed Size field, or
2427 /* Position in dec_index() */
2434 /* Size of the Index in bytes */
2437 /* Number of Records (matches block.count in valid files) */
2441 * Hash calculated from the Records (matches block.hash in
2479 * Fill s->temp by copying data starting from b->in[b->in_pos]. Caller
2488 memcpy(s->temp.buf + s->temp.pos, b->in + b->in_pos, copy_size);
2501 static enum xz_ret dec_vli(struct xz_dec *s, const uint8_t *in,
2510 byte = in[*in_pos];
2535 * they don't exceed the values possibly stored in the Block Header
2538 * the CRC32 or CRC64 field was indicated in Stream Header.
2541 * the sizes possibly stored in the Block Header. Update the hash and
2615 s->crc = xz_crc32(b->in + s->in_start, in_used, s->crc);
2631 ret = dec_vli(s, b->in, &b->in_pos, b->in_size);
2644 * there were Blocks in the Stream.
2684 if (((s->crc >> s->pos) & 0xFF) != b->in[b->in_pos++])
2791 * in the chain, so we catch that with the same test.
2879 * Store the start position for the case when we are in the middle
2892 * simple. Similar approach is used in many places
2893 * in this file.
2901 * to continue decoding if working in multi-call
2917 if (b->in[b->in_pos] == 0) {
2928 = ((uint32_t)b->in[b->in_pos] + 1) * 4;
2963 if (b->in[b->in_pos++] != 0)
3004 if (b->in[b->in_pos++] != 0)
3038 * xz_dec_run() is a wrapper for dec_main() to handle some special cases in
3041 * In multi-call mode, we must return XZ_BUF_ERROR when it seems clear that we
3049 * In single-call mode, if we couldn't decode everything and no error
3054 * file is corrupt in a way that decoding it produces too big output.
3058 * be any valid uncompressed data in the output buffer unless the decoding
