8c0cbfdb84af3c42b9f5bda6660070cb6e874909
[deb_ffmpeg.git] / ffmpeg / libavcodec / xface.c
1 /*
2 * Copyright (c) 1990 James Ashton - Sydney University
3 * Copyright (c) 2012 Stefano Sabatini
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 /**
23 * @file
24 * X-Face common data and utilities definition.
25 */
26
27 #include "libavutil/avassert.h"
28
29 #include "xface.h"
30
31 void ff_big_add(BigInt *b, uint8_t a)
32 {
33 int i;
34 uint8_t *w;
35 uint16_t c;
36
37 a &= XFACE_WORDMASK;
38 if (a == 0)
39 return;
40 w = b->words;
41 c = a;
42 for (i = 0; i < b->nb_words && c; i++) {
43 c += *w;
44 *w++ = c & XFACE_WORDMASK;
45 c >>= XFACE_BITSPERWORD;
46 }
47 if (i == b->nb_words && c) {
48 av_assert0(b->nb_words < XFACE_MAX_WORDS);
49 b->nb_words++;
50 *w = c & XFACE_WORDMASK;
51 }
52 }
53
54 void ff_big_div(BigInt *b, uint8_t a, uint8_t *r)
55 {
56 int i;
57 uint8_t *w;
58 uint16_t c, d;
59
60 a &= XFACE_WORDMASK;
61 if (a == 1 || b->nb_words == 0) {
62 *r = 0;
63 return;
64 }
65
66 /* treat this as a == WORDCARRY and just shift everything right a WORD */
67 if (a == 0) {
68 i = --b->nb_words;
69 w = b->words;
70 *r = *w;
71 while (i--) {
72 *w = *(w + 1);
73 w++;
74 }
75 *w = 0;
76 return;
77 }
78 i = b->nb_words;
79 w = b->words + i;
80 c = 0;
81 while (i--) {
82 c <<= XFACE_BITSPERWORD;
83 c += *--w;
84 d = c / (uint16_t)a;
85 c = c % (uint16_t)a;
86 *w = d & XFACE_WORDMASK;
87 }
88 *r = c;
89 if (b->words[b->nb_words - 1] == 0)
90 b->nb_words--;
91 }
92
93 void ff_big_mul(BigInt *b, uint8_t a)
94 {
95 int i;
96 uint8_t *w;
97 uint16_t c;
98
99 a &= XFACE_WORDMASK;
100 if (a == 1 || b->nb_words == 0)
101 return;
102 if (a == 0) {
103 /* treat this as a == WORDCARRY and just shift everything left a WORD */
104 av_assert0(b->nb_words < XFACE_MAX_WORDS);
105 i = b->nb_words++;
106 w = b->words + i;
107 while (i--) {
108 *w = *(w - 1);
109 w--;
110 }
111 *w = 0;
112 return;
113 }
114 i = b->nb_words;
115 w = b->words;
116 c = 0;
117 while (i--) {
118 c += (uint16_t)*w * (uint16_t)a;
119 *(w++) = c & XFACE_WORDMASK;
120 c >>= XFACE_BITSPERWORD;
121 }
122 if (c) {
123 av_assert0(b->nb_words < XFACE_MAX_WORDS);
124 b->nb_words++;
125 *w = c & XFACE_WORDMASK;
126 }
127 }
128
129 const ProbRange ff_xface_probranges_per_level[4][3] = {
130 // black grey white
131 { { 1, 255}, {251, 0}, { 4, 251} }, /* Top of tree almost always grey */
132 { { 1, 255}, {200, 0}, { 55, 200} },
133 { { 33, 223}, {159, 0}, { 64, 159} },
134 { {131, 0}, { 0, 0}, {125, 131} }, /* Grey disallowed at bottom */
135 };
136
137 const ProbRange ff_xface_probranges_2x2[16] = {
138 { 0, 0}, {38, 0}, {38, 38}, {13, 152},
139 {38, 76}, {13, 165}, {13, 178}, { 6, 230},
140 {38, 114}, {13, 191}, {13, 204}, { 6, 236},
141 {13, 217}, { 6, 242}, { 5, 248}, { 3, 253},
142 };
143
144 /*
145 * The "guess the next pixel" tables follow. Normally there are 12
146 * neighbour pixels used to give 1<<12 cases as we get closer to the
147 * upper left corner lesser numbers of neighbours are available.
148 *
149 * Each byte in the tables represents 8 boolean values starting from
150 * the most significant bit.
151 */
152
153 static const uint8_t g_00[] = {
154 0x00, 0x00, 0x01, 0x01, 0x00, 0x00, 0xe3, 0xdf, 0x05, 0x17,
155 0x05, 0x0f, 0x00, 0x1b, 0x0f, 0xdf, 0x00, 0x04, 0x00, 0x00,
156 0x0d, 0x0f, 0x03, 0x7f, 0x00, 0x00, 0x00, 0x01, 0x00, 0x1d,
157 0x45, 0x2f, 0x00, 0x00, 0x00, 0x0d, 0x00, 0x0a, 0xff, 0xff,
158 0x00, 0x04, 0x00, 0x05, 0x01, 0x3f, 0xcf, 0xff, 0x10, 0x01,
159 0x80, 0xc9, 0x0f, 0x0f, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00,
160 0x1b, 0x1f, 0xff, 0xff, 0x4f, 0x54, 0x07, 0x1f, 0x57, 0x47,
161 0xd7, 0x3d, 0xff, 0xff, 0x5f, 0x1f, 0x7f, 0xff, 0x7f, 0x7f,
162 0x05, 0x0f, 0x01, 0x0f, 0x0f, 0x5f, 0x9b, 0xdf, 0x7f, 0xff,
163 0x5f, 0x1d, 0x5f, 0xff, 0x0f, 0x1f, 0x0f, 0x5f, 0x03, 0x1f,
164 0x4f, 0x5f, 0xf7, 0x7f, 0x7f, 0xff, 0x0d, 0x0f, 0xfb, 0xff,
165 0xf7, 0xbf, 0x0f, 0x4f, 0xd7, 0x3f, 0x4f, 0x7f, 0xff, 0xff,
166 0x67, 0xbf, 0x56, 0x25, 0x1f, 0x7f, 0x9f, 0xff, 0x00, 0x00,
167 0x00, 0x05, 0x5f, 0x7f, 0x01, 0xdf, 0x14, 0x00, 0x05, 0x0f,
168 0x07, 0xa2, 0x09, 0x0f, 0x00, 0x00, 0x00, 0x00, 0x0f, 0x5f,
169 0x18, 0xd7, 0x94, 0x71, 0x00, 0x05, 0x1f, 0xb7, 0x0c, 0x07,
170 0x0f, 0x0f, 0x00, 0x0f, 0x0f, 0x1f, 0x84, 0x8f, 0x05, 0x15,
171 0x05, 0x0f, 0x4f, 0xff, 0x87, 0xdf, 0x05, 0x01, 0x10, 0x00,
172 0x0f, 0x0f, 0x00, 0x08, 0x05, 0x04, 0x04, 0x01, 0x4f, 0xff,
173 0x9f, 0x8f, 0x4a, 0x40, 0x5f, 0x5f, 0xff, 0xfe, 0xdf, 0xff,
174 0x7f, 0xf7, 0xff, 0x7f, 0xff, 0xff, 0x7b, 0xff, 0x0f, 0xfd,
175 0xd7, 0x5f, 0x4f, 0x7f, 0x7f, 0xdf, 0xff, 0xff, 0xff, 0xff,
176 0xff, 0x77, 0xdf, 0x7f, 0x4f, 0xef, 0xff, 0xff, 0x77, 0xff,
177 0xff, 0xff, 0x6f, 0xff, 0x0f, 0x4f, 0xff, 0xff, 0x9d, 0xff,
178 0x0f, 0xef, 0xff, 0xdf, 0x6f, 0xff, 0xff, 0xff, 0x4f, 0xff,
179 0xcd, 0x0f, 0x4f, 0xff, 0xff, 0xdf, 0x00, 0x00, 0x00, 0x0b,
180 0x05, 0x02, 0x02, 0x0f, 0x04, 0x00, 0x00, 0x0c, 0x01, 0x06,
181 0x00, 0x0f, 0x20, 0x03, 0x00, 0x00, 0x05, 0x0f, 0x40, 0x08,
182 0x00, 0x00, 0x00, 0x01, 0x00, 0x01, 0x0c, 0x0f, 0x01, 0x00,
183 0x80, 0x00, 0x00, 0x00, 0x80, 0x00, 0x00, 0x14, 0x01, 0x05,
184 0x01, 0x15, 0xaf, 0x0f, 0x00, 0x01, 0x10, 0x00, 0x08, 0x00,
185 0x46, 0x0c, 0x20, 0x00, 0x88, 0x00, 0x0f, 0x15, 0xff, 0xdf,
186 0x02, 0x00, 0x00, 0x0f, 0x7f, 0x5f, 0xdb, 0xff, 0x4f, 0x3e,
187 0x05, 0x0f, 0x7f, 0xf7, 0x95, 0x4f, 0x0d, 0x0f, 0x01, 0x0f,
188 0x4f, 0x5f, 0x9f, 0xdf, 0x25, 0x0e, 0x0d, 0x0d, 0x4f, 0x7f,
189 0x8f, 0x0f, 0x0f, 0xfa, 0x04, 0x4f, 0x4f, 0xff, 0xf7, 0x77,
190 0x47, 0xed, 0x05, 0x0f, 0xff, 0xff, 0xdf, 0xff, 0x4f, 0x6f,
191 0xd8, 0x5f, 0x0f, 0x7f, 0xdf, 0x5f, 0x07, 0x0f, 0x94, 0x0d,
192 0x1f, 0xff, 0xff, 0xff, 0x00, 0x02, 0x00, 0x03, 0x46, 0x57,
193 0x01, 0x0d, 0x01, 0x08, 0x01, 0x0f, 0x47, 0x6c, 0x0d, 0x0f,
194 0x02, 0x00, 0x00, 0x00, 0x0b, 0x4f, 0x00, 0x08, 0x05, 0x00,
195 0x95, 0x01, 0x0f, 0x7f, 0x0c, 0x0f, 0x01, 0x0e, 0x00, 0x00,
196 0x0f, 0x41, 0x00, 0x00, 0x04, 0x24, 0x0d, 0x0f, 0x0f, 0x7f,
197 0xcf, 0xdf, 0x00, 0x00, 0x00, 0x00, 0x04, 0x40, 0x00, 0x00,
198 0x06, 0x26, 0xcf, 0x05, 0xcf, 0x7f, 0xdf, 0xdf, 0x00, 0x00,
199 0x17, 0x5f, 0xff, 0xfd, 0xff, 0xff, 0x46, 0x09, 0x4f, 0x5f,
200 0x7f, 0xfd, 0xdf, 0xff, 0x0a, 0x88, 0xa7, 0x7f, 0x7f, 0xff,
201 0xff, 0xff, 0x0f, 0x04, 0xdf, 0x7f, 0x4f, 0xff, 0x9f, 0xff,
202 0x0e, 0xe6, 0xdf, 0xff, 0x7f, 0xff, 0xff, 0xff, 0x0f, 0xec,
203 0x8f, 0x4f, 0x7f, 0xff, 0xdf, 0xff, 0x0f, 0xcf, 0xdf, 0xff,
204 0x6f, 0x7f, 0xff, 0xff, 0x03, 0x0c, 0x9d, 0x0f, 0x7f, 0xff,
205 0xff, 0xff,
206 };
207
208 static const uint8_t g_01[] = {
209 0x37, 0x73, 0x00, 0x19, 0x57, 0x7f, 0xf5, 0xfb, 0x70, 0x33,
210 0xf0, 0xf9, 0x7f, 0xff, 0xff, 0xff,
211 };
212
213 static const uint8_t g_02[] = {
214 0x50,
215 };
216
217 static const uint8_t g_10[] = {
218 0x00, 0x00, 0x00, 0x00, 0x50, 0x00, 0xf3, 0x5f, 0x84, 0x04,
219 0x17, 0x9f, 0x04, 0x23, 0x05, 0xff, 0x00, 0x00, 0x00, 0x02,
220 0x03, 0x03, 0x33, 0xd7, 0x05, 0x03, 0x5f, 0x3f, 0x17, 0x33,
221 0xff, 0xff, 0x00, 0x80, 0x02, 0x04, 0x12, 0x00, 0x11, 0x57,
222 0x05, 0x25, 0x05, 0x03, 0x35, 0xbf, 0x9f, 0xff, 0x07, 0x6f,
223 0x20, 0x40, 0x17, 0x06, 0xfa, 0xe8, 0x01, 0x07, 0x1f, 0x9f,
224 0x1f, 0xff, 0xff, 0xff,
225 };
226
227 static const uint8_t g_20[] = {
228 0x04, 0x00, 0x01, 0x01, 0x43, 0x2e, 0xff, 0x3f,
229 };
230
231 static const uint8_t g_30[] = {
232 0x11, 0x11, 0x11, 0x11, 0x51, 0x11, 0x13, 0x11, 0x11, 0x11,
233 0x13, 0x11, 0x11, 0x11, 0x33, 0x11, 0x13, 0x11, 0x13, 0x13,
234 0x13, 0x13, 0x31, 0x31, 0x11, 0x01, 0x11, 0x11, 0x71, 0x11,
235 0x11, 0x75,
236 };
237
238 static const uint8_t g_40[] = {
239 0x00, 0x0f, 0x00, 0x09, 0x00, 0x0d, 0x00, 0x0d, 0x00, 0x0f,
240 0x00, 0x4e, 0xe4, 0x0d, 0x10, 0x0f, 0x00, 0x0f, 0x44, 0x4f,
241 0x00, 0x1e, 0x0f, 0x0f, 0xae, 0xaf, 0x45, 0x7f, 0xef, 0xff,
242 0x0f, 0xff, 0x00, 0x09, 0x01, 0x11, 0x00, 0x01, 0x1c, 0xdd,
243 0x00, 0x15, 0x00, 0xff, 0x00, 0x10, 0x00, 0xfd, 0x00, 0x0f,
244 0x4f, 0x5f, 0x3d, 0xff, 0xff, 0xff, 0x4f, 0xff, 0x1c, 0xff,
245 0xdf, 0xff, 0x8f, 0xff, 0x00, 0x0d, 0x00, 0x00, 0x00, 0x15,
246 0x01, 0x07, 0x00, 0x01, 0x02, 0x1f, 0x01, 0x11, 0x05, 0x7f,
247 0x00, 0x1f, 0x41, 0x57, 0x1f, 0xff, 0x05, 0x77, 0x0d, 0x5f,
248 0x4d, 0xff, 0x4f, 0xff, 0x0f, 0xff, 0x00, 0x00, 0x02, 0x05,
249 0x00, 0x11, 0x05, 0x7d, 0x10, 0x15, 0x2f, 0xff, 0x40, 0x50,
250 0x0d, 0xfd, 0x04, 0x0f, 0x07, 0x1f, 0x07, 0x7f, 0x0f, 0xbf,
251 0x0d, 0x7f, 0x0f, 0xff, 0x4d, 0x7d, 0x0f, 0xff,
252 };
253
254 static const uint8_t g_11[] = {
255 0x01, 0x13, 0x03, 0x7f,
256 };
257
258 static const uint8_t g_21[] = {
259 0x17,
260 };
261
262 static const uint8_t g_31[] = {
263 0x55, 0x57, 0x57, 0x7f,
264 };
265
266 static const uint8_t g_41[] = {
267 0x01, 0x01, 0x01, 0x1f, 0x03, 0x1f, 0x3f, 0xff,
268 };
269
270 static const uint8_t g_12[] = {
271 0x40,
272 };
273
274 static const uint8_t g_22[] = {
275 0x00,
276 };
277
278 static const uint8_t g_32[] = {
279 0x10,
280 };
281
282 static const uint8_t g_42[] = {
283 0x10,
284 };
285
286 void ff_xface_generate_face(uint8_t *dst, uint8_t * const src)
287 {
288 int h, i, j, k, l, m;
289
290 for (j = 0; j < XFACE_HEIGHT; j++) {
291 for (i = 0; i < XFACE_WIDTH; i++) {
292 h = i + j * XFACE_WIDTH;
293 k = 0;
294
295 /*
296 Compute k, encoding the bits *before* the current one, contained in the
297 image buffer. That is, given the grid:
298
299 l i
300 | |
301 v v
302 +--+--+--+--+--+
303 m -> | 1| 2| 3| 4| 5|
304 +--+--+--+--+--+
305 | 6| 7| 8| 9|10|
306 +--+--+--+--+--+
307 j -> |11|12| *| | |
308 +--+--+--+--+--+
309
310 the value k for the pixel marked as "*" will contain the bit encoding of
311 the values in the matrix marked from "1" to "12". In case the pixel is
312 near the border of the grid, the number of values contained within the
313 grid will be lesser than 12.
314 */
315
316 for (l = i - 2; l <= i + 2; l++) {
317 for (m = j - 2; m <= j; m++) {
318 if (l >= i && m == j)
319 continue;
320 if (l > 0 && l <= XFACE_WIDTH && m > 0)
321 k = 2*k + src[l + m * XFACE_WIDTH];
322 }
323 }
324
325 /*
326 Use the guess for the given position and the computed value of k.
327
328 The following table shows the number of digits in k, depending on
329 the position of the pixel, and shows the corresponding guess table
330 to use:
331
332 i=1 i=2 i=3 i=w-1 i=w
333 +----+----+----+ ... +----+----+
334 j=1 | 0 | 1 | 2 | | 2 | 2 |
335 |g22 |g12 |g02 | |g42 |g32 |
336 +----+----+----+ ... +----+----+
337 j=2 | 3 | 5 | 7 | | 6 | 5 |
338 |g21 |g11 |g01 | |g41 |g31 |
339 +----+----+----+ ... +----+----+
340 j=3 | 5 | 9 | 12 | | 10 | 8 |
341 |g20 |g10 |g00 | |g40 |g30 |
342 +----+----+----+ ... +----+----+
343 */
344
345 #define GEN(table) dst[h] ^= (table[k>>3]>>(7-(k&7)))&1
346
347 switch (i) {
348 case 1:
349 switch (j) {
350 case 1: GEN(g_22); break;
351 case 2: GEN(g_21); break;
352 default: GEN(g_20); break;
353 }
354 break;
355 case 2:
356 switch (j) {
357 case 1: GEN(g_12); break;
358 case 2: GEN(g_11); break;
359 default: GEN(g_10); break;
360 }
361 break;
362 case XFACE_WIDTH - 1:
363 switch (j) {
364 case 1: GEN(g_42); break;
365 case 2: GEN(g_41); break;
366 default: GEN(g_40); break;
367 }
368 break;
369 case XFACE_WIDTH:
370 switch (j) {
371 case 1: GEN(g_32); break;
372 case 2: GEN(g_31); break;
373 default: GEN(g_30); break;
374 }
375 break;
376 default:
377 switch (j) {
378 case 1: GEN(g_02); break;
379 case 2: GEN(g_01); break;
380 default: GEN(g_00); break;
381 }
382 break;
383 }
384 }
385 }
386 }