@@ -24,27 +24,29 @@

  * different IIR filters implementation

  */

-#include "iirfilter.h"

 #include <math.h>

+

 #include "libavutil/attributes.h"

 #include "libavutil/common.h"

+#include "iirfilter.h"

+

 /**

  * IIR filter global parameters

  */

-typedef struct FFIIRFilterCoeffs{

+typedef struct FFIIRFilterCoeffs {

     int   order;

     float gain;

     int   *cx;

     float *cy;

-}FFIIRFilterCoeffs;

+} FFIIRFilterCoeffs;

 /**

  * IIR filter state

  */

-typedef struct FFIIRFilterState{

+typedef struct FFIIRFilterState {

     float x[1];

-}FFIIRFilterState;

+} FFIIRFilterState;

 /// maximum supported filter order

 #define MAXORDER 30

@@ -61,51 +63,50 @@ static av_cold int butterworth_init_coeffs(void *avc,

     if (filt_mode != FF_FILTER_MODE_LOWPASS) {

         av_log(avc, AV_LOG_ERROR, "Butterworth filter currently only supports "

-               "low-pass filter mode\n");

+                                  "low-pass filter mode\n");

         return -1;

     }

     if (order & 1) {

         av_log(avc, AV_LOG_ERROR, "Butterworth filter currently only supports "

-               "even filter orders\n");

+                                  "even filter orders\n");

         return -1;

     }

     wa = 2 * tan(M_PI * 0.5 * cutoff_ratio);

     c->cx[0] = 1;

-    for(i = 1; i < (order >> 1) + 1; i++)

+    for (i = 1; i < (order >> 1) + 1; i++)

         c->cx[i] = c->cx[i - 1] * (order - i + 1LL) / i;

     p[0][0] = 1.0;

     p[0][1] = 0.0;

-    for(i = 1; i <= order; i++)

+    for (i = 1; i <= order; i++)

         p[i][0] = p[i][1] = 0.0;

-    for(i = 0; i < order; i++){

+    for (i = 0; i < order; i++) {

         double zp[2];

         double th = (i + (order >> 1) + 0.5) * M_PI / order;

         double a_re, a_im, c_re, c_im;

         zp[0] = cos(th) * wa;

         zp[1] = sin(th) * wa;

-        a_re = zp[0] + 2.0;

-        c_re = zp[0] - 2.0;

-        a_im =

-        c_im = zp[1];

+        a_re  = zp[0] + 2.0;

+        c_re  = zp[0] - 2.0;

+        a_im  =

+        c_im  = zp[1];

         zp[0] = (a_re * c_re + a_im * c_im) / (c_re * c_re + c_im * c_im);

         zp[1] = (a_im * c_re - a_re * c_im) / (c_re * c_re + c_im * c_im);

-        for(j = order; j >= 1; j--)

-        {

-            a_re = p[j][0];

-            a_im = p[j][1];

-            p[j][0] = a_re*zp[0] - a_im*zp[1] + p[j-1][0];

-            p[j][1] = a_re*zp[1] + a_im*zp[0] + p[j-1][1];

+        for (j = order; j >= 1; j--) {

+            a_re    = p[j][0];

+            a_im    = p[j][1];

+            p[j][0] = a_re * zp[0] - a_im * zp[1] + p[j - 1][0];

+            p[j][1] = a_re * zp[1] + a_im * zp[0] + p[j - 1][1];

         }

-        a_re    = p[0][0]*zp[0] - p[0][1]*zp[1];

-        p[0][1] = p[0][0]*zp[1] + p[0][1]*zp[0];

+        a_re    = p[0][0] * zp[0] - p[0][1] * zp[1];

+        p[0][1] = p[0][0] * zp[1] + p[0][1] * zp[0];

         p[0][0] = a_re;

     }

     c->gain = p[order][0];

-    for(i = 0; i < order; i++){

+    for (i = 0; i < order; i++) {

         c->gain += p[i][0];

         c->cy[i] = (-p[i][0] * p[order][0] + -p[i][1] * p[order][1]) /

                    (p[order][0] * p[order][0] + p[order][1] * p[order][1]);

@@ -125,7 +126,7 @@ static av_cold int biquad_init_coeffs(void *avc, struct FFIIRFilterCoeffs *c,

     if (filt_mode != FF_FILTER_MODE_HIGHPASS &&

         filt_mode != FF_FILTER_MODE_LOWPASS) {

         av_log(avc, AV_LOG_ERROR, "Biquad filter currently only supports "

-               "high-pass and low-pass filter modes\n");

+                                  "high-pass and low-pass filter modes\n");

         return -1;

     }

     if (order != 2) {

@@ -158,11 +159,11 @@ static av_cold int biquad_init_coeffs(void *avc, struct FFIIRFilterCoeffs *c,

     return 0;

 }

-av_cold struct FFIIRFilterCoeffs* ff_iir_filter_init_coeffs(void *avc,

-                                                enum IIRFilterType filt_type,

-                                                enum IIRFilterMode filt_mode,

-                                                int order, float cutoff_ratio,

-                                                float stopband, float ripple)

+av_cold struct FFIIRFilterCoeffs *ff_iir_filter_init_coeffs(void *avc,

+                                                            enum IIRFilterType filt_type,

+                                                            enum IIRFilterMode filt_mode,

+                                                            int order, float cutoff_ratio,

+                                                            float stopband, float ripple)

 {

     FFIIRFilterCoeffs *c;

     int ret = 0;

@@ -170,12 +171,12 @@ av_cold struct FFIIRFilterCoeffs* ff_iir_filter_init_coeffs(void *avc,

     if (order <= 0 || order > MAXORDER || cutoff_ratio >= 1.0)

         return NULL;

-    FF_ALLOCZ_OR_GOTO(avc, c,     sizeof(FFIIRFilterCoeffs),

-                      init_fail);

-    FF_ALLOC_OR_GOTO (avc, c->cx, sizeof(c->cx[0]) * ((order >> 1) + 1),

-                      init_fail);

-    FF_ALLOC_OR_GOTO (avc, c->cy, sizeof(c->cy[0]) * order,

+    FF_ALLOCZ_OR_GOTO(avc, c, sizeof(FFIIRFilterCoeffs),

                       init_fail);

+    FF_ALLOC_OR_GOTO(avc, c->cx, sizeof(c->cx[0]) * ((order >> 1) + 1),

+                     init_fail);

+    FF_ALLOC_OR_GOTO(avc, c->cy, sizeof(c->cy[0]) * order,

+                     init_fail);

     c->order = order;

     switch (filt_type) {

@@ -200,9 +201,9 @@ init_fail:

     return NULL;

 }

-av_cold struct FFIIRFilterState* ff_iir_filter_init_state(int order)

+av_cold struct FFIIRFilterState *ff_iir_filter_init_state(int order)

 {

-    FFIIRFilterState* s = av_mallocz(sizeof(FFIIRFilterState) + sizeof(s->x[0]) * (order - 1));

+    FFIIRFilterState *s = av_mallocz(sizeof(FFIIRFilterState) + sizeof(s->x[0]) * (order - 1));

     return s;

 }

@@ -210,17 +211,19 @@ av_cold struct FFIIRFilterState* ff_iir_filter_init_state(int order)

 #define CONV_FLT(dest, source) dest = source;

-#define FILTER_BW_O4_1(i0, i1, i2, i3, fmt)         \

-    in = *src0 * c->gain                            \

-         + c->cy[0]*s->x[i0] + c->cy[1]*s->x[i1]    \

-         + c->cy[2]*s->x[i2] + c->cy[3]*s->x[i3];   \

-    res =  (s->x[i0] + in      )*1                  \

-         + (s->x[i1] + s->x[i3])*4                  \

-         +  s->x[i2]            *6;                 \

-    CONV_##fmt(*dst0, res)                          \

-    s->x[i0] = in;                                  \

-    src0 += sstep;                                  \

-    dst0 += dstep;

+#define FILTER_BW_O4_1(i0, i1, i2, i3, fmt)             \

+    in = *src0    * c->gain  +                          \

+         c->cy[0] * s->x[i0] +                          \

+         c->cy[1] * s->x[i1] +                          \

+         c->cy[2] * s->x[i2] +                          \

+         c->cy[3] * s->x[i3];                           \

+    res = (s->x[i0] + in)       * 1 +                   \

+          (s->x[i1] + s->x[i3]) * 4 +                   \

+           s->x[i2]             * 6;                    \

+    CONV_ ## fmt(*dst0, res)                            \

+    s->x[i0] = in;                                      \

+    src0    += sstep;                                   \

+    dst0    += dstep;

 #define FILTER_BW_O4(type, fmt) {           \

     int i;                                  \

@@ -243,17 +246,17 @@ av_cold struct FFIIRFilterState* ff_iir_filter_init_state(int order)

         int j;                                                              \

         float in, res;                                                      \

         in = *src0 * c->gain;                                               \

-        for(j = 0; j < c->order; j++)                                       \

+        for (j = 0; j < c->order; j++)                                      \

             in += c->cy[j] * s->x[j];                                       \

         res = s->x[0] + in + s->x[c->order >> 1] * c->cx[c->order >> 1];    \

-        for(j = 1; j < c->order >> 1; j++)                                  \

+        for (j = 1; j < c->order >> 1; j++)                                 \

             res += (s->x[j] + s->x[c->order - j]) * c->cx[j];               \

-        for(j = 0; j < c->order - 1; j++)                                   \

+        for (j = 0; j < c->order - 1; j++)                                  \

             s->x[j] = s->x[j + 1];                                          \

-        CONV_##fmt(*dst0, res)                                              \

+        CONV_ ## fmt(*dst0, res)                                            \

         s->x[c->order - 1] = in;                                            \

-        src0 += sstep;                                                      \

-        dst0 += dstep;                                                      \

+        src0              += sstep;                                         \

+        dst0              += dstep;                                         \

     }                                                                       \

 }

@@ -265,11 +268,11 @@ av_cold struct FFIIRFilterState* ff_iir_filter_init_state(int order)

         float in = *src0   * c->gain  +                                     \

                    s->x[0] * c->cy[0] +                                     \

                    s->x[1] * c->cy[1];                                      \

-        CONV_##fmt(*dst0, s->x[0] + in + s->x[1] * c->cx[1])                \

+        CONV_ ## fmt(*dst0, s->x[0] + in + s->x[1] * c->cx[1])              \

         s->x[0] = s->x[1];                                                  \

         s->x[1] = in;                                                       \

-        src0 += sstep;                                                      \

-        dst0 += dstep;                                                      \

+        src0   += sstep;                                                    \

+        dst0   += dstep;                                                    \

     }                                                                       \

 }

@@ -306,7 +309,7 @@ av_cold void ff_iir_filter_free_state(struct FFIIRFilterState *state)

 av_cold void ff_iir_filter_free_coeffs(struct FFIIRFilterCoeffs *coeffs)

 {

-    if(coeffs){

+    if (coeffs) {

         av_free(coeffs->cx);

         av_free(coeffs->cy);

     }

@@ -331,9 +334,8 @@ int main(void)

                                         cutoff_coeff, 0.0, 0.0);

     fstate  = ff_iir_filter_init_state(FILT_ORDER);

-    for (i = 0; i < SIZE; i++) {

-        x[i] = lrint(0.75 * INT16_MAX * sin(0.5*M_PI*i*i/SIZE));

-    }

+    for (i = 0; i < SIZE; i++)

+        x[i] = lrint(0.75 * INT16_MAX * sin(0.5 * M_PI * i * i / SIZE));

     ff_iir_filter(fcoeffs, fstate, SIZE, x, 1, y, 1);

@@ -55,7 +55,7 @@ av_cold void ff_init_range_decoder(RangeCoder *c, const uint8_t *buf,

     /* cast to avoid compiler warning */

     ff_init_range_encoder(c, (uint8_t *)buf, buf_size);

-    c->low = AV_RB16(c->bytestream);

+    c->low         = AV_RB16(c->bytestream);

     c->bytestream += 2;

 }

@@ -21,9 +21,9 @@

  */

 #include "common.h"

-#include "aes.h"

 #include "intreadwrite.h"

 #include "timer.h"

+#include "aes.h"

 typedef union {

     uint64_t u64[2];

@@ -46,7 +46,7 @@ struct AVAES *av_aes_alloc(void)

 }

 static const uint8_t rcon[10] = {

-  0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80, 0x1b, 0x36

+    0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80, 0x1b, 0x36

 };

 static uint8_t     sbox[256];

@@ -109,7 +109,8 @@ static void subshift(av_aes_block s0[2], int s, const uint8_t *box)

     s3[0].u8[ 5] = box[s3[1].u8[ 1]];

 }

-static inline int mix_core(uint32_t multbl[][256], int a, int b, int c, int d){

+static inline int mix_core(uint32_t multbl[][256], int a, int b, int c, int d)

+{

 #if CONFIG_SMALL

     return multbl[0][a] ^ ROT(multbl[0][b], 8) ^ ROT(multbl[0][c], 16) ^ ROT(multbl[0][d], 24);

 #else

@@ -117,12 +118,13 @@ static inline int mix_core(uint32_t multbl[][256], int a, int b, int c, int d){

 #endif

 }

-static inline void mix(av_aes_block state[2], uint32_t multbl[][256], int s1, int s3){

+static inline void mix(av_aes_block state[2], uint32_t multbl[][256], int s1, int s3)

+{

     uint8_t (*src)[4] = state[1].u8x4;

-    state[0].u32[0] = mix_core(multbl, src[0][0], src[s1  ][1], src[2][2], src[s3  ][3]);

-    state[0].u32[1] = mix_core(multbl, src[1][0], src[s3-1][1], src[3][2], src[s1-1][3]);

-    state[0].u32[2] = mix_core(multbl, src[2][0], src[s3  ][1], src[0][2], src[s1  ][3]);

-    state[0].u32[3] = mix_core(multbl, src[3][0], src[s1-1][1], src[1][2], src[s3-1][3]);

+    state[0].u32[0] = mix_core(multbl, src[0][0], src[s1    ][1], src[2][2], src[s3    ][3]);

+    state[0].u32[1] = mix_core(multbl, src[1][0], src[s3 - 1][1], src[3][2], src[s1 - 1][3]);

+    state[0].u32[2] = mix_core(multbl, src[2][0], src[s3    ][1], src[0][2], src[s1    ][3]);

+    state[0].u32[3] = mix_core(multbl, src[3][0], src[s1 - 1][1], src[1][2], src[s3 - 1][3]);

 }

 static inline void crypt(AVAES *a, int s, const uint8_t *sbox,

@@ -178,7 +180,7 @@ static void init_multbl2(uint32_t tbl[][256], const int c[4],

             l = alog8[x + log8[c[1]]];

             m = alog8[x + log8[c[2]]];

             n = alog8[x + log8[c[3]]];

-            tbl[0][i] = AV_NE(MKBETAG(k,l,m,n), MKTAG(k,l,m,n));

+            tbl[0][i] = AV_NE(MKBETAG(k, l, m, n), MKTAG(k, l, m, n));

 #if !CONFIG_SMALL

             tbl[1][i] = ROT(tbl[0][i], 8);

             tbl[2][i] = ROT(tbl[0][i], 16);

@@ -198,7 +200,7 @@ int av_aes_init(AVAES *a, const uint8_t *key, int key_bits, int decrypt)

     uint8_t log8[256];

     uint8_t alog8[512];

-    if (!enc_multbl[FF_ARRAY_ELEMS(enc_multbl)-1][FF_ARRAY_ELEMS(enc_multbl[0])-1]) {

+    if (!enc_multbl[FF_ARRAY_ELEMS(enc_multbl) - 1][FF_ARRAY_ELEMS(enc_multbl[0]) - 1]) {

         j = 1;

         for (i = 0; i < 255; i++) {

             alog8[i] = alog8[i + 255] = j;

@@ -212,7 +214,7 @@ int av_aes_init(AVAES *a, const uint8_t *key, int key_bits, int decrypt)

             j ^= (j << 1) ^ (j << 2) ^ (j << 3) ^ (j << 4);

             j = (j ^ (j >> 8) ^ 99) & 255;

             inv_sbox[j] = i;

-            sbox[i] = j;

+            sbox[i]     = j;

         }

         init_multbl2(dec_multbl, (const int[4]) { 0xe, 0x9, 0xd, 0xb },

                      log8, alog8, inv_sbox);

@@ -254,9 +256,8 @@ int av_aes_init(AVAES *a, const uint8_t *key, int key_bits, int decrypt)

             a->round_key[i] = tmp[0];

         }

     } else {

-        for (i = 0; i < (rounds + 1) >> 1; i++) {

-            FFSWAP(av_aes_block, a->round_key[i], a->round_key[rounds-i]);

-        }

+        for (i = 0; i < (rounds + 1) >> 1; i++)

+            FFSWAP(av_aes_block, a->round_key[i], a->round_key[rounds - i]);

     }

     return 0;

@@ -264,6 +265,7 @@ int av_aes_init(AVAES *a, const uint8_t *key, int key_bits, int decrypt)

 #ifdef TEST

 #include <string.h>

+

 #include "lfg.h"

 #include "log.h"

@@ -276,12 +278,12 @@ int main(int argc, char **argv)

         { 0x10, 0xa5, 0x88, 0x69, 0xd7, 0x4b, 0xe5, 0xa3,

           0x74, 0xcf, 0x86, 0x7c, 0xfb, 0x47, 0x38, 0x59 }

     };

-    uint8_t pt[16], rpt[2][16]= {

+    uint8_t pt[16], rpt[2][16] = {

         { 0x6a, 0x84, 0x86, 0x7c, 0xd7, 0x7e, 0x12, 0xad,

           0x07, 0xea, 0x1b, 0xe8, 0x95, 0xc5, 0x3f, 0xa3 },

         { 0 }

     };

-    uint8_t rct[2][16]= {

+    uint8_t rct[2][16] = {

         { 0x73, 0x22, 0x81, 0xc0, 0xa0, 0xaa, 0xb8, 0xf7,

           0xa5, 0x4a, 0x0c, 0x67, 0xa0, 0xc4, 0x5e, 0xcf },

         { 0x6d, 0x25, 0x1e, 0x69, 0x44, 0xb0, 0x51, 0xe0,

@@ -313,9 +315,8 @@ int main(int argc, char **argv)

         av_lfg_init(&prng, 1);

         for (i = 0; i < 10000; i++) {

-            for (j = 0; j < 16; j++) {

+            for (j = 0; j < 16; j++)

                 pt[j] = av_lfg_get(&prng);

-            }

             {

                 START_TIMER;

                 av_aes_crypt(&ae, temp, pt, 1, NULL, 0);

@@ -19,8 +19,9 @@

  */

 #include "config.h"

-#include "common.h"

+

 #include "bswap.h"

+#include "common.h"

 #include "crc.h"

 #if CONFIG_HARDCODED_TABLES

@@ -287,7 +288,7 @@ int av_crc_init(AVCRC *ctx, int le, int bits, uint32_t poly, int ctx_size)

     if (ctx_size >= sizeof(AVCRC) * 1024)

         for (i = 0; i < 256; i++)

             for (j = 0; j < 3; j++)

-                ctx[256 *(j + 1) + i] =

+                ctx[256 * (j + 1) + i] =

                     (ctx[256 * j + i] >> 8) ^ ctx[ctx[256 * j + i] & 0xFF];

 #endif

@@ -338,11 +339,12 @@ int main(void)

 {

     uint8_t buf[1999];

     int i;

-    int p[5][3] = { { AV_CRC_32_IEEE_LE, 0xEDB88320, 0x3D5CDD04 },

-                    { AV_CRC_32_IEEE   , 0x04C11DB7, 0xC0F5BAE0 },

-                    { AV_CRC_16_ANSI_LE, 0xA001    , 0xBFD8     },

-                    { AV_CRC_16_ANSI   , 0x8005    , 0x1FBB     },

-                    { AV_CRC_8_ATM     , 0x07      , 0xE3       }

+    int p[5][3] = {

+        { AV_CRC_32_IEEE_LE, 0xEDB88320, 0x3D5CDD04 },

+        { AV_CRC_32_IEEE,    0x04C11DB7, 0xC0F5BAE0 },

+        { AV_CRC_16_ANSI_LE,     0xA001,     0xBFD8 },

+        { AV_CRC_16_ANSI,        0x8005,     0x1FBB },

+        { AV_CRC_8_ATM,            0x07,       0xE3 }

     };

     const AVCRC *ctx;

@@ -34,7 +34,7 @@ struct AVDES {

 };

 #endif

-#define T(a, b, c, d, e, f, g, h) 64-a,64-b,64-c,64-d,64-e,64-f,64-g,64-h

+#define T(a, b, c, d, e, f, g, h) 64 - a, 64 - b, 64 - c, 64 - d, 64 - e, 64 - f, 64 - g, 64 - h

 static const uint8_t IP_shuffle[] = {

     T(58, 50, 42, 34, 26, 18, 10, 2),

     T(60, 52, 44, 36, 28, 20, 12, 4),

@@ -48,7 +48,7 @@ static const uint8_t IP_shuffle[] = {

 #undef T

 #if CONFIG_SMALL || defined(GENTABLES)

-#define T(a, b, c, d) 32-a,32-b,32-c,32-d

+#define T(a, b, c, d) 32 - a, 32 - b, 32 - c, 32 - d

 static const uint8_t P_shuffle[] = {

     T(16,  7, 20, 21),

     T(29, 12, 28, 17),

@@ -62,7 +62,7 @@ static const uint8_t P_shuffle[] = {

 #undef T

 #endif

-#define T(a, b, c, d, e, f, g) 64-a,64-b,64-c,64-d,64-e,64-f,64-g

+#define T(a, b, c, d, e, f, g) 64 - a, 64 - b, 64 - c, 64 - d, 64 - e, 64 - f, 64 - g

 static const uint8_t PC1_shuffle[] = {

     T(57, 49, 41, 33, 25, 17,  9),

     T( 1, 58, 50, 42, 34, 26, 18),

@@ -75,7 +75,7 @@ static const uint8_t PC1_shuffle[] = {

 };

 #undef T

-#define T(a, b, c, d, e, f) 56-a,56-b,56-c,56-d,56-e,56-f

+#define T(a, b, c, d, e, f) 56 - a, 56 - b, 56 - c, 56 - d, 56 - e, 56 - f

 static const uint8_t PC2_shuffle[] = {

     T(14, 17, 11, 24,  1,  5),

     T( 3, 28, 15,  6, 21, 10),

@@ -90,30 +90,22 @@ static const uint8_t PC2_shuffle[] = {

 #if CONFIG_SMALL

 static const uint8_t S_boxes[8][32] = {

-    {

-    0x0e, 0xf4, 0x7d, 0x41, 0xe2, 0x2f, 0xdb, 0x18, 0xa3, 0x6a, 0xc6, 0xbc, 0x95, 0x59, 0x30, 0x87,

-    0xf4, 0xc1, 0x8e, 0x28, 0x4d, 0x96, 0x12, 0x7b, 0x5f, 0xbc, 0x39, 0xe7, 0xa3, 0x0a, 0x65, 0xd0,

-    }, {

-    0x3f, 0xd1, 0x48, 0x7e, 0xf6, 0x2b, 0x83, 0xe4, 0xc9, 0x07, 0x12, 0xad, 0x6c, 0x90, 0xb5, 0x5a,

-    0xd0, 0x8e, 0xa7, 0x1b, 0x3a, 0xf4, 0x4d, 0x21, 0xb5, 0x68, 0x7c, 0xc6, 0x09, 0x53, 0xe2, 0x9f,

-    }, {

-    0xda, 0x70, 0x09, 0x9e, 0x36, 0x43, 0x6f, 0xa5, 0x21, 0x8d, 0x5c, 0xe7, 0xcb, 0xb4, 0xf2, 0x18,

-    0x1d, 0xa6, 0xd4, 0x09, 0x68, 0x9f, 0x83, 0x70, 0x4b, 0xf1, 0xe2, 0x3c, 0xb5, 0x5a, 0x2e, 0xc7,

-    }, {

-    0xd7, 0x8d, 0xbe, 0x53, 0x60, 0xf6, 0x09, 0x3a, 0x41, 0x72, 0x28, 0xc5, 0x1b, 0xac, 0xe4, 0x9f,

-    0x3a, 0xf6, 0x09, 0x60, 0xac, 0x1b, 0xd7, 0x8d, 0x9f, 0x41, 0x53, 0xbe, 0xc5, 0x72, 0x28, 0xe4,

-    }, {

-    0xe2, 0xbc, 0x24, 0xc1, 0x47, 0x7a, 0xdb, 0x16, 0x58, 0x05, 0xf3, 0xaf, 0x3d, 0x90, 0x8e, 0x69,

-    0xb4, 0x82, 0xc1, 0x7b, 0x1a, 0xed, 0x27, 0xd8, 0x6f, 0xf9, 0x0c, 0x95, 0xa6, 0x43, 0x50, 0x3e,

-    }, {

-    0xac, 0xf1, 0x4a, 0x2f, 0x79, 0xc2, 0x96, 0x58, 0x60, 0x1d, 0xd3, 0xe4, 0x0e, 0xb7, 0x35, 0x8b,

-    0x49, 0x3e, 0x2f, 0xc5, 0x92, 0x58, 0xfc, 0xa3, 0xb7, 0xe0, 0x14, 0x7a, 0x61, 0x0d, 0x8b, 0xd6,

-    }, {

-    0xd4, 0x0b, 0xb2, 0x7e, 0x4f, 0x90, 0x18, 0xad, 0xe3, 0x3c, 0x59, 0xc7, 0x25, 0xfa, 0x86, 0x61,

-    0x61, 0xb4, 0xdb, 0x8d, 0x1c, 0x43, 0xa7, 0x7e, 0x9a, 0x5f, 0x06, 0xf8, 0xe0, 0x25, 0x39, 0xc2,

-    }, {

-    0x1d, 0xf2, 0xd8, 0x84, 0xa6, 0x3f, 0x7b, 0x41, 0xca, 0x59, 0x63, 0xbe, 0x05, 0xe0, 0x9c, 0x27,

-    0x27, 0x1b, 0xe4, 0x71, 0x49, 0xac, 0x8e, 0xd2, 0xf0, 0xc6, 0x9a, 0x0d, 0x3f, 0x53, 0x65, 0xb8,

+    { 0x0e, 0xf4, 0x7d, 0x41, 0xe2, 0x2f, 0xdb, 0x18, 0xa3, 0x6a, 0xc6, 0xbc, 0x95, 0x59, 0x30, 0x87,

+      0xf4, 0xc1, 0x8e, 0x28, 0x4d, 0x96, 0x12, 0x7b, 0x5f, 0xbc, 0x39, 0xe7, 0xa3, 0x0a, 0x65, 0xd0, },

+    { 0x3f, 0xd1, 0x48, 0x7e, 0xf6, 0x2b, 0x83, 0xe4, 0xc9, 0x07, 0x12, 0xad, 0x6c, 0x90, 0xb5, 0x5a,

+      0xd0, 0x8e, 0xa7, 0x1b, 0x3a, 0xf4, 0x4d, 0x21, 0xb5, 0x68, 0x7c, 0xc6, 0x09, 0x53, 0xe2, 0x9f, },

+    { 0xda, 0x70, 0x09, 0x9e, 0x36, 0x43, 0x6f, 0xa5, 0x21, 0x8d, 0x5c, 0xe7, 0xcb, 0xb4, 0xf2, 0x18,

+      0x1d, 0xa6, 0xd4, 0x09, 0x68, 0x9f, 0x83, 0x70, 0x4b, 0xf1, 0xe2, 0x3c, 0xb5, 0x5a, 0x2e, 0xc7, },

+    { 0xd7, 0x8d, 0xbe, 0x53, 0x60, 0xf6, 0x09, 0x3a, 0x41, 0x72, 0x28, 0xc5, 0x1b, 0xac, 0xe4, 0x9f,

+      0x3a, 0xf6, 0x09, 0x60, 0xac, 0x1b, 0xd7, 0x8d, 0x9f, 0x41, 0x53, 0xbe, 0xc5, 0x72, 0x28, 0xe4, },

+    { 0xe2, 0xbc, 0x24, 0xc1, 0x47, 0x7a, 0xdb, 0x16, 0x58, 0x05, 0xf3, 0xaf, 0x3d, 0x90, 0x8e, 0x69,

+      0xb4, 0x82, 0xc1, 0x7b, 0x1a, 0xed, 0x27, 0xd8, 0x6f, 0xf9, 0x0c, 0x95, 0xa6, 0x43, 0x50, 0x3e, },

+    { 0xac, 0xf1, 0x4a, 0x2f, 0x79, 0xc2, 0x96, 0x58, 0x60, 0x1d, 0xd3, 0xe4, 0x0e, 0xb7, 0x35, 0x8b,

+      0x49, 0x3e, 0x2f, 0xc5, 0x92, 0x58, 0xfc, 0xa3, 0xb7, 0xe0, 0x14, 0x7a, 0x61, 0x0d, 0x8b, 0xd6, },

+    { 0xd4, 0x0b, 0xb2, 0x7e, 0x4f, 0x90, 0x18, 0xad, 0xe3, 0x3c, 0x59, 0xc7, 0x25, 0xfa, 0x86, 0x61,

+      0x61, 0xb4, 0xdb, 0x8d, 0x1c, 0x43, 0xa7, 0x7e, 0x9a, 0x5f, 0x06, 0xf8, 0xe0, 0x25, 0x39, 0xc2, },

+    { 0x1d, 0xf2, 0xd8, 0x84, 0xa6, 0x3f, 0x7b, 0x41, 0xca, 0x59, 0x63, 0xbe, 0x05, 0xe0, 0x9c, 0x27,

+      0x27, 0x1b, 0xe4, 0x71, 0x49, 0xac, 0x8e, 0xd2, 0xf0, 0xc6, 0x9a, 0x0d, 0x3f, 0x53, 0x65, 0xb8,

     }

 };

 #else

@@ -122,90 +114,75 @@ static const uint8_t S_boxes[8][32] = {

  * It can be regenerated by compiling this file with -DCONFIG_SMALL -DTEST -DGENTABLES

  */

 static const uint32_t S_boxes_P_shuffle[8][64] = {

-    {

-    0x00808200, 0x00000000, 0x00008000, 0x00808202, 0x00808002, 0x00008202, 0x00000002, 0x00008000,

-    0x00000200, 0x00808200, 0x00808202, 0x00000200, 0x00800202, 0x00808002, 0x00800000, 0x00000002,

-    0x00000202, 0x00800200, 0x00800200, 0x00008200, 0x00008200, 0x00808000, 0x00808000, 0x00800202,

-    0x00008002, 0x00800002, 0x00800002, 0x00008002, 0x00000000, 0x00000202, 0x00008202, 0x00800000,

-    0x00008000, 0x00808202, 0x00000002, 0x00808000, 0x00808200, 0x00800000, 0x00800000, 0x00000200,

-    0x00808002, 0x00008000, 0x00008200, 0x00800002, 0x00000200, 0x00000002, 0x00800202, 0x00008202,

-    0x00808202, 0x00008002, 0x00808000, 0x00800202, 0x00800002, 0x00000202, 0x00008202, 0x00808200,

-    0x00000202, 0x00800200, 0x00800200, 0x00000000, 0x00008002, 0x00008200, 0x00000000, 0x00808002,

-    },

-    {

-    0x40084010, 0x40004000, 0x00004000, 0x00084010, 0x00080000, 0x00000010, 0x40080010, 0x40004010,

-    0x40000010, 0x40084010, 0x40084000, 0x40000000, 0x40004000, 0x00080000, 0x00000010, 0x40080010,

-    0x00084000, 0x00080010, 0x40004010, 0x00000000, 0x40000000, 0x00004000, 0x00084010, 0x40080000,

-    0x00080010, 0x40000010, 0x00000000, 0x00084000, 0x00004010, 0x40084000, 0x40080000, 0x00004010,

-    0x00000000, 0x00084010, 0x40080010, 0x00080000, 0x40004010, 0x40080000, 0x40084000, 0x00004000,

-    0x40080000, 0x40004000, 0x00000010, 0x40084010, 0x00084010, 0x00000010, 0x00004000, 0x40000000,

-    0x00004010, 0x40084000, 0x00080000, 0x40000010, 0x00080010, 0x40004010, 0x40000010, 0x00080010,

-    0x00084000, 0x00000000, 0x40004000, 0x00004010, 0x40000000, 0x40080010, 0x40084010, 0x00084000,

-    },

-    {

-    0x00000104, 0x04010100, 0x00000000, 0x04010004, 0x04000100, 0x00000000, 0x00010104, 0x04000100,

-    0x00010004, 0x04000004, 0x04000004, 0x00010000, 0x04010104, 0x00010004, 0x04010000, 0x00000104,

-    0x04000000, 0x00000004, 0x04010100, 0x00000100, 0x00010100, 0x04010000, 0x04010004, 0x00010104,

-    0x04000104, 0x00010100, 0x00010000, 0x04000104, 0x00000004, 0x04010104, 0x00000100, 0x04000000,

-    0x04010100, 0x04000000, 0x00010004, 0x00000104, 0x00010000, 0x04010100, 0x04000100, 0x00000000,

-    0x00000100, 0x00010004, 0x04010104, 0x04000100, 0x04000004, 0x00000100, 0x00000000, 0x04010004,

-    0x04000104, 0x00010000, 0x04000000, 0x04010104, 0x00000004, 0x00010104, 0x00010100, 0x04000004,

-    0x04010000, 0x04000104, 0x00000104, 0x04010000, 0x00010104, 0x00000004, 0x04010004, 0x00010100,

-    },

-    {

-    0x80401000, 0x80001040, 0x80001040, 0x00000040, 0x00401040, 0x80400040, 0x80400000, 0x80001000,

-    0x00000000, 0x00401000, 0x00401000, 0x80401040, 0x80000040, 0x00000000, 0x00400040, 0x80400000,

-    0x80000000, 0x00001000, 0x00400000, 0x80401000, 0x00000040, 0x00400000, 0x80001000, 0x00001040,

-    0x80400040, 0x80000000, 0x00001040, 0x00400040, 0x00001000, 0x00401040, 0x80401040, 0x80000040,

-    0x00400040, 0x80400000, 0x00401000, 0x80401040, 0x80000040, 0x00000000, 0x00000000, 0x00401000,

-    0x00001040, 0x00400040, 0x80400040, 0x80000000, 0x80401000, 0x80001040, 0x80001040, 0x00000040,

-    0x80401040, 0x80000040, 0x80000000, 0x00001000, 0x80400000, 0x80001000, 0x00401040, 0x80400040,

-    0x80001000, 0x00001040, 0x00400000, 0x80401000, 0x00000040, 0x00400000, 0x00001000, 0x00401040,

-    },

-    {

-    0x00000080, 0x01040080, 0x01040000, 0x21000080, 0x00040000, 0x00000080, 0x20000000, 0x01040000,

-    0x20040080, 0x00040000, 0x01000080, 0x20040080, 0x21000080, 0x21040000, 0x00040080, 0x20000000,

-    0x01000000, 0x20040000, 0x20040000, 0x00000000, 0x20000080, 0x21040080, 0x21040080, 0x01000080,

-    0x21040000, 0x20000080, 0x00000000, 0x21000000, 0x01040080, 0x01000000, 0x21000000, 0x00040080,

-    0x00040000, 0x21000080, 0x00000080, 0x01000000, 0x20000000, 0x01040000, 0x21000080, 0x20040080,

-    0x01000080, 0x20000000, 0x21040000, 0x01040080, 0x20040080, 0x00000080, 0x01000000, 0x21040000,

-    0x21040080, 0x00040080, 0x21000000, 0x21040080, 0x01040000, 0x00000000, 0x20040000, 0x21000000,

-    0x00040080, 0x01000080, 0x20000080, 0x00040000, 0x00000000, 0x20040000, 0x01040080, 0x20000080,

-    },

-    {

-    0x10000008, 0x10200000, 0x00002000, 0x10202008, 0x10200000, 0x00000008, 0x10202008, 0x00200000,

-    0x10002000, 0x00202008, 0x00200000, 0x10000008, 0x00200008, 0x10002000, 0x10000000, 0x00002008,

-    0x00000000, 0x00200008, 0x10002008, 0x00002000, 0x00202000, 0x10002008, 0x00000008, 0x10200008,

-    0x10200008, 0x00000000, 0x00202008, 0x10202000, 0x00002008, 0x00202000, 0x10202000, 0x10000000,

-    0x10002000, 0x00000008, 0x10200008, 0x00202000, 0x10202008, 0x00200000, 0x00002008, 0x10000008,

-    0x00200000, 0x10002000, 0x10000000, 0x00002008, 0x10000008, 0x10202008, 0x00202000, 0x10200000,

-    0x00202008, 0x10202000, 0x00000000, 0x10200008, 0x00000008, 0x00002000, 0x10200000, 0x00202008,

-    0x00002000, 0x00200008, 0x10002008, 0x00000000, 0x10202000, 0x10000000, 0x00200008, 0x10002008,

-    },

-    {

-    0x00100000, 0x02100001, 0x02000401, 0x00000000, 0x00000400, 0x02000401, 0x00100401, 0x02100400,

-    0x02100401, 0x00100000, 0x00000000, 0x02000001, 0x00000001, 0x02000000, 0x02100001, 0x00000401,

-    0x02000400, 0x00100401, 0x00100001, 0x02000400, 0x02000001, 0x02100000, 0x02100400, 0x00100001,

-    0x02100000, 0x00000400, 0x00000401, 0x02100401, 0x00100400, 0x00000001, 0x02000000, 0x00100400,

-    0x02000000, 0x00100400, 0x00100000, 0x02000401, 0x02000401, 0x02100001, 0x02100001, 0x00000001,

-    0x00100001, 0x02000000, 0x02000400, 0x00100000, 0x02100400, 0x00000401, 0x00100401, 0x02100400,

-    0x00000401, 0x02000001, 0x02100401, 0x02100000, 0x00100400, 0x00000000, 0x00000001, 0x02100401,

-    0x00000000, 0x00100401, 0x02100000, 0x00000400, 0x02000001, 0x02000400, 0x00000400, 0x00100001,

-    },

-    {

-    0x08000820, 0x00000800, 0x00020000, 0x08020820, 0x08000000, 0x08000820, 0x00000020, 0x08000000,

-    0x00020020, 0x08020000, 0x08020820, 0x00020800, 0x08020800, 0x00020820, 0x00000800, 0x00000020,

-    0x08020000, 0x08000020, 0x08000800, 0x00000820, 0x00020800, 0x00020020, 0x08020020, 0x08020800,

-    0x00000820, 0x00000000, 0x00000000, 0x08020020, 0x08000020, 0x08000800, 0x00020820, 0x00020000,

-    0x00020820, 0x00020000, 0x08020800, 0x00000800, 0x00000020, 0x08020020, 0x00000800, 0x00020820,

-    0x08000800, 0x00000020, 0x08000020, 0x08020000, 0x08020020, 0x08000000, 0x00020000, 0x08000820,

-    0x00000000, 0x08020820, 0x00020020, 0x08000020, 0x08020000, 0x08000800, 0x08000820, 0x00000000,

-    0x08020820, 0x00020800, 0x00020800, 0x00000820, 0x00000820, 0x00020020, 0x08000000, 0x08020800,

-    },

+    { 0x00808200, 0x00000000, 0x00008000, 0x00808202, 0x00808002, 0x00008202, 0x00000002, 0x00008000,

+      0x00000200, 0x00808200, 0x00808202, 0x00000200, 0x00800202, 0x00808002, 0x00800000, 0x00000002,

+      0x00000202, 0x00800200, 0x00800200, 0x00008200, 0x00008200, 0x00808000, 0x00808000, 0x00800202,

+      0x00008002, 0x00800002, 0x00800002, 0x00008002, 0x00000000, 0x00000202, 0x00008202, 0x00800000,

+      0x00008000, 0x00808202, 0x00000002, 0x00808000, 0x00808200, 0x00800000, 0x00800000, 0x00000200,

+      0x00808002, 0x00008000, 0x00008200, 0x00800002, 0x00000200, 0x00000002, 0x00800202, 0x00008202,

+      0x00808202, 0x00008002, 0x00808000, 0x00800202, 0x00800002, 0x00000202, 0x00008202, 0x00808200,

+      0x00000202, 0x00800200, 0x00800200, 0x00000000, 0x00008002, 0x00008200, 0x00000000, 0x00808002, },

+    { 0x40084010, 0x40004000, 0x00004000, 0x00084010, 0x00080000, 0x00000010, 0x40080010, 0x40004010,

+      0x40000010, 0x40084010, 0x40084000, 0x40000000, 0x40004000, 0x00080000, 0x00000010, 0x40080010,

+      0x00084000, 0x00080010, 0x40004010, 0x00000000, 0x40000000, 0x00004000, 0x00084010, 0x40080000,

+      0x00080010, 0x40000010, 0x00000000, 0x00084000, 0x00004010, 0x40084000, 0x40080000, 0x00004010,

+      0x00000000, 0x00084010, 0x40080010, 0x00080000, 0x40004010, 0x40080000, 0x40084000, 0x00004000,

+      0x40080000, 0x40004000, 0x00000010, 0x40084010, 0x00084010, 0x00000010, 0x00004000, 0x40000000,

+      0x00004010, 0x40084000, 0x00080000, 0x40000010, 0x00080010, 0x40004010, 0x40000010, 0x00080010,

+      0x00084000, 0x00000000, 0x40004000, 0x00004010, 0x40000000, 0x40080010, 0x40084010, 0x00084000, },

+    { 0x00000104, 0x04010100, 0x00000000, 0x04010004, 0x04000100, 0x00000000, 0x00010104, 0x04000100,

+      0x00010004, 0x04000004, 0x04000004, 0x00010000, 0x04010104, 0x00010004, 0x04010000, 0x00000104,

+      0x04000000, 0x00000004, 0x04010100, 0x00000100, 0x00010100, 0x04010000, 0x04010004, 0x00010104,

+      0x04000104, 0x00010100, 0x00010000, 0x04000104, 0x00000004, 0x04010104, 0x00000100, 0x04000000,

+      0x04010100, 0x04000000, 0x00010004, 0x00000104, 0x00010000, 0x04010100, 0x04000100, 0x00000000,

+      0x00000100, 0x00010004, 0x04010104, 0x04000100, 0x04000004, 0x00000100, 0x00000000, 0x04010004,

+      0x04000104, 0x00010000, 0x04000000, 0x04010104, 0x00000004, 0x00010104, 0x00010100, 0x04000004,

+      0x04010000, 0x04000104, 0x00000104, 0x04010000, 0x00010104, 0x00000004, 0x04010004, 0x00010100, },

+    { 0x80401000, 0x80001040, 0x80001040, 0x00000040, 0x00401040, 0x80400040, 0x80400000, 0x80001000,

+      0x00000000, 0x00401000, 0x00401000, 0x80401040, 0x80000040, 0x00000000, 0x00400040, 0x80400000,

+      0x80000000, 0x00001000, 0x00400000, 0x80401000, 0x00000040, 0x00400000, 0x80001000, 0x00001040,

+      0x80400040, 0x80000000, 0x00001040, 0x00400040, 0x00001000, 0x00401040, 0x80401040, 0x80000040,

+      0x00400040, 0x80400000, 0x00401000, 0x80401040, 0x80000040, 0x00000000, 0x00000000, 0x00401000,

+      0x00001040, 0x00400040, 0x80400040, 0x80000000, 0x80401000, 0x80001040, 0x80001040, 0x00000040,

+      0x80401040, 0x80000040, 0x80000000, 0x00001000, 0x80400000, 0x80001000, 0x00401040, 0x80400040,

+      0x80001000, 0x00001040, 0x00400000, 0x80401000, 0x00000040, 0x00400000, 0x00001000, 0x00401040, },

+    { 0x00000080, 0x01040080, 0x01040000, 0x21000080, 0x00040000, 0x00000080, 0x20000000, 0x01040000,

+      0x20040080, 0x00040000, 0x01000080, 0x20040080, 0x21000080, 0x21040000, 0x00040080, 0x20000000,

+      0x01000000, 0x20040000, 0x20040000, 0x00000000, 0x20000080, 0x21040080, 0x21040080, 0x01000080,

+      0x21040000, 0x20000080, 0x00000000, 0x21000000, 0x01040080, 0x01000000, 0x21000000, 0x00040080,

+      0x00040000, 0x21000080, 0x00000080, 0x01000000, 0x20000000, 0x01040000, 0x21000080, 0x20040080,

+      0x01000080, 0x20000000, 0x21040000, 0x01040080, 0x20040080, 0x00000080, 0x01000000, 0x21040000,

+      0x21040080, 0x00040080, 0x21000000, 0x21040080, 0x01040000, 0x00000000, 0x20040000, 0x21000000,

+      0x00040080, 0x01000080, 0x20000080, 0x00040000, 0x00000000, 0x20040000, 0x01040080, 0x20000080, },

+    { 0x10000008, 0x10200000, 0x00002000, 0x10202008, 0x10200000, 0x00000008, 0x10202008, 0x00200000,

+      0x10002000, 0x00202008, 0x00200000, 0x10000008, 0x00200008, 0x10002000, 0x10000000, 0x00002008,

+      0x00000000, 0x00200008, 0x10002008, 0x00002000, 0x00202000, 0x10002008, 0x00000008, 0x10200008,

+      0x10200008, 0x00000000, 0x00202008, 0x10202000, 0x00002008, 0x00202000, 0x10202000, 0x10000000,

+      0x10002000, 0x00000008, 0x10200008, 0x00202000, 0x10202008, 0x00200000, 0x00002008, 0x10000008,

+      0x00200000, 0x10002000, 0x10000000, 0x00002008, 0x10000008, 0x10202008, 0x00202000, 0x10200000,

+      0x00202008, 0x10202000, 0x00000000, 0x10200008, 0x00000008, 0x00002000, 0x10200000, 0x00202008,

+      0x00002000, 0x00200008, 0x10002008, 0x00000000, 0x10202000, 0x10000000, 0x00200008, 0x10002008, },

+    { 0x00100000, 0x02100001, 0x02000401, 0x00000000, 0x00000400, 0x02000401, 0x00100401, 0x02100400,

+      0x02100401, 0x00100000, 0x00000000, 0x02000001, 0x00000001, 0x02000000, 0x02100001, 0x00000401,

+      0x02000400, 0x00100401, 0x00100001, 0x02000400, 0x02000001, 0x02100000, 0x02100400, 0x00100001,

+      0x02100000, 0x00000400, 0x00000401, 0x02100401, 0x00100400, 0x00000001, 0x02000000, 0x00100400,

+      0x02000000, 0x00100400, 0x00100000, 0x02000401, 0x02000401, 0x02100001, 0x02100001, 0x00000001,

+      0x00100001, 0x02000000, 0x02000400, 0x00100000, 0x02100400, 0x00000401, 0x00100401, 0x02100400,

+      0x00000401, 0x02000001, 0x02100401, 0x02100000, 0x00100400, 0x00000000, 0x00000001, 0x02100401,

+      0x00000000, 0x00100401, 0x02100000, 0x00000400, 0x02000001, 0x02000400, 0x00000400, 0x00100001, },

+    { 0x08000820, 0x00000800, 0x00020000, 0x08020820, 0x08000000, 0x08000820, 0x00000020, 0x08000000,

+      0x00020020, 0x08020000, 0x08020820, 0x00020800, 0x08020800, 0x00020820, 0x00000800, 0x00000020,

+      0x08020000, 0x08000020, 0x08000800, 0x00000820, 0x00020800, 0x00020020, 0x08020020, 0x08020800,

+      0x00000820, 0x00000000, 0x00000000, 0x08020020, 0x08000020, 0x08000800, 0x00020820, 0x00020000,

+      0x00020820, 0x00020000, 0x08020800, 0x00000800, 0x00000020, 0x08020020, 0x00000800, 0x00020820,

+      0x08000800, 0x00000020, 0x08000020, 0x08020000, 0x08020020, 0x08000000, 0x00020000, 0x08000820,

+      0x00000000, 0x08020820, 0x00020020, 0x08000020, 0x08020000, 0x08000800, 0x08000820, 0x00000000,

+      0x08020820, 0x00020800, 0x00020800, 0x00000820, 0x00000820, 0x00020020, 0x08000000, 0x08020800, },

 };

 #endif

-static uint64_t shuffle(uint64_t in, const uint8_t *shuffle, int shuffle_len) {

+static uint64_t shuffle(uint64_t in, const uint8_t *shuffle, int shuffle_len)

+{

     int i;

     uint64_t res = 0;

     for (i = 0; i < shuffle_len; i++)

@@ -213,7 +190,8 @@ static uint64_t shuffle(uint64_t in, const uint8_t *shuffle, int shuffle_len) {

     return res;

 }

-static uint64_t shuffle_inv(uint64_t in, const uint8_t *shuffle, int shuffle_len) {

+static uint64_t shuffle_inv(uint64_t in, const uint8_t *shuffle, int shuffle_len)

+{

     int i;

     uint64_t res = 0;

     shuffle += shuffle_len - 1;

@@ -224,7 +202,8 @@ static uint64_t shuffle_inv(uint64_t in, const uint8_t *shuffle, int shuffle_len

     return res;

 }

-static uint32_t f_func(uint32_t r, uint64_t k) {

+static uint32_t f_func(uint32_t r, uint64_t k)

+{

     int i;

     uint32_t out = 0;

     // rotate to get first part of E-shuffle in the lowest 6 bits

@@ -234,13 +213,14 @@ static uint32_t f_func(uint32_t r, uint64_t k) {

         uint8_t tmp = (r ^ k) & 0x3f;

 #if CONFIG_SMALL

         uint8_t v = S_boxes[i][tmp >> 1];

-        if (tmp & 1) v >>= 4;

+        if (tmp & 1)

+            v >>= 4;

         out = (out >> 4) | (v << 28);

 #else

         out |= S_boxes_P_shuffle[i][tmp];

 #endif

         // get next 6 bits of E-shuffle and round key k into the lowest bits

-        r = (r >> 4) | (r << 28);

+        r   = (r >> 4) | (r << 28);

         k >>= 6;

     }

 #if CONFIG_SMALL

@@ -255,15 +235,17 @@ static uint32_t f_func(uint32_t r, uint64_t k) {

  * Note: the specification calls this "shift", so I kept it although

  * it is confusing.

  */

-static uint64_t key_shift_left(uint64_t CDn) {

+static uint64_t key_shift_left(uint64_t CDn)

+{

     uint64_t carries = (CDn >> 27) & 0x10000001;

     CDn <<= 1;

-    CDn &= ~0x10000001;

-    CDn |= carries;

+    CDn  &= ~0x10000001;

+    CDn  |= carries;

     return CDn;

 }

-static void gen_roundkeys(uint64_t K[16], uint64_t key) {

+static void gen_roundkeys(uint64_t K[16], uint64_t key)

+{

     int i;

     // discard parity bits from key and shuffle it into C and D parts

     uint64_t CDn = shuffle(key, PC1_shuffle, sizeof(PC1_shuffle));

@@ -276,7 +258,8 @@ static void gen_roundkeys(uint64_t K[16], uint64_t key) {

     }

 }

-static uint64_t des_encdec(uint64_t in, uint64_t K[16], int decrypt) {

+static uint64_t des_encdec(uint64_t in, uint64_t K[16], int decrypt)

+{

     int i;

     // used to apply round keys in reverse order for decryption

     decrypt = decrypt ? 15 : 0;

@@ -285,8 +268,8 @@ static uint64_t des_encdec(uint64_t in, uint64_t K[16], int decrypt) {

     for (i = 0; i < 16; i++) {

         uint32_t f_res;

         f_res = f_func(in, K[decrypt ^ i]);

-        in = (in << 32) | (in >> 32);

-        in ^= f_res;

+        in    = (in << 32) | (in >> 32);

+        in   ^= f_res;

     }

     in = (in << 32) | (in >> 32);

     // reverse shuffle used to ease hardware implementations

@@ -299,7 +282,8 @@ AVDES *av_des_alloc(void)

     return av_mallocz(sizeof(struct AVDES));

 }

-int av_des_init(AVDES *d, const uint8_t *key, int key_bits, int decrypt) {

+int av_des_init(AVDES *d, const uint8_t *key, int key_bits, int decrypt)

+{

     if (key_bits != 64 && key_bits != 192)

         return -1;

     d->triple_des = key_bits > 64;

@@ -311,7 +295,9 @@ int av_des_init(AVDES *d, const uint8_t *key, int key_bits, int decrypt) {

     return 0;

 }

-static void av_des_crypt_mac(AVDES *d, uint8_t *dst, const uint8_t *src, int count, uint8_t *iv, int decrypt, int mac) {

+static void av_des_crypt_mac(AVDES *d, uint8_t *dst, const uint8_t *src,

+                             int count, uint8_t *iv, int decrypt, int mac)

+{

     uint64_t iv_val = iv ? AV_RB64(iv) : 0;

     while (count-- > 0) {

         uint64_t dst_val;

@@ -323,7 +309,7 @@ static void av_des_crypt_mac(AVDES *d, uint8_t *dst, const uint8_t *src, int cou

                 src_val = des_encdec(src_val, d->round_keys[1], 0);

             }

             dst_val = des_encdec(src_val, d->round_keys[0], 1) ^ iv_val;

-            iv_val = iv ? tmp : 0;

+            iv_val  = iv ? tmp : 0;

         } else {

             dst_val = des_encdec(src_val ^ iv_val, d->round_keys[0], 0);

             if (d->triple_des) {

@@ -341,12 +327,15 @@ static void av_des_crypt_mac(AVDES *d, uint8_t *dst, const uint8_t *src, int cou

         AV_WB64(iv, iv_val);

 }

-void av_des_crypt(AVDES *d, uint8_t *dst, const uint8_t *src, int count, uint8_t *iv, int decrypt) {

+void av_des_crypt(AVDES *d, uint8_t *dst, const uint8_t *src,

+                  int count, uint8_t *iv, int decrypt)

+{

     av_des_crypt_mac(d, dst, src, count, iv, decrypt, 0);

 }

-void av_des_mac(AVDES *d, uint8_t *dst, const uint8_t *src, int count) {

-    av_des_crypt_mac(d, dst, src, count, (uint8_t[8]){0}, 0, 1);

+void av_des_mac(AVDES *d, uint8_t *dst, const uint8_t *src, int count)

+{

+    av_des_crypt_mac(d, dst, src, count, (uint8_t[8]) { 0 }, 0, 1);

 }

 #ifdef TEST

@@ -355,15 +344,16 @@ void av_des_mac(AVDES *d, uint8_t *dst, const uint8_t *src, int count) {

 #include "time.h"

-static uint64_t rand64(void) {

+static uint64_t rand64(void)

+{

     uint64_t r = rand();

     r = (r << 32) | rand();

     return r;

 }

-static const uint8_t test_key[] = {0x12, 0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0};

-static const DECLARE_ALIGNED(8, uint8_t, plain)[] = {0xfe, 0xdc, 0xba, 0x98, 0x76, 0x54, 0x32, 0x10};

-static const DECLARE_ALIGNED(8, uint8_t, crypt)[] = {0x4a, 0xb6, 0x5b, 0x3d, 0x4b, 0x06, 0x15, 0x18};

+static const uint8_t test_key[] = { 0x12, 0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0 };

+static const DECLARE_ALIGNED(8, uint8_t, plain)[] = { 0xfe, 0xdc, 0xba, 0x98, 0x76, 0x54, 0x32, 0x10 };

+static const DECLARE_ALIGNED(8, uint8_t, crypt)[] = { 0x4a, 0xb6, 0x5b, 0x3d, 0x4b, 0x06, 0x15, 0x18 };

 static DECLARE_ALIGNED(8, uint8_t, tmp)[8];

 static DECLARE_ALIGNED(8, uint8_t, large_buffer)[10002][8];

 static const uint8_t cbc_key[] = {

@@ -372,7 +362,8 @@ static const uint8_t cbc_key[] = {

     0x45, 0x67, 0x89, 0xab, 0xcd, 0xef, 0x01, 0x23

 };

-static int run_test(int cbc, int decrypt) {

+static int run_test(int cbc, int decrypt)

+{

     AVDES d;

     int delay = cbc && !decrypt ? 2 : 1;

     uint64_t res;

@@ -395,7 +386,8 @@ static int run_test(int cbc, int decrypt) {

     }

 }

-int main(void) {

+int main(void)

+{

     AVDES d;

     int i;

     uint64_t key[3];

@@ -404,7 +396,7 @@ int main(void) {

     uint64_t roundkeys[16];

     srand(av_gettime());

     key[0] = AV_RB64(test_key);

-    data = AV_RB64(plain);

+    data   = AV_RB64(plain);

     gen_roundkeys(roundkeys, key[0]);

     if (des_encdec(data, roundkeys, 0) != AV_RB64(crypt)) {

         printf("Test 1 failed\n");

@@ -421,8 +413,10 @@ int main(void) {

         return 1;

     }

     for (i = 0; i < 1000; i++) {

-        key[0] = rand64(); key[1] = rand64(); key[2] = rand64();

-        data = rand64();

+        key[0] = rand64();

+        key[1] = rand64();

+        key[2] = rand64();

+        data   = rand64();

         av_des_init(&d, key, 192, 0);

         av_des_crypt(&d, &ct, &data, 1, NULL, 0);

         av_des_init(&d, key, 192, 1);

@@ -439,9 +433,9 @@ int main(void) {

         printf("    {");

         for (j = 0; j < 64; j++) {

             uint32_t v = S_boxes[i][j >> 1];

-            v = j & 1 ? v >> 4 : v & 0xf;

+            v   = j & 1 ? v >> 4 : v & 0xf;

             v <<= 28 - 4 * i;

-            v = shuffle(v, P_shuffle, sizeof(P_shuffle));

+            v   = shuffle(v, P_shuffle, sizeof(P_shuffle));

             printf((j & 7) == 0 ? "\n    " : " ");

             printf("0x%08X,", v);

         }

@@ -141,7 +141,7 @@ int main(void)

         LOCAL_ALIGNED(32, double, var, [4]);

         double eval;

-        var[0] = (av_lfg_get(&lfg) / (double) UINT_MAX - 0.5) * 2;

+        var[0] =         (av_lfg_get(&lfg) / (double) UINT_MAX - 0.5) * 2;

         var[1] = var[0] + av_lfg_get(&lfg) / (double) UINT_MAX - 0.5;

         var[2] = var[1] + av_lfg_get(&lfg) / (double) UINT_MAX - 0.5;

         var[3] = var[2] + av_lfg_get(&lfg) / (double) UINT_MAX - 0.5;

@@ -31,12 +31,13 @@

  */

 #include <stdint.h>

+

 #include "bswap.h"

 #include "intreadwrite.h"

-#include "md5.h"

 #include "mem.h"

+#include "md5.h"

-typedef struct AVMD5{

+typedef struct AVMD5 {

     uint64_t len;

     uint8_t  block[64];

     uint32_t ABCD[4];

@@ -76,16 +77,21 @@ static const uint32_t T[64] = { // T[i]= fabs(sin(i+1)<<32)

     0xf7537e82, 0xbd3af235, 0x2ad7d2bb, 0xeb86d391,

 };