49 static const uint32_t
KA[4] = {
50 0x5a827999, 0x6ed9eba1, 0x8f1bbcdc, 0xa953fd4e
53 static const uint32_t
KB[4] = {
54 0x50a28be6, 0x5c4dd124, 0x6d703ef3, 0x7a6d76e9
57 static const int ROTA[80] = {
58 11, 14, 15, 12, 5, 8, 7 , 9, 11, 13, 14, 15, 6, 7, 9, 8,
59 7 , 6, 8, 13, 11, 9, 7, 15, 7, 12, 15, 9, 11, 7, 13, 12,
60 11, 13, 6, 7, 14, 9, 13, 15, 14, 8, 13, 6, 5, 12, 7, 5,
61 11, 12, 14, 15, 14, 15, 9, 8, 9, 14, 5, 6, 8, 6, 5, 12,
62 9, 15, 5, 11, 6, 8, 13, 12, 5, 12, 13, 14, 11, 8, 5, 6
65 static const int ROTB[80] = {
66 8, 9, 9, 11, 13, 15, 15, 5, 7, 7, 8, 11, 14, 14, 12, 6,
67 9, 13, 15, 7, 12, 8, 9, 11, 7, 7, 12, 7, 6, 15, 13, 11,
68 9, 7, 15, 11, 8, 6, 6, 14, 12, 13, 5, 14, 13, 13, 7, 5,
69 15, 5, 8, 11, 14, 14, 6, 14, 6, 9, 12, 9, 12, 5, 15, 8,
70 8, 5, 12, 9, 12, 5, 14, 6, 8, 13, 6, 5, 15, 13, 11, 11
73 static const int WA[80] = {
74 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15,
75 7, 4, 13, 1, 10, 6, 15, 3, 12, 0, 9, 5, 2, 14, 11, 8,
76 3, 10, 14, 4, 9, 15, 8, 1, 2, 7, 0, 6, 13, 11, 5, 12,
77 1, 9, 11, 10, 0, 8, 12, 4, 13, 3, 7, 15, 14, 5, 6, 2,
78 4, 0, 5, 9, 7, 12, 2, 10, 14, 1, 3, 8, 11, 6, 15, 13
81 static const int WB[80] = {
82 5, 14, 7, 0, 9, 2, 11, 4, 13, 6, 15, 8, 1, 10, 3, 12,
83 6, 11, 3, 7, 0, 13, 5, 10, 14, 15, 8, 12, 4, 9, 1, 2,
84 15, 5, 1, 3, 7, 14, 6, 9, 11, 8, 12, 2, 10, 0, 4, 13,
85 8, 6, 4, 1, 3, 11, 15, 0, 5, 12, 2, 13, 9, 7, 10, 14,
86 12, 15, 10, 4, 1, 5, 8, 7, 6, 2, 13, 14, 0, 3, 9, 11
89 #define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) 91 #define ROUND128_0_TO_15(a,b,c,d,e,f,g,h) \ 92 a = rol(a + (( b ^ c ^ d) + block[WA[n]]), ROTA[n]); \ 93 e = rol(e + ((((f ^ g) & h) ^ g) + block[WB[n]] + KB[0]), ROTB[n]); \ 96 #define ROUND128_16_TO_31(a,b,c,d,e,f,g,h) \ 97 a = rol(a + ((((c ^ d) & b) ^ d) + block[WA[n]] + KA[0]), ROTA[n]); \ 98 e = rol(e + (((~g | f) ^ h) + block[WB[n]] + KB[1]), ROTB[n]); \ 101 #define ROUND128_32_TO_47(a,b,c,d,e,f,g,h) \ 102 a = rol(a + (((~c | b) ^ d) + block[WA[n]] + KA[1]), ROTA[n]); \ 103 e = rol(e + ((((g ^ h) & f) ^ h) + block[WB[n]] + KB[2]), ROTB[n]); \ 106 #define ROUND128_48_TO_63(a,b,c,d,e,f,g,h) \ 107 a = rol(a + ((((b ^ c) & d) ^ c) + block[WA[n]] + KA[2]), ROTA[n]); \ 108 e = rol(e + (( f ^ g ^ h) + block[WB[n]]), ROTB[n]); \ 112 ROUND128_0_TO_15(a,b,c,d,e,f,g,h); \ 113 ROUND128_0_TO_15(d,a,b,c,h,e,f,g); \ 114 ROUND128_0_TO_15(c,d,a,b,g,h,e,f); \ 115 ROUND128_0_TO_15(b,c,d,a,f,g,h,e) 118 ROUND128_16_TO_31(a,b,c,d,e,f,g,h); \ 119 ROUND128_16_TO_31(d,a,b,c,h,e,f,g); \ 120 ROUND128_16_TO_31(c,d,a,b,g,h,e,f); \ 121 ROUND128_16_TO_31(b,c,d,a,f,g,h,e) 124 ROUND128_32_TO_47(a,b,c,d,e,f,g,h); \ 125 ROUND128_32_TO_47(d,a,b,c,h,e,f,g); \ 126 ROUND128_32_TO_47(c,d,a,b,g,h,e,f); \ 127 ROUND128_32_TO_47(b,c,d,a,f,g,h,e) 130 ROUND128_48_TO_63(a,b,c,d,e,f,g,h); \ 131 ROUND128_48_TO_63(d,a,b,c,h,e,f,g); \ 132 ROUND128_48_TO_63(c,d,a,b,g,h,e,f); \ 133 ROUND128_48_TO_63(b,c,d,a,f,g,h,e) 146 for (n = 0; n < 16; n++)
147 block[n] =
AV_RL32(buffer + 4 * n);
153 t = d; d =
c; c =
b; b =
a; a = t;
154 t =
h; h =
g; g =
f; f = e; e = t;
159 t = d; d =
c; c =
b; b =
a; a = t;
160 t =
h; h =
g; g =
f; f = e; e = t;
165 t = d; d =
c; c =
b; b =
a; a = t;
166 t =
h; h =
g; g =
f; f = e; e = t;
171 t = d; d =
c; c =
b; b =
a; a = t;
172 t =
h; h =
g; g =
f; f = e; e = t;
186 state[1] = state[2] + d + e;
187 state[2] = state[3] + a +
f;
188 state[3] = state[0] + b +
g;
198 a = state[0]; b = state[1]; c = state[2]; d = state[3];
199 e = state[4]; f = state[5]; g = state[6]; h = state[7];
201 for (n = 0; n < 16; n++)
202 block[n] =
AV_RL32(buffer + 4 * n);
208 t = d; d =
c; c =
b; b =
a; a = t;
209 t =
h; h =
g; g =
f; f = e; e = t;
215 t = d; d =
c; c =
b; b =
a; a = t;
216 t =
h; h =
g; g =
f; f = e; e = t;
222 t = d; d =
c; c =
b; b =
a; a = t;
223 t =
h; h =
g; g =
f; f = e; e = t;
229 t = d; d =
c; c =
b; b =
a; a = t;
230 t =
h; h =
g; g =
f; f = e; e = t;
248 state[0] +=
a; state[1] +=
b; state[2] +=
c; state[3] += d;
249 state[4] += e; state[5] +=
f; state[6] +=
g; state[7] +=
h;
252 #define ROTATE(x,y) \ 257 #define ROUND160_0_TO_15(a,b,c,d,e,f,g,h,i,j) \ 258 a = rol(a + (( b ^ c ^ d) + block[WA[n]]), ROTA[n]) + e; \ 259 f = rol(f + (((~i | h) ^ g) + block[WB[n]] + KB[0]), ROTB[n]) + j; \ 262 #define ROUND160_16_TO_31(a,b,c,d,e,f,g,h,i,j) \ 263 a = rol(a + ((((c ^ d) & b) ^ d) + block[WA[n]] + KA[0]), ROTA[n]) + e; \ 264 f = rol(f + ((((g ^ h) & i) ^ h) + block[WB[n]] + KB[1]), ROTB[n]) + j; \ 267 #define ROUND160_32_TO_47(a,b,c,d,e,f,g,h,i,j) \ 268 a = rol(a + (((~c | b) ^ d) + block[WA[n]] + KA[1]), ROTA[n]) + e; \ 269 f = rol(f + (((~h | g) ^ i) + block[WB[n]] + KB[2]), ROTB[n]) + j; \ 272 #define ROUND160_48_TO_63(a,b,c,d,e,f,g,h,i,j) \ 273 a = rol(a + ((((b ^ c) & d) ^ c) + block[WA[n]] + KA[2]), ROTA[n]) + e; \ 274 f = rol(f + ((((h ^ i) & g) ^ i) + block[WB[n]] + KB[3]), ROTB[n]) + j; \ 277 #define ROUND160_64_TO_79(a,b,c,d,e,f,g,h,i,j) \ 278 a = rol(a + (((~d | c) ^ b) + block[WA[n]] + KA[3]), ROTA[n]) + e; \ 279 f = rol(f + (( g ^ h ^ i) + block[WB[n]]), ROTB[n]) + j; \ 283 ROUND160_0_TO_15(a,b,c,d,e,f,g,h,i,j); \ 284 ROUND160_0_TO_15(e,a,b,c,d,j,f,g,h,i); \ 285 ROUND160_0_TO_15(d,e,a,b,c,i,j,f,g,h); \ 286 ROUND160_0_TO_15(c,d,e,a,b,h,i,j,f,g); \ 287 ROUND160_0_TO_15(b,c,d,e,a,g,h,i,j,f) 290 ROUND160_16_TO_31(e,a,b,c,d,j,f,g,h,i); \ 291 ROUND160_16_TO_31(d,e,a,b,c,i,j,f,g,h); \ 292 ROUND160_16_TO_31(c,d,e,a,b,h,i,j,f,g); \ 293 ROUND160_16_TO_31(b,c,d,e,a,g,h,i,j,f); \ 294 ROUND160_16_TO_31(a,b,c,d,e,f,g,h,i,j) 297 ROUND160_32_TO_47(d,e,a,b,c,i,j,f,g,h); \ 298 ROUND160_32_TO_47(c,d,e,a,b,h,i,j,f,g); \ 299 ROUND160_32_TO_47(b,c,d,e,a,g,h,i,j,f); \ 300 ROUND160_32_TO_47(a,b,c,d,e,f,g,h,i,j); \ 301 ROUND160_32_TO_47(e,a,b,c,d,j,f,g,h,i) 304 ROUND160_48_TO_63(c,d,e,a,b,h,i,j,f,g); \ 305 ROUND160_48_TO_63(b,c,d,e,a,g,h,i,j,f); \ 306 ROUND160_48_TO_63(a,b,c,d,e,f,g,h,i,j); \ 307 ROUND160_48_TO_63(e,a,b,c,d,j,f,g,h,i); \ 308 ROUND160_48_TO_63(d,e,a,b,c,i,j,f,g,h) 311 ROUND160_64_TO_79(b,c,d,e,a,g,h,i,j,f); \ 312 ROUND160_64_TO_79(a,b,c,d,e,f,g,h,i,j); \ 313 ROUND160_64_TO_79(e,a,b,c,d,j,f,g,h,i); \ 314 ROUND160_64_TO_79(d,e,a,b,c,i,j,f,g,h); \ 315 ROUND160_64_TO_79(c,d,e,a,b,h,i,j,f,g) 319 uint32_t
a,
b,
c, d, e,
f,
g,
h,
i, j,
av_unused t;
329 for (n = 0; n < 16; n++)
330 block[n] =
AV_RL32(buffer + 4 * n);
336 t = e; e = d; d =
c; c =
b; b =
a; a = t;
337 t = j; j =
i; i =
h; h =
g; g =
f; f = t;
342 t = e; e = d; d =
c; c =
b; b =
a; a = t;
343 t = j; j =
i; i =
h; h =
g; g =
f; f = t;
348 t = e; e = d; d =
c; c =
b; b =
a; a = t;
349 t = j; j =
i; i =
h; h =
g; g =
f; f = t;
354 t = e; e = d; d =
c; c =
b; b =
a; a = t;
355 t = j; j =
i; i =
h; h =
g; g =
f; f = t;
360 t = e; e = d; d =
c; c =
b; b =
a; a = t;
361 t = j; j =
i; i =
h; h =
g; g =
f; f = t;
382 state[1] = state[2] + d + j;
383 state[2] = state[3] + e +
f;
384 state[3] = state[4] + a +
g;
385 state[4] = state[0] + b +
h;
391 uint32_t
a,
b,
c, d, e,
f,
g,
h,
i, j,
av_unused t;
395 a = state[0]; b = state[1]; c = state[2]; d = state[3]; e = state[4];
396 f = state[5]; g = state[6]; h = state[7]; i = state[8]; j = state[9];
398 for (n = 0; n < 16; n++)
399 block[n] =
AV_RL32(buffer + 4 * n);
405 t = e; e = d; d =
c; c =
b; b =
a; a = t;
406 t = j; j =
i; i =
h; h =
g; g =
f; f = t;
412 t = e; e = d; d =
c; c =
b; b =
a; a = t;
413 t = j; j =
i; i =
h; h =
g; g =
f; f = t;
419 t = e; e = d; d =
c; c =
b; b =
a; a = t;
420 t = j; j =
i; i =
h; h =
g; g =
f; f = t;
426 t = e; e = d; d =
c; c =
b; b =
a; a = t;
427 t = j; j =
i; i =
h; h =
g; g =
f; f = t;
433 t = e; e = d; d =
c; c =
b; b =
a; a = t;
434 t = j; j =
i; i =
h; h =
g; g =
f; f = t;
460 state[0] +=
a; state[1] +=
b; state[2] +=
c; state[3] += d; state[4] += e;
461 state[5] +=
f; state[6] +=
g; state[7] +=
h; state[8] +=
i; state[9] += j;
469 ctx->
state[0] = 0x67452301;
470 ctx->
state[1] = 0xEFCDAB89;
471 ctx->
state[2] = 0x98BADCFE;
472 ctx->
state[3] = 0x10325476;
476 ctx->
state[0] = 0x67452301;
477 ctx->
state[1] = 0xEFCDAB89;
478 ctx->
state[2] = 0x98BADCFE;
479 ctx->
state[3] = 0x10325476;
480 ctx->
state[4] = 0xC3D2E1F0;
484 ctx->
state[0] = 0x67452301;
485 ctx->
state[1] = 0xEFCDAB89;
486 ctx->
state[2] = 0x98BADCFE;
487 ctx->
state[3] = 0x10325476;
488 ctx->
state[4] = 0x76543210;
489 ctx->
state[5] = 0xFEDCBA98;
490 ctx->
state[6] = 0x89ABCDEF;
491 ctx->
state[7] = 0x01234567;
495 ctx->
state[0] = 0x67452301;
496 ctx->
state[1] = 0xEFCDAB89;
497 ctx->
state[2] = 0x98BADCFE;
498 ctx->
state[3] = 0x10325476;
499 ctx->
state[4] = 0xC3D2E1F0;
500 ctx->
state[5] = 0x76543210;
501 ctx->
state[6] = 0xFEDCBA98;
502 ctx->
state[7] = 0x89ABCDEF;
503 ctx->
state[8] = 0x01234567;
504 ctx->
state[9] = 0x3C2D1E0F;
514 #if FF_API_CRYPTO_SIZE_T 525 for (i = 0; i <
len; i++) {
533 if ((j + len) > 63) {
534 memcpy(&ctx->
buffer[j], data, (i = 64 - j));
536 for (; i + 63 <
len; i += 64)
541 memcpy(&ctx->
buffer[j], &data[i], len - i);
551 while ((ctx->
count & 63) != 56)
ptrdiff_t const GLvoid * data
void av_ripemd_update(AVRIPEMD *ctx, const uint8_t *data, unsigned int len)
Update hash value.
Memory handling functions.
Public header for RIPEMD hash function implementation.
#define ROUND160_0_TO_15(a, b, c, d, e, f, g, h, i, j)
The reader does not expect b to be semantically here and if the code is changed by maybe adding a a division or other the signedness will almost certainly be mistaken To avoid this confusion a new type was SUINT is the C unsigned type but it holds a signed int to use the same example SUINT a
Convenience header that includes libavutil's core.
static const uint32_t KB[4]
void * av_mallocz(size_t size)
Allocate a memory block with alignment suitable for all memory accesses (including vectors if availab...
static void ripemd320_transform(uint32_t *state, const uint8_t buffer[64])
Macro definitions for various function/variable attributes.
void av_ripemd_final(AVRIPEMD *ctx, uint8_t *digest)
Finish hashing and output digest value.
The exact code depends on how similar the blocks are and how related they are to the block
Undefined Behavior In the C some operations are like signed integer dereferencing freed accessing outside allocated Undefined Behavior must not occur in a C it is not safe even if the output of undefined operations is unused The unsafety may seem nit picking but Optimizing compilers have in fact optimized code on the assumption that no undefined Behavior occurs Optimizing code based on wrong assumptions can and has in some cases lead to effects beyond the output of computations The signed integer overflow problem in speed critical code Code which is highly optimized and works with signed integers sometimes has the problem that often the output of the computation does not c
#define ROUND160_48_TO_63(a, b, c, d, e, f, g, h, i, j)
#define ROUND128_0_TO_15(a, b, c, d, e, f, g, h)
uint8_t buffer[64]
512-bit buffer of input values used in hash updating
#define ROUND160_64_TO_79(a, b, c, d, e, f, g, h, i, j)
struct AVRIPEMD * av_ripemd_alloc(void)
Allocate an AVRIPEMD context.
static const int ROTB[80]
typedef void(APIENTRY *FF_PFNGLACTIVETEXTUREPROC)(GLenum texture)
static void ripemd128_transform(uint32_t *state, const uint8_t buffer[64])
static const uint32_t KA[4]
#define ROUND128_32_TO_47(a, b, c, d, e, f, g, h)
uint64_t count
number of bytes in buffer
static const int ROTA[80]
#define ROUND160_32_TO_47(a, b, c, d, e, f, g, h, i, j)
uint8_t digest_len
digest length in 32-bit words
static void ripemd256_transform(uint32_t *state, const uint8_t buffer[64])
#define ROUND160_16_TO_31(a, b, c, d, e, f, g, h, i, j)
#define ROUND128_48_TO_63(a, b, c, d, e, f, g, h)
av_cold int av_ripemd_init(AVRIPEMD *ctx, int bits)
Initialize RIPEMD hashing.
uint32_t state[10]
current hash value
static void ripemd160_transform(uint32_t *state, const uint8_t buffer[64])
void(* transform)(uint32_t *state, const uint8_t buffer[64])
function used to update hash for 512-bit input block
#define FFSWAP(type, a, b)
Filter the word “frame” indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample they are references to shared objects When the negotiation mechanism computes the intersection of the formats supported at each end of a all references to both lists are replaced with a reference to the intersection And when a single format is eventually chosen for a link amongst the remaining all references to the list are updated That means that if a filter requires that its input and output have the same format amongst a supported all it has to do is use a reference to the same list of formats query_formats can leave some formats unset and return AVERROR(EAGAIN) to cause the negotiation mechanism toagain later.That can be used by filters with complex requirements to use the format negotiated on one link to set the formats supported on another.Frame references ownership and permissions
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_RL32
#define ROUND128_16_TO_31(a, b, c, d, e, f, g, h)