+include $(SUBDIR)../config.mak

+

+ bprint.h \

+ cast5.h \

+ camellia.h \

+ hash.h \

+ motion_vector.h \

+ murmur3.h \

+ pixelutils.h \

+ ripemd.h \

+ sha512.h \

+ threadmessage.h \

+ timecode.h \

+ timestamp.h \

+ twofish.h \

+ tea.h \

+HEADERS-$(CONFIG_OPENCL) += opencl.h

+

+BUILT_HEADERS = avconfig.h \

+ ffversion.h

+ bprint.o \

+ cast5.o \

+ camellia.o \

+ color_utils.o \

+ fixed_dsp.o \

+ hash.o \

+ murmur3.o \

+ pixelutils.o \

+ ripemd.o \

+ sha512.o \

+ threadmessage.o \

+ timecode.o \

+ twofish.o \

+ xga_font_data.o \

+ tea.o \

+

+OBJS-$(!HAVE_ATOMICS_NATIVE) += atomic.o \

+OBJS-$(CONFIG_OPENCL) += opencl.o opencl_internal.o

+# Windows resource file

+SLIBOBJS-$(HAVE_GNU_WINDRES) += avutilres.o

+

+SKIPHEADERS-$(CONFIG_OPENCL) += opencl.h

+ bprint \

+ cast5 \

+ camellia \

+ dict \

+ error \

+ file \

+ log \

+ murmur3 \

+ pca \

+ pixdesc \

+ pixelutils \

+ random_seed \

+ rational \

+ ripemd \

+ sha512 \

+ softfloat \

+ twofish \

+ utf8 \

+ tea \

+

+TESTPROGS-$(HAVE_LZO1X_999_COMPRESS) += lzo

+

+TOOLS = crypto_bench ffhash ffeval ffescape

+

+tools/crypto_bench$(EXESUF): ELIBS += $(if $(VERSUS),$(subst +, -l,+$(VERSUS)),)

+tools/crypto_bench$(EXESUF): CFLAGS += -DUSE_EXT_LIBS=0$(if $(VERSUS),$(subst +,+USE_,+$(VERSUS)),)

+

+$(SUBDIR)lzo-test$(EXESUF): ELIBS = -llzo2

+ * This file is part of FFmpeg.

+ * FFmpeg is free software; you can redistribute it and/or

+ * FFmpeg is distributed in the hope that it will be useful,

+ * License along with FFmpeg; if not, write to the Free Software

+ * This file is part of FFmpeg.

+ * FFmpeg is free software; you can redistribute it and/or

+ * FFmpeg is distributed in the hope that it will be useful,

+ * License along with FFmpeg; if not, write to the Free Software

+ * This file is part of FFmpeg.

+ * FFmpeg is free software; you can redistribute it and/or

+ * FFmpeg is distributed in the hope that it will be useful,

+ * License along with FFmpeg; if not, write to the Free Software

+ * This file is part of FFmpeg.

+ * FFmpeg is free software; you can redistribute it and/or

+ * FFmpeg is distributed in the hope that it will be useful,

+ * License along with FFmpeg; if not, write to the Free Software

+ * This file is part of FFmpeg.

+ * FFmpeg is free software; you can redistribute it and/or

+ * FFmpeg is distributed in the hope that it will be useful,

+ * License along with FFmpeg; if not, write to the Free Software

+ * This file is part of FFmpeg.

+ * FFmpeg is free software; you can redistribute it and/or

+ * FFmpeg is distributed in the hope that it will be useful,

+ * License along with FFmpeg; if not, write to the Free Software

+ * This file is part of FFmpeg.

+ * FFmpeg is free software; you can redistribute it and/or

+ * FFmpeg is distributed in the hope that it will be useful,

+ * License along with FFmpeg; if not, write to the Free Software

+#include "common.h"

+#include "intreadwrite.h"

+#if HAVE_FAST_64BIT && HAVE_FAST_UNALIGNED && !CONFIG_SMALL

+ unsigned len2 = FFMIN((len-1) & ~7, 23*8);

+ if (len2) {

+ uint64_t a1= 0;

+ uint64_t a2= 0;

+ uint64_t b1= 0;

+ uint64_t b2= 0;

+ len -= len2;

+ s2 += s1*len2;

+ while (len2 >= 8) {

+ uint64_t v = AV_RN64(buf);

+ a2 += a1;

+ b2 += b1;

+ a1 += v &0x00FF00FF00FF00FF;

+ b1 += (v>>8)&0x00FF00FF00FF00FF;

+ len2 -= 8;

+ buf+=8;

+ }

+

+ //We combine the 8 interleaved adler32 checksums without overflows

+ //Decreasing the number of iterations would allow below code to be

+ //simplified but would likely be slower due to the fewer iterations

+ //of the inner loop

+ s1 += ((a1+b1)*0x1000100010001)>>48;

+ s2 += ((((a2&0xFFFF0000FFFF)+(b2&0xFFFF0000FFFF)+((a2>>16)&0xFFFF0000FFFF)+((b2>>16)&0xFFFF0000FFFF))*0x800000008)>>32)

+#if HAVE_BIGENDIAN

+ + 2*((b1*0x1000200030004)>>48)

+ + ((a1*0x1000100010001)>>48)

+ + 2*((a1*0x0000100020003)>>48);

+#else

+ + 2*((a1*0x4000300020001)>>48)

+ + ((b1*0x1000100010001)>>48)

+ + 2*((b1*0x3000200010000)>>48);

+#endif

+ }

+#else

+// LCOV_EXCL_START

+ uint8_t data[LEN];

+// LCOV_EXCL_STOP

+ * This file is part of FFmpeg.

+ * FFmpeg is free software; you can redistribute it and/or

+ * FFmpeg is distributed in the hope that it will be useful,

+ * License along with FFmpeg; if not, write to the Free Software

+ * This file is part of FFmpeg.

+ * FFmpeg is free software; you can redistribute it and/or

+ * FFmpeg is distributed in the hope that it will be useful,

+ * License along with FFmpeg; if not, write to the Free Software

+# define ROT(x, s) (((x) >> (s)) | ((x) << (32-(s))))

+# define ROT(x, s) (((x) << (s)) | ((x) >> (32-(s))))

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

+ aes_crypt(a, 0, inv_sbox, dec_multbl);

+ aes_crypt(a, 2, sbox, enc_multbl);

+// LCOV_EXCL_START

+ av_aes_init(&ae, (const uint8_t*)"PI=3.141592654..", 128, 0);

+ av_aes_init(&ad, (const uint8_t*)"PI=3.141592654..", 128, 1);

+// LCOV_EXCL_STOP

+ * This file is part of FFmpeg.

+ * FFmpeg is free software; you can redistribute it and/or

+ * FFmpeg is distributed in the hope that it will be useful,

+ * License along with FFmpeg; if not, write to the Free Software

+extern const int av_aes_size;

+ * This file is part of FFmpeg.

+ * FFmpeg is free software; you can redistribute it and/or

+ * FFmpeg is distributed in the hope that it will be useful,

+ * License along with FFmpeg; if not, write to the Free Software

+ * This file is part of FFmpeg.

+ * FFmpeg is free software; you can redistribute it and/or

+ * FFmpeg is distributed in the hope that it will be useful,

+ * License along with FFmpeg; if not, write to the Free Software

+ * This file is part of FFmpeg.

+ * FFmpeg is free software; you can redistribute it and/or

+ * FFmpeg is distributed in the hope that it will be useful,

+ * License along with FFmpeg; if not, write to the Free Software

+ else if (flags & (AV_CPU_FLAG_ARMV6T2 | AV_CPU_FLAG_ARMV6))

+ /* Some functions use the 'setend' instruction which is deprecated on ARMv8

+ * and serializing on some ARMv7 cores. This ensures such functions

+ * are only enabled on ARMv6. */

+ flags |= AV_CPU_FLAG_SETEND;

+

+ AV_CPU_FLAG_NEON * HAVE_NEON |

+ AV_CPU_FLAG_SETEND * !(HAVE_NEON | HAVE_VFPV3);

+ * This file is part of FFmpeg.

+ * FFmpeg is free software; you can redistribute it and/or

+ * FFmpeg is distributed in the hope that it will be useful,

+ * License along with FFmpeg; if not, write to the Free Software

+#define have_setend(flags) CPUEXT(flags, SETEND)

+ * This file is part of FFmpeg.

+ * FFmpeg is free software; you can redistribute it and/or

+ * FFmpeg is distributed in the hope that it will be useful,

+ * License along with FFmpeg; if not, write to the Free Software

+ * This file is part of FFmpeg.

+ * FFmpeg is free software; you can redistribute it and/or

+ * FFmpeg is distributed in the hope that it will be useful,

+ * License along with FFmpeg; if not, write to the Free Software

+ * This file is part of FFmpeg.

+ * FFmpeg is free software; you can redistribute it and/or

+ * FFmpeg is distributed in the hope that it will be useful,

+ * License along with FFmpeg; if not, write to the Free Software

+ * This file is part of FFmpeg.

+ * FFmpeg is free software; you can redistribute it and/or

+ * FFmpeg is distributed in the hope that it will be useful,

+ * License along with FFmpeg; if not, write to the Free Software

+void ff_butterflies_float_vfp(float *av_restrict v1, float *av_restrict v2, int len);

+ * This file is part of FFmpeg.

+ * FFmpeg is free software; you can redistribute it and/or

+ * FFmpeg is distributed in the hope that it will be useful,

+ * License along with FFmpeg; if not, write to the Free Software

+ * This file is part of FFmpeg

+ * FFmpeg is free software; you can redistribute it and/or

+ * FFmpeg is distributed in the hope that it will be useful,

+ * License along with FFmpeg; if not, write to the Free Software

+ * This file is part of FFmpeg.

+ * FFmpeg is free software; you can redistribute it and/or

+ * FFmpeg is distributed in the hope that it will be useful,

+ * License along with FFmpeg; if not, write to the Free Software

+static av_always_inline av_const int av_clip_uint8_arm(int a)

+ int x;

+static av_always_inline av_const int av_clip_uint16_arm(int a)

+ int x;

+ * This file is part of FFmpeg.

+ * FFmpeg is free software; you can redistribute it and/or

+ * FFmpeg is distributed in the hope that it will be useful,

+ * License along with FFmpeg; if not, write to the Free Software

+ * This file is part of FFmpeg.

+ * FFmpeg is free software; you can redistribute it and/or

+ * FFmpeg is distributed in the hope that it will be useful,

+ * License along with FFmpeg; if not, write to the Free Software

+ * This file is part of FFmpeg.

+ * FFmpeg is free software; you can redistribute it and/or

+ * FFmpeg is distributed in the hope that it will be useful,

+ * License along with FFmpeg; if not, write to the Free Software

+ * This file is part of FFmpeg.

+ * FFmpeg is free software; you can redistribute it and/or

+ * FFmpeg is distributed in the hope that it will be useful,

+ * License along with FFmpeg; if not, write to the Free Software

+ if (ret == oldval)

+#include "avassert.h"

+ av_assert0(res == 2);

+ av_assert0(res == 3);

+ * This file is part of FFmpeg.

+ * FFmpeg is free software; you can redistribute it and/or

+ * FFmpeg is distributed in the hope that it will be useful,

+ * License along with FFmpeg; if not, write to the Free Software

+ * This file is part of FFmpeg.

+ * FFmpeg is free software; you can redistribute it and/or

+ * FFmpeg is distributed in the hope that it will be useful,

+ * License along with FFmpeg; if not, write to the Free Software

+#if HAVE_ATOMIC_COMPARE_EXCHANGE

+ return __atomic_load_n(ptr, __ATOMIC_SEQ_CST);

+#else

+#endif

+#if HAVE_ATOMIC_COMPARE_EXCHANGE

+ __atomic_store_n(ptr, val, __ATOMIC_SEQ_CST);

+#else

+#endif

+#if HAVE_ATOMIC_COMPARE_EXCHANGE

+ return __atomic_add_fetch(ptr, inc, __ATOMIC_SEQ_CST);

+#else

+#endif

+#if HAVE_SYNC_VAL_COMPARE_AND_SWAP

+#else

+ __atomic_compare_exchange_n(ptr, &oldval, newval, 0, __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST);

+ return oldval;

+#endif

+ * This file is part of FFmpeg.

+ * FFmpeg is free software; you can redistribute it and/or

+ * FFmpeg is distributed in the hope that it will be useful,

+ * License along with FFmpeg; if not, write to the Free Software

+ * This file is part of FFmpeg.

+ * FFmpeg is free software; you can redistribute it and/or

+ * FFmpeg is distributed in the hope that it will be useful,

+ * License along with FFmpeg; if not, write to the Free Software

+#define WIN32_LEAN_AND_MEAN

+ * This file is part of FFmpeg.

+ * FFmpeg is free software; you can redistribute it and/or

+ * FFmpeg is distributed in the hope that it will be useful,

+ * License along with FFmpeg; if not, write to the Free Software

+# define AV_GCC_VERSION_AT_LEAST(x,y) (__GNUC__ > (x) || __GNUC__ == (x) && __GNUC_MINOR__ >= (y))

+#ifndef av_always_inline

+#endif

+

+#ifndef av_extern_inline

+#if defined(__ICL) && __ICL >= 1210 || defined(__GNUC_STDC_INLINE__)

+# define av_extern_inline extern inline

+#else

+# define av_extern_inline inline

+#endif

+#endif

+/**

+ * Disable warnings about deprecated features

+ * This is useful for sections of code kept for backward compatibility and

+ * scheduled for removal.

+ */

+#ifndef AV_NOWARN_DEPRECATED

+#if AV_GCC_VERSION_AT_LEAST(4,6)

+# define AV_NOWARN_DEPRECATED(code) \

+ _Pragma("GCC diagnostic push") \

+ _Pragma("GCC diagnostic ignored \"-Wdeprecated-declarations\"") \

+ code \

+ _Pragma("GCC diagnostic pop")

+#elif defined(_MSC_VER)

+# define AV_NOWARN_DEPRECATED(code) \

+ __pragma(warning(push)) \

+ __pragma(warning(disable : 4996)) \

+ code; \

+ __pragma(warning(pop))

+#else

+# define AV_NOWARN_DEPRECATED(code) code

+#endif

+#endif

+

+

+#if defined(__GNUC__) && !defined(__INTEL_COMPILER) && !defined(__clang__)

+ * This file is part of FFmpeg.

+ * FFmpeg is free software; you can redistribute it and/or

+ * FFmpeg is distributed in the hope that it will be useful,

+ * License along with FFmpeg; if not, write to the Free Software

+ av_freep(&af->buf);

+ af->buf = av_mallocz_array(af->nb_buffers, sizeof(*af->buf));

+ * This file is part of FFmpeg.

+ * FFmpeg is free software; you can redistribute it and/or

+ * FFmpeg is distributed in the hope that it will be useful,

+ * License along with FFmpeg; if not, write to the Free Software

+ * code on failure. If successful, the number of samples

+ * actually written will always be nb_samples.

+ * on failure. The number of samples actually read will not

+ * be greater than nb_samples, and will only be less than

+ * nb_samples if av_audio_fifo_size is less than nb_samples.

+ * This file is part of FFmpeg.

+ * FFmpeg is free software; you can redistribute it and/or

+ * FFmpeg is distributed in the hope that it will be useful,

+ * License along with FFmpeg; if not, write to the Free Software

+ av_log(NULL, AV_LOG_PANIC, "Assertion %s failed at %s:%d\n", \

+ * This file is part of FFmpeg.

+ * FFmpeg is free software; you can redistribute it and/or

+ * FFmpeg is distributed in the hope that it will be useful,

+ * License along with FFmpeg; if not, write to the Free Software

+ * This file is part of FFmpeg.

+ * FFmpeg is free software; you can redistribute it and/or

+ * FFmpeg is distributed in the hope that it will be useful,

+ * License along with FFmpeg; if not, write to the Free Software

+ * This file is part of FFmpeg.

+ * FFmpeg is free software; you can redistribute it and/or

+ * FFmpeg is distributed in the hope that it will be useful,

+ * License along with FFmpeg; if not, write to the Free Software

+#include "avassert.h"

+#include "bprint.h"

+ return (char*)(intptr_t)s1;

+ return (char*)(intptr_t)s1;

+ return (char*)haystack;

+ return (char*)haystack;

+ size_t len = strlen(dst);

+char *av_asprintf(const char *fmt, ...)

+{

+ char *p = NULL;

+ va_list va;

+ int len;

+

+ va_start(va, fmt);

+ len = vsnprintf(NULL, 0, fmt, va);

+ va_end(va);

+ if (len < 0)

+ goto end;

+

+ p = av_malloc(len + 1);

+ if (!p)

+ goto end;

+

+ va_start(va, fmt);

+ len = vsnprintf(p, len + 1, fmt, va);

+ va_end(va);

+ if (len < 0)

+ av_freep(&p);

+

+end:

+ return p;

+}

+

+char *av_strtok(char *s, const char *delim, char **saveptr)

+{

+ char *tok;

+

+ if (!s && !(s = *saveptr))

+ return NULL;

+

+ /* skip leading delimiters */

+ s += strspn(s, delim);

+

+ /* s now points to the first non delimiter char, or to the end of the string */

+ if (!*s) {

+ *saveptr = NULL;

+ return NULL;

+ }

+ tok = s++;

+

+ /* skip non delimiters */

+ s += strcspn(s, delim);

+ if (*s) {

+ *s = 0;

+ *saveptr = s+1;

+ } else {

+ *saveptr = NULL;

+ }

+

+ return tok;

+}

+

+char *av_append_path_component(const char *path, const char *component)

+{

+ size_t p_len, c_len;

+ char *fullpath;

+

+ if (!path)

+ return av_strdup(component);

+ if (!component)

+ return av_strdup(path);

+

+ p_len = strlen(path);

+ c_len = strlen(component);

+ if (p_len > SIZE_MAX - c_len || p_len + c_len > SIZE_MAX - 2)

+ return NULL;

+ fullpath = av_malloc(p_len + c_len + 2);

+ if (fullpath) {

+ if (p_len) {

+ av_strlcpy(fullpath, path, p_len + 1);

+ if (c_len) {

+ if (fullpath[p_len - 1] != '/' && component[0] != '/')

+ fullpath[p_len++] = '/';

+ else if (fullpath[p_len - 1] == '/' && component[0] == '/')

+ p_len--;

+ }

+ }

+ av_strlcpy(&fullpath[p_len], component, c_len + 1);

+ fullpath[p_len + c_len] = 0;

+ }

+ return fullpath;

+}

+

+int av_escape(char **dst, const char *src, const char *special_chars,

+ enum AVEscapeMode mode, int flags)

+{

+ AVBPrint dstbuf;

+

+ av_bprint_init(&dstbuf, 1, AV_BPRINT_SIZE_UNLIMITED);

+ av_bprint_escape(&dstbuf, src, special_chars, mode, flags);

+

+ if (!av_bprint_is_complete(&dstbuf)) {

+ av_bprint_finalize(&dstbuf, NULL);

+ return AVERROR(ENOMEM);

+ } else {

+ av_bprint_finalize(&dstbuf, dst);

+ return dstbuf.len;

+ }

+}

+

+int av_utf8_decode(int32_t *codep, const uint8_t **bufp, const uint8_t *buf_end,

+ unsigned int flags)

+{

+ const uint8_t *p = *bufp;

+ uint32_t top;

+ uint64_t code;

+ int ret = 0, tail_len;

+ uint32_t overlong_encoding_mins[6] = {

+ 0x00000000, 0x00000080, 0x00000800, 0x00010000, 0x00200000, 0x04000000,

+ };

+ if (p >= buf_end)

+ return 0;

+

+ code = *p++;

+

+ /* first sequence byte starts with 10, or is 1111-1110 or 1111-1111,

+ which is not admitted */

+ if ((code & 0xc0) == 0x80 || code >= 0xFE) {

+ ret = AVERROR(EILSEQ);

+ goto end;

+ }

+ top = (code & 128) >> 1;

+

+ tail_len = 0;

+ while (code & top) {

+ int tmp;

+ tail_len++;

+ if (p >= buf_end) {

+ (*bufp) ++;

+ return AVERROR(EILSEQ); /* incomplete sequence */

+ }

+

+ /* we assume the byte to be in the form 10xx-xxxx */

+ tmp = *p++ - 128; /* strip leading 1 */

+ if (tmp>>6) {

+ (*bufp) ++;

+ return AVERROR(EILSEQ);

+ }

+ code = (code<<6) + tmp;

+ top <<= 5;

+ }

+ code &= (top << 1) - 1;

+

+ /* check for overlong encodings */

+ av_assert0(tail_len <= 5);

+ if (code < overlong_encoding_mins[tail_len]) {

+ ret = AVERROR(EILSEQ);

+ goto end;

+ }

+

+ if (code >= 1U<<31) {

+ ret = AVERROR(EILSEQ); /* out-of-range value */

+ goto end;

+ }

+

+ *codep = code;

+

+ if (code > 0x10FFFF &&

+ !(flags & AV_UTF8_FLAG_ACCEPT_INVALID_BIG_CODES))

+ ret = AVERROR(EILSEQ);

+ if (code < 0x20 && code != 0x9 && code != 0xA && code != 0xD &&

+ flags & AV_UTF8_FLAG_EXCLUDE_XML_INVALID_CONTROL_CODES)

+ ret = AVERROR(EILSEQ);

+ if (code >= 0xD800 && code <= 0xDFFF &&

+ !(flags & AV_UTF8_FLAG_ACCEPT_SURROGATES))

+ ret = AVERROR(EILSEQ);

+ if ((code == 0xFFFE || code == 0xFFFF) &&

+ !(flags & AV_UTF8_FLAG_ACCEPT_NON_CHARACTERS))

+ ret = AVERROR(EILSEQ);

+

+end:

+ *bufp = p;

+ return ret;

+}

+

+int av_match_list(const char *name, const char *list, char separator)

+{

+ const char *p, *q;

+

+ for (p = name; p && *p; ) {

+ for (q = list; q && *q; ) {

+ int k;

+ for (k = 0; p[k] == q[k] || (p[k]*q[k] == 0 && p[k]+q[k] == separator); k++)

+ if (k && (!p[k] || p[k] == separator))

+ return 1;

+ q = strchr(q, separator);

+ q += !!q;

+ }

+ p = strchr(p, separator);

+ p += !!p;

+ }

+

+ return 0;

+}

+ char *fullpath;

+ static const char * const strings[] = {

+ printf("Testing av_append_path_component()\n");

+ #define TEST_APPEND_PATH_COMPONENT(path, component, expected) \

+ fullpath = av_append_path_component((path), (component)); \

+ printf("%s = %s\n", fullpath ? fullpath : "(null)", expected); \

+ av_free(fullpath);

+ TEST_APPEND_PATH_COMPONENT(NULL, NULL, "(null)")

+ TEST_APPEND_PATH_COMPONENT("path", NULL, "path");

+ TEST_APPEND_PATH_COMPONENT(NULL, "comp", "comp");

+ TEST_APPEND_PATH_COMPONENT("path", "comp", "path/comp");

+ TEST_APPEND_PATH_COMPONENT("path/", "comp", "path/comp");

+ TEST_APPEND_PATH_COMPONENT("path", "/comp", "path/comp");

+ TEST_APPEND_PATH_COMPONENT("path/", "/comp", "path/comp");

+ TEST_APPEND_PATH_COMPONENT("path/path2/", "/comp/comp2", "path/path2/comp/comp2");

+ * This file is part of FFmpeg.

+ * FFmpeg is free software; you can redistribute it and/or

+ * FFmpeg is distributed in the hope that it will be useful,

+ * License along with FFmpeg; if not, write to the Free Software

+#include <stdint.h>

+ * Get the count of continuous non zero chars starting from the beginning.

+ *

+ * @param len maximum number of characters to check in the string, that

+ * is the maximum value which is returned by the function

+ */

+static inline size_t av_strnlen(const char *s, size_t len)

+{

+ size_t i;

+ for (i = 0; i < len && s[i]; i++)

+ ;

+ return i;

+}

+

+/**

+ * Print arguments following specified format into a large enough auto

+ * allocated buffer. It is similar to GNU asprintf().

+ * @param fmt printf-compatible format string, specifying how the

+ * following parameters are used.

+ * @return the allocated string

+ * @note You have to free the string yourself with av_free().

+ */

+char *av_asprintf(const char *fmt, ...) av_printf_format(1, 2);

+

+/**

+ * Split the string into several tokens which can be accessed by

+ * successive calls to av_strtok().

+ *

+ * A token is defined as a sequence of characters not belonging to the

+ * set specified in delim.

+ *

+ * On the first call to av_strtok(), s should point to the string to

+ * parse, and the value of saveptr is ignored. In subsequent calls, s

+ * should be NULL, and saveptr should be unchanged since the previous

+ * call.

+ *

+ * This function is similar to strtok_r() defined in POSIX.1.

+ *

+ * @param s the string to parse, may be NULL

+ * @param delim 0-terminated list of token delimiters, must be non-NULL

+ * @param saveptr user-provided pointer which points to stored

+ * information necessary for av_strtok() to continue scanning the same

+ * string. saveptr is updated to point to the next character after the

+ * first delimiter found, or to NULL if the string was terminated

+ * @return the found token, or NULL when no token is found

+ */

+char *av_strtok(char *s, const char *delim, char **saveptr);

+

+/**

+/**

+ * Append path component to the existing path.

+ * Path separator '/' is placed between when needed.

+ * Resulting string have to be freed with av_free().

+ * @param path base path

+ * @param component component to be appended

+ * @return new path or NULL on error.

+ */

+char *av_append_path_component(const char *path, const char *component);

+

+enum AVEscapeMode {

+ AV_ESCAPE_MODE_AUTO, ///< Use auto-selected escaping mode.

+ AV_ESCAPE_MODE_BACKSLASH, ///< Use backslash escaping.

+ AV_ESCAPE_MODE_QUOTE, ///< Use single-quote escaping.

+};

+

+/**

+ * Consider spaces special and escape them even in the middle of the

+ * string.

+ *

+ * This is equivalent to adding the whitespace characters to the special

+ * characters lists, except it is guaranteed to use the exact same list

+ * of whitespace characters as the rest of libavutil.

+ */

+#define AV_ESCAPE_FLAG_WHITESPACE 0x01

+

+/**

+ * Escape only specified special characters.

+ * Without this flag, escape also any characters that may be considered

+ * special by av_get_token(), such as the single quote.

+ */

+#define AV_ESCAPE_FLAG_STRICT 0x02

+

+/**

+ * Escape string in src, and put the escaped string in an allocated

+ * string in *dst, which must be freed with av_free().

+ *

+ * @param dst pointer where an allocated string is put

+ * @param src string to escape, must be non-NULL

+ * @param special_chars string containing the special characters which

+ * need to be escaped, can be NULL

+ * @param mode escape mode to employ, see AV_ESCAPE_MODE_* macros.

+ * Any unknown value for mode will be considered equivalent to

+ * AV_ESCAPE_MODE_BACKSLASH, but this behaviour can change without

+ * notice.

+ * @param flags flags which control how to escape, see AV_ESCAPE_FLAG_ macros

+ * @return the length of the allocated string, or a negative error code in case of error

+ * @see av_bprint_escape()

+ */

+int av_escape(char **dst, const char *src, const char *special_chars,

+ enum AVEscapeMode mode, int flags);

+

+#define AV_UTF8_FLAG_ACCEPT_INVALID_BIG_CODES 1 ///< accept codepoints over 0x10FFFF

+#define AV_UTF8_FLAG_ACCEPT_NON_CHARACTERS 2 ///< accept non-characters - 0xFFFE and 0xFFFF

+#define AV_UTF8_FLAG_ACCEPT_SURROGATES 4 ///< accept UTF-16 surrogates codes

+#define AV_UTF8_FLAG_EXCLUDE_XML_INVALID_CONTROL_CODES 8 ///< exclude control codes not accepted by XML

+

+#define AV_UTF8_FLAG_ACCEPT_ALL \

+ AV_UTF8_FLAG_ACCEPT_INVALID_BIG_CODES|AV_UTF8_FLAG_ACCEPT_NON_CHARACTERS|AV_UTF8_FLAG_ACCEPT_SURROGATES

+

+/**

+ * Read and decode a single UTF-8 code point (character) from the

+ * buffer in *buf, and update *buf to point to the next byte to

+ * decode.

+ *

+ * In case of an invalid byte sequence, the pointer will be updated to

+ * the next byte after the invalid sequence and the function will

+ * return an error code.

+ *

+ * Depending on the specified flags, the function will also fail in

+ * case the decoded code point does not belong to a valid range.

+ *

+ * @note For speed-relevant code a carefully implemented use of

+ * GET_UTF8() may be preferred.

+ *

+ * @param codep pointer used to return the parsed code in case of success.

+ * The value in *codep is set even in case the range check fails.

+ * @param bufp pointer to the address the first byte of the sequence

+ * to decode, updated by the function to point to the

+ * byte next after the decoded sequence

+ * @param buf_end pointer to the end of the buffer, points to the next

+ * byte past the last in the buffer. This is used to

+ * avoid buffer overreads (in case of an unfinished

+ * UTF-8 sequence towards the end of the buffer).

+ * @param flags a collection of AV_UTF8_FLAG_* flags

+ * @return >= 0 in case a sequence was successfully read, a negative

+ * value in case of invalid sequence

+ */

+int av_utf8_decode(int32_t *codep, const uint8_t **bufp, const uint8_t *buf_end,

+ unsigned int flags);

+

+/**

+ * Check if a name is in a list.

+ * @returns 0 if not found, or the 1 based index where it has been found in the

+ * list.

+ */

+int av_match_list(const char *name, const char *list, char separator);

+

+/**

+ * This file is part of FFmpeg.

+ * FFmpeg is free software; you can redistribute it and/or

+ * FFmpeg is distributed in the hope that it will be useful,

+ * License along with FFmpeg; if not, write to the Free Software

+ * @section ffmpeg_intro Introduction

+ * provided by FFmpeg.

+ * @li @ref lswr "libswresample" audio resampling, format conversion and mixing

+ * @li @ref lpp "libpostproc" post processing library

+ * @li @ref libsws "libswscale" color conversion and scaling library

+ * @section ffmpeg_versioning Versioning and compatibility

+ * Each of the FFmpeg libraries contains a version.h header, which defines a

+ * FFmpeg guarantees backward API and ABI compatibility for each library as long

+ * In other words, any correct program that works with a given FFmpeg snapshot

+ * FFmpeg versions or to replacing the dynamic FFmpeg libraries that a program

+ * FFmpeg). New macros and enum values may be added. Behavior in undocumented

+ * libavutil contains the code shared across all the other FFmpeg

+ *

+ * @defgroup version_utils Library Version Macros

+ *

+ * @{

+ *

+ * @}

+ * Return a string describing the media_type enum, NULL if media_type

+ * is unknown.

+ */

+const char *av_get_media_type_string(enum AVMediaType media_type);

+

+/**

+ * FFmpeg internal timebase and timestamp definitions

+#define AV_NOPTS_VALUE ((int64_t)UINT64_C(0x8000000000000000))

+ AV_PICTURE_TYPE_NONE = 0, ///< Undefined

+ AV_PICTURE_TYPE_I, ///< Intra

+#include "common.h"

+#include "mathematics.h"

+#include "log.h"

+#include "pixfmt.h"

+

+/**

+ * Return x default pointer in case p is NULL.

+ */

+static inline void *av_x_if_null(const void *p, const void *x)

+{

+ return (void *)(intptr_t)(p ? p : x);

+}

+

+/**

+ * Compute the length of an integer list.

+ *

+ * @param elsize size in bytes of each list element (only 1, 2, 4 or 8)

+ * @param term list terminator (usually 0 or -1)

+ * @param list pointer to the list

+ * @return length of the list, in elements, not counting the terminator

+ */

+unsigned av_int_list_length_for_size(unsigned elsize,

+ const void *list, uint64_t term) av_pure;

+

+/**

+ * Compute the length of an integer list.

+ *

+ * @param term list terminator (usually 0 or -1)

+ * @param list pointer to the list

+ * @return length of the list, in elements, not counting the terminator

+ */

+#define av_int_list_length(list, term) \

+ av_int_list_length_for_size(sizeof(*(list)), list, term)

+

+/**

+ * Open a file using a UTF-8 filename.

+ * The API of this function matches POSIX fopen(), errors are returned through

+ * errno.

+ */

+FILE *av_fopen_utf8(const char *path, const char *mode);

+/*

+ * Windows resource file for libavutil

+ *

+ * Copyright (C) 2012 James Almer

+ * Copyright (C) 2013 Tiancheng "Timothy" Gu

+ *

+ * This file is part of FFmpeg.

+ *

+ * FFmpeg is free software; you can redistribute it and/or

+ * modify it under the terms of the GNU Lesser General Public

+ * License as published by the Free Software Foundation; either

+ * version 2.1 of the License, or (at your option) any later version.

+ *

+ * FFmpeg is distributed in the hope that it will be useful,

+ * but WITHOUT ANY WARRANTY; without even the implied warranty of

+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU

+ * Lesser General Public License for more details.

+ *

+ * You should have received a copy of the GNU Lesser General Public

+ * License along with FFmpeg; if not, write to the Free Software

+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA

+ */

+

+#include <windows.h>

+#include "libavutil/version.h"

+#include "libavutil/ffversion.h"

+#include "config.h"

+

+1 VERSIONINFO

+FILEVERSION LIBAVUTIL_VERSION_MAJOR, LIBAVUTIL_VERSION_MINOR, LIBAVUTIL_VERSION_MICRO, 0

+PRODUCTVERSION LIBAVUTIL_VERSION_MAJOR, LIBAVUTIL_VERSION_MINOR, LIBAVUTIL_VERSION_MICRO, 0

+FILEFLAGSMASK VS_FFI_FILEFLAGSMASK

+FILEOS VOS_NT_WINDOWS32

+FILETYPE VFT_DLL

+{

+ BLOCK "StringFileInfo"

+ {

+ BLOCK "040904B0"

+ {

+ VALUE "CompanyName", "FFmpeg Project"

+ VALUE "FileDescription", "FFmpeg utility library"

+ VALUE "FileVersion", AV_STRINGIFY(LIBAVUTIL_VERSION)

+ VALUE "InternalName", "libavutil"

+ VALUE "LegalCopyright", "Copyright (C) 2000-" AV_STRINGIFY(CONFIG_THIS_YEAR) " FFmpeg Project"

+ VALUE "OriginalFilename", "avutil" BUILDSUF "-" AV_STRINGIFY(LIBAVUTIL_VERSION_MAJOR) SLIBSUF

+ VALUE "ProductName", "FFmpeg"

+ VALUE "ProductVersion", FFMPEG_VERSION

+ }

+ }

+

+ BLOCK "VarFileInfo"

+ {

+ VALUE "Translation", 0x0409, 0x04B0

+ }

+}

+ * This file is part of FFmpeg.

+ * FFmpeg is free software; you can redistribute it and/or

+ * FFmpeg is distributed in the hope that it will be useful,

+ * License along with FFmpeg; if not, write to the Free Software

+#include "intreadwrite.h"

+#include "timer.h"

+static const uint8_t map2[256] =

+ 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,

+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,

+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,

+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,

+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,

+ 0xff, 0xff, 0xff,

+

+ 0xff, 0xff, 0xfe, 0xff, 0xff, 0xff, 0x00, 0x01,

+ 0x2c, 0x2d, 0x2e, 0x2f, 0x30, 0x31, 0x32, 0x33,

+

+ 0xff, 0xff, 0xff, 0xff, 0xff,

+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,

+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,

+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,

+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,

+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,

+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,

+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,

+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,

+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,

+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,

+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,

+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,

+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,

+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,

+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,

+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,

+#define BASE64_DEC_STEP(i) do { \

+ bits = map2[in[i]]; \

+ if (bits & 0x80) \

+ goto out ## i; \

+ v = i ? (v << 6) + bits : bits; \

+} while(0)

+

+int av_base64_decode(uint8_t *out, const char *in_str, int out_size)

+ uint8_t *end = out + out_size;

+ // no sign extension

+ const uint8_t *in = in_str;

+ unsigned bits = 0xff;

+ unsigned v;

+ while (end - dst > 3) {

+ BASE64_DEC_STEP(0);

+ BASE64_DEC_STEP(1);

+ BASE64_DEC_STEP(2);

+ BASE64_DEC_STEP(3);

+ // Using AV_WB32 directly confuses compiler

+ v = av_be2ne32(v << 8);

+ AV_WN32(dst, v);

+ dst += 3;

+ in += 4;

+ }

+ if (end - dst) {

+ BASE64_DEC_STEP(0);

+ BASE64_DEC_STEP(1);

+ BASE64_DEC_STEP(2);

+ BASE64_DEC_STEP(3);

+ *dst++ = v >> 16;

+ if (end - dst)

+ *dst++ = v >> 8;

+ if (end - dst)

+ *dst++ = v;

+ in += 4;

+ }

+ while (1) {

+ BASE64_DEC_STEP(0);

+ in++;

+ BASE64_DEC_STEP(0);

+ in++;

+ BASE64_DEC_STEP(0);

+ in++;

+ BASE64_DEC_STEP(0);

+ in++;

+out3:

+ *dst++ = v >> 10;

+ v <<= 2;

+out2:

+ *dst++ = v >> 4;

+out1:

+out0:

+ return bits & 1 ? AVERROR_INVALIDDATA : dst - out;

+ while (bytes_remaining > 3) {

+ i_bits = AV_RB32(in);

+ in += 3; bytes_remaining -= 3;

+ *dst++ = b64[ i_bits>>26 ];

+ *dst++ = b64[(i_bits>>20) & 0x3F];

+ *dst++ = b64[(i_bits>>14) & 0x3F];

+ *dst++ = b64[(i_bits>>8 ) & 0x3F];

+ }

+ i_bits = 0;

+ }

+ while (i_shift > 0) {

+ *dst++ = b64[(i_bits << 6 >> i_shift) & 0x3f];

+ i_shift -= 6;

+// LCOV_EXCL_START

+ if ((data2_size = av_base64_decode(data2, encoded, max_data2_size)) != data_size) {

+ if ((data2_size = av_base64_decode(data2, encoded, data_size)) != data_size) {

+ printf("Failed: cannot decode with minimal buffer\n"

+ "Encoded:\n%s\n", encoded);

+ return 1;

+ }

+ if (av_base64_decode(NULL, encoded, 0) != 0) {

+ printf("Failed: decode to NULL buffer\n");

+ return 1;

+ }

+ if (strlen(encoded)) {

+ char *end = strchr(encoded, '=');

+ if (!end)

+ end = encoded + strlen(encoded) - 1;

+ *end = '%';

+ if (av_base64_decode(NULL, encoded, 0) >= 0) {

+ printf("Failed: error detection\n");

+ return 1;

+ }

+ }

+int main(int argc, char ** argv)

+ char in[1024], out[2048];

+ if (argc>1 && !strcmp(argv[1], "-t")) {

+ memset(in, 123, sizeof(in));

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

+ START_TIMER

+ av_base64_encode(out, sizeof(out), in, sizeof(in));

+ STOP_TIMER("encode")

+ }

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

+ START_TIMER

+ av_base64_decode(in, out, sizeof(in));

+ STOP_TIMER("decode")

+ }

+

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

+ START_TIMER

+ av_base64_decode(NULL, out, 0);

+ STOP_TIMER("syntax check")

+ }

+ }

+

+// LCOV_EXCL_STOP

+ * This file is part of FFmpeg.

+ * FFmpeg is free software; you can redistribute it and/or

+ * FFmpeg is distributed in the hope that it will be useful,

+ * License along with FFmpeg; if not, write to the Free Software

+ * @param out_size size in bytes of the out buffer (including the

+ * null terminator), must be at least AV_BASE64_SIZE(in_size)

+ * @param in input buffer containing the data to encode

+ * @param in_size size in bytes of the in buffer

+ * @return out or NULL in case of error

+ * Calculate the output size needed to base64-encode x bytes to a

+ * null-terminated string.

+ * This file is part of FFmpeg.

+ * FFmpeg is free software; you can redistribute it and/or

+ * FFmpeg is distributed in the hope that it will be useful,

+ * License along with FFmpeg; if not, write to the Free Software

+ * This file is part of FFmpeg.

+ * FFmpeg is free software; you can redistribute it and/or

+ * FFmpeg is distributed in the hope that it will be useful,

+ * License along with FFmpeg; if not, write to the Free Software

+ * This file is part of FFmpeg.

+ * FFmpeg is free software; you can redistribute it and/or

+ * FFmpeg is distributed in the hope that it will be useful,

+ * License along with FFmpeg; if not, write to the Free Software

+#define F(Xl, Xr, P) \

+ Xr ^=((( ctx->s[0][ Xl >> 24 ] \

+ + ctx->s[1][(Xl >> 16) & 0xFF])\

+ ^ ctx->s[2][(Xl >> 8) & 0xFF])\

+ + ctx->s[3][ Xl & 0xFF])\

+ ^ P;

+ Xl ^= ctx->p[AV_BF_ROUNDS + 1];

+ for (i = AV_BF_ROUNDS; i > 0; i-=2) {

+ F(Xl, Xr, ctx->p[i ]);

+ F(Xr, Xl, ctx->p[i-1]);

+ }

+ Xr ^= ctx->p[0];

+ Xl ^= ctx->p[0];

+ for (i = 1; i < AV_BF_ROUNDS+1; i+=2){

+ F(Xl, Xr, ctx->p[i ]);

+ F(Xr, Xl, ctx->p[i+1]);

+ }

+ Xr ^= ctx->p[AV_BF_ROUNDS + 1];

+ * Copyright (c) 2012 Samuel Pitoiset

+ * This file is part of FFmpeg.

+ * FFmpeg is free software; you can redistribute it and/or

+ * FFmpeg is distributed in the hope that it will be useful,

+ * License along with FFmpeg; if not, write to the Free Software

+/*

+ * Copyright (c) 2012 Nicolas George

+ *

+ * This file is part of FFmpeg.

+ *

+ * FFmpeg is free software; you can redistribute it and/or

+ * modify it under the terms of the GNU Lesser General Public

+ * License as published by the Free Software Foundation; either

+ * version 2.1 of the License, or (at your option) any later version.

+ *

+ * FFmpeg is distributed in the hope that it will be useful,

+ * but WITHOUT ANY WARRANTY; without even the implied warranty of

+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU

+ * Lesser General Public License for more details.

+ *

+ * You should have received a copy of the GNU Lesser General Public

+ * License along with FFmpeg; if not, write to the Free Software

+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA

+ */

+

+#include <stdarg.h>

+#include <stdio.h>

+#include <string.h>

+#include <time.h>

+#include "avassert.h"

+#include "avstring.h"

+#include "bprint.h"

+#include "common.h"

+#include "compat/va_copy.h"

+#include "error.h"

+#include "mem.h"

+

+#define av_bprint_room(buf) ((buf)->size - FFMIN((buf)->len, (buf)->size))

+#define av_bprint_is_allocated(buf) ((buf)->str != (buf)->reserved_internal_buffer)

+

+static int av_bprint_alloc(AVBPrint *buf, unsigned room)

+{

+ char *old_str, *new_str;

+ unsigned min_size, new_size;

+

+ if (buf->size == buf->size_max)

+ return AVERROR(EIO);

+ if (!av_bprint_is_complete(buf))

+ return AVERROR_INVALIDDATA; /* it is already truncated anyway */

+ min_size = buf->len + 1 + FFMIN(UINT_MAX - buf->len - 1, room);

+ new_size = buf->size > buf->size_max / 2 ? buf->size_max : buf->size * 2;

+ if (new_size < min_size)

+ new_size = FFMIN(buf->size_max, min_size);

+ old_str = av_bprint_is_allocated(buf) ? buf->str : NULL;

+ new_str = av_realloc(old_str, new_size);

+ if (!new_str)

+ return AVERROR(ENOMEM);

+ if (!old_str)

+ memcpy(new_str, buf->str, buf->len + 1);

+ buf->str = new_str;

+ buf->size = new_size;

+ return 0;

+}

+

+static void av_bprint_grow(AVBPrint *buf, unsigned extra_len)

+{

+ /* arbitrary margin to avoid small overflows */

+ extra_len = FFMIN(extra_len, UINT_MAX - 5 - buf->len);

+ buf->len += extra_len;

+ if (buf->size)

+ buf->str[FFMIN(buf->len, buf->size - 1)] = 0;

+}

+

+void av_bprint_init(AVBPrint *buf, unsigned size_init, unsigned size_max)

+{

+ unsigned size_auto = (char *)buf + sizeof(*buf) -

+ buf->reserved_internal_buffer;

+

+ if (size_max == 1)

+ size_max = size_auto;

+ buf->str = buf->reserved_internal_buffer;

+ buf->len = 0;

+ buf->size = FFMIN(size_auto, size_max);

+ buf->size_max = size_max;

+ *buf->str = 0;

+ if (size_init > buf->size)

+ av_bprint_alloc(buf, size_init - 1);

+}

+

+void av_bprint_init_for_buffer(AVBPrint *buf, char *buffer, unsigned size)

+{

+ buf->str = buffer;

+ buf->len = 0;

+ buf->size = size;

+ buf->size_max = size;

+ *buf->str = 0;

+}

+

+void av_bprintf(AVBPrint *buf, const char *fmt, ...)

+{

+ unsigned room;

+ char *dst;

+ va_list vl;

+ int extra_len;

+

+ while (1) {

+ room = av_bprint_room(buf);

+ dst = room ? buf->str + buf->len : NULL;

+ va_start(vl, fmt);

+ extra_len = vsnprintf(dst, room, fmt, vl);

+ va_end(vl);

+ if (extra_len <= 0)

+ return;

+ if (extra_len < room)

+ break;

+ if (av_bprint_alloc(buf, extra_len))

+ break;

+ }

+ av_bprint_grow(buf, extra_len);

+}

+

+void av_vbprintf(AVBPrint *buf, const char *fmt, va_list vl_arg)

+{

+ unsigned room;

+ char *dst;

+ int extra_len;

+ va_list vl;

+

+ while (1) {

+ room = av_bprint_room(buf);

+ dst = room ? buf->str + buf->len : NULL;

+ va_copy(vl, vl_arg);

+ extra_len = vsnprintf(dst, room, fmt, vl);

+ va_end(vl);

+ if (extra_len <= 0)

+ return;

+ if (extra_len < room)

+ break;

+ if (av_bprint_alloc(buf, extra_len))

+ break;

+ }

+ av_bprint_grow(buf, extra_len);

+}

+

+void av_bprint_chars(AVBPrint *buf, char c, unsigned n)

+{

+ unsigned room, real_n;

+

+ while (1) {

+ room = av_bprint_room(buf);

+ if (n < room)

+ break;

+ if (av_bprint_alloc(buf, n))

+ break;

+ }

+ if (room) {

+ real_n = FFMIN(n, room - 1);

+ memset(buf->str + buf->len, c, real_n);

+ }

+ av_bprint_grow(buf, n);

+}

+

+void av_bprint_append_data(AVBPrint *buf, const char *data, unsigned size)

+{

+ unsigned room, real_n;

+

+ while (1) {

+ room = av_bprint_room(buf);

+ if (size < room)

+ break;

+ if (av_bprint_alloc(buf, size))

+ break;

+ }

+ if (room) {

+ real_n = FFMIN(size, room - 1);

+ memcpy(buf->str + buf->len, data, real_n);

+ }

+ av_bprint_grow(buf, size);

+}

+

+void av_bprint_strftime(AVBPrint *buf, const char *fmt, const struct tm *tm)

+{

+ unsigned room;

+ size_t l;

+

+ if (!*fmt)

+ return;

+ while (1) {

+ room = av_bprint_room(buf);

+ if (room && (l = strftime(buf->str + buf->len, room, fmt, tm)))

+ break;

+ /* strftime does not tell us how much room it would need: let us

+ retry with twice as much until the buffer is large enough */

+ room = !room ? strlen(fmt) + 1 :

+ room <= INT_MAX / 2 ? room * 2 : INT_MAX;

+ if (av_bprint_alloc(buf, room)) {

+ /* impossible to grow, try to manage something useful anyway */

+ room = av_bprint_room(buf);

+ if (room < 1024) {

+ /* if strftime fails because the buffer has (almost) reached

+ its maximum size, let us try in a local buffer; 1k should

+ be enough to format any real date+time string */

+ char buf2[1024];

+ if ((l = strftime(buf2, sizeof(buf2), fmt, tm))) {

+ av_bprintf(buf, "%s", buf2);

+ return;

+ }

+ }

+ if (room) {

+ /* if anything else failed and the buffer is not already

+ truncated, let us add a stock string and force truncation */

+ static const char txt[] = "[truncated strftime output]";

+ memset(buf->str + buf->len, '!', room);

+ memcpy(buf->str + buf->len, txt, FFMIN(sizeof(txt) - 1, room));

+ av_bprint_grow(buf, room); /* force truncation */

+ }

+ return;

+ }

+ }

+ av_bprint_grow(buf, l);

+}

+

+void av_bprint_get_buffer(AVBPrint *buf, unsigned size,

+ unsigned char **mem, unsigned *actual_size)

+{

+ if (size > av_bprint_room(buf))

+ av_bprint_alloc(buf, size);

+ *actual_size = av_bprint_room(buf);

+ *mem = *actual_size ? buf->str + buf->len : NULL;

+}

+

+void av_bprint_clear(AVBPrint *buf)

+{

+ if (buf->len) {

+ *buf->str = 0;

+ buf->len = 0;

+ }

+}

+

+int av_bprint_finalize(AVBPrint *buf, char **ret_str)

+{

+ unsigned real_size = FFMIN(buf->len + 1, buf->size);

+ char *str;

+ int ret = 0;

+

+ if (ret_str) {

+ if (av_bprint_is_allocated(buf)) {

+ str = av_realloc(buf->str, real_size);

+ if (!str)

+ str = buf->str;

+ buf->str = NULL;

+ } else {

+ str = av_malloc(real_size);

+ if (str)

+ memcpy(str, buf->str, real_size);

+ else

+ ret = AVERROR(ENOMEM);

+ }

+ *ret_str = str;

+ } else {

+ if (av_bprint_is_allocated(buf))

+ av_freep(&buf->str);

+ }

+ buf->size = real_size;

+ return ret;

+}

+

+#define WHITESPACES " \n\t"

+

+void av_bprint_escape(AVBPrint *dstbuf, const char *src, const char *special_chars,

+ enum AVEscapeMode mode, int flags)

+{

+ const char *src0 = src;

+

+ if (mode == AV_ESCAPE_MODE_AUTO)

+ mode = AV_ESCAPE_MODE_BACKSLASH; /* TODO: implement a heuristic */

+

+ switch (mode) {

+ case AV_ESCAPE_MODE_QUOTE:

+ /* enclose the string between '' */

+ av_bprint_chars(dstbuf, '\'', 1);

+ for (; *src; src++) {

+ if (*src == '\'')

+ av_bprintf(dstbuf, "'\\''");

+ else

+ av_bprint_chars(dstbuf, *src, 1);

+ }

+ av_bprint_chars(dstbuf, '\'', 1);

+ break;

+

+ /* case AV_ESCAPE_MODE_BACKSLASH or unknown mode */

+ default:

+ /* \-escape characters */

+ for (; *src; src++) {

+ int is_first_last = src == src0 || !*(src+1);

+ int is_ws = !!strchr(WHITESPACES, *src);

+ int is_strictly_special = special_chars && strchr(special_chars, *src);

+ int is_special =

+ is_strictly_special || strchr("'\\", *src) ||

+ (is_ws && (flags & AV_ESCAPE_FLAG_WHITESPACE));

+

+ if (is_strictly_special ||

+ (!(flags & AV_ESCAPE_FLAG_STRICT) &&

+ (is_special || (is_ws && is_first_last))))

+ av_bprint_chars(dstbuf, '\\', 1);

+ av_bprint_chars(dstbuf, *src, 1);

+ }

+ break;

+ }

+}

+

+#ifdef TEST

+

+#undef printf

+

+static void bprint_pascal(AVBPrint *b, unsigned size)

+{

+ unsigned i, j;

+ unsigned p[42];

+

+ av_assert0(size < FF_ARRAY_ELEMS(p));

+

+ p[0] = 1;

+ av_bprintf(b, "%8d\n", 1);

+ for (i = 1; i <= size; i++) {

+ p[i] = 1;

+ for (j = i - 1; j > 0; j--)

+ p[j] = p[j] + p[j - 1];

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

+ av_bprintf(b, "%8d", p[j]);

+ av_bprintf(b, "\n");

+ }

+}

+

+int main(void)

+{

+ AVBPrint b;

+ char buf[256];

+ struct tm testtime = { .tm_year = 100, .tm_mon = 11, .tm_mday = 20 };

+

+ av_bprint_init(&b, 0, -1);

+ bprint_pascal(&b, 5);

+ printf("Short text in unlimited buffer: %u/%u\n", (unsigned)strlen(b.str), b.len);

+ printf("%s\n", b.str);

+ av_bprint_finalize(&b, NULL);

+

+ av_bprint_init(&b, 0, -1);

+ bprint_pascal(&b, 25);

+ printf("Long text in unlimited buffer: %u/%u\n", (unsigned)strlen(b.str), b.len);

+ av_bprint_finalize(&b, NULL);

+

+ av_bprint_init(&b, 0, 2048);

+ bprint_pascal(&b, 25);

+ printf("Long text in limited buffer: %u/%u\n", (unsigned)strlen(b.str), b.len);

+ av_bprint_finalize(&b, NULL);

+

+ av_bprint_init(&b, 0, 1);

+ bprint_pascal(&b, 5);

+ printf("Short text in automatic buffer: %u/%u\n", (unsigned)strlen(b.str), b.len);

+

+ av_bprint_init(&b, 0, 1);

+ bprint_pascal(&b, 25);

+ printf("Long text in automatic buffer: %u/%u\n", (unsigned)strlen(b.str)/8*8, b.len);

+ /* Note that the size of the automatic buffer is arch-dependent. */

+

+ av_bprint_init(&b, 0, 0);

+ bprint_pascal(&b, 25);

+ printf("Long text count only buffer: %u/%u\n", (unsigned)strlen(b.str), b.len);

+

+ av_bprint_init_for_buffer(&b, buf, sizeof(buf));

+ bprint_pascal(&b, 25);

+ printf("Long text count only buffer: %u/%u\n", (unsigned)strlen(buf), b.len);

+

+ av_bprint_init(&b, 0, -1);

+ av_bprint_strftime(&b, "%Y-%m-%d", &testtime);

+ printf("strftime full: %u/%u \"%s\"\n", (unsigned)strlen(buf), b.len, b.str);

+ av_bprint_finalize(&b, NULL);

+

+ av_bprint_init(&b, 0, 8);

+ av_bprint_strftime(&b, "%Y-%m-%d", &testtime);

+ printf("strftime truncated: %u/%u \"%s\"\n", (unsigned)strlen(buf), b.len, b.str);

+

+ return 0;

+}

+

+#endif

+/*

+ * Copyright (c) 2012 Nicolas George

+ *

+ * This file is part of FFmpeg.

+ *

+ * FFmpeg is free software; you can redistribute it and/or

+ * modify it under the terms of the GNU Lesser General Public

+ * License as published by the Free Software Foundation; either

+ * version 2.1 of the License, or (at your option) any later version.

+ *

+ * FFmpeg is distributed in the hope that it will be useful,

+ * but WITHOUT ANY WARRANTY; without even the implied warranty of

+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU

+ * Lesser General Public License for more details.

+ *

+ * You should have received a copy of the GNU Lesser General Public

+ * License along with FFmpeg; if not, write to the Free Software

+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA

+ */

+

+#ifndef AVUTIL_BPRINT_H

+#define AVUTIL_BPRINT_H

+

+#include <stdarg.h>

+

+#include "attributes.h"

+#include "avstring.h"

+

+/**

+ * Define a structure with extra padding to a fixed size

+ * This helps ensuring binary compatibility with future versions.

+ */

+

+#define FF_PAD_STRUCTURE(name, size, ...) \

+struct ff_pad_helper_##name { __VA_ARGS__ }; \

+typedef struct name { \

+ __VA_ARGS__ \

+ char reserved_padding[size - sizeof(struct ff_pad_helper_##name)]; \

+} name;

+

+/**

+ * Buffer to print data progressively

+ *

+ * The string buffer grows as necessary and is always 0-terminated.

+ * The content of the string is never accessed, and thus is

+ * encoding-agnostic and can even hold binary data.

+ *

+ * Small buffers are kept in the structure itself, and thus require no

+ * memory allocation at all (unless the contents of the buffer is needed

+ * after the structure goes out of scope). This is almost as lightweight as

+ * declaring a local "char buf[512]".

+ *

+ * The length of the string can go beyond the allocated size: the buffer is

+ * then truncated, but the functions still keep account of the actual total

+ * length.

+ *

+ * In other words, buf->len can be greater than buf->size and records the

+ * total length of what would have been to the buffer if there had been

+ * enough memory.

+ *

+ * Append operations do not need to be tested for failure: if a memory

+ * allocation fails, data stop being appended to the buffer, but the length

+ * is still updated. This situation can be tested with

+ * av_bprint_is_complete().

+ *

+ * The size_max field determines several possible behaviours:

+ *

+ * size_max = -1 (= UINT_MAX) or any large value will let the buffer be

+ * reallocated as necessary, with an amortized linear cost.

+ *

+ * size_max = 0 prevents writing anything to the buffer: only the total

+ * length is computed. The write operations can then possibly be repeated in

+ * a buffer with exactly the necessary size

+ * (using size_init = size_max = len + 1).

+ *

+ * size_max = 1 is automatically replaced by the exact size available in the

+ * structure itself, thus ensuring no dynamic memory allocation. The

+ * internal buffer is large enough to hold a reasonable paragraph of text,

+ * such as the current paragraph.

+ */

+

+FF_PAD_STRUCTURE(AVBPrint, 1024,

+ char *str; /**< string so far */

+ unsigned len; /**< length so far */

+ unsigned size; /**< allocated memory */

+ unsigned size_max; /**< maximum allocated memory */

+ char reserved_internal_buffer[1];

+)

+

+/**

+ * Convenience macros for special values for av_bprint_init() size_max

+ * parameter.

+ */

+#define AV_BPRINT_SIZE_UNLIMITED ((unsigned)-1)

+#define AV_BPRINT_SIZE_AUTOMATIC 1

+#define AV_BPRINT_SIZE_COUNT_ONLY 0

+

+/**

+ * Init a print buffer.

+ *

+ * @param buf buffer to init

+ * @param size_init initial size (including the final 0)

+ * @param size_max maximum size;

+ * 0 means do not write anything, just count the length;

+ * 1 is replaced by the maximum value for automatic storage;

+ * any large value means that the internal buffer will be

+ * reallocated as needed up to that limit; -1 is converted to

+ * UINT_MAX, the largest limit possible.

+ * Check also AV_BPRINT_SIZE_* macros.

+ */

+void av_bprint_init(AVBPrint *buf, unsigned size_init, unsigned size_max);

+

+/**

+ * Init a print buffer using a pre-existing buffer.

+ *

+ * The buffer will not be reallocated.

+ *

+ * @param buf buffer structure to init

+ * @param buffer byte buffer to use for the string data

+ * @param size size of buffer

+ */

+void av_bprint_init_for_buffer(AVBPrint *buf, char *buffer, unsigned size);

+

+/**

+ * Append a formatted string to a print buffer.

+ */

+void av_bprintf(AVBPrint *buf, const char *fmt, ...) av_printf_format(2, 3);

+

+/**

+ * Append a formatted string to a print buffer.

+ */

+void av_vbprintf(AVBPrint *buf, const char *fmt, va_list vl_arg);

+

+/**

+ * Append char c n times to a print buffer.

+ */

+void av_bprint_chars(AVBPrint *buf, char c, unsigned n);

+

+/**

+ * Append data to a print buffer.

+ *

+ * param buf bprint buffer to use

+ * param data pointer to data

+ * param size size of data

+ */

+void av_bprint_append_data(AVBPrint *buf, const char *data, unsigned size);

+

+struct tm;

+/**

+ * Append a formatted date and time to a print buffer.

+ *

+ * param buf bprint buffer to use

+ * param fmt date and time format string, see strftime()

+ * param tm broken-down time structure to translate

+ *

+ * @note due to poor design of the standard strftime function, it may

+ * produce poor results if the format string expands to a very long text and

+ * the bprint buffer is near the limit stated by the size_max option.

+ */

+void av_bprint_strftime(AVBPrint *buf, const char *fmt, const struct tm *tm);

+

+/**

+ * Allocate bytes in the buffer for external use.

+ *

+ * @param[in] buf buffer structure

+ * @param[in] size required size

+ * @param[out] mem pointer to the memory area

+ * @param[out] actual_size size of the memory area after allocation;

+ * can be larger or smaller than size

+ */

+void av_bprint_get_buffer(AVBPrint *buf, unsigned size,

+ unsigned char **mem, unsigned *actual_size);

+

+/**

+ * Reset the string to "" but keep internal allocated data.

+ */

+void av_bprint_clear(AVBPrint *buf);

+

+/**

+ * Test if the print buffer is complete (not truncated).

+ *

+ * It may have been truncated due to a memory allocation failure

+ * or the size_max limit (compare size and size_max if necessary).

+ */

+static inline int av_bprint_is_complete(const AVBPrint *buf)

+{

+ return buf->len < buf->size;

+}

+

+/**

+ * Finalize a print buffer.

+ *

+ * The print buffer can no longer be used afterwards,

+ * but the len and size fields are still valid.

+ *

+ * @arg[out] ret_str if not NULL, used to return a permanent copy of the

+ * buffer contents, or NULL if memory allocation fails;

+ * if NULL, the buffer is discarded and freed

+ * @return 0 for success or error code (probably AVERROR(ENOMEM))

+ */

+int av_bprint_finalize(AVBPrint *buf, char **ret_str);

+

+/**

+ * Escape the content in src and append it to dstbuf.

+ *

+ * @param dstbuf already inited destination bprint buffer

+ * @param src string containing the text to escape

+ * @param special_chars string containing the special characters which

+ * need to be escaped, can be NULL

+ * @param mode escape mode to employ, see AV_ESCAPE_MODE_* macros.

+ * Any unknown value for mode will be considered equivalent to

+ * AV_ESCAPE_MODE_BACKSLASH, but this behaviour can change without

+ * notice.

+ * @param flags flags which control how to escape, see AV_ESCAPE_FLAG_* macros

+ */

+void av_bprint_escape(AVBPrint *dstbuf, const char *src, const char *special_chars,

+ enum AVEscapeMode mode, int flags);

+

+#endif /* AVUTIL_BPRINT_H */

+ * This file is part of FFmpeg.

+ * FFmpeg is free software; you can redistribute it and/or

+ * FFmpeg is distributed in the hope that it will be useful,

+ * License along with FFmpeg; if not, write to the Free Software

+ * This file is part of FFmpeg.

+ * FFmpeg is free software; you can redistribute it and/or

+ * FFmpeg is distributed in the hope that it will be useful,

+ * License along with FFmpeg; if not, write to the Free Software

+static void buffer_replace(AVBufferRef **dst, AVBufferRef **src)

+ b = (*dst)->buffer;

+

+ if (src) {

+ **dst = **src;

+ av_freep(src);

+ } else

+ av_freep(dst);

+void av_buffer_unref(AVBufferRef **buf)

+{

+ if (!buf || !*buf)

+ return;

+

+ buffer_replace(buf, NULL);

+}

+

+ return avpriv_atomic_int_get(&buf->buffer->refcount) == 1;

+}

+

+void *av_buffer_get_opaque(const AVBufferRef *buf)

+{

+ return buf->buffer->opaque;

+}

+

+int av_buffer_get_ref_count(const AVBufferRef *buf)

+{

+ return buf->buffer->refcount;

+

+ buffer_replace(pbuf, &newbuf);

+ buffer_replace(pbuf, &new);

+#if USE_ATOMICS

+/* remove the whole buffer list from the pool and return it */

+static BufferPoolEntry *get_pool(AVBufferPool *pool)

+{

+ BufferPoolEntry *cur = *(void * volatile *)&pool->pool, *last = NULL;

+

+ while (cur != last) {

+ last = cur;

+ cur = avpriv_atomic_ptr_cas((void * volatile *)&pool->pool, last, NULL);

+ if (!cur)

+ return NULL;

+ }

+

+ return cur;

+}

+

+static void add_to_pool(BufferPoolEntry *buf)

+{

+ AVBufferPool *pool;

+ BufferPoolEntry *cur, *end = buf;

+

+ if (!buf)

+ return;

+ pool = buf->pool;

+

+ while (end->next)

+ end = end->next;

+

+ while (avpriv_atomic_ptr_cas((void * volatile *)&pool->pool, NULL, buf)) {

+ /* pool is not empty, retrieve it and append it to our list */

+ cur = get_pool(pool);

+ end->next = cur;

+ while (end->next)

+ end = end->next;

+ }

+}

+#endif

+

+ if(CONFIG_MEMORY_POISONING)

+ memset(buf->data, FF_MEMORY_POISON, pool->size);

+

+#if USE_ATOMICS

+ add_to_pool(buf);

+#else

+#endif

+#if USE_ATOMICS

+ avpriv_atomic_int_add_and_fetch(&pool->refcount, 1);

+ avpriv_atomic_int_add_and_fetch(&pool->nb_allocated, 1);

+#endif

+

+#if USE_ATOMICS

+ /* check whether the pool is empty */

+ buf = get_pool(pool);

+ if (!buf && pool->refcount <= pool->nb_allocated) {

+ av_log(NULL, AV_LOG_DEBUG, "Pool race dectected, spining to avoid overallocation and eventual OOM\n");

+ while (!buf && avpriv_atomic_int_get(&pool->refcount) <= avpriv_atomic_int_get(&pool->nb_allocated))

+ buf = get_pool(pool);

+ }

+

+ if (!buf)

+ return pool_alloc_buffer(pool);

+

+ /* keep the first entry, return the rest of the list to the pool */

+ add_to_pool(buf->next);

+ buf->next = NULL;

+

+ ret = av_buffer_create(buf->data, pool->size, pool_release_buffer,

+ buf, 0);

+ if (!ret) {

+ add_to_pool(buf);

+ return NULL;

+ }

+#else

+#endif

+ * This file is part of FFmpeg.

+ * FFmpeg is free software; you can redistribute it and/or

+ * FFmpeg is distributed in the hope that it will be useful,

+ * License along with FFmpeg; if not, write to the Free Software

+ * The convention throughout this API and the rest of FFmpeg is such that the

+ * @param opaque parameter to be got for processing or passed to free

+ * @return the opaque parameter set by av_buffer_create.

+ */

+void *av_buffer_get_opaque(const AVBufferRef *buf);

+

+int av_buffer_get_ref_count(const AVBufferRef *buf);

+

+/**

+ * This file is part of FFmpeg.

+ * FFmpeg is free software; you can redistribute it and/or

+ * FFmpeg is distributed in the hope that it will be useful,

+ * License along with FFmpeg; if not, write to the Free Software

+ volatile int nb_allocated;

+

+/*

+ * An implementation of the CAMELLIA algorithm as mentioned in RFC3713

+ * Copyright (c) 2014 Supraja Meedinti

+ *

+ * This file is part of FFmpeg.

+ *

+ * FFmpeg is free software; you can redistribute it and/or

+ * modify it under the terms of the GNU Lesser General Public

+ * License as published by the Free Software Foundation; either

+ * version 2.1 of the License, or (at your option) any later version.

+ *

+ * FFmpeg is distributed in the hope that it will be useful,

+ * but WITHOUT ANY WARRANTY; without even the implied warranty of

+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU

+ * Lesser General Public License for more details.

+ *

+ * You should have received a copy of the GNU Lesser General Public

+ * License along with FFmpeg; if not, write to the Free Software

+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA

+ */

+#include "camellia.h"

+#include "common.h"

+#include "intreadwrite.h"

+#include "attributes.h"

+

+#define LR32(x,c) ((x) << (c) | (x) >> (32 - (c)))

+#define RR32(x,c) ((x) >> (c) | (x) << (32 - (c)))

+

+#define MASK8 0xff

+#define MASK32 0xffffffff

+#define MASK64 0xffffffffffffffff

+

+#define Sigma1 0xA09E667F3BCC908B

+#define Sigma2 0xB67AE8584CAA73B2

+#define Sigma3 0xC6EF372FE94F82BE

+#define Sigma4 0x54FF53A5F1D36F1C

+#define Sigma5 0x10E527FADE682D1D

+#define Sigma6 0xB05688C2B3E6C1FD

+

+static uint64_t SP[8][256];

+

+typedef struct AVCAMELLIA {

+ uint64_t Kw[4];

+ uint64_t Ke[6];

+ uint64_t K[24];

+ int key_bits;

+} AVCAMELLIA;

+

+static const uint8_t SBOX1[256] = {

+112, 130, 44, 236, 179, 39, 192, 229, 228, 133, 87, 53, 234, 12, 174, 65,

+ 35, 239, 107, 147, 69, 25, 165, 33, 237, 14, 79, 78, 29, 101, 146, 189,

+134, 184, 175, 143, 124, 235, 31, 206, 62, 48, 220, 95, 94, 197, 11, 26,

+166, 225, 57, 202, 213, 71, 93, 61, 217, 1, 90, 214, 81, 86, 108, 77,

+139, 13, 154, 102, 251, 204, 176, 45, 116, 18, 43, 32, 240, 177, 132, 153,

+223, 76, 203, 194, 52, 126, 118, 5, 109, 183, 169, 49, 209, 23, 4, 215,

+ 20, 88, 58, 97, 222, 27, 17, 28, 50, 15, 156, 22, 83, 24, 242, 34,

+254, 68, 207, 178, 195, 181, 122, 145, 36, 8, 232, 168, 96, 252, 105, 80,

+170, 208, 160, 125, 161, 137, 98, 151, 84, 91, 30, 149, 224, 255, 100, 210,

+ 16, 196, 0, 72, 163, 247, 117, 219, 138, 3, 230, 218, 9, 63, 221, 148,

+135, 92, 131, 2, 205, 74, 144, 51, 115, 103, 246, 243, 157, 127, 191, 226,

+ 82, 155, 216, 38, 200, 55, 198, 59, 129, 150, 111, 75, 19, 190, 99, 46,

+233, 121, 167, 140, 159, 110, 188, 142, 41, 245, 249, 182, 47, 253, 180, 89,

+120, 152, 6, 106, 231, 70, 113, 186, 212, 37, 171, 66, 136, 162, 141, 250,

+114, 7, 185, 85, 248, 238, 172, 10, 54, 73, 42, 104, 60, 56, 241, 164,

+ 64, 40, 211, 123, 187, 201, 67, 193, 21, 227, 173, 244, 119, 199, 128, 158

+};

+

+static const uint8_t SBOX2[256] = {

+224, 5, 88, 217, 103, 78, 129, 203, 201, 11, 174, 106, 213, 24, 93, 130,

+ 70, 223, 214, 39, 138, 50, 75, 66, 219, 28, 158, 156, 58, 202, 37, 123,

+ 13, 113, 95, 31, 248, 215, 62, 157, 124, 96, 185, 190, 188, 139, 22, 52,

+ 77, 195, 114, 149, 171, 142, 186, 122, 179, 2, 180, 173, 162, 172, 216, 154,

+ 23, 26, 53, 204, 247, 153, 97, 90, 232, 36, 86, 64, 225, 99, 9, 51,

+191, 152, 151, 133, 104, 252, 236, 10, 218, 111, 83, 98, 163, 46, 8, 175,

+ 40, 176, 116, 194, 189, 54, 34, 56, 100, 30, 57, 44, 166, 48, 229, 68,

+253, 136, 159, 101, 135, 107, 244, 35, 72, 16, 209, 81, 192, 249, 210, 160,

+ 85, 161, 65, 250, 67, 19, 196, 47, 168, 182, 60, 43, 193, 255, 200, 165,

+ 32, 137, 0, 144, 71, 239, 234, 183, 21, 6, 205, 181, 18, 126, 187, 41,

+ 15, 184, 7, 4, 155, 148, 33, 102, 230, 206, 237, 231, 59, 254, 127, 197,

+164, 55, 177, 76, 145, 110, 141, 118, 3, 45, 222, 150, 38, 125, 198, 92,

+211, 242, 79, 25, 63, 220, 121, 29, 82, 235, 243, 109, 94, 251, 105, 178,

+240, 49, 12, 212, 207, 140, 226, 117, 169, 74, 87, 132, 17, 69, 27, 245,

+228, 14, 115, 170, 241, 221, 89, 20, 108, 146, 84, 208, 120, 112, 227, 73,

+128, 80, 167, 246, 119, 147, 134, 131, 42, 199, 91, 233, 238, 143, 1, 61

+};

+

+static const uint8_t SBOX3[256] = {

+ 56, 65, 22, 118, 217, 147, 96, 242, 114, 194, 171, 154, 117, 6, 87, 160,

+145, 247, 181, 201, 162, 140, 210, 144, 246, 7, 167, 39, 142, 178, 73, 222,

+ 67, 92, 215, 199, 62, 245, 143, 103, 31, 24, 110, 175, 47, 226, 133, 13,

+ 83, 240, 156, 101, 234, 163, 174, 158, 236, 128, 45, 107, 168, 43, 54, 166,

+197, 134, 77, 51, 253, 102, 88, 150, 58, 9, 149, 16, 120, 216, 66, 204,

+239, 38, 229, 97, 26, 63, 59, 130, 182, 219, 212, 152, 232, 139, 2, 235,

+ 10, 44, 29, 176, 111, 141, 136, 14, 25, 135, 78, 11, 169, 12, 121, 17,

+127, 34, 231, 89, 225, 218, 61, 200, 18, 4, 116, 84, 48, 126, 180, 40,

+ 85, 104, 80, 190, 208, 196, 49, 203, 42, 173, 15, 202, 112, 255, 50, 105,

+ 8, 98, 0, 36, 209, 251, 186, 237, 69, 129, 115, 109, 132, 159, 238, 74,

+195, 46, 193, 1, 230, 37, 72, 153, 185, 179, 123, 249, 206, 191, 223, 113,

+ 41, 205, 108, 19, 100, 155, 99, 157, 192, 75, 183, 165, 137, 95, 177, 23,

+244, 188, 211, 70, 207, 55, 94, 71, 148, 250, 252, 91, 151, 254, 90, 172,

+ 60, 76, 3, 53, 243, 35, 184, 93, 106, 146, 213, 33, 68, 81, 198, 125,

+ 57, 131, 220, 170, 124, 119, 86, 5, 27, 164, 21, 52, 30, 28, 248, 82,

+ 32, 20, 233, 189, 221, 228, 161, 224, 138, 241, 214, 122, 187, 227, 64, 79

+};

+

+static const uint8_t SBOX4[256] = {

+112, 44, 179, 192, 228, 87, 234, 174, 35, 107, 69, 165, 237, 79, 29, 146,

+134, 175, 124, 31, 62, 220, 94, 11, 166, 57, 213, 93, 217, 90, 81, 108,

+139, 154, 251, 176, 116, 43, 240, 132, 223, 203, 52, 118, 109, 169, 209, 4,

+ 20, 58, 222, 17, 50, 156, 83, 242, 254, 207, 195, 122, 36, 232, 96, 105,

+170, 160, 161, 98, 84, 30, 224, 100, 16, 0, 163, 117, 138, 230, 9, 221,

+135, 131, 205, 144, 115, 246, 157, 191, 82, 216, 200, 198, 129, 111, 19, 99,

+233, 167, 159, 188, 41, 249, 47, 180, 120, 6, 231, 113, 212, 171, 136, 141,

+114, 185, 248, 172, 54, 42, 60, 241, 64, 211, 187, 67, 21, 173, 119, 128,

+130, 236, 39, 229, 133, 53, 12, 65, 239, 147, 25, 33, 14, 78, 101, 189,

+184, 143, 235, 206, 48, 95, 197, 26, 225, 202, 71, 61, 1, 214, 86, 77,

+ 13, 102, 204, 45, 18, 32, 177, 153, 76, 194, 126, 5, 183, 49, 23, 215,

+ 88, 97, 27, 28, 15, 22, 24, 34, 68, 178, 181, 145, 8, 168, 252, 80,

+208, 125, 137, 151, 91, 149, 255, 210, 196, 72, 247, 219, 3, 218, 63, 148,

+ 92, 2, 74, 51, 103, 243, 127, 226, 155, 38, 55, 59, 150, 75, 190, 46,

+121, 140, 110, 142, 245, 182, 253, 89, 152, 106, 70, 186, 37, 66, 162, 250,

+ 7, 85, 238, 10, 73, 104, 56, 164, 40, 123, 201, 193, 227, 244, 199, 158

+};

+

+const int av_camellia_size = sizeof(AVCAMELLIA);

+

+static void LR128(uint64_t d[2], const uint64_t K[2], int x)

+{

+ int i = 0;

+ if (64 <= x && x < 128) {

+ i = 1;

+ x -= 64;

+ }

+ if (x <= 0 || x >= 128) {

+ d[0] = K[i];

+ d[1] = K[!i];

+ return;

+ }

+ d[0] = (K[i] << x | K[!i] >> (64 - x));

+ d[1] = (K[!i] << x | K[i] >> (64 - x));

+}

+

+static uint64_t F(uint64_t F_IN, uint64_t KE)

+{

+ KE ^= F_IN;

+ F_IN=SP[0][KE >> 56]^SP[1][(KE >> 48) & MASK8]^SP[2][(KE >> 40) & MASK8]^SP[3][(KE >> 32) & MASK8]^SP[4][(KE >> 24) & MASK8]^SP[5][(KE >> 16) & MASK8]^SP[6][(KE >> 8) & MASK8]^SP[7][KE & MASK8];

+ return F_IN;

+}

+

+static uint64_t FL(uint64_t FL_IN, uint64_t KE)

+{

+ uint32_t x1, x2, k1, k2;

+ x1 = FL_IN >> 32;

+ x2 = FL_IN & MASK32;

+ k1 = KE >> 32;

+ k2 = KE & MASK32;

+ x2 = x2 ^ LR32((x1 & k1), 1);

+ x1 = x1 ^ (x2 | k2);

+ return ((uint64_t)x1 << 32) | (uint64_t)x2;

+}

+

+static uint64_t FLINV(uint64_t FLINV_IN, uint64_t KE)

+{

+ uint32_t x1, x2, k1, k2;

+ x1 = FLINV_IN >> 32;

+ x2 = FLINV_IN & MASK32;

+ k1 = KE >> 32;

+ k2 = KE & MASK32;

+ x1 = x1 ^ (x2 | k2);

+ x2 = x2 ^ LR32((x1 & k1), 1);

+ return ((uint64_t)x1 << 32) | (uint64_t)x2;

+}

+

+static const uint8_t shifts[2][12] = {

+ {0, 15, 15, 45, 45, 60, 94, 94, 111},

+ {0, 15, 15, 30, 45, 45, 60, 60, 77, 94, 94, 111}

+};

+

+static const uint8_t vars[2][12] = {

+ {2, 0, 2, 0, 2, 2, 0, 2, 0},

+ {3, 1, 2, 3, 0, 2, 1, 3, 0, 1, 2, 0}

+};

+

+static void generate_round_keys(AVCAMELLIA *cs, uint64_t Kl[2], uint64_t Kr[2], uint64_t Ka[2], uint64_t Kb[2])

+{

+ int i;

+ uint64_t *Kd[4], d[2];

+ Kd[0] = Kl;

+ Kd[1] = Kr;

+ Kd[2] = Ka;

+ Kd[3] = Kb;

+ cs->Kw[0] = Kl[0];

+ cs->Kw[1] = Kl[1];

+ if (cs->key_bits == 128) {

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

+ LR128(d, Kd[vars[0][i]], shifts[0][i]);

+ cs->K[2*i] = d[0];

+ cs->K[2*i+1] = d[1];

+ }

+ LR128(d, Kd[0], 60);

+ cs->K[9] = d[1];

+ LR128(d, Kd[2], 30);

+ cs->Ke[0] = d[0];

+ cs->Ke[1] = d[1];

+ LR128(d, Kd[0], 77);

+ cs->Ke[2] = d[0];

+ cs->Ke[3] = d[1];

+ LR128(d, Kd[2], 111);

+ cs->Kw[2] = d[0];

+ cs->Kw[3] = d[1];

+ } else {

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

+ LR128(d, Kd[vars[1][i]], shifts[1][i]);

+ cs->K[2*i] = d[0];

+ cs->K[2*i+1] = d[1];

+ }

+ LR128(d, Kd[1], 30);

+ cs->Ke[0] = d[0];

+ cs->Ke[1] = d[1];

+ LR128(d, Kd[0], 60);

+ cs->Ke[2] = d[0];

+ cs->Ke[3] = d[1];

+ LR128(d, Kd[2], 77);

+ cs->Ke[4] = d[0];

+ cs->Ke[5] = d[1];

+ LR128(d, Kd[3], 111);

+ cs->Kw[2] = d[0];

+ cs->Kw[3] = d[1];

+ }

+}

+

+static void camellia_encrypt(AVCAMELLIA *cs, uint8_t *dst, const uint8_t *src)

+{

+ uint64_t D1, D2;

+ D1 = AV_RB64(src);

+ D2 = AV_RB64(src + 8);

+ D1 ^= cs->Kw[0];

+ D2 ^= cs->Kw[1];

+ D2 ^= F(D1, cs->K[0]);

+ D1 ^= F(D2, cs->K[1]);

+ D2 ^= F(D1, cs->K[2]);

+ D1 ^= F(D2, cs->K[3]);

+ D2 ^= F(D1, cs->K[4]);

+ D1 ^= F(D2, cs->K[5]);

+ D1 = FL(D1, cs->Ke[0]);

+ D2 = FLINV(D2, cs->Ke[1]);

+ D2 ^= F(D1, cs->K[6]);

+ D1 ^= F(D2, cs->K[7]);

+ D2 ^= F(D1, cs->K[8]);

+ D1 ^= F(D2, cs->K[9]);

+ D2 ^= F(D1, cs->K[10]);

+ D1 ^= F(D2, cs->K[11]);

+ D1 = FL(D1, cs->Ke[2]);

+ D2 = FLINV(D2, cs->Ke[3]);

+ D2 ^= F(D1, cs->K[12]);

+ D1 ^= F(D2, cs->K[13]);

+ D2 ^= F(D1, cs->K[14]);

+ D1 ^= F(D2, cs->K[15]);

+ D2 ^= F(D1, cs->K[16]);

+ D1 ^= F(D2, cs->K[17]);

+ if (cs->key_bits != 128) {

+ D1 = FL(D1, cs->Ke[4]);

+ D2 = FLINV(D2, cs->Ke[5]);

+ D2 ^= F(D1, cs->K[18]);

+ D1 ^= F(D2, cs->K[19]);

+ D2 ^= F(D1, cs->K[20]);

+ D1 ^= F(D2, cs->K[21]);

+ D2 ^= F(D1, cs->K[22]);

+ D1 ^= F(D2, cs->K[23]);

+ }

+ D2 ^= cs->Kw[2];

+ D1 ^= cs->Kw[3];

+ AV_WB64(dst, D2);

+ AV_WB64(dst + 8, D1);

+}

+

+static void camellia_decrypt(AVCAMELLIA *cs, uint8_t *dst, const uint8_t *src, uint8_t *iv)

+{

+ uint64_t D1, D2;

+ D1 = AV_RB64(src);

+ D2 = AV_RB64(src + 8);

+ D1 ^= cs->Kw[2];

+ D2 ^= cs->Kw[3];

+ if (cs->key_bits != 128) {

+ D2 ^= F(D1, cs->K[23]);

+ D1 ^= F(D2, cs->K[22]);

+ D2 ^= F(D1, cs->K[21]);

+ D1 ^= F(D2, cs->K[20]);

+ D2 ^= F(D1, cs->K[19]);

+ D1 ^= F(D2, cs->K[18]);

+ D1 = FL(D1, cs->Ke[5]);

+ D2 = FLINV(D2, cs->Ke[4]);

+ }

+ D2 ^= F(D1, cs->K[17]);

+ D1 ^= F(D2, cs->K[16]);

+ D2 ^= F(D1, cs->K[15]);

+ D1 ^= F(D2, cs->K[14]);

+ D2 ^= F(D1, cs->K[13]);

+ D1 ^= F(D2, cs->K[12]);

+ D1 = FL(D1, cs->Ke[3]);

+ D2 = FLINV(D2, cs->Ke[2]);

+ D2 ^= F(D1, cs->K[11]);

+ D1 ^= F(D2, cs->K[10]);

+ D2 ^= F(D1, cs->K[9]);

+ D1 ^= F(D2, cs->K[8]);

+ D2 ^= F(D1, cs->K[7]);

+ D1 ^= F(D2, cs->K[6]);

+ D1 = FL(D1, cs->Ke[1]);

+ D2 = FLINV(D2, cs->Ke[0]);

+ D2 ^= F(D1, cs->K[5]);

+ D1 ^= F(D2, cs->K[4]);

+ D2 ^= F(D1, cs->K[3]);

+ D1 ^= F(D2, cs->K[2]);

+ D2 ^= F(D1, cs->K[1]);

+ D1 ^= F(D2, cs->K[0]);

+ D2 ^= cs->Kw[0];

+ D1 ^= cs->Kw[1];

+ if (iv) {

+ D2 ^= AV_RB64(iv);

+ D1 ^= AV_RB64(iv + 8);

+ memcpy(iv, src, 16);

+ }

+ AV_WB64(dst, D2);

+ AV_WB64(dst + 8, D1);

+}

+

+static void computeSP(void)

+{

+ uint64_t z;

+ int i;

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

+ z = SBOX1[i];

+ SP[0][i] = (z << 56) ^ (z << 48) ^ (z << 40) ^ (z << 24) ^ z;

+ SP[7][i] = (z << 56) ^ (z << 48) ^ (z << 40) ^ (z << 24) ^ (z << 16) ^ (z << 8);

+ z = SBOX2[i];

+ SP[1][i] = (z << 48) ^ (z << 40) ^ (z << 32) ^ (z << 24) ^ (z << 16);

+ SP[4][i] = (z << 48) ^ (z << 40) ^ (z << 32) ^ (z << 16) ^ (z << 8) ^ z;

+ z = SBOX3[i];

+ SP[2][i] = (z << 56) ^ (z << 40) ^ (z << 32) ^ (z << 16) ^ (z << 8);

+ SP[5][i] = (z << 56) ^ (z << 40) ^ (z << 32) ^ (z << 24) ^ (z << 8) ^ z;

+ z = SBOX4[i];

+ SP[3][i] = (z << 56) ^ (z << 48) ^ (z << 32) ^ (z << 8) ^ z;

+ SP[6][i] = (z << 56) ^ (z << 48) ^ (z << 32) ^ (z << 24) ^ (z << 16) ^ z;

+ }

+}

+

+struct AVCAMELLIA *av_camellia_alloc(void)

+{

+ return av_mallocz(sizeof(struct AVCAMELLIA));

+}

+

+av_cold int av_camellia_init(AVCAMELLIA *cs, const uint8_t *key, int key_bits)

+{

+ uint64_t Kl[2], Kr[2], Ka[2], Kb[2];

+ uint64_t D1, D2;

+ if (key_bits != 128 && key_bits != 192 && key_bits != 256)

+ return -1;

+ memset(Kb, 0, sizeof(Kb));

+ memset(Kr, 0, sizeof(Kr));

+ cs->key_bits = key_bits;

+ Kl[0] = AV_RB64(key);

+ Kl[1] = AV_RB64(key + 8);

+ if (key_bits == 192) {

+ Kr[0] = AV_RB64(key + 16);

+ Kr[1] = ~Kr[0];

+ } else if (key_bits == 256) {

+ Kr[0] = AV_RB64(key + 16);

+ Kr[1] = AV_RB64(key + 24);

+ }

+ computeSP();

+ D1 = Kl[0] ^ Kr[0];

+ D2 = Kl[1] ^ Kr[1];

+ D2 ^= F(D1, Sigma1);

+ D1 ^= F(D2, Sigma2);

+ D1 ^= Kl[0];

+ D2 ^= Kl[1];

+ D2 ^= F(D1, Sigma3);

+ D1 ^= F(D2, Sigma4);

+ Ka[0] = D1;

+ Ka[1] = D2;

+ if (key_bits != 128) {

+ D1 = Ka[0] ^ Kr[0];

+ D2 = Ka[1] ^ Kr[1];

+ D2 ^= F(D1, Sigma5);

+ D1 ^= F(D2, Sigma6);

+ Kb[0] = D1;

+ Kb[1] = D2;

+ }

+ generate_round_keys(cs, Kl, Kr, Ka, Kb);

+ return 0;

+}

+

+void av_camellia_crypt(AVCAMELLIA *cs, uint8_t *dst, const uint8_t *src, int count, uint8_t *iv, int decrypt)

+{

+ int i;

+ while (count--) {

+ if (decrypt) {

+ camellia_decrypt(cs, dst, src, iv);

+ } else {

+ if (iv) {

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

+ dst[i] = src[i] ^ iv[i];

+ camellia_encrypt(cs, dst, dst);

+ memcpy(iv, dst, 16);

+ } else {

+ camellia_encrypt(cs, dst, src);

+ }

+ }

+ src = src + 16;

+ dst = dst + 16;

+ }

+}

+

+#ifdef TEST

+#include<stdio.h>

+#include<stdlib.h>

+#include"log.h"

+

+int main(int argc, char *argv[])

+{

+ const uint8_t Key[3][32] = {

+ {0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef, 0xfe, 0xdc, 0xba, 0x98, 0x76, 0x54, 0x32, 0x10},

+ {0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef, 0xfe, 0xdc, 0xba, 0x98, 0x76, 0x54, 0x32, 0x10, 0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77},

+ {0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef, 0xfe, 0xdc, 0xba, 0x98, 0x76, 0x54, 0x32, 0x10, 0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88, 0x99, 0xaa, 0xbb, 0xcc, 0xdd, 0xee, 0xff}

+ };

+ const uint8_t rct[3][16] = {

+ {0x67, 0x67, 0x31, 0x38, 0x54, 0x96, 0x69, 0x73, 0x08, 0x57, 0x06, 0x56, 0x48, 0xea, 0xbe, 0x43},

+ {0xb4, 0x99, 0x34, 0x01, 0xb3, 0xe9,0x96, 0xf8, 0x4e, 0xe5, 0xce, 0xe7, 0xd7, 0x9b, 0x09, 0xb9},

+ {0x9a, 0xcc, 0x23, 0x7d, 0xff, 0x16, 0xd7, 0x6c, 0x20, 0xef, 0x7c, 0x91, 0x9e, 0x3a, 0x75, 0x09}

+ };

+ const uint8_t rpt[32] = {0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef, 0xfe, 0xdc, 0xba, 0x98, 0x76, 0x54, 0x32, 0x10, 0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef, 0xfe, 0xdc, 0xba, 0x98, 0x76, 0x54, 0x32, 0x10};

+ const int kbits[3] = {128, 192, 256};

+ int i, j, err = 0;

+ uint8_t temp[32], iv[16];

+ AVCAMELLIA *cs;

+ cs = av_camellia_alloc();

+ if (!cs)

+ return 1;

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

+ av_camellia_init(cs, Key[j], kbits[j]);

+ av_camellia_crypt(cs, temp, rpt, 1, NULL, 0);

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

+ if (rct[j][i] != temp[i]) {

+ av_log(NULL, AV_LOG_ERROR, "%d %02x %02x\n", i, rct[j][i], temp[i]);

+ err = 1;

+ }

+ }

+ av_camellia_crypt(cs, temp, rct[j], 1, NULL, 1);

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

+ if (rpt[i] != temp[i]) {

+ av_log(NULL, AV_LOG_ERROR, "%d %02x %02x\n", i, rpt[i], temp[i]);

+ err = 1;

+ }

+ }

+ }

+ av_camellia_init(cs, Key[0], 128);

+ memcpy(iv, "HALLO123HALLO123", 16);

+ av_camellia_crypt(cs, temp, rpt, 2, iv, 0);

+ memcpy(iv, "HALLO123HALLO123", 16);

+ av_camellia_crypt(cs, temp, temp, 2, iv, 1);

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

+ if (rpt[i] != temp[i]) {

+ av_log(NULL, AV_LOG_ERROR, "%d %02x %02x\n", i, rpt[i], temp[i]);

+ err = 1;

+ }

+ }

+ av_free(cs);

+ return err;

+}

+#endif

+/*

+ * An implementation of the CAMELLIA algorithm as mentioned in RFC3713

+ * Copyright (c) 2014 Supraja Meedinti

+ *

+ * This file is part of FFmpeg.

+ *

+ * FFmpeg is free software; you can redistribute it and/or

+ * modify it under the terms of the GNU Lesser General Public

+ * License as published by the Free Software Foundation; either

+ * version 2.1 of the License, or (at your option) any later version.

+ *

+ * FFmpeg is distributed in the hope that it will be useful,

+ * but WITHOUT ANY WARRANTY; without even the implied warranty of

+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU

+ * Lesser General Public License for more details.

+ *

+ * You should have received a copy of the GNU Lesser General Public

+ * License along with FFmpeg; if not, write to the Free Software

+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA

+ */

+

+#ifndef AVUTIL_CAMELLIA_H

+#define AVUTIL_CAMELLIA_H

+

+#include <stdint.h>

+

+

+/**

+ * @file

+ * @brief Public header for libavutil CAMELLIA algorithm

+ * @defgroup lavu_camellia CAMELLIA

+ * @ingroup lavu_crypto

+ * @{

+ */

+

+extern const int av_camellia_size;

+

+struct AVCAMELLIA;

+

+/**

+ * Allocate an AVCAMELLIA context

+ * To free the struct: av_free(ptr)

+ */

+struct AVCAMELLIA *av_camellia_alloc(void);

+

+/**

+ * Initialize an AVCAMELLIA context.

+ *

+ * @param ctx an AVCAMELLIA context

+ * @param key a key of 16, 24, 32 bytes used for encryption/decryption

+ * @param key_bits number of keybits: possible are 128, 192, 256

+ */

+int av_camellia_init(struct AVCAMELLIA *ctx, const uint8_t *key, int key_bits);

+

+/**

+ * Encrypt or decrypt a buffer using a previously initialized context

+ *

+ * @param ctx an AVCAMELLIA context

+ * @param dst destination array, can be equal to src

+ * @param src source array, can be equal to dst

+ * @param count number of 16 byte blocks

+ * @paran iv initialization vector for CBC mode, NULL for ECB mode

+ * @param decrypt 0 for encryption, 1 for decryption

+ */

+void av_camellia_crypt(struct AVCAMELLIA *ctx, uint8_t *dst, const uint8_t *src, int count, uint8_t* iv, int decrypt);

+

+/**

+ * @}

+ */

+#endif /* AVUTIL_CAMELLIA_H */

+/*

+ * An implementation of the CAST128 algorithm as mentioned in RFC2144

+ * Copyright (c) 2014 Supraja Meedinti

+ *

+ * This file is part of FFmpeg.

+ *

+ * FFmpeg is free software; you can redistribute it and/or

+ * modify it under the terms of the GNU Lesser General Public

+ * License as published by the Free Software Foundation; either

+ * version 2.1 of the License, or (at your option) any later version.

+ *

+ * FFmpeg is distributed in the hope that it will be useful,

+ * but WITHOUT ANY WARRANTY; without even the implied warranty of

+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU

+ * Lesser General Public License for more details.

+ *

+ * You should have received a copy of the GNU Lesser General Public

+ * License along with FFmpeg; if not, write to the Free Software

+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA

+ */

+#include "cast5.h"

+#include "common.h"

+#include "intreadwrite.h"

+#include "attributes.h"

+

+#define IA(x) ((x) >> 24)

+#define IB(x) (((x) >> 16) & 0xff)

+#define IC(x) (((x) >> 8) & 0xff)

+#define ID(x) ((x) & 0xff)

+

+#define LR(x, c) (((x) << (c)) | ((x) >> (32 - (c))))

+

+#define F3(l, r, i) \

+ do { \

+ I = LR(cs->Km[i] - r, cs->Kr[i]); \

+ f = ((S1[IA(I)] + S2[IB(I)]) ^ S3[IC(I)]) - S4[ID(I)]; \

+ l = f ^ l; \

+ } while (0)

+

+#define F2(l, r, i) \

+ do { \

+ I = LR(cs->Km[i] ^ r, cs->Kr[i]); \

+ f = ((S1[IA(I)] - S2[IB(I)]) + S3[IC(I)]) ^ S4[ID(I)]; \

+ l = f ^ l; \

+ } while (0)

+

+#define F1(l, r, i) \

+ do { \

+ I = LR(cs->Km[i] + r, cs->Kr[i]); \

+ f = ((S1[IA(I)] ^ S2[IB(I)]) - S3[IC(I)]) + S4[ID(I)]; \

+ l = f ^ l; \

+ } while (0)

+

+#define COMPUTE_Z \

+ do { \

+ z[0] = x[0] ^ S5[IB(x[3])] ^ S6[ID(x[3])] ^ S7[IA(x[3])] ^ S8[IC(x[3])] ^ S7[IA(x[2])]; \

+ z[1] = x[2] ^ S5[IA(z[0])] ^ S6[IC(z[0])] ^ S7[IB(z[0])] ^ S8[ID(z[0])] ^ S8[IC(x[2])]; \

+ z[2] = x[3] ^ S5[ID(z[1])] ^ S6[IC(z[1])] ^ S7[IB(z[1])] ^ S8[IA(z[1])] ^ S5[IB(x[2])]; \

+ z[3] = x[1] ^ S5[IC(z[2])] ^ S6[IB(z[2])] ^ S7[ID(z[2])] ^ S8[IA(z[2])] ^ S6[ID(x[2])]; \

+ } while (0)

+

+#define COMPUTE_X \

+ do { \

+ x[0] = z[2] ^ S5[IB(z[1])] ^ S6[ID(z[1])] ^ S7[IA(z[1])] ^ S8[IC(z[1])] ^ S7[IA(z[0])]; \

+ x[1] = z[0] ^ S5[IA(x[0])] ^ S6[IC(x[0])] ^ S7[IB(x[0])] ^ S8[ID(x[0])] ^ S8[IC(z[0])]; \

+ x[2] = z[1] ^ S5[ID(x[1])] ^ S6[IC(x[1])] ^ S7[IB(x[1])] ^ S8[IA(x[1])] ^ S5[IB(z[0])]; \

+ x[3] = z[3] ^ S5[IC(x[2])] ^ S6[IB(x[2])] ^ S7[ID(x[2])] ^ S8[IA(x[2])] ^ S6[ID(z[0])]; \

+ } while (0)

+

+

+typedef struct AVCAST5 {

+ uint32_t Km[17];

+ uint32_t Kr[17];

+ int rounds;

+} AVCAST5;

+

+const int av_cast5_size = sizeof(AVCAST5);

+

+static const uint32_t S1[256] = {

+ 0x30fb40d4, 0x9fa0ff0b, 0x6beccd2f, 0x3f258c7a, 0x1e213f2f, 0x9c004dd3, 0x6003e540, 0xcf9fc949,

+ 0xbfd4af27, 0x88bbbdb5, 0xe2034090, 0x98d09675, 0x6e63a0e0, 0x15c361d2, 0xc2e7661d, 0x22d4ff8e,

+ 0x28683b6f, 0xc07fd059, 0xff2379c8, 0x775f50e2, 0x43c340d3, 0xdf2f8656, 0x887ca41a, 0xa2d2bd2d,

+ 0xa1c9e0d6, 0x346c4819, 0x61b76d87, 0x22540f2f, 0x2abe32e1, 0xaa54166b, 0x22568e3a, 0xa2d341d0,

+ 0x66db40c8, 0xa784392f, 0x004dff2f, 0x2db9d2de, 0x97943fac, 0x4a97c1d8, 0x527644b7, 0xb5f437a7,

+ 0xb82cbaef, 0xd751d159, 0x6ff7f0ed, 0x5a097a1f, 0x827b68d0, 0x90ecf52e, 0x22b0c054, 0xbc8e5935,

+ 0x4b6d2f7f, 0x50bb64a2, 0xd2664910, 0xbee5812d, 0xb7332290, 0xe93b159f, 0xb48ee411, 0x4bff345d,

+ 0xfd45c240, 0xad31973f, 0xc4f6d02e, 0x55fc8165, 0xd5b1caad, 0xa1ac2dae, 0xa2d4b76d, 0xc19b0c50,

+ 0x882240f2, 0x0c6e4f38, 0xa4e4bfd7, 0x4f5ba272, 0x564c1d2f, 0xc59c5319, 0xb949e354, 0xb04669fe,

+ 0xb1b6ab8a, 0xc71358dd, 0x6385c545, 0x110f935d, 0x57538ad5, 0x6a390493, 0xe63d37e0, 0x2a54f6b3,

+ 0x3a787d5f, 0x6276a0b5, 0x19a6fcdf, 0x7a42206a, 0x29f9d4d5, 0xf61b1891, 0xbb72275e, 0xaa508167,

+ 0x38901091, 0xc6b505eb, 0x84c7cb8c, 0x2ad75a0f, 0x874a1427, 0xa2d1936b, 0x2ad286af, 0xaa56d291,

+ 0xd7894360, 0x425c750d, 0x93b39e26, 0x187184c9, 0x6c00b32d, 0x73e2bb14, 0xa0bebc3c, 0x54623779,

+ 0x64459eab, 0x3f328b82, 0x7718cf82, 0x59a2cea6, 0x04ee002e, 0x89fe78e6, 0x3fab0950, 0x325ff6c2,

+ 0x81383f05, 0x6963c5c8, 0x76cb5ad6, 0xd49974c9, 0xca180dcf, 0x380782d5, 0xc7fa5cf6, 0x8ac31511,

+ 0x35e79e13, 0x47da91d0, 0xf40f9086, 0xa7e2419e, 0x31366241, 0x051ef495, 0xaa573b04, 0x4a805d8d,

+ 0x548300d0, 0x00322a3c, 0xbf64cddf, 0xba57a68e, 0x75c6372b, 0x50afd341, 0xa7c13275, 0x915a0bf5,

+ 0x6b54bfab, 0x2b0b1426, 0xab4cc9d7, 0x449ccd82, 0xf7fbf265, 0xab85c5f3, 0x1b55db94, 0xaad4e324,

+ 0xcfa4bd3f, 0x2deaa3e2, 0x9e204d02, 0xc8bd25ac, 0xeadf55b3, 0xd5bd9e98, 0xe31231b2, 0x2ad5ad6c,

+ 0x954329de, 0xadbe4528, 0xd8710f69, 0xaa51c90f, 0xaa786bf6, 0x22513f1e, 0xaa51a79b, 0x2ad344cc,

+ 0x7b5a41f0, 0xd37cfbad, 0x1b069505, 0x41ece491, 0xb4c332e6, 0x032268d4, 0xc9600acc, 0xce387e6d,

+ 0xbf6bb16c, 0x6a70fb78, 0x0d03d9c9, 0xd4df39de, 0xe01063da, 0x4736f464, 0x5ad328d8, 0xb347cc96,

+ 0x75bb0fc3, 0x98511bfb, 0x4ffbcc35, 0xb58bcf6a, 0xe11f0abc, 0xbfc5fe4a, 0xa70aec10, 0xac39570a,

+ 0x3f04442f, 0x6188b153, 0xe0397a2e, 0x5727cb79, 0x9ceb418f, 0x1cacd68d, 0x2ad37c96, 0x0175cb9d,

+ 0xc69dff09, 0xc75b65f0, 0xd9db40d8, 0xec0e7779, 0x4744ead4, 0xb11c3274, 0xdd24cb9e, 0x7e1c54bd,

+ 0xf01144f9, 0xd2240eb1, 0x9675b3fd, 0xa3ac3755, 0xd47c27af, 0x51c85f4d, 0x56907596, 0xa5bb15e6,

+ 0x580304f0, 0xca042cf1, 0x011a37ea, 0x8dbfaadb, 0x35ba3e4a, 0x3526ffa0, 0xc37b4d09, 0xbc306ed9,

+ 0x98a52666, 0x5648f725, 0xff5e569d, 0x0ced63d0, 0x7c63b2cf, 0x700b45e1, 0xd5ea50f1, 0x85a92872,

+ 0xaf1fbda7, 0xd4234870, 0xa7870bf3, 0x2d3b4d79, 0x42e04198, 0x0cd0ede7, 0x26470db8, 0xf881814c,

+ 0x474d6ad7, 0x7c0c5e5c, 0xd1231959, 0x381b7298, 0xf5d2f4db, 0xab838653, 0x6e2f1e23, 0x83719c9e,

+ 0xbd91e046, 0x9a56456e, 0xdc39200c, 0x20c8c571, 0x962bda1c, 0xe1e696ff, 0xb141ab08, 0x7cca89b9,

+ 0x1a69e783, 0x02cc4843, 0xa2f7c579, 0x429ef47d, 0x427b169c, 0x5ac9f049, 0xdd8f0f00, 0x5c8165bf

+};

+

+static const uint32_t S2[256] = {

+ 0x1f201094, 0xef0ba75b, 0x69e3cf7e, 0x393f4380, 0xfe61cf7a, 0xeec5207a, 0x55889c94, 0x72fc0651,

+ 0xada7ef79, 0x4e1d7235, 0xd55a63ce, 0xde0436ba, 0x99c430ef, 0x5f0c0794, 0x18dcdb7d, 0xa1d6eff3,

+ 0xa0b52f7b, 0x59e83605, 0xee15b094, 0xe9ffd909, 0xdc440086, 0xef944459, 0xba83ccb3, 0xe0c3cdfb,

+ 0xd1da4181, 0x3b092ab1, 0xf997f1c1, 0xa5e6cf7b, 0x01420ddb, 0xe4e7ef5b, 0x25a1ff41, 0xe180f806,

+ 0x1fc41080, 0x179bee7a, 0xd37ac6a9, 0xfe5830a4, 0x98de8b7f, 0x77e83f4e, 0x79929269, 0x24fa9f7b,

+ 0xe113c85b, 0xacc40083, 0xd7503525, 0xf7ea615f, 0x62143154, 0x0d554b63, 0x5d681121, 0xc866c359,

+ 0x3d63cf73, 0xcee234c0, 0xd4d87e87, 0x5c672b21, 0x071f6181, 0x39f7627f, 0x361e3084, 0xe4eb573b,

+ 0x602f64a4, 0xd63acd9c, 0x1bbc4635, 0x9e81032d, 0x2701f50c, 0x99847ab4, 0xa0e3df79, 0xba6cf38c,

+ 0x10843094, 0x2537a95e, 0xf46f6ffe, 0xa1ff3b1f, 0x208cfb6a, 0x8f458c74, 0xd9e0a227, 0x4ec73a34,

+ 0xfc884f69, 0x3e4de8df, 0xef0e0088, 0x3559648d, 0x8a45388c, 0x1d804366, 0x721d9bfd, 0xa58684bb,

+ 0xe8256333, 0x844e8212, 0x128d8098, 0xfed33fb4, 0xce280ae1, 0x27e19ba5, 0xd5a6c252, 0xe49754bd,

+ 0xc5d655dd, 0xeb667064, 0x77840b4d, 0xa1b6a801, 0x84db26a9, 0xe0b56714, 0x21f043b7, 0xe5d05860,

+ 0x54f03084, 0x066ff472, 0xa31aa153, 0xdadc4755, 0xb5625dbf, 0x68561be6, 0x83ca6b94, 0x2d6ed23b,

+ 0xeccf01db, 0xa6d3d0ba, 0xb6803d5c, 0xaf77a709, 0x33b4a34c, 0x397bc8d6, 0x5ee22b95, 0x5f0e5304,

+ 0x81ed6f61, 0x20e74364, 0xb45e1378, 0xde18639b, 0x881ca122, 0xb96726d1, 0x8049a7e8, 0x22b7da7b,

+ 0x5e552d25, 0x5272d237, 0x79d2951c, 0xc60d894c, 0x488cb402, 0x1ba4fe5b, 0xa4b09f6b, 0x1ca815cf,

+ 0xa20c3005, 0x8871df63, 0xb9de2fcb, 0x0cc6c9e9, 0x0beeff53, 0xe3214517, 0xb4542835, 0x9f63293c,

+ 0xee41e729, 0x6e1d2d7c, 0x50045286, 0x1e6685f3, 0xf33401c6, 0x30a22c95, 0x31a70850, 0x60930f13,

+ 0x73f98417, 0xa1269859, 0xec645c44, 0x52c877a9, 0xcdff33a6, 0xa02b1741, 0x7cbad9a2, 0x2180036f,

+ 0x50d99c08, 0xcb3f4861, 0xc26bd765, 0x64a3f6ab, 0x80342676, 0x25a75e7b, 0xe4e6d1fc, 0x20c710e6,

+ 0xcdf0b680, 0x17844d3b, 0x31eef84d, 0x7e0824e4, 0x2ccb49eb, 0x846a3bae, 0x8ff77888, 0xee5d60f6,

+ 0x7af75673, 0x2fdd5cdb, 0xa11631c1, 0x30f66f43, 0xb3faec54, 0x157fd7fa, 0xef8579cc, 0xd152de58,

+ 0xdb2ffd5e, 0x8f32ce19, 0x306af97a, 0x02f03ef8, 0x99319ad5, 0xc242fa0f, 0xa7e3ebb0, 0xc68e4906,

+ 0xb8da230c, 0x80823028, 0xdcdef3c8, 0xd35fb171, 0x088a1bc8, 0xbec0c560, 0x61a3c9e8, 0xbca8f54d,

+ 0xc72feffa, 0x22822e99, 0x82c570b4, 0xd8d94e89, 0x8b1c34bc, 0x301e16e6, 0x273be979, 0xb0ffeaa6,

+ 0x61d9b8c6, 0x00b24869, 0xb7ffce3f, 0x08dc283b, 0x43daf65a, 0xf7e19798, 0x7619b72f, 0x8f1c9ba4,

+ 0xdc8637a0, 0x16a7d3b1, 0x9fc393b7, 0xa7136eeb, 0xc6bcc63e, 0x1a513742, 0xef6828bc, 0x520365d6,

+ 0x2d6a77ab, 0x3527ed4b, 0x821fd216, 0x095c6e2e, 0xdb92f2fb, 0x5eea29cb, 0x145892f5, 0x91584f7f,

+ 0x5483697b, 0x2667a8cc, 0x85196048, 0x8c4bacea, 0x833860d4, 0x0d23e0f9, 0x6c387e8a, 0x0ae6d249,

+ 0xb284600c, 0xd835731d, 0xdcb1c647, 0xac4c56ea, 0x3ebd81b3, 0x230eabb0, 0x6438bc87, 0xf0b5b1fa,

+ 0x8f5ea2b3, 0xfc184642, 0x0a036b7a, 0x4fb089bd, 0x649da589, 0xa345415e, 0x5c038323, 0x3e5d3bb9,

+ 0x43d79572, 0x7e6dd07c, 0x06dfdf1e, 0x6c6cc4ef, 0x7160a539, 0x73bfbe70, 0x83877605, 0x4523ecf1

+};

+

+static const uint32_t S3[256] = {

+ 0x8defc240, 0x25fa5d9f, 0xeb903dbf, 0xe810c907, 0x47607fff, 0x369fe44b, 0x8c1fc644, 0xaececa90,

+ 0xbeb1f9bf, 0xeefbcaea, 0xe8cf1950, 0x51df07ae, 0x920e8806, 0xf0ad0548, 0xe13c8d83, 0x927010d5,

+ 0x11107d9f, 0x07647db9, 0xb2e3e4d4, 0x3d4f285e, 0xb9afa820, 0xfade82e0, 0xa067268b, 0x8272792e,

+ 0x553fb2c0, 0x489ae22b, 0xd4ef9794, 0x125e3fbc, 0x21fffcee, 0x825b1bfd, 0x9255c5ed, 0x1257a240,

+ 0x4e1a8302, 0xbae07fff, 0x528246e7, 0x8e57140e, 0x3373f7bf, 0x8c9f8188, 0xa6fc4ee8, 0xc982b5a5,

+ 0xa8c01db7, 0x579fc264, 0x67094f31, 0xf2bd3f5f, 0x40fff7c1, 0x1fb78dfc, 0x8e6bd2c1, 0x437be59b,

+ 0x99b03dbf, 0xb5dbc64b, 0x638dc0e6, 0x55819d99, 0xa197c81c, 0x4a012d6e, 0xc5884a28, 0xccc36f71,

+ 0xb843c213, 0x6c0743f1, 0x8309893c, 0x0feddd5f, 0x2f7fe850, 0xd7c07f7e, 0x02507fbf, 0x5afb9a04,

+ 0xa747d2d0, 0x1651192e, 0xaf70bf3e, 0x58c31380, 0x5f98302e, 0x727cc3c4, 0x0a0fb402, 0x0f7fef82,

+ 0x8c96fdad, 0x5d2c2aae, 0x8ee99a49, 0x50da88b8, 0x8427f4a0, 0x1eac5790, 0x796fb449, 0x8252dc15,

+ 0xefbd7d9b, 0xa672597d, 0xada840d8, 0x45f54504, 0xfa5d7403, 0xe83ec305, 0x4f91751a, 0x925669c2,

+ 0x23efe941, 0xa903f12e, 0x60270df2, 0x0276e4b6, 0x94fd6574, 0x927985b2, 0x8276dbcb, 0x02778176,

+ 0xf8af918d, 0x4e48f79e, 0x8f616ddf, 0xe29d840e, 0x842f7d83, 0x340ce5c8, 0x96bbb682, 0x93b4b148,

+ 0xef303cab, 0x984faf28, 0x779faf9b, 0x92dc560d, 0x224d1e20, 0x8437aa88, 0x7d29dc96, 0x2756d3dc,

+ 0x8b907cee, 0xb51fd240, 0xe7c07ce3, 0xe566b4a1, 0xc3e9615e, 0x3cf8209d, 0x6094d1e3, 0xcd9ca341,

+ 0x5c76460e, 0x00ea983b, 0xd4d67881, 0xfd47572c, 0xf76cedd9, 0xbda8229c, 0x127dadaa, 0x438a074e,

+ 0x1f97c090, 0x081bdb8a, 0x93a07ebe, 0xb938ca15, 0x97b03cff, 0x3dc2c0f8, 0x8d1ab2ec, 0x64380e51,

+ 0x68cc7bfb, 0xd90f2788, 0x12490181, 0x5de5ffd4, 0xdd7ef86a, 0x76a2e214, 0xb9a40368, 0x925d958f,

+ 0x4b39fffa, 0xba39aee9, 0xa4ffd30b, 0xfaf7933b, 0x6d498623, 0x193cbcfa, 0x27627545, 0x825cf47a,

+ 0x61bd8ba0, 0xd11e42d1, 0xcead04f4, 0x127ea392, 0x10428db7, 0x8272a972, 0x9270c4a8, 0x127de50b,

+ 0x285ba1c8, 0x3c62f44f, 0x35c0eaa5, 0xe805d231, 0x428929fb, 0xb4fcdf82, 0x4fb66a53, 0x0e7dc15b,

+ 0x1f081fab, 0x108618ae, 0xfcfd086d, 0xf9ff2889, 0x694bcc11, 0x236a5cae, 0x12deca4d, 0x2c3f8cc5,

+ 0xd2d02dfe, 0xf8ef5896, 0xe4cf52da, 0x95155b67, 0x494a488c, 0xb9b6a80c, 0x5c8f82bc, 0x89d36b45,

+ 0x3a609437, 0xec00c9a9, 0x44715253, 0x0a874b49, 0xd773bc40, 0x7c34671c, 0x02717ef6, 0x4feb5536,

+ 0xa2d02fff, 0xd2bf60c4, 0xd43f03c0, 0x50b4ef6d, 0x07478cd1, 0x006e1888, 0xa2e53f55, 0xb9e6d4bc,

+ 0xa2048016, 0x97573833, 0xd7207d67, 0xde0f8f3d, 0x72f87b33, 0xabcc4f33, 0x7688c55d, 0x7b00a6b0,

+ 0x947b0001, 0x570075d2, 0xf9bb88f8, 0x8942019e, 0x4264a5ff, 0x856302e0, 0x72dbd92b, 0xee971b69,

+ 0x6ea22fde, 0x5f08ae2b, 0xaf7a616d, 0xe5c98767, 0xcf1febd2, 0x61efc8c2, 0xf1ac2571, 0xcc8239c2,

+ 0x67214cb8, 0xb1e583d1, 0xb7dc3e62, 0x7f10bdce, 0xf90a5c38, 0x0ff0443d, 0x606e6dc6, 0x60543a49,

+ 0x5727c148, 0x2be98a1d, 0x8ab41738, 0x20e1be24, 0xaf96da0f, 0x68458425, 0x99833be5, 0x600d457d,

+ 0x282f9350, 0x8334b362, 0xd91d1120, 0x2b6d8da0, 0x642b1e31, 0x9c305a00, 0x52bce688, 0x1b03588a,

+ 0xf7baefd5, 0x4142ed9c, 0xa4315c11, 0x83323ec5, 0xdfef4636, 0xa133c501, 0xe9d3531c, 0xee353783

+};

+

+static const uint32_t S4[256] = {

+ 0x9db30420, 0x1fb6e9de, 0xa7be7bef, 0xd273a298, 0x4a4f7bdb, 0x64ad8c57, 0x85510443, 0xfa020ed1,

+ 0x7e287aff, 0xe60fb663, 0x095f35a1, 0x79ebf120, 0xfd059d43, 0x6497b7b1, 0xf3641f63, 0x241e4adf,

+ 0x28147f5f, 0x4fa2b8cd, 0xc9430040, 0x0cc32220, 0xfdd30b30, 0xc0a5374f, 0x1d2d00d9, 0x24147b15,

+ 0xee4d111a, 0x0fca5167, 0x71ff904c, 0x2d195ffe, 0x1a05645f, 0x0c13fefe, 0x081b08ca, 0x05170121,

+ 0x80530100, 0xe83e5efe, 0xac9af4f8, 0x7fe72701, 0xd2b8ee5f, 0x06df4261, 0xbb9e9b8a, 0x7293ea25,

+ 0xce84ffdf, 0xf5718801, 0x3dd64b04, 0xa26f263b, 0x7ed48400, 0x547eebe6, 0x446d4ca0, 0x6cf3d6f5,

+ 0x2649abdf, 0xaea0c7f5, 0x36338cc1, 0x503f7e93, 0xd3772061, 0x11b638e1, 0x72500e03, 0xf80eb2bb,

+ 0xabe0502e, 0xec8d77de, 0x57971e81, 0xe14f6746, 0xc9335400, 0x6920318f, 0x081dbb99, 0xffc304a5,

+ 0x4d351805, 0x7f3d5ce3, 0xa6c866c6, 0x5d5bcca9, 0xdaec6fea, 0x9f926f91, 0x9f46222f, 0x3991467d,

+ 0xa5bf6d8e, 0x1143c44f, 0x43958302, 0xd0214eeb, 0x022083b8, 0x3fb6180c, 0x18f8931e, 0x281658e6,

+ 0x26486e3e, 0x8bd78a70, 0x7477e4c1, 0xb506e07c, 0xf32d0a25, 0x79098b02, 0xe4eabb81, 0x28123b23,

+ 0x69dead38, 0x1574ca16, 0xdf871b62, 0x211c40b7, 0xa51a9ef9, 0x0014377b, 0x041e8ac8, 0x09114003,

+ 0xbd59e4d2, 0xe3d156d5, 0x4fe876d5, 0x2f91a340, 0x557be8de, 0x00eae4a7, 0x0ce5c2ec, 0x4db4bba6,

+ 0xe756bdff, 0xdd3369ac, 0xec17b035, 0x06572327, 0x99afc8b0, 0x56c8c391, 0x6b65811c, 0x5e146119,

+ 0x6e85cb75, 0xbe07c002, 0xc2325577, 0x893ff4ec, 0x5bbfc92d, 0xd0ec3b25, 0xb7801ab7, 0x8d6d3b24,

+ 0x20c763ef, 0xc366a5fc, 0x9c382880, 0x0ace3205, 0xaac9548a, 0xeca1d7c7, 0x041afa32, 0x1d16625a,

+ 0x6701902c, 0x9b757a54, 0x31d477f7, 0x9126b031, 0x36cc6fdb, 0xc70b8b46, 0xd9e66a48, 0x56e55a79,

+ 0x026a4ceb, 0x52437eff, 0x2f8f76b4, 0x0df980a5, 0x8674cde3, 0xedda04eb, 0x17a9be04, 0x2c18f4df,

+ 0xb7747f9d, 0xab2af7b4, 0xefc34d20, 0x2e096b7c, 0x1741a254, 0xe5b6a035, 0x213d42f6, 0x2c1c7c26,

+ 0x61c2f50f, 0x6552daf9, 0xd2c231f8, 0x25130f69, 0xd8167fa2, 0x0418f2c8, 0x001a96a6, 0x0d1526ab,

+ 0x63315c21, 0x5e0a72ec, 0x49bafefd, 0x187908d9, 0x8d0dbd86, 0x311170a7, 0x3e9b640c, 0xcc3e10d7,

+ 0xd5cad3b6, 0x0caec388, 0xf73001e1, 0x6c728aff, 0x71eae2a1, 0x1f9af36e, 0xcfcbd12f, 0xc1de8417,

+ 0xac07be6b, 0xcb44a1d8, 0x8b9b0f56, 0x013988c3, 0xb1c52fca, 0xb4be31cd, 0xd8782806, 0x12a3a4e2,

+ 0x6f7de532, 0x58fd7eb6, 0xd01ee900, 0x24adffc2, 0xf4990fc5, 0x9711aac5, 0x001d7b95, 0x82e5e7d2,

+ 0x109873f6, 0x00613096, 0xc32d9521, 0xada121ff, 0x29908415, 0x7fbb977f, 0xaf9eb3db, 0x29c9ed2a,

+ 0x5ce2a465, 0xa730f32c, 0xd0aa3fe8, 0x8a5cc091, 0xd49e2ce7, 0x0ce454a9, 0xd60acd86, 0x015f1919,

+ 0x77079103, 0xdea03af6, 0x78a8565e, 0xdee356df, 0x21f05cbe, 0x8b75e387, 0xb3c50651, 0xb8a5c3ef,

+ 0xd8eeb6d2, 0xe523be77, 0xc2154529, 0x2f69efdf, 0xafe67afb, 0xf470c4b2, 0xf3e0eb5b, 0xd6cc9876,

+ 0x39e4460c, 0x1fda8538, 0x1987832f, 0xca007367, 0xa99144f8, 0x296b299e, 0x492fc295, 0x9266beab,

+ 0xb5676e69, 0x9bd3ddda, 0xdf7e052f, 0xdb25701c, 0x1b5e51ee, 0xf65324e6, 0x6afce36c, 0x0316cc04,

+ 0x8644213e, 0xb7dc59d0, 0x7965291f, 0xccd6fd43, 0x41823979, 0x932bcdf6, 0xb657c34d, 0x4edfd282,

+ 0x7ae5290c, 0x3cb9536b, 0x851e20fe, 0x9833557e, 0x13ecf0b0, 0xd3ffb372, 0x3f85c5c1, 0x0aef7ed2

+};

+

+static const uint32_t S5[256] = {

+ 0x7ec90c04, 0x2c6e74b9, 0x9b0e66df, 0xa6337911, 0xb86a7fff, 0x1dd358f5, 0x44dd9d44, 0x1731167f,

+ 0x08fbf1fa, 0xe7f511cc, 0xd2051b00, 0x735aba00, 0x2ab722d8, 0x386381cb, 0xacf6243a, 0x69befd7a,

+ 0xe6a2e77f, 0xf0c720cd, 0xc4494816, 0xccf5c180, 0x38851640, 0x15b0a848, 0xe68b18cb, 0x4caadeff,

+ 0x5f480a01, 0x0412b2aa, 0x259814fc, 0x41d0efe2, 0x4e40b48d, 0x248eb6fb, 0x8dba1cfe, 0x41a99b02,

+ 0x1a550a04, 0xba8f65cb, 0x7251f4e7, 0x95a51725, 0xc106ecd7, 0x97a5980a, 0xc539b9aa, 0x4d79fe6a,

+ 0xf2f3f763, 0x68af8040, 0xed0c9e56, 0x11b4958b, 0xe1eb5a88, 0x8709e6b0, 0xd7e07156, 0x4e29fea7,

+ 0x6366e52d, 0x02d1c000, 0xc4ac8e05, 0x9377f571, 0x0c05372a, 0x578535f2, 0x2261be02, 0xd642a0c9,

+ 0xdf13a280, 0x74b55bd2, 0x682199c0, 0xd421e5ec, 0x53fb3ce8, 0xc8adedb3, 0x28a87fc9, 0x3d959981,

+ 0x5c1ff900, 0xfe38d399, 0x0c4eff0b, 0x062407ea, 0xaa2f4fb1, 0x4fb96976, 0x90c79505, 0xb0a8a774,

+ 0xef55a1ff, 0xe59ca2c2, 0xa6b62d27, 0xe66a4263, 0xdf65001f, 0x0ec50966, 0xdfdd55bc, 0x29de0655,

+ 0x911e739a, 0x17af8975, 0x32c7911c, 0x89f89468, 0x0d01e980, 0x524755f4, 0x03b63cc9, 0x0cc844b2,

+ 0xbcf3f0aa, 0x87ac36e9, 0xe53a7426, 0x01b3d82b, 0x1a9e7449, 0x64ee2d7e, 0xcddbb1da, 0x01c94910,

+ 0xb868bf80, 0x0d26f3fd, 0x9342ede7, 0x04a5c284, 0x636737b6, 0x50f5b616, 0xf24766e3, 0x8eca36c1,

+ 0x136e05db, 0xfef18391, 0xfb887a37, 0xd6e7f7d4, 0xc7fb7dc9, 0x3063fcdf, 0xb6f589de, 0xec2941da,

+ 0x26e46695, 0xb7566419, 0xf654efc5, 0xd08d58b7, 0x48925401, 0xc1bacb7f, 0xe5ff550f, 0xb6083049,

+ 0x5bb5d0e8, 0x87d72e5a, 0xab6a6ee1, 0x223a66ce, 0xc62bf3cd, 0x9e0885f9, 0x68cb3e47, 0x086c010f,

+ 0xa21de820, 0xd18b69de, 0xf3f65777, 0xfa02c3f6, 0x407edac3, 0xcbb3d550, 0x1793084d, 0xb0d70eba,

+ 0x0ab378d5, 0xd951fb0c, 0xded7da56, 0x4124bbe4, 0x94ca0b56, 0x0f5755d1, 0xe0e1e56e, 0x6184b5be,

+ 0x580a249f, 0x94f74bc0, 0xe327888e, 0x9f7b5561, 0xc3dc0280, 0x05687715, 0x646c6bd7, 0x44904db3,

+ 0x66b4f0a3, 0xc0f1648a, 0x697ed5af, 0x49e92ff6, 0x309e374f, 0x2cb6356a, 0x85808573, 0x4991f840,

+ 0x76f0ae02, 0x083be84d, 0x28421c9a, 0x44489406, 0x736e4cb8, 0xc1092910, 0x8bc95fc6, 0x7d869cf4,

+ 0x134f616f, 0x2e77118d, 0xb31b2be1, 0xaa90b472, 0x3ca5d717, 0x7d161bba, 0x9cad9010, 0xaf462ba2,

+ 0x9fe459d2, 0x45d34559, 0xd9f2da13, 0xdbc65487, 0xf3e4f94e, 0x176d486f, 0x097c13ea, 0x631da5c7,

+ 0x445f7382, 0x175683f4, 0xcdc66a97, 0x70be0288, 0xb3cdcf72, 0x6e5dd2f3, 0x20936079, 0x459b80a5,

+ 0xbe60e2db, 0xa9c23101, 0xeba5315c, 0x224e42f2, 0x1c5c1572, 0xf6721b2c, 0x1ad2fff3, 0x8c25404e,

+ 0x324ed72f, 0x4067b7fd, 0x0523138e, 0x5ca3bc78, 0xdc0fd66e, 0x75922283, 0x784d6b17, 0x58ebb16e,

+ 0x44094f85, 0x3f481d87, 0xfcfeae7b, 0x77b5ff76, 0x8c2302bf, 0xaaf47556, 0x5f46b02a, 0x2b092801,

+ 0x3d38f5f7, 0x0ca81f36, 0x52af4a8a, 0x66d5e7c0, 0xdf3b0874, 0x95055110, 0x1b5ad7a8, 0xf61ed5ad,

+ 0x6cf6e479, 0x20758184, 0xd0cefa65, 0x88f7be58, 0x4a046826, 0x0ff6f8f3, 0xa09c7f70, 0x5346aba0,

+ 0x5ce96c28, 0xe176eda3, 0x6bac307f, 0x376829d2, 0x85360fa9, 0x17e3fe2a, 0x24b79767, 0xf5a96b20,

+ 0xd6cd2595, 0x68ff1ebf, 0x7555442c, 0xf19f06be, 0xf9e0659a, 0xeeb9491d, 0x34010718, 0xbb30cab8,

+ 0xe822fe15, 0x88570983, 0x750e6249, 0xda627e55, 0x5e76ffa8, 0xb1534546, 0x6d47de08, 0xefe9e7d4

+};

+

+static const uint32_t S6[256] = {

+ 0xf6fa8f9d, 0x2cac6ce1, 0x4ca34867, 0xe2337f7c, 0x95db08e7, 0x016843b4, 0xeced5cbc, 0x325553ac,

+ 0xbf9f0960, 0xdfa1e2ed, 0x83f0579d, 0x63ed86b9, 0x1ab6a6b8, 0xde5ebe39, 0xf38ff732, 0x8989b138,

+ 0x33f14961, 0xc01937bd, 0xf506c6da, 0xe4625e7e, 0xa308ea99, 0x4e23e33c, 0x79cbd7cc, 0x48a14367,

+ 0xa3149619, 0xfec94bd5, 0xa114174a, 0xeaa01866, 0xa084db2d, 0x09a8486f, 0xa888614a, 0x2900af98,

+ 0x01665991, 0xe1992863, 0xc8f30c60, 0x2e78ef3c, 0xd0d51932, 0xcf0fec14, 0xf7ca07d2, 0xd0a82072,

+ 0xfd41197e, 0x9305a6b0, 0xe86be3da, 0x74bed3cd, 0x372da53c, 0x4c7f4448, 0xdab5d440, 0x6dba0ec3,

+ 0x083919a7, 0x9fbaeed9, 0x49dbcfb0, 0x4e670c53, 0x5c3d9c01, 0x64bdb941, 0x2c0e636a, 0xba7dd9cd,

+ 0xea6f7388, 0xe70bc762, 0x35f29adb, 0x5c4cdd8d, 0xf0d48d8c, 0xb88153e2, 0x08a19866, 0x1ae2eac8,

+ 0x284caf89, 0xaa928223, 0x9334be53, 0x3b3a21bf, 0x16434be3, 0x9aea3906, 0xefe8c36e, 0xf890cdd9,

+ 0x80226dae, 0xc340a4a3, 0xdf7e9c09, 0xa694a807, 0x5b7c5ecc, 0x221db3a6, 0x9a69a02f, 0x68818a54,

+ 0xceb2296f, 0x53c0843a, 0xfe893655, 0x25bfe68a, 0xb4628abc, 0xcf222ebf, 0x25ac6f48, 0xa9a99387,

+ 0x53bddb65, 0xe76ffbe7, 0xe967fd78, 0x0ba93563, 0x8e342bc1, 0xe8a11be9, 0x4980740d, 0xc8087dfc,

+ 0x8de4bf99, 0xa11101a0, 0x7fd37975, 0xda5a26c0, 0xe81f994f, 0x9528cd89, 0xfd339fed, 0xb87834bf,

+ 0x5f04456d, 0x22258698, 0xc9c4c83b, 0x2dc156be, 0x4f628daa, 0x57f55ec5, 0xe2220abe, 0xd2916ebf,

+ 0x4ec75b95, 0x24f2c3c0, 0x42d15d99, 0xcd0d7fa0, 0x7b6e27ff, 0xa8dc8af0, 0x7345c106, 0xf41e232f,

+ 0x35162386, 0xe6ea8926, 0x3333b094, 0x157ec6f2, 0x372b74af, 0x692573e4, 0xe9a9d848, 0xf3160289,

+ 0x3a62ef1d, 0xa787e238, 0xf3a5f676, 0x74364853, 0x20951063, 0x4576698d, 0xb6fad407, 0x592af950,

+ 0x36f73523, 0x4cfb6e87, 0x7da4cec0, 0x6c152daa, 0xcb0396a8, 0xc50dfe5d, 0xfcd707ab, 0x0921c42f,

+ 0x89dff0bb, 0x5fe2be78, 0x448f4f33, 0x754613c9, 0x2b05d08d, 0x48b9d585, 0xdc049441, 0xc8098f9b,

+ 0x7dede786, 0xc39a3373, 0x42410005, 0x6a091751, 0x0ef3c8a6, 0x890072d6, 0x28207682, 0xa9a9f7be,

+ 0xbf32679d, 0xd45b5b75, 0xb353fd00, 0xcbb0e358, 0x830f220a, 0x1f8fb214, 0xd372cf08, 0xcc3c4a13,

+ 0x8cf63166, 0x061c87be, 0x88c98f88, 0x6062e397, 0x47cf8e7a, 0xb6c85283, 0x3cc2acfb, 0x3fc06976,

+ 0x4e8f0252, 0x64d8314d, 0xda3870e3, 0x1e665459, 0xc10908f0, 0x513021a5, 0x6c5b68b7, 0x822f8aa0,

+ 0x3007cd3e, 0x74719eef, 0xdc872681, 0x073340d4, 0x7e432fd9, 0x0c5ec241, 0x8809286c, 0xf592d891,

+ 0x08a930f6, 0x957ef305, 0xb7fbffbd, 0xc266e96f, 0x6fe4ac98, 0xb173ecc0, 0xbc60b42a, 0x953498da,

+ 0xfba1ae12, 0x2d4bd736, 0x0f25faab, 0xa4f3fceb, 0xe2969123, 0x257f0c3d, 0x9348af49, 0x361400bc,

+ 0xe8816f4a, 0x3814f200, 0xa3f94043, 0x9c7a54c2, 0xbc704f57, 0xda41e7f9, 0xc25ad33a, 0x54f4a084,

+ 0xb17f5505, 0x59357cbe, 0xedbd15c8, 0x7f97c5ab, 0xba5ac7b5, 0xb6f6deaf, 0x3a479c3a, 0x5302da25,

+ 0x653d7e6a, 0x54268d49, 0x51a477ea, 0x5017d55b, 0xd7d25d88, 0x44136c76, 0x0404a8c8, 0xb8e5a121,

+ 0xb81a928a, 0x60ed5869, 0x97c55b96, 0xeaec991b, 0x29935913, 0x01fdb7f1, 0x088e8dfa, 0x9ab6f6f5,

+ 0x3b4cbf9f, 0x4a5de3ab, 0xe6051d35, 0xa0e1d855, 0xd36b4cf1, 0xf544edeb, 0xb0e93524, 0xbebb8fbd,

+ 0xa2d762cf, 0x49c92f54, 0x38b5f331, 0x7128a454, 0x48392905, 0xa65b1db8, 0x851c97bd, 0xd675cf2f

+};

+

+static const uint32_t S7[256] = {

+ 0x85e04019, 0x332bf567, 0x662dbfff, 0xcfc65693, 0x2a8d7f6f, 0xab9bc912, 0xde6008a1, 0x2028da1f,

+ 0x0227bce7, 0x4d642916, 0x18fac300, 0x50f18b82, 0x2cb2cb11, 0xb232e75c, 0x4b3695f2, 0xb28707de,

+ 0xa05fbcf6, 0xcd4181e9, 0xe150210c, 0xe24ef1bd, 0xb168c381, 0xfde4e789, 0x5c79b0d8, 0x1e8bfd43,

+ 0x4d495001, 0x38be4341, 0x913cee1d, 0x92a79c3f, 0x089766be, 0xbaeeadf4, 0x1286becf, 0xb6eacb19,

+ 0x2660c200, 0x7565bde4, 0x64241f7a, 0x8248dca9, 0xc3b3ad66, 0x28136086, 0x0bd8dfa8, 0x356d1cf2,

+ 0x107789be, 0xb3b2e9ce, 0x0502aa8f, 0x0bc0351e, 0x166bf52a, 0xeb12ff82, 0xe3486911, 0xd34d7516,

+ 0x4e7b3aff, 0x5f43671b, 0x9cf6e037, 0x4981ac83, 0x334266ce, 0x8c9341b7, 0xd0d854c0, 0xcb3a6c88,

+ 0x47bc2829, 0x4725ba37, 0xa66ad22b, 0x7ad61f1e, 0x0c5cbafa, 0x4437f107, 0xb6e79962, 0x42d2d816,

+ 0x0a961288, 0xe1a5c06e, 0x13749e67, 0x72fc081a, 0xb1d139f7, 0xf9583745, 0xcf19df58, 0xbec3f756,

+ 0xc06eba30, 0x07211b24, 0x45c28829, 0xc95e317f, 0xbc8ec511, 0x38bc46e9, 0xc6e6fa14, 0xbae8584a,

+ 0xad4ebc46, 0x468f508b, 0x7829435f, 0xf124183b, 0x821dba9f, 0xaff60ff4, 0xea2c4e6d, 0x16e39264,

+ 0x92544a8b, 0x009b4fc3, 0xaba68ced, 0x9ac96f78, 0x06a5b79a, 0xb2856e6e, 0x1aec3ca9, 0xbe838688,

+ 0x0e0804e9, 0x55f1be56, 0xe7e5363b, 0xb3a1f25d, 0xf7debb85, 0x61fe033c, 0x16746233, 0x3c034c28,

+ 0xda6d0c74, 0x79aac56c, 0x3ce4e1ad, 0x51f0c802, 0x98f8f35a, 0x1626a49f, 0xeed82b29, 0x1d382fe3,

+ 0x0c4fb99a, 0xbb325778, 0x3ec6d97b, 0x6e77a6a9, 0xcb658b5c, 0xd45230c7, 0x2bd1408b, 0x60c03eb7,

+ 0xb9068d78, 0xa33754f4, 0xf430c87d, 0xc8a71302, 0xb96d8c32, 0xebd4e7be, 0xbe8b9d2d, 0x7979fb06,

+ 0xe7225308, 0x8b75cf77, 0x11ef8da4, 0xe083c858, 0x8d6b786f, 0x5a6317a6, 0xfa5cf7a0, 0x5dda0033,

+ 0xf28ebfb0, 0xf5b9c310, 0xa0eac280, 0x08b9767a, 0xa3d9d2b0, 0x79d34217, 0x021a718d, 0x9ac6336a,

+ 0x2711fd60, 0x438050e3, 0x069908a8, 0x3d7fedc4, 0x826d2bef, 0x4eeb8476, 0x488dcf25, 0x36c9d566,

+ 0x28e74e41, 0xc2610aca, 0x3d49a9cf, 0xbae3b9df, 0xb65f8de6, 0x92aeaf64, 0x3ac7d5e6, 0x9ea80509,

+ 0xf22b017d, 0xa4173f70, 0xdd1e16c3, 0x15e0d7f9, 0x50b1b887, 0x2b9f4fd5, 0x625aba82, 0x6a017962,

+ 0x2ec01b9c, 0x15488aa9, 0xd716e740, 0x40055a2c, 0x93d29a22, 0xe32dbf9a, 0x058745b9, 0x3453dc1e,

+ 0xd699296e, 0x496cff6f, 0x1c9f4986, 0xdfe2ed07, 0xb87242d1, 0x19de7eae, 0x053e561a, 0x15ad6f8c,

+ 0x66626c1c, 0x7154c24c, 0xea082b2a, 0x93eb2939, 0x17dcb0f0, 0x58d4f2ae, 0x9ea294fb, 0x52cf564c,

+ 0x9883fe66, 0x2ec40581, 0x763953c3, 0x01d6692e, 0xd3a0c108, 0xa1e7160e, 0xe4f2dfa6, 0x693ed285,

+ 0x74904698, 0x4c2b0edd, 0x4f757656, 0x5d393378, 0xa132234f, 0x3d321c5d, 0xc3f5e194, 0x4b269301,

+ 0xc79f022f, 0x3c997e7e, 0x5e4f9504, 0x3ffafbbd, 0x76f7ad0e, 0x296693f4, 0x3d1fce6f, 0xc61e45be,

+ 0xd3b5ab34, 0xf72bf9b7, 0x1b0434c0, 0x4e72b567, 0x5592a33d, 0xb5229301, 0xcfd2a87f, 0x60aeb767,

+ 0x1814386b, 0x30bcc33d, 0x38a0c07d, 0xfd1606f2, 0xc363519b, 0x589dd390, 0x5479f8e6, 0x1cb8d647,

+ 0x97fd61a9, 0xea7759f4, 0x2d57539d, 0x569a58cf, 0xe84e63ad, 0x462e1b78, 0x6580f87e, 0xf3817914,

+ 0x91da55f4, 0x40a230f3, 0xd1988f35, 0xb6e318d2, 0x3ffa50bc, 0x3d40f021, 0xc3c0bdae, 0x4958c24c,

+ 0x518f36b2, 0x84b1d370, 0x0fedce83, 0x878ddada, 0xf2a279c7, 0x94e01be8, 0x90716f4b, 0x954b8aa3

+};

+

+static const uint32_t S8[256] = {

+ 0xe216300d, 0xbbddfffc, 0xa7ebdabd, 0x35648095, 0x7789f8b7, 0xe6c1121b, 0x0e241600, 0x052ce8b5,

+ 0x11a9cfb0, 0xe5952f11, 0xece7990a, 0x9386d174, 0x2a42931c, 0x76e38111, 0xb12def3a, 0x37ddddfc,

+ 0xde9adeb1, 0x0a0cc32c, 0xbe197029, 0x84a00940, 0xbb243a0f, 0xb4d137cf, 0xb44e79f0, 0x049eedfd,

+ 0x0b15a15d, 0x480d3168, 0x8bbbde5a, 0x669ded42, 0xc7ece831, 0x3f8f95e7, 0x72df191b, 0x7580330d,

+ 0x94074251, 0x5c7dcdfa, 0xabbe6d63, 0xaa402164, 0xb301d40a, 0x02e7d1ca, 0x53571dae, 0x7a3182a2,

+ 0x12a8ddec, 0xfdaa335d, 0x176f43e8, 0x71fb46d4, 0x38129022, 0xce949ad4, 0xb84769ad, 0x965bd862,

+ 0x82f3d055, 0x66fb9767, 0x15b80b4e, 0x1d5b47a0, 0x4cfde06f, 0xc28ec4b8, 0x57e8726e, 0x647a78fc,

+ 0x99865d44, 0x608bd593, 0x6c200e03, 0x39dc5ff6, 0x5d0b00a3, 0xae63aff2, 0x7e8bd632, 0x70108c0c,

+ 0xbbd35049, 0x2998df04, 0x980cf42a, 0x9b6df491, 0x9e7edd53, 0x06918548, 0x58cb7e07, 0x3b74ef2e,

+ 0x522fffb1, 0xd24708cc, 0x1c7e27cd, 0xa4eb215b, 0x3cf1d2e2, 0x19b47a38, 0x424f7618, 0x35856039,

+ 0x9d17dee7, 0x27eb35e6, 0xc9aff67b, 0x36baf5b8, 0x09c467cd, 0xc18910b1, 0xe11dbf7b, 0x06cd1af8,

+ 0x7170c608, 0x2d5e3354, 0xd4de495a, 0x64c6d006, 0xbcc0c62c, 0x3dd00db3, 0x708f8f34, 0x77d51b42,

+ 0x264f620f, 0x24b8d2bf, 0x15c1b79e, 0x46a52564, 0xf8d7e54e, 0x3e378160, 0x7895cda5, 0x859c15a5,

+ 0xe6459788, 0xc37bc75f, 0xdb07ba0c, 0x0676a3ab, 0x7f229b1e, 0x31842e7b, 0x24259fd7, 0xf8bef472,

+ 0x835ffcb8, 0x6df4c1f2, 0x96f5b195, 0xfd0af0fc, 0xb0fe134c, 0xe2506d3d, 0x4f9b12ea, 0xf215f225,

+ 0xa223736f, 0x9fb4c428, 0x25d04979, 0x34c713f8, 0xc4618187, 0xea7a6e98, 0x7cd16efc, 0x1436876c,

+ 0xf1544107, 0xbedeee14, 0x56e9af27, 0xa04aa441, 0x3cf7c899, 0x92ecbae6, 0xdd67016d, 0x151682eb,

+ 0xa842eedf, 0xfdba60b4, 0xf1907b75, 0x20e3030f, 0x24d8c29e, 0xe139673b, 0xefa63fb8, 0x71873054,

+ 0xb6f2cf3b, 0x9f326442, 0xcb15a4cc, 0xb01a4504, 0xf1e47d8d, 0x844a1be5, 0xbae7dfdc, 0x42cbda70,

+ 0xcd7dae0a, 0x57e85b7a, 0xd53f5af6, 0x20cf4d8c, 0xcea4d428, 0x79d130a4, 0x3486ebfb, 0x33d3cddc,

+ 0x77853b53, 0x37effcb5, 0xc5068778, 0xe580b3e6, 0x4e68b8f4, 0xc5c8b37e, 0x0d809ea2, 0x398feb7c,

+ 0x132a4f94, 0x43b7950e, 0x2fee7d1c, 0x223613bd, 0xdd06caa2, 0x37df932b, 0xc4248289, 0xacf3ebc3,

+ 0x5715f6b7, 0xef3478dd, 0xf267616f, 0xc148cbe4, 0x9052815e, 0x5e410fab, 0xb48a2465, 0x2eda7fa4,

+ 0xe87b40e4, 0xe98ea084, 0x5889e9e1, 0xefd390fc, 0xdd07d35b, 0xdb485694, 0x38d7e5b2, 0x57720101,

+ 0x730edebc, 0x5b643113, 0x94917e4f, 0x503c2fba, 0x646f1282, 0x7523d24a, 0xe0779695, 0xf9c17a8f,

+ 0x7a5b2121, 0xd187b896, 0x29263a4d, 0xba510cdf, 0x81f47c9f, 0xad1163ed, 0xea7b5965, 0x1a00726e,

+ 0x11403092, 0x00da6d77, 0x4a0cdd61, 0xad1f4603, 0x605bdfb0, 0x9eedc364, 0x22ebe6a8, 0xcee7d28a,

+ 0xa0e736a0, 0x5564a6b9, 0x10853209, 0xc7eb8f37, 0x2de705ca, 0x8951570f, 0xdf09822b, 0xbd691a6c,

+ 0xaa12e4f2, 0x87451c0f, 0xe0f6a27a, 0x3ada4819, 0x4cf1764f, 0x0d771c2b, 0x67cdb156, 0x350d8384,

+ 0x5938fa0f, 0x42399ef3, 0x36997b07, 0x0e84093d, 0x4aa93e61, 0x8360d87b, 0x1fa98b0c, 0x1149382c,

+ 0xe97625a5, 0x0614d1b7, 0x0e25244b, 0x0c768347, 0x589e8d82, 0x0d2059d1, 0xa466bb1e, 0xf8da0a82,

+ 0x04f19130, 0xba6e4ec0, 0x99265164, 0x1ee7230d, 0x50b2ad80, 0xeaee6801, 0x8db2a283, 0xea8bf59e

+};

+

+static void generate_round_keys(int rnds, uint32_t* K, uint32_t* x, uint32_t* z)

+{

+ COMPUTE_Z;

+

+ K[1] = S5[IA(z[2])] ^ S6[IB(z[2])] ^ S7[ID(z[1])] ^ S8[IC(z[1])] ^ S5[IC(z[0])];

+ K[2] = S5[IC(z[2])] ^ S6[ID(z[2])] ^ S7[IB(z[1])] ^ S8[IA(z[1])] ^ S6[IC(z[1])];

+ K[3] = S5[IA(z[3])] ^ S6[IB(z[3])] ^ S7[ID(z[0])] ^ S8[IC(z[0])] ^ S7[IB(z[2])];

+ K[4] = S5[IC(z[3])] ^ S6[ID(z[3])] ^ S7[IB(z[0])] ^ S8[IA(z[0])] ^ S8[IA(z[3])];

+

+ COMPUTE_X;

+

+ K[5] = S5[ID(x[0])] ^ S6[IC(x[0])] ^ S7[IA(x[3])] ^ S8[IB(x[3])] ^ S5[IA(x[2])];

+ K[6] = S5[IB(x[0])] ^ S6[IA(x[0])] ^ S7[IC(x[3])] ^ S8[ID(x[3])] ^ S6[IB(x[3])];

+ K[7] = S5[ID(x[1])] ^ S6[IC(x[1])] ^ S7[IA(x[2])] ^ S8[IB(x[2])] ^ S7[ID(x[0])];

+ K[8] = S5[IB(x[1])] ^ S6[IA(x[1])] ^ S7[IC(x[2])] ^ S8[ID(x[2])] ^ S8[ID(x[1])];

+

+ COMPUTE_Z;

+

+ K[9] = S5[ID(z[0])] ^ S6[IC(z[0])] ^ S7[IA(z[3])] ^ S8[IB(z[3])] ^ S5[IB(z[2])];

+ K[10] = S5[IB(z[0])] ^ S6[IA(z[0])] ^ S7[IC(z[3])] ^ S8[ID(z[3])] ^ S6[IA(z[3])];

+ K[11] = S5[ID(z[1])] ^ S6[IC(z[1])] ^ S7[IA(z[2])] ^ S8[IB(z[2])] ^ S7[IC(z[0])];

+ K[12] = S5[IB(z[1])] ^ S6[IA(z[1])] ^ S7[IC(z[2])] ^ S8[ID(z[2])] ^ S8[IC(z[1])];

+

+ COMPUTE_X;

+

+ if (rnds == 16) {

+ K[13] = S5[IA(x[2])] ^ S6[IB(x[2])] ^ S7[ID(x[1])] ^ S8[IC(x[1])] ^ S5[ID(x[0])];

+ K[14] = S5[IC(x[2])] ^ S6[ID(x[2])] ^ S7[IB(x[1])] ^ S8[IA(x[1])] ^ S6[ID(x[1])];

+ K[15] = S5[IA(x[3])] ^ S6[IB(x[3])] ^ S7[ID(x[0])] ^ S8[IC(x[0])] ^ S7[IA(x[2])];

+ K[16] = S5[IC(x[3])] ^ S6[ID(x[3])] ^ S7[IB(x[0])] ^ S8[IA(x[0])] ^ S8[IB(x[3])];

+ }

+}

+

+static void encipher(AVCAST5* cs, uint8_t* dst, const uint8_t* src)

+{

+ uint32_t r, l, f, I;

+ l = AV_RB32(src);

+ r = AV_RB32(src + 4);

+ F1(l, r, 1);

+ F2(r, l, 2);

+ F3(l, r, 3);

+ F1(r, l, 4);

+ F2(l, r, 5);

+ F3(r, l, 6);

+ F1(l, r, 7);

+ F2(r, l, 8);

+ F3(l, r, 9);

+ F1(r, l, 10);

+ F2(l, r, 11);

+ F3(r, l, 12);

+ if (cs->rounds == 16) {

+ F1(l, r, 13);

+ F2(r, l, 14);

+ F3(l, r, 15);

+ F1(r, l, 16);

+ }

+ AV_WB32(dst, r);

+ AV_WB32(dst + 4, l);

+}

+

+static void decipher(AVCAST5* cs, uint8_t* dst, const uint8_t* src, uint8_t *iv)

+{

+ uint32_t f, I, r, l;

+ l = AV_RB32(src);

+ r = AV_RB32(src + 4);

+ if (cs->rounds == 16) {

+ F1(l, r, 16);

+ F3(r, l, 15);

+ F2(l, r, 14);

+ F1(r, l, 13);

+ }

+ F3(l, r, 12);

+ F2(r, l, 11);

+ F1(l, r, 10);

+ F3(r, l, 9);

+ F2(l, r, 8);

+ F1(r, l, 7);

+ F3(l, r, 6);

+ F2(r, l, 5);

+ F1(l, r, 4);

+ F3(r, l, 3);

+ F2(l, r, 2);

+ F1(r, l, 1);

+ if (iv) {

+ r ^= AV_RB32(iv);

+ l ^= AV_RB32(iv + 4);

+ memcpy(iv, src, 8);

+ }

+ AV_WB32(dst, r);

+ AV_WB32(dst + 4, l);

+}

+

+struct AVCAST5 *av_cast5_alloc(void)

+{

+ return av_mallocz(sizeof(struct AVCAST5));

+}

+

+av_cold int av_cast5_init(AVCAST5* cs, const uint8_t *key, int key_bits)

+{

+ uint8_t newKey[16];

+ int i;

+ uint32_t p[4], q[4];

+ if (key_bits % 8 || key_bits < 40 || key_bits > 128)

+ return -1;

+ memset(newKey, 0, sizeof(newKey));

+ memcpy(newKey, key, key_bits >> 3);

+

+ cs->rounds = key_bits <= 80 ? 12 : 16;

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

+ q[i] = AV_RB32(newKey + (4 * i));

+ generate_round_keys(cs->rounds, cs->Km, q, p);

+ generate_round_keys(cs->rounds, cs->Kr, q, p);

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

+ cs->Kr[i] = cs->Kr[i] & 0x1f;

+ return 0;

+}

+

+void av_cast5_crypt2(AVCAST5* cs, uint8_t* dst, const uint8_t* src, int count, uint8_t *iv, int decrypt)

+{

+ int i;

+ while (count--) {

+ if (decrypt) {

+ decipher(cs, dst, src, iv);

+ } else {

+ if (iv) {

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

+ dst[i] = src[i] ^ iv[i];

+ encipher(cs, dst, dst);

+ memcpy(iv, dst, 8);

+ } else {

+ encipher(cs, dst, src);

+ }

+ }

+ src = src + 8;

+ dst = dst + 8;

+ }

+}

+void av_cast5_crypt(AVCAST5* cs, uint8_t* dst, const uint8_t* src, int count, int decrypt)

+{

+ while (count--) {

+ if (decrypt){

+ decipher(cs, dst, src, NULL);

+ } else {

+ encipher(cs, dst, src);

+ }

+ src = src + 8;

+ dst = dst + 8;

+ }

+}

+

+#ifdef TEST

+#include<stdio.h>

+#include<stdlib.h>

+#include"log.h"

+

+int main(int argc, char** argv)

+{

+

+ static const uint8_t Key[3][16] = {

+ {0x01, 0x23, 0x45, 0x67, 0x12, 0x34, 0x56, 0x78, 0x23, 0x45, 0x67, 0x89, 0x34, 0x56, 0x78, 0x9a},

+ {0x01, 0x23, 0x45, 0x67, 0x12, 0x34, 0x56, 0x78, 0x23, 0x45},

+ {0x01, 0x23, 0x45, 0x67, 0x12}

+ };

+ static const uint8_t rpt[8] = {0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef};

+ static const uint8_t rct[3][8] = {

+ {0x23, 0x8b, 0x4f, 0xe5, 0x84, 0x7e, 0x44, 0xb2},

+ {0xeb, 0x6a, 0x71, 0x1a, 0x2c, 0x02, 0x27, 0x1b},

+ {0x7a, 0xc8, 0x16, 0xd1, 0x6e, 0x9b, 0x30, 0x2e}

+ };

+ static const uint8_t rct2[2][16] = {

+ {0xee, 0xa9, 0xd0, 0xa2, 0x49, 0xfd, 0x3b, 0xa6, 0xb3, 0x43, 0x6f, 0xb8, 0x9d, 0x6d, 0xca, 0x92},

+ {0xb2, 0xc9, 0x5e, 0xb0, 0x0c, 0x31, 0xad, 0x71, 0x80, 0xac, 0x05, 0xb8, 0xe8, 0x3d, 0x69, 0x6e}

+ };

+ static const uint8_t iv[8] = {0xee, 0xa9, 0xd0, 0xa2, 0x49, 0xfd, 0x3b, 0xa6};

+ static uint8_t rpt2[2][16];

+ int i, j, err = 0;

+ static const int key_bits[3] = {128, 80, 40};

+ uint8_t temp[8];

+ AVCAST5 *cs;

+ cs = av_cast5_alloc();

+ if (!cs)

+ return 1;

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

+

+ av_cast5_init(cs, Key[j], key_bits[j]);

+ av_cast5_crypt(cs, temp, rpt, 1, 0);

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

+ if (rct[j][i] != temp[i]){

+ av_log(NULL, AV_LOG_ERROR, "%d %02x %02x\n", i, rct[j][i], temp[i]);

+ err = 1;

+ }