Lines Matching refs:state
217 * This method is slower than single-call functions, due to state management.
220 * XXH state must first be allocated, using XXH*_createState() .
222 * Start a new hash by initializing state with a seed, using XXH*_reset().
224 * Then, feed the hash state by calling XXH*_update() as many times as necessary.
230 * It's still possible to continue inserting input into the hash state after a digest,
233 * When done, release the state, using XXH*_freeState().
320 * static allocation of XXH state, on stack or in a struct for example.
819 XXH32_state_t state;
820 XXH32_reset(&state, seed);
821 XXH32_update(&state, (const xxh_u8*)input, len);
822 return XXH32_digest(&state);
856 XXH32_state_t state; /* using a local state to memcpy() in order to avoid strict-aliasing warnings */
857 memset(&state, 0, sizeof(state));
858 state.v1 = seed + PRIME32_1 + PRIME32_2;
859 state.v2 = seed + PRIME32_2;
860 state.v3 = seed + 0;
861 state.v4 = seed - PRIME32_1;
863 memcpy(statePtr, &state, sizeof(state) - sizeof(state.reserved));
869 XXH32_update(XXH32_state_t* state, const void* input, size_t len)
881 state->total_len_32 += (XXH32_hash_t)len;
882 state->large_len |= (XXH32_hash_t)((len>=16) | (state->total_len_32>=16));
884 if (state->memsize + len < 16) { /* fill in tmp buffer */
885 XXH_memcpy((xxh_u8*)(state->mem32) + state->memsize, input, len);
886 state->memsize += (XXH32_hash_t)len;
890 if (state->memsize) { /* some data left from previous update */
891 XXH_memcpy((xxh_u8*)(state->mem32) + state->memsize, input, 16-state->memsize);
892 { const xxh_u32* p32 = state->mem32;
893 state->v1 = XXH32_round(state->v1, XXH_readLE32(p32)); p32++;
894 state->v2 = XXH32_round(state->v2, XXH_readLE32(p32)); p32++;
895 state->v3 = XXH32_round(state->v3, XXH_readLE32(p32)); p32++;
896 state->v4 = XXH32_round(state->v4, XXH_readLE32(p32));
898 p += 16-state->memsize;
899 state->memsize = 0;
904 xxh_u32 v1 = state->v1;
905 xxh_u32 v2 = state->v2;
906 xxh_u32 v3 = state->v3;
907 xxh_u32 v4 = state->v4;
916 state->v1 = v1;
917 state->v2 = v2;
918 state->v3 = v3;
919 state->v4 = v4;
923 XXH_memcpy(state->mem32, p, (size_t)(bEnd-p));
924 state->memsize = (unsigned)(bEnd-p);
932 XXH_PUBLIC_API XXH32_hash_t XXH32_digest (const XXH32_state_t* state)
936 if (state->large_len) {
937 h32 = XXH_rotl32(state->v1, 1)
938 + XXH_rotl32(state->v2, 7)
939 + XXH_rotl32(state->v3, 12)
940 + XXH_rotl32(state->v4, 18);
942 h32 = state->v3 /* == seed */ + PRIME32_5;
945 h32 += state->total_len_32;
947 return XXH32_finalize(h32, (const xxh_u8*)state->mem32, state->memsize, XXH_aligned);
1281 XXH64_state_t state;
1282 XXH64_reset(&state, seed);
1283 XXH64_update(&state, (const xxh_u8*)input, len);
1284 return XXH64_digest(&state);
1317 XXH64_state_t state; /* using a local state to memcpy() in order to avoid strict-aliasing warnings */
1318 memset(&state, 0, sizeof(state));
1319 state.v1 = seed + PRIME64_1 + PRIME64_2;
1320 state.v2 = seed + PRIME64_2;
1321 state.v3 = seed + 0;
1322 state.v4 = seed - PRIME64_1;
1324 memcpy(statePtr, &state, sizeof(state) - sizeof(state.reserved64));
1329 XXH64_update (XXH64_state_t* state, const void* input, size_t len)
1341 state->total_len += len;
1343 if (state->memsize + len < 32) { /* fill in tmp buffer */
1344 XXH_memcpy(((xxh_u8*)state->mem64) + state->memsize, input, len);
1345 state->memsize += (xxh_u32)len;
1349 if (state->memsize) { /* tmp buffer is full */
1350 XXH_memcpy(((xxh_u8*)state->mem64) + state->memsize, input, 32-state->memsize);
1351 state->v1 = XXH64_round(state->v1, XXH_readLE64(state->mem64+0));
1352 state->v2 = XXH64_round(state->v2, XXH_readLE64(state->mem64+1));
1353 state->v3 = XXH64_round(state->v3, XXH_readLE64(state->mem64+2));
1354 state->v4 = XXH64_round(state->v4, XXH_readLE64(state->mem64+3));
1355 p += 32-state->memsize;
1356 state->memsize = 0;
1361 xxh_u64 v1 = state->v1;
1362 xxh_u64 v2 = state->v2;
1363 xxh_u64 v3 = state->v3;
1364 xxh_u64 v4 = state->v4;
1373 state->v1 = v1;
1374 state->v2 = v2;
1375 state->v3 = v3;
1376 state->v4 = v4;
1380 XXH_memcpy(state->mem64, p, (size_t)(bEnd-p));
1381 state->memsize = (unsigned)(bEnd-p);
1389 XXH_PUBLIC_API XXH64_hash_t XXH64_digest (const XXH64_state_t* state)
1393 if (state->total_len >= 32) {
1394 xxh_u64 const v1 = state->v1;
1395 xxh_u64 const v2 = state->v2;
1396 xxh_u64 const v3 = state->v3;
1397 xxh_u64 const v4 = state->v4;
1405 h64 = state->v3 /*seed*/ + PRIME64_5;
1408 h64 += (xxh_u64) state->total_len;
1410 return XXH64_finalize(h64, (const xxh_u8*)state->mem64, (size_t)state->total_len, XXH_aligned);