20 self->chunk_counter = 0;
23 self->blocks_compressed = 0;
30 self->chunk_counter = chunk_counter;
31 self->blocks_compressed = 0;
42 const uint8_t *
input,
size_t input_len) {
44 if (take > input_len) {
47 uint8_t *dest =
self->buf + ((
size_t)self->buf_len);
49 self->buf_len += (uint8_t)take;
54 if (self->blocks_compressed == 0) {
76 ret.block_len = block_len;
77 ret.counter = counter;
90 memcpy(cv_words, self->input_cv, 32);
92 self->counter, self->flags);
98 uint64_t output_block_counter = seek / 64;
99 size_t offset_within_block = seek % 64;
100 uint8_t wide_buf[64];
101 while (out_len > 0) {
103 output_block_counter, self->flags |
ROOT, wide_buf);
104 size_t available_bytes = 64 - offset_within_block;
106 if (out_len > available_bytes) {
107 memcpy_len = available_bytes;
109 memcpy_len = out_len;
111 memcpy(out, wide_buf + offset_within_block, memcpy_len);
113 out_len -= memcpy_len;
114 output_block_counter += 1;
115 offset_within_block = 0;
121 if (self->buf_len > 0) {
129 self->blocks_compressed += 1;
139 self->blocks_compressed += 1;
150 uint8_t block_flags =
152 return make_output(self->cv, self->buf, self->buf_len, self->chunk_counter,
157 const uint32_t key[8], uint8_t flags) {
177 uint64_t chunk_counter, uint8_t flags,
179 #if defined(BLAKE3_TESTING)
185 size_t input_position = 0;
186 size_t chunks_array_len = 0;
188 chunks_array[chunks_array_len] = &
input[input_position];
190 chunks_array_len += 1;
199 if (input_len > input_position) {
203 chunk_state.chunk_counter = counter;
205 input_len - input_position);
208 return chunks_array_len + 1;
210 return chunks_array_len;
220 size_t num_chaining_values,
221 const uint32_t key[8], uint8_t flags,
223 #if defined(BLAKE3_TESTING)
224 assert(2 <= num_chaining_values);
229 size_t parents_array_len = 0;
230 while (num_chaining_values - (2 * parents_array_len) >= 2) {
231 parents_array[parents_array_len] =
233 parents_array_len += 1;
244 if (num_chaining_values > 2 * parents_array_len) {
248 return parents_array_len + 1;
250 return parents_array_len;
275 uint8_t flags, uint8_t *out) {
289 size_t left_input_len =
left_len(input_len);
290 size_t right_input_len = input_len - left_input_len;
291 const uint8_t *right_input = &
input[left_input_len];
312 chunk_counter, flags, cv_array);
314 right_input, right_input_len, key, right_chunk_counter, flags, right_cvs);
325 size_t num_chaining_values = left_n + right_n;
341 const uint8_t *
input,
size_t input_len,
const uint32_t key[8],
343 #if defined(BLAKE3_TESTING)
349 chunk_counter, flags, cv_array);
373 self->cv_stack_len = 0;
386 size_t context_len) {
412 size_t post_merge_stack_len = (
size_t)
popcnt(total_len);
413 while (self->cv_stack_len > post_merge_stack_len) {
414 uint8_t *parent_node =
418 self->cv_stack_len -= 1;
459 self->cv_stack_len += 1;
468 if (input_len == 0) {
472 const uint8_t *input_bytes = (
const uint8_t *)
input;
478 if (take > input_len) {
488 uint8_t chunk_cv[32];
528 while ((((
uint64_t)(subtree_len - 1)) & count_so_far) != 0) {
537 chunk_state.chunk_counter =
self->chunk.chunk_counter;
548 self->chunk.chunk_counter,
549 self->chunk.flags, cv_pair);
552 self->chunk.chunk_counter + (subtree_chunks / 2));
554 self->chunk.chunk_counter += subtree_chunks;
555 input_bytes += subtree_len;
556 input_len -= subtree_len;
574 #if LLVM_MEMORY_SANITIZER_BUILD
581 uint8_t *out,
size_t out_len) {
591 if (self->cv_stack_len == 0) {
604 size_t cvs_remaining;
606 cvs_remaining =
self->cv_stack_len;
610 cvs_remaining =
self->cv_stack_len - 2;
614 while (cvs_remaining > 0) {
617 memcpy(parent_block, &self->cv_stack[cvs_remaining * 32], 32);
626 self->cv_stack_len = 0;