repositories / deb_ffmpeg.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Imported Debian version 2.5.0~trusty1.1
[deb_ffmpeg.git] / ffmpeg / libavutil / ripemd.c
1 /*
2 * Copyright (C) 2007 Michael Niedermayer <michaelni@gmx.at>
3 * Copyright (C) 2013 James Almer
4 *
5 * This file is part of FFmpeg.
6 *
7 * FFmpeg 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 * FFmpeg 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 FFmpeg; if not, write to the Free Software
19 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20 */
21
22 #include <string.h>
23
24 #include "attributes.h"
25 #include "avutil.h"
26 #include "bswap.h"
27 #include "intreadwrite.h"
28 #include "ripemd.h"
29 #include "mem.h"
30
31 /** hash context */
32 typedef struct AVRIPEMD {
33 uint8_t digest_len; ///< digest length in 32-bit words
34 uint64_t count; ///< number of bytes in buffer
35 uint8_t buffer[64]; ///< 512-bit buffer of input values used in hash updating
36 uint32_t state[10]; ///< current hash value
37 uint8_t ext; ///< extension (0 for 128 and 160, 1 for 256 and 320)
38 /** function used to update hash for 512-bit input block */
39 void (*transform)(uint32_t *state, const uint8_t buffer[64], int ext);
40 } AVRIPEMD;
41
42 const int av_ripemd_size = sizeof(AVRIPEMD);
43
44 struct AVRIPEMD *av_ripemd_alloc(void)
45 {
46 return av_mallocz(sizeof(struct AVRIPEMD));
47 }
48
49 static const uint32_t KA[4] = {
50 0x5a827999, 0x6ed9eba1, 0x8f1bbcdc, 0xa953fd4e
51 };
52
53 static const uint32_t KB[4] = {
54 0x50a28be6, 0x5c4dd124, 0x6d703ef3, 0x7a6d76e9
55 };
56
57 static const int ROTA[80] = {
58 11, 14, 15, 12, 5, 8, 7 , 9, 11, 13, 14, 15, 6, 7, 9, 8,
59 7 , 6, 8, 13, 11, 9, 7, 15, 7, 12, 15, 9, 11, 7, 13, 12,
60 11, 13, 6, 7, 14, 9, 13, 15, 14, 8, 13, 6, 5, 12, 7, 5,
61 11, 12, 14, 15, 14, 15, 9, 8, 9, 14, 5, 6, 8, 6, 5, 12,
62 9, 15, 5, 11, 6, 8, 13, 12, 5, 12, 13, 14, 11, 8, 5, 6
63 };
64
65 static const int ROTB[80] = {
66 8, 9, 9, 11, 13, 15, 15, 5, 7, 7, 8, 11, 14, 14, 12, 6,
67 9, 13, 15, 7, 12, 8, 9, 11, 7, 7, 12, 7, 6, 15, 13, 11,
68 9, 7, 15, 11, 8, 6, 6, 14, 12, 13, 5, 14, 13, 13, 7, 5,
69 15, 5, 8, 11, 14, 14, 6, 14, 6, 9, 12, 9, 12, 5, 15, 8,
70 8, 5, 12, 9, 12, 5, 14, 6, 8, 13, 6, 5, 15, 13, 11, 11
71 };
72
73 static const int WA[80] = {
74 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15,
75 7, 4, 13, 1, 10, 6, 15, 3, 12, 0, 9, 5, 2, 14, 11, 8,
76 3, 10, 14, 4, 9, 15, 8, 1, 2, 7, 0, 6, 13, 11, 5, 12,
77 1, 9, 11, 10, 0, 8, 12, 4, 13, 3, 7, 15, 14, 5, 6, 2,
78 4, 0, 5, 9, 7, 12, 2, 10, 14, 1, 3, 8, 11, 6, 15, 13
79 };
80
81 static const int WB[80] = {
82 5, 14, 7, 0, 9, 2, 11, 4, 13, 6, 15, 8, 1, 10, 3, 12,
83 6, 11, 3, 7, 0, 13, 5, 10, 14, 15, 8, 12, 4, 9, 1, 2,
84 15, 5, 1, 3, 7, 14, 6, 9, 11, 8, 12, 2, 10, 0, 4, 13,
85 8, 6, 4, 1, 3, 11, 15, 0, 5, 12, 2, 13, 9, 7, 10, 14,
86 12, 15, 10, 4, 1, 5, 8, 7, 6, 2, 13, 14, 0, 3, 9, 11
87 };
88
89 #define rol(value, bits) ((value << bits) | (value >> (32 - bits)))
90
91 #define SWAP(a,b) if (ext) { t = a; a = b; b = t; }
92
93 #define ROUND128_0_TO_15(a,b,c,d,e,f,g,h) \
94 a = rol(a + (( b ^ c ^ d) + block[WA[n]]), ROTA[n]); \
95 e = rol(e + ((((f ^ g) & h) ^ g) + block[WB[n]] + KB[0]), ROTB[n]); \
96 n++
97
98 #define ROUND128_16_TO_31(a,b,c,d,e,f,g,h) \
99 a = rol(a + ((((c ^ d) & b) ^ d) + block[WA[n]] + KA[0]), ROTA[n]); \
100 e = rol(e + (((~g | f) ^ h) + block[WB[n]] + KB[1]), ROTB[n]); \
101 n++
102
103 #define ROUND128_32_TO_47(a,b,c,d,e,f,g,h) \
104 a = rol(a + (((~c | b) ^ d) + block[WA[n]] + KA[1]), ROTA[n]); \
105 e = rol(e + ((((g ^ h) & f) ^ h) + block[WB[n]] + KB[2]), ROTB[n]); \
106 n++
107
108 #define ROUND128_48_TO_63(a,b,c,d,e,f,g,h) \
109 a = rol(a + ((((b ^ c) & d) ^ c) + block[WA[n]] + KA[2]), ROTA[n]); \
110 e = rol(e + (( f ^ g ^ h) + block[WB[n]]), ROTB[n]); \
111 n++
112
113 static void ripemd128_transform(uint32_t *state, const uint8_t buffer[64], int ext)
114 {
115 uint32_t a, b, c, d, e, f, g, h, t;
116 uint32_t block[16];
117 int n;
118
119 if (ext) {
120 a = state[0]; b = state[1]; c = state[2]; d = state[3];
121 e = state[4]; f = state[5]; g = state[6]; h = state[7];
122 } else {
123 a = e = state[0];
124 b = f = state[1];
125 c = g = state[2];
126 d = h = state[3];
127 }
128
129 for (n = 0; n < 16; n++)
130 block[n] = AV_RL32(buffer + 4 * n);
131 n = 0;
132
133 #if CONFIG_SMALL
134 for (; n < 16;) {
135 ROUND128_0_TO_15(a,b,c,d,e,f,g,h);
136 t = d; d = c; c = b; b = a; a = t;
137 t = h; h = g; g = f; f = e; e = t;
138 }
139 SWAP(a,e)
140
141 for (; n < 32;) {
142 ROUND128_16_TO_31(a,b,c,d,e,f,g,h);
143 t = d; d = c; c = b; b = a; a = t;
144 t = h; h = g; g = f; f = e; e = t;
145 }
146 SWAP(b,f)
147
148 for (; n < 48;) {
149 ROUND128_32_TO_47(a,b,c,d,e,f,g,h);
150 t = d; d = c; c = b; b = a; a = t;
151 t = h; h = g; g = f; f = e; e = t;
152 }
153 SWAP(c,g)
154
155 for (; n < 64;) {
156 ROUND128_48_TO_63(a,b,c,d,e,f,g,h);
157 t = d; d = c; c = b; b = a; a = t;
158 t = h; h = g; g = f; f = e; e = t;
159 }
160 SWAP(d,h)
161 #else
162
163 #define R128_0 \
164 ROUND128_0_TO_15(a,b,c,d,e,f,g,h); \
165 ROUND128_0_TO_15(d,a,b,c,h,e,f,g); \
166 ROUND128_0_TO_15(c,d,a,b,g,h,e,f); \
167 ROUND128_0_TO_15(b,c,d,a,f,g,h,e)
168
169 R128_0; R128_0; R128_0; R128_0;
170 SWAP(a,e)
171
172 #define R128_16 \
173 ROUND128_16_TO_31(a,b,c,d,e,f,g,h); \
174 ROUND128_16_TO_31(d,a,b,c,h,e,f,g); \
175 ROUND128_16_TO_31(c,d,a,b,g,h,e,f); \
176 ROUND128_16_TO_31(b,c,d,a,f,g,h,e)
177
178 R128_16; R128_16; R128_16; R128_16;
179 SWAP(b,f)
180
181 #define R128_32 \
182 ROUND128_32_TO_47(a,b,c,d,e,f,g,h); \
183 ROUND128_32_TO_47(d,a,b,c,h,e,f,g); \
184 ROUND128_32_TO_47(c,d,a,b,g,h,e,f); \
185 ROUND128_32_TO_47(b,c,d,a,f,g,h,e)
186
187 R128_32; R128_32; R128_32; R128_32;
188 SWAP(c,g)
189
190 #define R128_48 \
191 ROUND128_48_TO_63(a,b,c,d,e,f,g,h); \
192 ROUND128_48_TO_63(d,a,b,c,h,e,f,g); \
193 ROUND128_48_TO_63(c,d,a,b,g,h,e,f); \
194 ROUND128_48_TO_63(b,c,d,a,f,g,h,e)
195
196 R128_48; R128_48; R128_48; R128_48;
197 SWAP(d,h)
198 #endif
199
200 if (ext) {
201 state[0] += a; state[1] += b; state[2] += c; state[3] += d;
202 state[4] += e; state[5] += f; state[6] += g; state[7] += h;
203 } else {
204 h += c + state[1];
205 state[1] = state[2] + d + e;
206 state[2] = state[3] + a + f;
207 state[3] = state[0] + b + g;
208 state[0] = h;
209 }
210 }
211
212 #define ROTATE(x,y) \
213 x = rol(x, 10); \
214 y = rol(y, 10); \
215 n++
216
217 #define ROUND160_0_TO_15(a,b,c,d,e,f,g,h,i,j) \
218 a = rol(a + (( b ^ c ^ d) + block[WA[n]]), ROTA[n]) + e; \
219 f = rol(f + (((~i | h) ^ g) + block[WB[n]] + KB[0]), ROTB[n]) + j; \
220 ROTATE(c,h)
221
222 #define ROUND160_16_TO_31(a,b,c,d,e,f,g,h,i,j) \
223 a = rol(a + ((((c ^ d) & b) ^ d) + block[WA[n]] + KA[0]), ROTA[n]) + e; \
224 f = rol(f + ((((g ^ h) & i) ^ h) + block[WB[n]] + KB[1]), ROTB[n]) + j; \
225 ROTATE(c,h)
226
227 #define ROUND160_32_TO_47(a,b,c,d,e,f,g,h,i,j) \
228 a = rol(a + (((~c | b) ^ d) + block[WA[n]] + KA[1]), ROTA[n]) + e; \
229 f = rol(f + (((~h | g) ^ i) + block[WB[n]] + KB[2]), ROTB[n]) + j; \
230 ROTATE(c,h)
231
232 #define ROUND160_48_TO_63(a,b,c,d,e,f,g,h,i,j) \
233 a = rol(a + ((((b ^ c) & d) ^ c) + block[WA[n]] + KA[2]), ROTA[n]) + e; \
234 f = rol(f + ((((h ^ i) & g) ^ i) + block[WB[n]] + KB[3]), ROTB[n]) + j; \
235 ROTATE(c,h)
236
237 #define ROUND160_64_TO_79(a,b,c,d,e,f,g,h,i,j) \
238 a = rol(a + (((~d | c) ^ b) + block[WA[n]] + KA[3]), ROTA[n]) + e; \
239 f = rol(f + (( g ^ h ^ i) + block[WB[n]]), ROTB[n]) + j; \
240 ROTATE(c,h)
241
242 static void ripemd160_transform(uint32_t *state, const uint8_t buffer[64], int ext)
243 {
244 uint32_t a, b, c, d, e, f, g, h, i, j, t;
245 uint32_t block[16];
246 int n;
247
248 if (ext) {
249 a = state[0]; b = state[1]; c = state[2]; d = state[3]; e = state[4];
250 f = state[5]; g = state[6]; h = state[7]; i = state[8]; j = state[9];
251 } else {
252 a = f = state[0];
253 b = g = state[1];
254 c = h = state[2];
255 d = i = state[3];
256 e = j = state[4];
257 }
258
259 for (n = 0; n < 16; n++)
260 block[n] = AV_RL32(buffer + 4 * n);
261 n = 0;
262
263 #if CONFIG_SMALL
264 for (; n < 16;) {
265 ROUND160_0_TO_15(a,b,c,d,e,f,g,h,i,j);
266 t = e; e = d; d = c; c = b; b = a; a = t;
267 t = j; j = i; i = h; h = g; g = f; f = t;
268 }
269 SWAP(b,g)
270
271 for (; n < 32;) {
272 ROUND160_16_TO_31(a,b,c,d,e,f,g,h,i,j);
273 t = e; e = d; d = c; c = b; b = a; a = t;
274 t = j; j = i; i = h; h = g; g = f; f = t;
275 }
276 SWAP(d,i)
277
278 for (; n < 48;) {
279 ROUND160_32_TO_47(a,b,c,d,e,f,g,h,i,j);
280 t = e; e = d; d = c; c = b; b = a; a = t;
281 t = j; j = i; i = h; h = g; g = f; f = t;
282 }
283 SWAP(a,f)
284
285 for (; n < 64;) {
286 ROUND160_48_TO_63(a,b,c,d,e,f,g,h,i,j);
287 t = e; e = d; d = c; c = b; b = a; a = t;
288 t = j; j = i; i = h; h = g; g = f; f = t;
289 }
290 SWAP(c,h)
291
292 for (; n < 80;) {
293 ROUND160_64_TO_79(a,b,c,d,e,f,g,h,i,j);
294 t = e; e = d; d = c; c = b; b = a; a = t;
295 t = j; j = i; i = h; h = g; g = f; f = t;
296 }
297 SWAP(e,j)
298 #else
299
300 #define R160_0 \
301 ROUND160_0_TO_15(a,b,c,d,e,f,g,h,i,j); \
302 ROUND160_0_TO_15(e,a,b,c,d,j,f,g,h,i); \
303 ROUND160_0_TO_15(d,e,a,b,c,i,j,f,g,h); \
304 ROUND160_0_TO_15(c,d,e,a,b,h,i,j,f,g); \
305 ROUND160_0_TO_15(b,c,d,e,a,g,h,i,j,f)
306
307 R160_0; R160_0; R160_0;
308 ROUND160_0_TO_15(a,b,c,d,e,f,g,h,i,j);
309 SWAP(a,f)
310
311 #define R160_16 \
312 ROUND160_16_TO_31(e,a,b,c,d,j,f,g,h,i); \
313 ROUND160_16_TO_31(d,e,a,b,c,i,j,f,g,h); \
314 ROUND160_16_TO_31(c,d,e,a,b,h,i,j,f,g); \
315 ROUND160_16_TO_31(b,c,d,e,a,g,h,i,j,f); \
316 ROUND160_16_TO_31(a,b,c,d,e,f,g,h,i,j)
317
318 R160_16; R160_16; R160_16;
319 ROUND160_16_TO_31(e,a,b,c,d,j,f,g,h,i);
320 SWAP(b,g)
321
322 #define R160_32 \
323 ROUND160_32_TO_47(d,e,a,b,c,i,j,f,g,h); \
324 ROUND160_32_TO_47(c,d,e,a,b,h,i,j,f,g); \
325 ROUND160_32_TO_47(b,c,d,e,a,g,h,i,j,f); \
326 ROUND160_32_TO_47(a,b,c,d,e,f,g,h,i,j); \
327 ROUND160_32_TO_47(e,a,b,c,d,j,f,g,h,i)
328
329 R160_32; R160_32; R160_32;
330 ROUND160_32_TO_47(d,e,a,b,c,i,j,f,g,h);
331 SWAP(c,h)
332
333 #define R160_48 \
334 ROUND160_48_TO_63(c,d,e,a,b,h,i,j,f,g); \
335 ROUND160_48_TO_63(b,c,d,e,a,g,h,i,j,f); \
336 ROUND160_48_TO_63(a,b,c,d,e,f,g,h,i,j); \
337 ROUND160_48_TO_63(e,a,b,c,d,j,f,g,h,i); \
338 ROUND160_48_TO_63(d,e,a,b,c,i,j,f,g,h)
339
340 R160_48; R160_48; R160_48;
341 ROUND160_48_TO_63(c,d,e,a,b,h,i,j,f,g);
342 SWAP(d,i)
343
344 #define R160_64 \
345 ROUND160_64_TO_79(b,c,d,e,a,g,h,i,j,f); \
346 ROUND160_64_TO_79(a,b,c,d,e,f,g,h,i,j); \
347 ROUND160_64_TO_79(e,a,b,c,d,j,f,g,h,i); \
348 ROUND160_64_TO_79(d,e,a,b,c,i,j,f,g,h); \
349 ROUND160_64_TO_79(c,d,e,a,b,h,i,j,f,g)
350
351 R160_64; R160_64; R160_64;
352 ROUND160_64_TO_79(b,c,d,e,a,g,h,i,j,f);
353 SWAP(e,j)
354 #endif
355
356 if (ext) {
357 state[0] += a; state[1] += b; state[2] += c; state[3] += d; state[4] += e;
358 state[5] += f; state[6] += g; state[7] += h; state[8] += i; state[9] += j;
359 } else {
360 i += c + state[1];
361 state[1] = state[2] + d + j;
362 state[2] = state[3] + e + f;
363 state[3] = state[4] + a + g;
364 state[4] = state[0] + b + h;
365 state[0] = i;
366 }
367 }
368
369 av_cold int av_ripemd_init(AVRIPEMD *ctx, int bits)
370 {
371 ctx->digest_len = bits >> 5;
372 switch (bits) {
373 case 128: // RIPEMD-128
374 ctx->state[0] = 0x67452301;
375 ctx->state[1] = 0xEFCDAB89;
376 ctx->state[2] = 0x98BADCFE;
377 ctx->state[3] = 0x10325476;
378 ctx->transform = ripemd128_transform;
379 ctx->ext = 0;
380 break;
381 case 160: // RIPEMD-160
382 ctx->state[0] = 0x67452301;
383 ctx->state[1] = 0xEFCDAB89;
384 ctx->state[2] = 0x98BADCFE;
385 ctx->state[3] = 0x10325476;
386 ctx->state[4] = 0xC3D2E1F0;
387 ctx->transform = ripemd160_transform;
388 ctx->ext = 0;
389 break;
390 case 256: // RIPEMD-256
391 ctx->state[0] = 0x67452301;
392 ctx->state[1] = 0xEFCDAB89;
393 ctx->state[2] = 0x98BADCFE;
394 ctx->state[3] = 0x10325476;
395 ctx->state[4] = 0x76543210;
396 ctx->state[5] = 0xFEDCBA98;
397 ctx->state[6] = 0x89ABCDEF;
398 ctx->state[7] = 0x01234567;
399 ctx->transform = ripemd128_transform;
400 ctx->ext = 1;
401 break;
402 case 320: // RIPEMD-320
403 ctx->state[0] = 0x67452301;
404 ctx->state[1] = 0xEFCDAB89;
405 ctx->state[2] = 0x98BADCFE;
406 ctx->state[3] = 0x10325476;
407 ctx->state[4] = 0xC3D2E1F0;
408 ctx->state[5] = 0x76543210;
409 ctx->state[6] = 0xFEDCBA98;
410 ctx->state[7] = 0x89ABCDEF;
411 ctx->state[8] = 0x01234567;
412 ctx->state[9] = 0x3C2D1E0F;
413 ctx->transform = ripemd160_transform;
414 ctx->ext = 1;
415 break;
416 default:
417 return -1;
418 }
419 ctx->count = 0;
420 return 0;
421 }
422
423 void av_ripemd_update(AVRIPEMD* ctx, const uint8_t* data, unsigned int len)
424 {
425 unsigned int i, j;
426
427 j = ctx->count & 63;
428 ctx->count += len;
429 #if CONFIG_SMALL
430 for (i = 0; i < len; i++) {
431 ctx->buffer[j++] = data[i];
432 if (64 == j) {
433 ctx->transform(ctx->state, ctx->buffer, ctx->ext);
434 j = 0;
435 }
436 }
437 #else
438 if ((j + len) > 63) {
439 memcpy(&ctx->buffer[j], data, (i = 64 - j));
440 ctx->transform(ctx->state, ctx->buffer, ctx->ext);
441 for (; i + 63 < len; i += 64)
442 ctx->transform(ctx->state, &data[i], ctx->ext);
443 j = 0;
444 } else
445 i = 0;
446 memcpy(&ctx->buffer[j], &data[i], len - i);
447 #endif
448 }
449
450 void av_ripemd_final(AVRIPEMD* ctx, uint8_t *digest)
451 {
452 int i;
453 uint64_t finalcount = av_le2ne64(ctx->count << 3);
454
455 av_ripemd_update(ctx, "\200", 1);
456 while ((ctx->count & 63) != 56)
457 av_ripemd_update(ctx, "", 1);
458 av_ripemd_update(ctx, (uint8_t *)&finalcount, 8); /* Should cause a transform() */
459 for (i = 0; i < ctx->digest_len; i++)
460 AV_WL32(digest + i*4, ctx->state[i]);
461 }
462
463 #ifdef TEST
464 #include <stdio.h>
465
466 int main(void)
467 {
468 int i, j, k;
469 AVRIPEMD ctx;
470 unsigned char digest[40];
471 static const int lengths[4] = { 128, 160, 256, 320 };
472
473 for (j = 0; j < 4; j++) {
474 printf("Testing RIPEMD-%d\n", lengths[j]);
475 for (k = 0; k < 3; k++) {
476 av_ripemd_init(&ctx, lengths[j]);
477 if (k == 0)
478 av_ripemd_update(&ctx, "abc", 3);
479 else if (k == 1)
480 av_ripemd_update(&ctx, "abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq", 56);
481 else
482 for (i = 0; i < 1000*1000; i++)
483 av_ripemd_update(&ctx, "a", 1);
484 av_ripemd_final(&ctx, digest);
485 for (i = 0; i < lengths[j] >> 3; i++)
486 printf("%02X", digest[i]);
487 putchar('\n');
488 }
489 switch (j) { //test vectors (from ISO:IEC 10118-3 (2004) and http://homes.esat.kuleuven.be/~bosselae/ripemd160.html)
490 case 0:
491 printf("c14a1219 9c66e4ba 84636b0f 69144c77\n"
492 "a1aa0689 d0fafa2d dc22e88b 49133a06\n"
493 "4a7f5723 f954eba1 216c9d8f 6320431f\n");
494 break;
495 case 1:
496 printf("8eb208f7 e05d987a 9b044a8e 98c6b087 f15a0bfc\n"
497 "12a05338 4a9c0c88 e405a06c 27dcf49a da62eb2b\n"
498 "52783243 c1697bdb e16d37f9 7f68f083 25dc1528\n");
499 break;
500 case 2:
501 printf("afbd6e22 8b9d8cbb cef5ca2d 03e6dba1 0ac0bc7d cbe4680e 1e42d2e9 75459b65\n"
502 "38430455 83aac6c8 c8d91285 73e7a980 9afb2a0f 34ccc36e a9e72f16 f6368e3f\n"
503 "ac953744 e10e3151 4c150d4d 8d7b6773 42e33399 788296e4 3ae4850c e4f97978\n");
504 break;
505 case 3:
506 printf("de4c01b3 054f8930 a79d09ae 738e9230 1e5a1708 5beffdc1 b8d11671 3e74f82f a942d64c dbc4682d\n"
507 "d034a795 0cf72202 1ba4b84d f769a5de 2060e259 df4c9bb4 a4268c0e 935bbc74 70a969c9 d072a1ac\n"
508 "bdee37f4 371e2064 6b8b0d86 2dda1629 2ae36f40 965e8c85 09e63d1d bddecc50 3e2b63eb 9245bb66\n");
509 break;
510 }
511 }
512
513 return 0;
514 }
515 #endif
ffmpeg Piment Noir Debian package repository