Fix Cycles viewport render not updating when tweaking displacement shader.
[blender.git] / intern / cycles / util / util_md5.cpp
1 /*
2  * Copyright (C) 1999, 2002 Aladdin Enterprises.  All rights reserved.
3  *
4  * This software is provided 'as-is', without any express or implied
5  * warranty.  In no event will the authors be held liable for any damages
6  * arising from the use of this software.
7  *
8  * Permission is granted to anyone to use this software for any purpose,
9  * including commercial applications, and to alter it and redistribute it
10  * freely, subject to the following restrictions:
11  *
12  * 1. The origin of this software must not be misrepresented; you must not
13  *      claim that you wrote the original software. If you use this software
14  *      in a product, an acknowledgment in the product documentation would be
15  *      appreciated but is not required.
16  * 2. Altered source versions must be plainly marked as such, and must not be
17  *      misrepresented as being the original software.
18  * 3. This notice may not be removed or altered from any source distribution.
19  *
20  * L. Peter Deutsch
21  * ghost@aladdin.com
22  */
23
24 /* Minor modifications done to remove some code and change style. */
25
26 #include "util_md5.h"
27 #include "util_path.h"
28
29 #include <string.h>
30 #include <stdio.h>
31
32 CCL_NAMESPACE_BEGIN
33
34 #define T_MASK ((uint32_t)~0)
35 #define T1 /* 0xd76aa478 */ (T_MASK ^ 0x28955b87)
36 #define T2 /* 0xe8c7b756 */ (T_MASK ^ 0x173848a9)
37 #define T3      0x242070db
38 #define T4 /* 0xc1bdceee */ (T_MASK ^ 0x3e423111)
39 #define T5 /* 0xf57c0faf */ (T_MASK ^ 0x0a83f050)
40 #define T6      0x4787c62a
41 #define T7 /* 0xa8304613 */ (T_MASK ^ 0x57cfb9ec)
42 #define T8 /* 0xfd469501 */ (T_MASK ^ 0x02b96afe)
43 #define T9      0x698098d8
44 #define T10 /* 0x8b44f7af */ (T_MASK ^ 0x74bb0850)
45 #define T11 /* 0xffff5bb1 */ (T_MASK ^ 0x0000a44e)
46 #define T12 /* 0x895cd7be */ (T_MASK ^ 0x76a32841)
47 #define T13     0x6b901122
48 #define T14 /* 0xfd987193 */ (T_MASK ^ 0x02678e6c)
49 #define T15 /* 0xa679438e */ (T_MASK ^ 0x5986bc71)
50 #define T16     0x49b40821
51 #define T17 /* 0xf61e2562 */ (T_MASK ^ 0x09e1da9d)
52 #define T18 /* 0xc040b340 */ (T_MASK ^ 0x3fbf4cbf)
53 #define T19     0x265e5a51
54 #define T20 /* 0xe9b6c7aa */ (T_MASK ^ 0x16493855)
55 #define T21 /* 0xd62f105d */ (T_MASK ^ 0x29d0efa2)
56 #define T22     0x02441453
57 #define T23 /* 0xd8a1e681 */ (T_MASK ^ 0x275e197e)
58 #define T24 /* 0xe7d3fbc8 */ (T_MASK ^ 0x182c0437)
59 #define T25     0x21e1cde6
60 #define T26 /* 0xc33707d6 */ (T_MASK ^ 0x3cc8f829)
61 #define T27 /* 0xf4d50d87 */ (T_MASK ^ 0x0b2af278)
62 #define T28     0x455a14ed
63 #define T29 /* 0xa9e3e905 */ (T_MASK ^ 0x561c16fa)
64 #define T30 /* 0xfcefa3f8 */ (T_MASK ^ 0x03105c07)
65 #define T31     0x676f02d9
66 #define T32 /* 0x8d2a4c8a */ (T_MASK ^ 0x72d5b375)
67 #define T33 /* 0xfffa3942 */ (T_MASK ^ 0x0005c6bd)
68 #define T34 /* 0x8771f681 */ (T_MASK ^ 0x788e097e)
69 #define T35     0x6d9d6122
70 #define T36 /* 0xfde5380c */ (T_MASK ^ 0x021ac7f3)
71 #define T37 /* 0xa4beea44 */ (T_MASK ^ 0x5b4115bb)
72 #define T38     0x4bdecfa9
73 #define T39 /* 0xf6bb4b60 */ (T_MASK ^ 0x0944b49f)
74 #define T40 /* 0xbebfbc70 */ (T_MASK ^ 0x4140438f)
75 #define T41     0x289b7ec6
76 #define T42 /* 0xeaa127fa */ (T_MASK ^ 0x155ed805)
77 #define T43 /* 0xd4ef3085 */ (T_MASK ^ 0x2b10cf7a)
78 #define T44     0x04881d05
79 #define T45 /* 0xd9d4d039 */ (T_MASK ^ 0x262b2fc6)
80 #define T46 /* 0xe6db99e5 */ (T_MASK ^ 0x1924661a)
81 #define T47     0x1fa27cf8
82 #define T48 /* 0xc4ac5665 */ (T_MASK ^ 0x3b53a99a)
83 #define T49 /* 0xf4292244 */ (T_MASK ^ 0x0bd6ddbb)
84 #define T50     0x432aff97
85 #define T51 /* 0xab9423a7 */ (T_MASK ^ 0x546bdc58)
86 #define T52 /* 0xfc93a039 */ (T_MASK ^ 0x036c5fc6)
87 #define T53     0x655b59c3
88 #define T54 /* 0x8f0ccc92 */ (T_MASK ^ 0x70f3336d)
89 #define T55 /* 0xffeff47d */ (T_MASK ^ 0x00100b82)
90 #define T56 /* 0x85845dd1 */ (T_MASK ^ 0x7a7ba22e)
91 #define T57     0x6fa87e4f
92 #define T58 /* 0xfe2ce6e0 */ (T_MASK ^ 0x01d3191f)
93 #define T59 /* 0xa3014314 */ (T_MASK ^ 0x5cfebceb)
94 #define T60     0x4e0811a1
95 #define T61 /* 0xf7537e82 */ (T_MASK ^ 0x08ac817d)
96 #define T62 /* 0xbd3af235 */ (T_MASK ^ 0x42c50dca)
97 #define T63     0x2ad7d2bb
98 #define T64 /* 0xeb86d391 */ (T_MASK ^ 0x14792c6e)
99
100 void MD5Hash::process(const uint8_t *data /*[64]*/)
101 {
102         uint32_t
103         a = abcd[0], b = abcd[1],
104         c = abcd[2], d = abcd[3];
105         uint32_t t;
106         /* Define storage for little-endian or both types of CPUs. */
107         uint32_t xbuf[16];
108         const uint32_t *X;
109
110         {
111                 /*
112                  * Determine dynamically whether this is a big-endian or
113                  * little-endian machine, since we can use a more efficient
114                  * algorithm on the latter.
115                  */
116                 static const int w = 1;
117
118                 if(*((const uint8_t *)&w)) /* dynamic little-endian */
119                 {
120                         /*
121                          * On little-endian machines, we can process properly aligned
122                          * data without copying it.
123                          */
124                         if(!((data - (const uint8_t *)0) & 3)) {
125                                 /* data are properly aligned */
126                                 X = (const uint32_t *)data;
127                         }
128                         else {
129                         /* not aligned */
130                         memcpy(xbuf, data, 64);
131                         X = xbuf;
132                         }
133                 }
134                 else { /* dynamic big-endian */
135                         /*
136                          * On big-endian machines, we must arrange the bytes in the
137                          * right order.
138                          */
139                         const uint8_t *xp = data;
140                         int i;
141
142                         X = xbuf;               /* (dynamic only) */
143                         for(i = 0; i < 16; ++i, xp += 4)
144                                 xbuf[i] = xp[0] + (xp[1] << 8) + (xp[2] << 16) + (xp[3] << 24);
145                 }
146         }
147
148 #define ROTATE_LEFT(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
149
150         /* Round 1. */
151         /* Let [abcd k s i] denote the operation
152          * a = b + ((a + F(b,c,d) + X[k] + T[i]) <<< s). */
153 #define F(x, y, z) (((x) & (y)) | (~(x) & (z)))
154 #define SET(a, b, c, d, k, s, Ti)\
155         t = a + F(b,c,d) + X[k] + Ti;\
156         a = ROTATE_LEFT(t, s) + b
157         /* Do the following 16 operations. */
158         SET(a, b, c, d,  0,  7,  T1);
159         SET(d, a, b, c,  1, 12,  T2);
160         SET(c, d, a, b,  2, 17,  T3);
161         SET(b, c, d, a,  3, 22,  T4);
162         SET(a, b, c, d,  4,  7,  T5);
163         SET(d, a, b, c,  5, 12,  T6);
164         SET(c, d, a, b,  6, 17,  T7);
165         SET(b, c, d, a,  7, 22,  T8);
166         SET(a, b, c, d,  8,  7,  T9);
167         SET(d, a, b, c,  9, 12, T10);
168         SET(c, d, a, b, 10, 17, T11);
169         SET(b, c, d, a, 11, 22, T12);
170         SET(a, b, c, d, 12,  7, T13);
171         SET(d, a, b, c, 13, 12, T14);
172         SET(c, d, a, b, 14, 17, T15);
173         SET(b, c, d, a, 15, 22, T16);
174 #undef SET
175
176         /* Round 2. */
177         /* Let [abcd k s i] denote the operation
178          * a = b + ((a + G(b,c,d) + X[k] + T[i]) <<< s). */
179 #define G(x, y, z) (((x) & (z)) | ((y) & ~(z)))
180 #define SET(a, b, c, d, k, s, Ti)\
181         t = a + G(b,c,d) + X[k] + Ti;\
182         a = ROTATE_LEFT(t, s) + b
183          /* Do the following 16 operations. */
184         SET(a, b, c, d,  1,  5, T17);
185         SET(d, a, b, c,  6,  9, T18);
186         SET(c, d, a, b, 11, 14, T19);
187         SET(b, c, d, a,  0, 20, T20);
188         SET(a, b, c, d,  5,  5, T21);
189         SET(d, a, b, c, 10,  9, T22);
190         SET(c, d, a, b, 15, 14, T23);
191         SET(b, c, d, a,  4, 20, T24);
192         SET(a, b, c, d,  9,  5, T25);
193         SET(d, a, b, c, 14,  9, T26);
194         SET(c, d, a, b,  3, 14, T27);
195         SET(b, c, d, a,  8, 20, T28);
196         SET(a, b, c, d, 13,  5, T29);
197         SET(d, a, b, c,  2,  9, T30);
198         SET(c, d, a, b,  7, 14, T31);
199         SET(b, c, d, a, 12, 20, T32);
200 #undef SET
201
202         /* Round 3. */
203         /* Let [abcd k s t] denote the operation
204          * a = b + ((a + H(b,c,d) + X[k] + T[i]) <<< s). */
205 #define H(x, y, z) ((x) ^ (y) ^ (z))
206 #define SET(a, b, c, d, k, s, Ti)\
207   t = a + H(b,c,d) + X[k] + Ti;\
208   a = ROTATE_LEFT(t, s) + b
209          /* Do the following 16 operations. */
210         SET(a, b, c, d,  5,  4, T33);
211         SET(d, a, b, c,  8, 11, T34);
212         SET(c, d, a, b, 11, 16, T35);
213         SET(b, c, d, a, 14, 23, T36);
214         SET(a, b, c, d,  1,  4, T37);
215         SET(d, a, b, c,  4, 11, T38);
216         SET(c, d, a, b,  7, 16, T39);
217         SET(b, c, d, a, 10, 23, T40);
218         SET(a, b, c, d, 13,  4, T41);
219         SET(d, a, b, c,  0, 11, T42);
220         SET(c, d, a, b,  3, 16, T43);
221         SET(b, c, d, a,  6, 23, T44);
222         SET(a, b, c, d,  9,  4, T45);
223         SET(d, a, b, c, 12, 11, T46);
224         SET(c, d, a, b, 15, 16, T47);
225         SET(b, c, d, a,  2, 23, T48);
226 #undef SET
227
228         /* Round 4. */
229         /* Let [abcd k s t] denote the operation
230          * a = b + ((a + I(b,c,d) + X[k] + T[i]) <<< s). */
231 #define I(x, y, z) ((y) ^ ((x) | ~(z)))
232 #define SET(a, b, c, d, k, s, Ti)\
233         t = a + I(b,c,d) + X[k] + Ti;\
234         a = ROTATE_LEFT(t, s) + b
235          /* Do the following 16 operations. */
236         SET(a, b, c, d,  0,  6, T49);
237         SET(d, a, b, c,  7, 10, T50);
238         SET(c, d, a, b, 14, 15, T51);
239         SET(b, c, d, a,  5, 21, T52);
240         SET(a, b, c, d, 12,  6, T53);
241         SET(d, a, b, c,  3, 10, T54);
242         SET(c, d, a, b, 10, 15, T55);
243         SET(b, c, d, a,  1, 21, T56);
244         SET(a, b, c, d,  8,  6, T57);
245         SET(d, a, b, c, 15, 10, T58);
246         SET(c, d, a, b,  6, 15, T59);
247         SET(b, c, d, a, 13, 21, T60);
248         SET(a, b, c, d,  4,  6, T61);
249         SET(d, a, b, c, 11, 10, T62);
250         SET(c, d, a, b,  2, 15, T63);
251         SET(b, c, d, a,  9, 21, T64);
252 #undef SET
253
254         /* Then perform the following additions. (That is increment each
255          * of the four registers by the value it had before this block
256          * was started.) */
257         abcd[0] += a;
258         abcd[1] += b;
259         abcd[2] += c;
260         abcd[3] += d;
261 }
262
263 MD5Hash::MD5Hash()
264 {
265         count[0] = count[1] = 0;
266         abcd[0] = 0x67452301;
267         abcd[1] = /*0xefcdab89*/ T_MASK ^ 0x10325476;
268         abcd[2] = /*0x98badcfe*/ T_MASK ^ 0x67452301;
269         abcd[3] = 0x10325476;
270 }
271
272 MD5Hash::~MD5Hash()
273 {
274 }
275
276 void MD5Hash::append(const uint8_t *data, int nbytes)
277 {
278         const uint8_t *p = data;
279         int left = nbytes;
280         int offset = (count[0] >> 3) & 63;
281         uint32_t nbits = (uint32_t)(nbytes << 3);
282
283         if(nbytes <= 0)
284                 return;
285
286         /* Update the message length. */
287         count[1] += nbytes >> 29;
288         count[0] += nbits;
289         if(count[0] < nbits)
290                 count[1]++;
291
292         /* Process an initial partial block. */
293         if(offset) {
294                 int copy = (offset + nbytes > 64 ? 64 - offset : nbytes);
295
296                 memcpy(buf + offset, p, copy);
297                 if(offset + copy < 64)
298                         return;
299                 p += copy;
300                 left -= copy;
301                 process(buf);
302         }
303
304         /* Process full blocks. */
305         for(; left >= 64; p += 64, left -= 64)
306                 process(p);
307
308         /* Process a final partial block. */
309         if(left)
310                 memcpy(buf, p, left);
311 }
312
313 void MD5Hash::append(const string& str)
314 {
315         if(str.size()) {
316                 append((const uint8_t*)str.c_str(), str.size());
317         }
318 }
319
320 bool MD5Hash::append_file(const string& filepath)
321 {
322         FILE *f = path_fopen(filepath, "rb");
323
324         if(!f) {
325                 fprintf(stderr, "MD5: failed to open file %s\n", filepath.c_str());
326                 return false;
327         }
328
329         const size_t buffer_size = 1024;
330         uint8_t buffer[buffer_size];
331         size_t n;
332
333         do {
334                 n = fread(buffer, 1, buffer_size, f);
335                 append(buffer, n);
336         } while(n == buffer_size);
337
338         bool success = (ferror(f) == 0);
339
340         fclose(f);
341         
342         return success;
343 }
344
345 void MD5Hash::finish(uint8_t digest[16])
346 {
347         static const uint8_t pad[64] = {
348                 0x80, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
349                 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
350                 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
351                 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
352
353         uint8_t data[8];
354         int i;
355
356         /* Save the length before padding. */
357         for(i = 0; i < 8; ++i)
358                 data[i] = (uint8_t)(count[i >> 2] >> ((i & 3) << 3));
359
360         /* Pad to 56 bytes mod 64. */
361         append(pad, ((55 - (count[0] >> 3)) & 63) + 1);
362         /* Append the length. */
363         append(data, 8);
364
365         for(i = 0; i < 16; ++i)
366                 digest[i] = (uint8_t)(abcd[i >> 2] >> ((i & 3) << 3));
367 }
368
369 string MD5Hash::get_hex()
370 {
371         uint8_t digest[16];
372         char buf[16*2+1];
373
374         finish(digest);
375
376         for(int i = 0; i < 16; i++)
377                 sprintf(buf + i*2, "%02X", (unsigned int)digest[i]);
378         buf[sizeof(buf)-1] = '\0';
379         
380         return string(buf);
381 }
382
383 string util_md5_string(const string& str)
384 {
385         MD5Hash md5;
386         md5.append((uint8_t*)str.c_str(), str.size());
387         return md5.get_hex();
388 }
389
390 CCL_NAMESPACE_END
391