2 * Copyright (C) 2013 Reimar Döffinger <Reimar.Doeffinger@gmx.de>
4 * This file is part of FFmpeg.
6 * FFmpeg is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU Lesser General Public
8 * License as published by the Free Software Foundation; either
9 * version 2.1 of the License, or (at your option) any later version.
11 * FFmpeg is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * Lesser General Public License for more details.
16 * You should have received a copy of the GNU Lesser General Public
17 * License along with FFmpeg; if not, write to the Free Software
18 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
22 #include "intreadwrite.h"
25 typedef struct AVMurMur3
{
32 AVMurMur3
*av_murmur3_alloc(void)
34 return av_mallocz(sizeof(AVMurMur3
));
37 void av_murmur3_init_seeded(AVMurMur3
*c
, uint64_t seed
)
39 memset(c
, 0, sizeof(*c
));
43 void av_murmur3_init(AVMurMur3
*c
)
45 // arbitrary random number as seed
46 av_murmur3_init_seeded(c
, 0x725acc55daddca55);
49 static const uint64_t c1
= UINT64_C(0x87c37b91114253d5);
50 static const uint64_t c2
= UINT64_C(0x4cf5ad432745937f);
52 #define ROT(a, b) ((a << b) | (a >> (64 - b)))
54 static uint64_t inline get_k1(const uint8_t *src
)
56 uint64_t k
= AV_RL64(src
);
63 static uint64_t inline get_k2(const uint8_t *src
)
65 uint64_t k
= AV_RL64(src
+ 8);
72 static uint64_t inline update_h1(uint64_t k
, uint64_t h1
, uint64_t h2
)
82 static uint64_t inline update_h2(uint64_t k
, uint64_t h1
, uint64_t h2
)
92 void av_murmur3_update(AVMurMur3
*c
, const uint8_t *src
, int len
)
95 uint64_t h1
= c
->h1
, h2
= c
->h2
;
99 if (c
->state_pos
> 0) {
100 while (c
->state_pos
< 16) {
101 c
->state
[c
->state_pos
++] = *src
++;
102 if (--len
<= 0) return;
105 k1
= get_k1(c
->state
);
106 k2
= get_k2(c
->state
);
107 h1
= update_h1(k1
, h1
, h2
);
108 h2
= update_h2(k2
, h1
, h2
);
111 end
= src
+ (len
& ~15);
113 // These could be done sequentially instead
114 // of interleaved, but like this is over 10% faster
117 h1
= update_h1(k1
, h1
, h2
);
118 h2
= update_h2(k2
, h1
, h2
);
126 memcpy(c
->state
, src
, len
);
131 static inline uint64_t fmix(uint64_t k
)
134 k
*= UINT64_C(0xff51afd7ed558ccd);
136 k
*= UINT64_C(0xc4ceb9fe1a85ec53);
141 void av_murmur3_final(AVMurMur3
*c
, uint8_t dst
[16])
143 uint64_t h1
= c
->h1
, h2
= c
->h2
;
144 memset(c
->state
+ c
->state_pos
, 0, sizeof(c
->state
) - c
->state_pos
);
145 h1
^= get_k1(c
->state
) ^ c
->len
;
146 h2
^= get_k2(c
->state
) ^ c
->len
;
154 AV_WL64(dst
+ 8, h2
);
161 uint8_t hash_result
[16] = {0};
162 AVMurMur3
*ctx
= av_murmur3_alloc();
164 uint8_t in
[256] = {0};
165 uint8_t *hashes
= av_mallocz(256 * 16);
166 for (i
= 0; i
< 256; i
++)
169 av_murmur3_init_seeded(ctx
, 256 - i
);
170 // Note: this actually tests hashing 0 bytes
171 av_murmur3_update(ctx
, in
, i
);
172 av_murmur3_final(ctx
, hashes
+ 16 * i
);
174 av_murmur3_init_seeded(ctx
, 0);
175 av_murmur3_update(ctx
, hashes
, 256 * 16);
176 av_murmur3_final(ctx
, hash_result
);
179 printf("result: 0x%"PRIx64
" 0x%"PRIx64
"\n", AV_RL64(hash_result
), AV_RL64(hash_result
+ 8));
180 // official reference value is 32 bit
181 return AV_RL32(hash_result
) != 0x6384ba69;
183 uint8_t *in
= av_mallocz(512*1024);
184 av_murmur3_init(ctx
);
185 for (i
= 0; i
< 40*1024; i
++)
186 av_murmur3_update(ctx
, in
, 512*1024);
187 av_murmur3_final(ctx
, hash_result
);
189 return hash_result
[0];