Libav
des.c
Go to the documentation of this file.
1 /*
2  * DES encryption/decryption
3  * Copyright (c) 2007 Reimar Doeffinger
4  *
5  * This file is part of Libav.
6  *
7  * Libav is free software; you can redistribute it and/or
8  * modify it under the terms of the GNU Lesser General Public
9  * License as published by the Free Software Foundation; either
10  * version 2.1 of the License, or (at your option) any later version.
11  *
12  * Libav is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15  * Lesser General Public License for more details.
16  *
17  * You should have received a copy of the GNU Lesser General Public
18  * License along with Libav; if not, write to the Free Software
19  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20  */
21 
22 #include <stdint.h>
23 
24 #include "avutil.h"
25 #include "common.h"
26 #include "intreadwrite.h"
27 #include "mem.h"
28 #include "des.h"
29 
30 #if !FF_API_CRYPTO_CONTEXT
31 struct AVDES {
32  uint64_t round_keys[3][16];
33  int triple_des;
34 };
35 #endif
36 
37 #define T(a, b, c, d, e, f, g, h) 64 - a, 64 - b, 64 - c, 64 - d, 64 - e, 64 - f, 64 - g, 64 - h
38 static const uint8_t IP_shuffle[] = {
39  T(58, 50, 42, 34, 26, 18, 10, 2),
40  T(60, 52, 44, 36, 28, 20, 12, 4),
41  T(62, 54, 46, 38, 30, 22, 14, 6),
42  T(64, 56, 48, 40, 32, 24, 16, 8),
43  T(57, 49, 41, 33, 25, 17, 9, 1),
44  T(59, 51, 43, 35, 27, 19, 11, 3),
45  T(61, 53, 45, 37, 29, 21, 13, 5),
46  T(63, 55, 47, 39, 31, 23, 15, 7)
47 };
48 #undef T
49 
50 #if CONFIG_SMALL || defined(GENTABLES)
51 #define T(a, b, c, d) 32 - a, 32 - b, 32 - c, 32 - d
52 static const uint8_t P_shuffle[] = {
53  T(16, 7, 20, 21),
54  T(29, 12, 28, 17),
55  T( 1, 15, 23, 26),
56  T( 5, 18, 31, 10),
57  T( 2, 8, 24, 14),
58  T(32, 27, 3, 9),
59  T(19, 13, 30, 6),
60  T(22, 11, 4, 25)
61 };
62 #undef T
63 #endif
64 
65 #define T(a, b, c, d, e, f, g) 64 - a, 64 - b, 64 - c, 64 - d, 64 - e, 64 - f, 64 - g
66 static const uint8_t PC1_shuffle[] = {
67  T(57, 49, 41, 33, 25, 17, 9),
68  T( 1, 58, 50, 42, 34, 26, 18),
69  T(10, 2, 59, 51, 43, 35, 27),
70  T(19, 11, 3, 60, 52, 44, 36),
71  T(63, 55, 47, 39, 31, 23, 15),
72  T( 7, 62, 54, 46, 38, 30, 22),
73  T(14, 6, 61, 53, 45, 37, 29),
74  T(21, 13, 5, 28, 20, 12, 4)
75 };
76 #undef T
77 
78 #define T(a, b, c, d, e, f) 56 - a, 56 - b, 56 - c, 56 - d, 56 - e, 56 - f
79 static const uint8_t PC2_shuffle[] = {
80  T(14, 17, 11, 24, 1, 5),
81  T( 3, 28, 15, 6, 21, 10),
82  T(23, 19, 12, 4, 26, 8),
83  T(16, 7, 27, 20, 13, 2),
84  T(41, 52, 31, 37, 47, 55),
85  T(30, 40, 51, 45, 33, 48),
86  T(44, 49, 39, 56, 34, 53),
87  T(46, 42, 50, 36, 29, 32)
88 };
89 #undef T
90 
91 #if CONFIG_SMALL
92 static const uint8_t S_boxes[8][32] = {
93  { 0x0e, 0xf4, 0x7d, 0x41, 0xe2, 0x2f, 0xdb, 0x18, 0xa3, 0x6a, 0xc6, 0xbc, 0x95, 0x59, 0x30, 0x87,
94  0xf4, 0xc1, 0x8e, 0x28, 0x4d, 0x96, 0x12, 0x7b, 0x5f, 0xbc, 0x39, 0xe7, 0xa3, 0x0a, 0x65, 0xd0, },
95  { 0x3f, 0xd1, 0x48, 0x7e, 0xf6, 0x2b, 0x83, 0xe4, 0xc9, 0x07, 0x12, 0xad, 0x6c, 0x90, 0xb5, 0x5a,
96  0xd0, 0x8e, 0xa7, 0x1b, 0x3a, 0xf4, 0x4d, 0x21, 0xb5, 0x68, 0x7c, 0xc6, 0x09, 0x53, 0xe2, 0x9f, },
97  { 0xda, 0x70, 0x09, 0x9e, 0x36, 0x43, 0x6f, 0xa5, 0x21, 0x8d, 0x5c, 0xe7, 0xcb, 0xb4, 0xf2, 0x18,
98  0x1d, 0xa6, 0xd4, 0x09, 0x68, 0x9f, 0x83, 0x70, 0x4b, 0xf1, 0xe2, 0x3c, 0xb5, 0x5a, 0x2e, 0xc7, },
99  { 0xd7, 0x8d, 0xbe, 0x53, 0x60, 0xf6, 0x09, 0x3a, 0x41, 0x72, 0x28, 0xc5, 0x1b, 0xac, 0xe4, 0x9f,
100  0x3a, 0xf6, 0x09, 0x60, 0xac, 0x1b, 0xd7, 0x8d, 0x9f, 0x41, 0x53, 0xbe, 0xc5, 0x72, 0x28, 0xe4, },
101  { 0xe2, 0xbc, 0x24, 0xc1, 0x47, 0x7a, 0xdb, 0x16, 0x58, 0x05, 0xf3, 0xaf, 0x3d, 0x90, 0x8e, 0x69,
102  0xb4, 0x82, 0xc1, 0x7b, 0x1a, 0xed, 0x27, 0xd8, 0x6f, 0xf9, 0x0c, 0x95, 0xa6, 0x43, 0x50, 0x3e, },
103  { 0xac, 0xf1, 0x4a, 0x2f, 0x79, 0xc2, 0x96, 0x58, 0x60, 0x1d, 0xd3, 0xe4, 0x0e, 0xb7, 0x35, 0x8b,
104  0x49, 0x3e, 0x2f, 0xc5, 0x92, 0x58, 0xfc, 0xa3, 0xb7, 0xe0, 0x14, 0x7a, 0x61, 0x0d, 0x8b, 0xd6, },
105  { 0xd4, 0x0b, 0xb2, 0x7e, 0x4f, 0x90, 0x18, 0xad, 0xe3, 0x3c, 0x59, 0xc7, 0x25, 0xfa, 0x86, 0x61,
106  0x61, 0xb4, 0xdb, 0x8d, 0x1c, 0x43, 0xa7, 0x7e, 0x9a, 0x5f, 0x06, 0xf8, 0xe0, 0x25, 0x39, 0xc2, },
107  { 0x1d, 0xf2, 0xd8, 0x84, 0xa6, 0x3f, 0x7b, 0x41, 0xca, 0x59, 0x63, 0xbe, 0x05, 0xe0, 0x9c, 0x27,
108  0x27, 0x1b, 0xe4, 0x71, 0x49, 0xac, 0x8e, 0xd2, 0xf0, 0xc6, 0x9a, 0x0d, 0x3f, 0x53, 0x65, 0xb8,
109  }
110 };
111 #else
112 
116 static const uint32_t S_boxes_P_shuffle[8][64] = {
117  { 0x00808200, 0x00000000, 0x00008000, 0x00808202, 0x00808002, 0x00008202, 0x00000002, 0x00008000,
118  0x00000200, 0x00808200, 0x00808202, 0x00000200, 0x00800202, 0x00808002, 0x00800000, 0x00000002,
119  0x00000202, 0x00800200, 0x00800200, 0x00008200, 0x00008200, 0x00808000, 0x00808000, 0x00800202,
120  0x00008002, 0x00800002, 0x00800002, 0x00008002, 0x00000000, 0x00000202, 0x00008202, 0x00800000,
121  0x00008000, 0x00808202, 0x00000002, 0x00808000, 0x00808200, 0x00800000, 0x00800000, 0x00000200,
122  0x00808002, 0x00008000, 0x00008200, 0x00800002, 0x00000200, 0x00000002, 0x00800202, 0x00008202,
123  0x00808202, 0x00008002, 0x00808000, 0x00800202, 0x00800002, 0x00000202, 0x00008202, 0x00808200,
124  0x00000202, 0x00800200, 0x00800200, 0x00000000, 0x00008002, 0x00008200, 0x00000000, 0x00808002, },
125  { 0x40084010, 0x40004000, 0x00004000, 0x00084010, 0x00080000, 0x00000010, 0x40080010, 0x40004010,
126  0x40000010, 0x40084010, 0x40084000, 0x40000000, 0x40004000, 0x00080000, 0x00000010, 0x40080010,
127  0x00084000, 0x00080010, 0x40004010, 0x00000000, 0x40000000, 0x00004000, 0x00084010, 0x40080000,
128  0x00080010, 0x40000010, 0x00000000, 0x00084000, 0x00004010, 0x40084000, 0x40080000, 0x00004010,
129  0x00000000, 0x00084010, 0x40080010, 0x00080000, 0x40004010, 0x40080000, 0x40084000, 0x00004000,
130  0x40080000, 0x40004000, 0x00000010, 0x40084010, 0x00084010, 0x00000010, 0x00004000, 0x40000000,
131  0x00004010, 0x40084000, 0x00080000, 0x40000010, 0x00080010, 0x40004010, 0x40000010, 0x00080010,
132  0x00084000, 0x00000000, 0x40004000, 0x00004010, 0x40000000, 0x40080010, 0x40084010, 0x00084000, },
133  { 0x00000104, 0x04010100, 0x00000000, 0x04010004, 0x04000100, 0x00000000, 0x00010104, 0x04000100,
134  0x00010004, 0x04000004, 0x04000004, 0x00010000, 0x04010104, 0x00010004, 0x04010000, 0x00000104,
135  0x04000000, 0x00000004, 0x04010100, 0x00000100, 0x00010100, 0x04010000, 0x04010004, 0x00010104,
136  0x04000104, 0x00010100, 0x00010000, 0x04000104, 0x00000004, 0x04010104, 0x00000100, 0x04000000,
137  0x04010100, 0x04000000, 0x00010004, 0x00000104, 0x00010000, 0x04010100, 0x04000100, 0x00000000,
138  0x00000100, 0x00010004, 0x04010104, 0x04000100, 0x04000004, 0x00000100, 0x00000000, 0x04010004,
139  0x04000104, 0x00010000, 0x04000000, 0x04010104, 0x00000004, 0x00010104, 0x00010100, 0x04000004,
140  0x04010000, 0x04000104, 0x00000104, 0x04010000, 0x00010104, 0x00000004, 0x04010004, 0x00010100, },
141  { 0x80401000, 0x80001040, 0x80001040, 0x00000040, 0x00401040, 0x80400040, 0x80400000, 0x80001000,
142  0x00000000, 0x00401000, 0x00401000, 0x80401040, 0x80000040, 0x00000000, 0x00400040, 0x80400000,
143  0x80000000, 0x00001000, 0x00400000, 0x80401000, 0x00000040, 0x00400000, 0x80001000, 0x00001040,
144  0x80400040, 0x80000000, 0x00001040, 0x00400040, 0x00001000, 0x00401040, 0x80401040, 0x80000040,
145  0x00400040, 0x80400000, 0x00401000, 0x80401040, 0x80000040, 0x00000000, 0x00000000, 0x00401000,
146  0x00001040, 0x00400040, 0x80400040, 0x80000000, 0x80401000, 0x80001040, 0x80001040, 0x00000040,
147  0x80401040, 0x80000040, 0x80000000, 0x00001000, 0x80400000, 0x80001000, 0x00401040, 0x80400040,
148  0x80001000, 0x00001040, 0x00400000, 0x80401000, 0x00000040, 0x00400000, 0x00001000, 0x00401040, },
149  { 0x00000080, 0x01040080, 0x01040000, 0x21000080, 0x00040000, 0x00000080, 0x20000000, 0x01040000,
150  0x20040080, 0x00040000, 0x01000080, 0x20040080, 0x21000080, 0x21040000, 0x00040080, 0x20000000,
151  0x01000000, 0x20040000, 0x20040000, 0x00000000, 0x20000080, 0x21040080, 0x21040080, 0x01000080,
152  0x21040000, 0x20000080, 0x00000000, 0x21000000, 0x01040080, 0x01000000, 0x21000000, 0x00040080,
153  0x00040000, 0x21000080, 0x00000080, 0x01000000, 0x20000000, 0x01040000, 0x21000080, 0x20040080,
154  0x01000080, 0x20000000, 0x21040000, 0x01040080, 0x20040080, 0x00000080, 0x01000000, 0x21040000,
155  0x21040080, 0x00040080, 0x21000000, 0x21040080, 0x01040000, 0x00000000, 0x20040000, 0x21000000,
156  0x00040080, 0x01000080, 0x20000080, 0x00040000, 0x00000000, 0x20040000, 0x01040080, 0x20000080, },
157  { 0x10000008, 0x10200000, 0x00002000, 0x10202008, 0x10200000, 0x00000008, 0x10202008, 0x00200000,
158  0x10002000, 0x00202008, 0x00200000, 0x10000008, 0x00200008, 0x10002000, 0x10000000, 0x00002008,
159  0x00000000, 0x00200008, 0x10002008, 0x00002000, 0x00202000, 0x10002008, 0x00000008, 0x10200008,
160  0x10200008, 0x00000000, 0x00202008, 0x10202000, 0x00002008, 0x00202000, 0x10202000, 0x10000000,
161  0x10002000, 0x00000008, 0x10200008, 0x00202000, 0x10202008, 0x00200000, 0x00002008, 0x10000008,
162  0x00200000, 0x10002000, 0x10000000, 0x00002008, 0x10000008, 0x10202008, 0x00202000, 0x10200000,
163  0x00202008, 0x10202000, 0x00000000, 0x10200008, 0x00000008, 0x00002000, 0x10200000, 0x00202008,
164  0x00002000, 0x00200008, 0x10002008, 0x00000000, 0x10202000, 0x10000000, 0x00200008, 0x10002008, },
165  { 0x00100000, 0x02100001, 0x02000401, 0x00000000, 0x00000400, 0x02000401, 0x00100401, 0x02100400,
166  0x02100401, 0x00100000, 0x00000000, 0x02000001, 0x00000001, 0x02000000, 0x02100001, 0x00000401,
167  0x02000400, 0x00100401, 0x00100001, 0x02000400, 0x02000001, 0x02100000, 0x02100400, 0x00100001,
168  0x02100000, 0x00000400, 0x00000401, 0x02100401, 0x00100400, 0x00000001, 0x02000000, 0x00100400,
169  0x02000000, 0x00100400, 0x00100000, 0x02000401, 0x02000401, 0x02100001, 0x02100001, 0x00000001,
170  0x00100001, 0x02000000, 0x02000400, 0x00100000, 0x02100400, 0x00000401, 0x00100401, 0x02100400,
171  0x00000401, 0x02000001, 0x02100401, 0x02100000, 0x00100400, 0x00000000, 0x00000001, 0x02100401,
172  0x00000000, 0x00100401, 0x02100000, 0x00000400, 0x02000001, 0x02000400, 0x00000400, 0x00100001, },
173  { 0x08000820, 0x00000800, 0x00020000, 0x08020820, 0x08000000, 0x08000820, 0x00000020, 0x08000000,
174  0x00020020, 0x08020000, 0x08020820, 0x00020800, 0x08020800, 0x00020820, 0x00000800, 0x00000020,
175  0x08020000, 0x08000020, 0x08000800, 0x00000820, 0x00020800, 0x00020020, 0x08020020, 0x08020800,
176  0x00000820, 0x00000000, 0x00000000, 0x08020020, 0x08000020, 0x08000800, 0x00020820, 0x00020000,
177  0x00020820, 0x00020000, 0x08020800, 0x00000800, 0x00000020, 0x08020020, 0x00000800, 0x00020820,
178  0x08000800, 0x00000020, 0x08000020, 0x08020000, 0x08020020, 0x08000000, 0x00020000, 0x08000820,
179  0x00000000, 0x08020820, 0x00020020, 0x08000020, 0x08020000, 0x08000800, 0x08000820, 0x00000000,
180  0x08020820, 0x00020800, 0x00020800, 0x00000820, 0x00000820, 0x00020020, 0x08000000, 0x08020800, },
181 };
182 #endif
183 
184 static uint64_t shuffle(uint64_t in, const uint8_t *shuffle, int shuffle_len)
185 {
186  int i;
187  uint64_t res = 0;
188  for (i = 0; i < shuffle_len; i++)
189  res += res + ((in >> *shuffle++) & 1);
190  return res;
191 }
192 
193 static uint64_t shuffle_inv(uint64_t in, const uint8_t *shuffle, int shuffle_len)
194 {
195  int i;
196  uint64_t res = 0;
197  shuffle += shuffle_len - 1;
198  for (i = 0; i < shuffle_len; i++) {
199  res |= (in & 1) << *shuffle--;
200  in >>= 1;
201  }
202  return res;
203 }
204 
205 static uint32_t f_func(uint32_t r, uint64_t k)
206 {
207  int i;
208  uint32_t out = 0;
209  // rotate to get first part of E-shuffle in the lowest 6 bits
210  r = (r << 1) | (r >> 31);
211  // apply S-boxes, those compress the data again from 8 * 6 to 8 * 4 bits
212  for (i = 7; i >= 0; i--) {
213  uint8_t tmp = (r ^ k) & 0x3f;
214 #if CONFIG_SMALL
215  uint8_t v = S_boxes[i][tmp >> 1];
216  if (tmp & 1)
217  v >>= 4;
218  out = (out >> 4) | (v << 28);
219 #else
220  out |= S_boxes_P_shuffle[i][tmp];
221 #endif
222  // get next 6 bits of E-shuffle and round key k into the lowest bits
223  r = (r >> 4) | (r << 28);
224  k >>= 6;
225  }
226 #if CONFIG_SMALL
227  out = shuffle(out, P_shuffle, sizeof(P_shuffle));
228 #endif
229  return out;
230 }
231 
238 static uint64_t key_shift_left(uint64_t CDn)
239 {
240  uint64_t carries = (CDn >> 27) & 0x10000001;
241  CDn <<= 1;
242  CDn &= ~0x10000001;
243  CDn |= carries;
244  return CDn;
245 }
246 
247 static void gen_roundkeys(uint64_t K[16], uint64_t key)
248 {
249  int i;
250  // discard parity bits from key and shuffle it into C and D parts
251  uint64_t CDn = shuffle(key, PC1_shuffle, sizeof(PC1_shuffle));
252  // generate round keys
253  for (i = 0; i < 16; i++) {
254  CDn = key_shift_left(CDn);
255  if (i > 1 && i != 8 && i != 15)
256  CDn = key_shift_left(CDn);
257  K[i] = shuffle(CDn, PC2_shuffle, sizeof(PC2_shuffle));
258  }
259 }
260 
261 static uint64_t des_encdec(uint64_t in, uint64_t K[16], int decrypt)
262 {
263  int i;
264  // used to apply round keys in reverse order for decryption
265  decrypt = decrypt ? 15 : 0;
266  // shuffle irrelevant to security but to ease hardware implementations
267  in = shuffle(in, IP_shuffle, sizeof(IP_shuffle));
268  for (i = 0; i < 16; i++) {
269  uint32_t f_res;
270  f_res = f_func(in, K[decrypt ^ i]);
271  in = (in << 32) | (in >> 32);
272  in ^= f_res;
273  }
274  in = (in << 32) | (in >> 32);
275  // reverse shuffle used to ease hardware implementations
276  in = shuffle_inv(in, IP_shuffle, sizeof(IP_shuffle));
277  return in;
278 }
279 
281 {
282  return av_mallocz(sizeof(struct AVDES));
283 }
284 
285 int av_des_init(AVDES *d, const uint8_t *key, int key_bits, int decrypt)
286 {
287  if (key_bits != 64 && key_bits != 192)
288  return -1;
289  d->triple_des = key_bits > 64;
290  gen_roundkeys(d->round_keys[0], AV_RB64(key));
291  if (d->triple_des) {
292  gen_roundkeys(d->round_keys[1], AV_RB64(key + 8));
293  gen_roundkeys(d->round_keys[2], AV_RB64(key + 16));
294  }
295  return 0;
296 }
297 
298 static void av_des_crypt_mac(AVDES *d, uint8_t *dst, const uint8_t *src,
299  int count, uint8_t *iv, int decrypt, int mac)
300 {
301  uint64_t iv_val = iv ? AV_RB64(iv) : 0;
302  while (count-- > 0) {
303  uint64_t dst_val;
304  uint64_t src_val = src ? AV_RB64(src) : 0;
305  if (decrypt) {
306  uint64_t tmp = src_val;
307  if (d->triple_des) {
308  src_val = des_encdec(src_val, d->round_keys[2], 1);
309  src_val = des_encdec(src_val, d->round_keys[1], 0);
310  }
311  dst_val = des_encdec(src_val, d->round_keys[0], 1) ^ iv_val;
312  iv_val = iv ? tmp : 0;
313  } else {
314  dst_val = des_encdec(src_val ^ iv_val, d->round_keys[0], 0);
315  if (d->triple_des) {
316  dst_val = des_encdec(dst_val, d->round_keys[1], 1);
317  dst_val = des_encdec(dst_val, d->round_keys[2], 0);
318  }
319  iv_val = iv ? dst_val : 0;
320  }
321  AV_WB64(dst, dst_val);
322  src += 8;
323  if (!mac)
324  dst += 8;
325  }
326  if (iv)
327  AV_WB64(iv, iv_val);
328 }
329 
330 void av_des_crypt(AVDES *d, uint8_t *dst, const uint8_t *src,
331  int count, uint8_t *iv, int decrypt)
332 {
333  av_des_crypt_mac(d, dst, src, count, iv, decrypt, 0);
334 }
335 
336 void av_des_mac(AVDES *d, uint8_t *dst, const uint8_t *src, int count)
337 {
338  av_des_crypt_mac(d, dst, src, count, (uint8_t[8]) { 0 }, 0, 1);
339 }
static uint64_t shuffle_inv(uint64_t in, const uint8_t *shuffle, int shuffle_len)
Definition: des.c:193
static void gen_roundkeys(uint64_t K[16], uint64_t key)
Definition: des.c:247
void av_des_crypt(AVDES *d, uint8_t *dst, const uint8_t *src, int count, uint8_t *iv, int decrypt)
Encrypts / decrypts using the DES algorithm.
Definition: des.c:330
memory handling functions
#define AV_RB64
Definition: intreadwrite.h:164
external API header
uint64_t round_keys[3][16]
Definition: des.h:36
static uint32_t f_func(uint32_t r, uint64_t k)
Definition: des.c:205
uint8_t
static uint64_t key_shift_left(uint64_t CDn)
rotate the two halves of the expanded 56 bit key each 1 bit left
Definition: des.c:238
#define r
Definition: input.c:51
static const uint8_t PC2_shuffle[]
Definition: des.c:79
#define src
Definition: vp8dsp.c:254
static void av_des_crypt_mac(AVDES *d, uint8_t *dst, const uint8_t *src, int count, uint8_t *iv, int decrypt, int mac)
Definition: des.c:298
static const uint8_t IP_shuffle[]
Definition: des.c:38
AVDES * av_des_alloc(void)
Allocate an AVDES context.
Definition: des.c:280
int av_des_init(AVDES *d, const uint8_t *key, int key_bits, int decrypt)
Initializes an AVDES context.
Definition: des.c:285
static const uint32_t S_boxes_P_shuffle[8][64]
This table contains the results of applying both the S-box and P-shuffle.
Definition: des.c:116
uint8_t pi<< 24) CONV_FUNC_GROUP(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_U8, uint8_t,(*(const uint8_t *) pi - 0x80) *(1.0f/(1<< 7))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_U8, uint8_t,(*(const uint8_t *) pi - 0x80) *(1.0/(1<< 7))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S16, int16_t,(*(const int16_t *) pi >> 8)+0x80) CONV_FUNC_GROUP(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S16, int16_t, *(const int16_t *) pi *(1.0f/(1<< 15))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S16, int16_t, *(const int16_t *) pi *(1.0/(1<< 15))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S32, int32_t,(*(const int32_t *) pi >> 24)+0x80) CONV_FUNC_GROUP(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S32, int32_t, *(const int32_t *) pi *(1.0f/(1U<< 31))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S32, int32_t, *(const int32_t *) pi *(1.0/(1U<< 31))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_FLT, float, av_clip_uint8(lrintf(*(const float *) pi *(1<< 7))+0x80)) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S16, int16_t, AV_SAMPLE_FMT_FLT, float, av_clip_int16(lrintf(*(const float *) pi *(1<< 15)))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S32, int32_t, AV_SAMPLE_FMT_FLT, float, av_clipl_int32(llrintf(*(const float *) pi *(1U<< 31)))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_DBL, double, av_clip_uint8(lrint(*(const double *) pi *(1<< 7))+0x80)) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S16, int16_t, AV_SAMPLE_FMT_DBL, double, av_clip_int16(lrint(*(const double *) pi *(1<< 15)))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S32, int32_t, AV_SAMPLE_FMT_DBL, double, av_clipl_int32(llrint(*(const double *) pi *(1U<< 31)))) #define SET_CONV_FUNC_GROUP(ofmt, ifmt) static void set_generic_function(AudioConvert *ac) { } void ff_audio_convert_free(AudioConvert **ac) { if(! *ac) return;ff_dither_free(&(*ac) ->dc);av_freep(ac);} AudioConvert *ff_audio_convert_alloc(AVAudioResampleContext *avr, enum AVSampleFormat out_fmt, enum AVSampleFormat in_fmt, int channels, int sample_rate, int apply_map) { AudioConvert *ac;int in_planar, out_planar;ac=av_mallocz(sizeof(*ac));if(!ac) return NULL;ac->avr=avr;ac->out_fmt=out_fmt;ac->in_fmt=in_fmt;ac->channels=channels;ac->apply_map=apply_map;if(avr->dither_method !=AV_RESAMPLE_DITHER_NONE &&av_get_packed_sample_fmt(out_fmt)==AV_SAMPLE_FMT_S16 &&av_get_bytes_per_sample(in_fmt) > 2) { ac->dc=ff_dither_alloc(avr, out_fmt, in_fmt, channels, sample_rate, apply_map);if(!ac->dc) { av_free(ac);return NULL;} return ac;} in_planar=ff_sample_fmt_is_planar(in_fmt, channels);out_planar=ff_sample_fmt_is_planar(out_fmt, channels);if(in_planar==out_planar) { ac->func_type=CONV_FUNC_TYPE_FLAT;ac->planes=in_planar ? ac->channels :1;} else if(in_planar) ac->func_type=CONV_FUNC_TYPE_INTERLEAVE;else ac->func_type=CONV_FUNC_TYPE_DEINTERLEAVE;set_generic_function(ac);if(ARCH_AARCH64) ff_audio_convert_init_aarch64(ac);if(ARCH_ARM) ff_audio_convert_init_arm(ac);if(ARCH_X86) ff_audio_convert_init_x86(ac);return ac;} int ff_audio_convert(AudioConvert *ac, AudioData *out, AudioData *in) { int use_generic=1;int len=in->nb_samples;int p;if(ac->dc) { av_log(ac->avr, AV_LOG_TRACE, "%d samples - audio_convert: %s to %s (dithered)\", len, av_get_sample_fmt_name(ac->in_fmt), av_get_sample_fmt_name(ac->out_fmt));return ff_convert_dither(ac-> in
void av_des_mac(AVDES *d, uint8_t *dst, const uint8_t *src, int count)
Calculates CBC-MAC using the DES algorithm.
Definition: des.c:336
static const uint8_t PC1_shuffle[]
Definition: des.c:66
int triple_des
Definition: des.h:37
#define AV_WB64(p, val)
Definition: intreadwrite.h:284
common internal and external API header
static uint64_t des_encdec(uint64_t in, uint64_t K[16], int decrypt)
Definition: des.c:261
static uint8_t tmp[8]
Definition: des.c:38
static uint64_t shuffle(uint64_t in, const uint8_t *shuffle, int shuffle_len)
Definition: des.c:184
#define T(a, b, c, d, e, f, g, h)
Definition: des.c:78
FILE * out
Definition: movenc.c:54
Definition: des.h:35
void * av_mallocz(size_t size)
Allocate a block of size bytes with alignment suitable for all memory accesses (including vectors if ...
Definition: mem.c:211