This source file includes following definitions.
- rlc
- derlc
- quantize_intra
- dequantize_intra
- quantize_inter
- dequantize_inter
- fwht
- fwht16
- ifwht
- fill_encoder_block
- var_intra
- var_inter
- decide_blocktype
- fill_decoder_block
- add_deltas
- encode_plane
- fwht_encode_frame
- decode_plane
- fwht_decode_frame
1
2
3
4
5
6
7
8
9
10
11
12 #include <linux/string.h>
13 #include <linux/kernel.h>
14 #include "codec-fwht.h"
15
16 #define OVERFLOW_BIT BIT(14)
17
18
19
20
21
22
23 #define PFRAME_BIT BIT(15)
24 #define DUPS_MASK 0x1ffe
25
26 #define PBLOCK 0
27 #define IBLOCK 1
28
29 #define ALL_ZEROS 15
30
31 static const uint8_t zigzag[64] = {
32 0,
33 1, 8,
34 2, 9, 16,
35 3, 10, 17, 24,
36 4, 11, 18, 25, 32,
37 5, 12, 19, 26, 33, 40,
38 6, 13, 20, 27, 34, 41, 48,
39 7, 14, 21, 28, 35, 42, 49, 56,
40 15, 22, 29, 36, 43, 50, 57,
41 23, 30, 37, 44, 51, 58,
42 31, 38, 45, 52, 59,
43 39, 46, 53, 60,
44 47, 54, 61,
45 55, 62,
46 63,
47 };
48
49
50
51
52
53 static int noinline_for_stack
54 rlc(const s16 *in, __be16 *output, int blocktype)
55 {
56 s16 block[8 * 8];
57 s16 *wp = block;
58 int i = 0;
59 int x, y;
60 int ret = 0;
61
62
63 int lastzero_run = 0;
64 int to_encode;
65
66 for (y = 0; y < 8; y++) {
67 for (x = 0; x < 8; x++) {
68 *wp = in[x + y * 8];
69 wp++;
70 }
71 }
72
73
74 for (i = 63; i >= 0 && !block[zigzag[i]]; i--)
75 lastzero_run++;
76
77 *output++ = (blocktype == PBLOCK ? htons(PFRAME_BIT) : 0);
78 ret++;
79
80 to_encode = 8 * 8 - (lastzero_run > 14 ? lastzero_run : 0);
81
82 i = 0;
83 while (i < to_encode) {
84 int cnt = 0;
85 int tmp;
86
87
88 while ((tmp = block[zigzag[i]]) == 0 && cnt < 14) {
89 cnt++;
90 i++;
91 if (i == to_encode) {
92 cnt--;
93 break;
94 }
95 }
96
97 *output++ = htons((cnt | tmp << 4));
98 i++;
99 ret++;
100 }
101 if (lastzero_run > 14) {
102 *output = htons(ALL_ZEROS | 0);
103 ret++;
104 }
105
106 return ret;
107 }
108
109
110
111
112
113 static noinline_for_stack u16
114 derlc(const __be16 **rlc_in, s16 *dwht_out, const __be16 *end_of_input)
115 {
116
117 const __be16 *input = *rlc_in;
118 u16 stat;
119 int dec_count = 0;
120 s16 block[8 * 8 + 16];
121 s16 *wp = block;
122 int i;
123
124 if (input > end_of_input)
125 return OVERFLOW_BIT;
126 stat = ntohs(*input++);
127
128
129
130
131
132
133
134
135
136 while (dec_count < 8 * 8) {
137 s16 in;
138 int length;
139 int coeff;
140
141 if (input > end_of_input)
142 return OVERFLOW_BIT;
143 in = ntohs(*input++);
144 length = in & 0xf;
145 coeff = in >> 4;
146
147
148 if (length == 15) {
149 for (i = 0; i < 64 - dec_count; i++)
150 *wp++ = 0;
151 break;
152 }
153
154 for (i = 0; i < length; i++)
155 *wp++ = 0;
156 *wp++ = coeff;
157 dec_count += length + 1;
158 }
159
160 wp = block;
161
162 for (i = 0; i < 64; i++) {
163 int pos = zigzag[i];
164 int y = pos / 8;
165 int x = pos % 8;
166
167 dwht_out[x + y * 8] = *wp++;
168 }
169 *rlc_in = input;
170 return stat;
171 }
172
173 static const int quant_table[] = {
174 2, 2, 2, 2, 2, 2, 2, 2,
175 2, 2, 2, 2, 2, 2, 2, 2,
176 2, 2, 2, 2, 2, 2, 2, 3,
177 2, 2, 2, 2, 2, 2, 3, 6,
178 2, 2, 2, 2, 2, 3, 6, 6,
179 2, 2, 2, 2, 3, 6, 6, 6,
180 2, 2, 2, 3, 6, 6, 6, 6,
181 2, 2, 3, 6, 6, 6, 6, 8,
182 };
183
184 static const int quant_table_p[] = {
185 3, 3, 3, 3, 3, 3, 3, 3,
186 3, 3, 3, 3, 3, 3, 3, 3,
187 3, 3, 3, 3, 3, 3, 3, 3,
188 3, 3, 3, 3, 3, 3, 3, 6,
189 3, 3, 3, 3, 3, 3, 6, 6,
190 3, 3, 3, 3, 3, 6, 6, 9,
191 3, 3, 3, 3, 6, 6, 9, 9,
192 3, 3, 3, 6, 6, 9, 9, 10,
193 };
194
195 static void quantize_intra(s16 *coeff, s16 *de_coeff, u16 qp)
196 {
197 const int *quant = quant_table;
198 int i, j;
199
200 for (j = 0; j < 8; j++) {
201 for (i = 0; i < 8; i++, quant++, coeff++, de_coeff++) {
202 *coeff >>= *quant;
203 if (*coeff >= -qp && *coeff <= qp)
204 *coeff = *de_coeff = 0;
205 else
206 *de_coeff = *coeff << *quant;
207 }
208 }
209 }
210
211 static void dequantize_intra(s16 *coeff)
212 {
213 const int *quant = quant_table;
214 int i, j;
215
216 for (j = 0; j < 8; j++)
217 for (i = 0; i < 8; i++, quant++, coeff++)
218 *coeff <<= *quant;
219 }
220
221 static void quantize_inter(s16 *coeff, s16 *de_coeff, u16 qp)
222 {
223 const int *quant = quant_table_p;
224 int i, j;
225
226 for (j = 0; j < 8; j++) {
227 for (i = 0; i < 8; i++, quant++, coeff++, de_coeff++) {
228 *coeff >>= *quant;
229 if (*coeff >= -qp && *coeff <= qp)
230 *coeff = *de_coeff = 0;
231 else
232 *de_coeff = *coeff << *quant;
233 }
234 }
235 }
236
237 static void dequantize_inter(s16 *coeff)
238 {
239 const int *quant = quant_table_p;
240 int i, j;
241
242 for (j = 0; j < 8; j++)
243 for (i = 0; i < 8; i++, quant++, coeff++)
244 *coeff <<= *quant;
245 }
246
247 static void noinline_for_stack fwht(const u8 *block, s16 *output_block,
248 unsigned int stride,
249 unsigned int input_step, bool intra)
250 {
251
252 s32 workspace1[8], workspace2[8];
253 const u8 *tmp = block;
254 s16 *out = output_block;
255 int add = intra ? 256 : 0;
256 unsigned int i;
257
258
259 for (i = 0; i < 8; i++, tmp += stride, out += 8) {
260 switch (input_step) {
261 case 1:
262 workspace1[0] = tmp[0] + tmp[1] - add;
263 workspace1[1] = tmp[0] - tmp[1];
264
265 workspace1[2] = tmp[2] + tmp[3] - add;
266 workspace1[3] = tmp[2] - tmp[3];
267
268 workspace1[4] = tmp[4] + tmp[5] - add;
269 workspace1[5] = tmp[4] - tmp[5];
270
271 workspace1[6] = tmp[6] + tmp[7] - add;
272 workspace1[7] = tmp[6] - tmp[7];
273 break;
274 case 2:
275 workspace1[0] = tmp[0] + tmp[2] - add;
276 workspace1[1] = tmp[0] - tmp[2];
277
278 workspace1[2] = tmp[4] + tmp[6] - add;
279 workspace1[3] = tmp[4] - tmp[6];
280
281 workspace1[4] = tmp[8] + tmp[10] - add;
282 workspace1[5] = tmp[8] - tmp[10];
283
284 workspace1[6] = tmp[12] + tmp[14] - add;
285 workspace1[7] = tmp[12] - tmp[14];
286 break;
287 case 3:
288 workspace1[0] = tmp[0] + tmp[3] - add;
289 workspace1[1] = tmp[0] - tmp[3];
290
291 workspace1[2] = tmp[6] + tmp[9] - add;
292 workspace1[3] = tmp[6] - tmp[9];
293
294 workspace1[4] = tmp[12] + tmp[15] - add;
295 workspace1[5] = tmp[12] - tmp[15];
296
297 workspace1[6] = tmp[18] + tmp[21] - add;
298 workspace1[7] = tmp[18] - tmp[21];
299 break;
300 default:
301 workspace1[0] = tmp[0] + tmp[4] - add;
302 workspace1[1] = tmp[0] - tmp[4];
303
304 workspace1[2] = tmp[8] + tmp[12] - add;
305 workspace1[3] = tmp[8] - tmp[12];
306
307 workspace1[4] = tmp[16] + tmp[20] - add;
308 workspace1[5] = tmp[16] - tmp[20];
309
310 workspace1[6] = tmp[24] + tmp[28] - add;
311 workspace1[7] = tmp[24] - tmp[28];
312 break;
313 }
314
315
316 workspace2[0] = workspace1[0] + workspace1[2];
317 workspace2[1] = workspace1[0] - workspace1[2];
318 workspace2[2] = workspace1[1] - workspace1[3];
319 workspace2[3] = workspace1[1] + workspace1[3];
320
321 workspace2[4] = workspace1[4] + workspace1[6];
322 workspace2[5] = workspace1[4] - workspace1[6];
323 workspace2[6] = workspace1[5] - workspace1[7];
324 workspace2[7] = workspace1[5] + workspace1[7];
325
326
327 out[0] = workspace2[0] + workspace2[4];
328 out[1] = workspace2[0] - workspace2[4];
329 out[2] = workspace2[1] - workspace2[5];
330 out[3] = workspace2[1] + workspace2[5];
331 out[4] = workspace2[2] + workspace2[6];
332 out[5] = workspace2[2] - workspace2[6];
333 out[6] = workspace2[3] - workspace2[7];
334 out[7] = workspace2[3] + workspace2[7];
335 }
336
337 out = output_block;
338
339 for (i = 0; i < 8; i++, out++) {
340
341 workspace1[0] = out[0] + out[1 * 8];
342 workspace1[1] = out[0] - out[1 * 8];
343
344 workspace1[2] = out[2 * 8] + out[3 * 8];
345 workspace1[3] = out[2 * 8] - out[3 * 8];
346
347 workspace1[4] = out[4 * 8] + out[5 * 8];
348 workspace1[5] = out[4 * 8] - out[5 * 8];
349
350 workspace1[6] = out[6 * 8] + out[7 * 8];
351 workspace1[7] = out[6 * 8] - out[7 * 8];
352
353
354 workspace2[0] = workspace1[0] + workspace1[2];
355 workspace2[1] = workspace1[0] - workspace1[2];
356 workspace2[2] = workspace1[1] - workspace1[3];
357 workspace2[3] = workspace1[1] + workspace1[3];
358
359 workspace2[4] = workspace1[4] + workspace1[6];
360 workspace2[5] = workspace1[4] - workspace1[6];
361 workspace2[6] = workspace1[5] - workspace1[7];
362 workspace2[7] = workspace1[5] + workspace1[7];
363
364 out[0 * 8] = workspace2[0] + workspace2[4];
365 out[1 * 8] = workspace2[0] - workspace2[4];
366 out[2 * 8] = workspace2[1] - workspace2[5];
367 out[3 * 8] = workspace2[1] + workspace2[5];
368 out[4 * 8] = workspace2[2] + workspace2[6];
369 out[5 * 8] = workspace2[2] - workspace2[6];
370 out[6 * 8] = workspace2[3] - workspace2[7];
371 out[7 * 8] = workspace2[3] + workspace2[7];
372 }
373 }
374
375
376
377
378
379
380
381 static void noinline_for_stack
382 fwht16(const s16 *block, s16 *output_block, int stride, int intra)
383 {
384
385 s32 workspace1[8], workspace2[8];
386 const s16 *tmp = block;
387 s16 *out = output_block;
388 int i;
389
390 for (i = 0; i < 8; i++, tmp += stride, out += 8) {
391
392 workspace1[0] = tmp[0] + tmp[1];
393 workspace1[1] = tmp[0] - tmp[1];
394
395 workspace1[2] = tmp[2] + tmp[3];
396 workspace1[3] = tmp[2] - tmp[3];
397
398 workspace1[4] = tmp[4] + tmp[5];
399 workspace1[5] = tmp[4] - tmp[5];
400
401 workspace1[6] = tmp[6] + tmp[7];
402 workspace1[7] = tmp[6] - tmp[7];
403
404
405 workspace2[0] = workspace1[0] + workspace1[2];
406 workspace2[1] = workspace1[0] - workspace1[2];
407 workspace2[2] = workspace1[1] - workspace1[3];
408 workspace2[3] = workspace1[1] + workspace1[3];
409
410 workspace2[4] = workspace1[4] + workspace1[6];
411 workspace2[5] = workspace1[4] - workspace1[6];
412 workspace2[6] = workspace1[5] - workspace1[7];
413 workspace2[7] = workspace1[5] + workspace1[7];
414
415
416 out[0] = workspace2[0] + workspace2[4];
417 out[1] = workspace2[0] - workspace2[4];
418 out[2] = workspace2[1] - workspace2[5];
419 out[3] = workspace2[1] + workspace2[5];
420 out[4] = workspace2[2] + workspace2[6];
421 out[5] = workspace2[2] - workspace2[6];
422 out[6] = workspace2[3] - workspace2[7];
423 out[7] = workspace2[3] + workspace2[7];
424 }
425
426 out = output_block;
427
428 for (i = 0; i < 8; i++, out++) {
429
430 workspace1[0] = out[0] + out[1*8];
431 workspace1[1] = out[0] - out[1*8];
432
433 workspace1[2] = out[2*8] + out[3*8];
434 workspace1[3] = out[2*8] - out[3*8];
435
436 workspace1[4] = out[4*8] + out[5*8];
437 workspace1[5] = out[4*8] - out[5*8];
438
439 workspace1[6] = out[6*8] + out[7*8];
440 workspace1[7] = out[6*8] - out[7*8];
441
442
443 workspace2[0] = workspace1[0] + workspace1[2];
444 workspace2[1] = workspace1[0] - workspace1[2];
445 workspace2[2] = workspace1[1] - workspace1[3];
446 workspace2[3] = workspace1[1] + workspace1[3];
447
448 workspace2[4] = workspace1[4] + workspace1[6];
449 workspace2[5] = workspace1[4] - workspace1[6];
450 workspace2[6] = workspace1[5] - workspace1[7];
451 workspace2[7] = workspace1[5] + workspace1[7];
452
453
454 out[0*8] = workspace2[0] + workspace2[4];
455 out[1*8] = workspace2[0] - workspace2[4];
456 out[2*8] = workspace2[1] - workspace2[5];
457 out[3*8] = workspace2[1] + workspace2[5];
458 out[4*8] = workspace2[2] + workspace2[6];
459 out[5*8] = workspace2[2] - workspace2[6];
460 out[6*8] = workspace2[3] - workspace2[7];
461 out[7*8] = workspace2[3] + workspace2[7];
462 }
463 }
464
465 static noinline_for_stack void
466 ifwht(const s16 *block, s16 *output_block, int intra)
467 {
468
469
470
471
472 int workspace1[8], workspace2[8];
473 int inter = intra ? 0 : 1;
474 const s16 *tmp = block;
475 s16 *out = output_block;
476 int i;
477
478 for (i = 0; i < 8; i++, tmp += 8, out += 8) {
479
480 workspace1[0] = tmp[0] + tmp[1];
481 workspace1[1] = tmp[0] - tmp[1];
482
483 workspace1[2] = tmp[2] + tmp[3];
484 workspace1[3] = tmp[2] - tmp[3];
485
486 workspace1[4] = tmp[4] + tmp[5];
487 workspace1[5] = tmp[4] - tmp[5];
488
489 workspace1[6] = tmp[6] + tmp[7];
490 workspace1[7] = tmp[6] - tmp[7];
491
492
493 workspace2[0] = workspace1[0] + workspace1[2];
494 workspace2[1] = workspace1[0] - workspace1[2];
495 workspace2[2] = workspace1[1] - workspace1[3];
496 workspace2[3] = workspace1[1] + workspace1[3];
497
498 workspace2[4] = workspace1[4] + workspace1[6];
499 workspace2[5] = workspace1[4] - workspace1[6];
500 workspace2[6] = workspace1[5] - workspace1[7];
501 workspace2[7] = workspace1[5] + workspace1[7];
502
503
504 out[0] = workspace2[0] + workspace2[4];
505 out[1] = workspace2[0] - workspace2[4];
506 out[2] = workspace2[1] - workspace2[5];
507 out[3] = workspace2[1] + workspace2[5];
508 out[4] = workspace2[2] + workspace2[6];
509 out[5] = workspace2[2] - workspace2[6];
510 out[6] = workspace2[3] - workspace2[7];
511 out[7] = workspace2[3] + workspace2[7];
512 }
513
514 out = output_block;
515
516 for (i = 0; i < 8; i++, out++) {
517
518 workspace1[0] = out[0] + out[1 * 8];
519 workspace1[1] = out[0] - out[1 * 8];
520
521 workspace1[2] = out[2 * 8] + out[3 * 8];
522 workspace1[3] = out[2 * 8] - out[3 * 8];
523
524 workspace1[4] = out[4 * 8] + out[5 * 8];
525 workspace1[5] = out[4 * 8] - out[5 * 8];
526
527 workspace1[6] = out[6 * 8] + out[7 * 8];
528 workspace1[7] = out[6 * 8] - out[7 * 8];
529
530
531 workspace2[0] = workspace1[0] + workspace1[2];
532 workspace2[1] = workspace1[0] - workspace1[2];
533 workspace2[2] = workspace1[1] - workspace1[3];
534 workspace2[3] = workspace1[1] + workspace1[3];
535
536 workspace2[4] = workspace1[4] + workspace1[6];
537 workspace2[5] = workspace1[4] - workspace1[6];
538 workspace2[6] = workspace1[5] - workspace1[7];
539 workspace2[7] = workspace1[5] + workspace1[7];
540
541
542 if (inter) {
543 int d;
544
545 out[0 * 8] = workspace2[0] + workspace2[4];
546 out[1 * 8] = workspace2[0] - workspace2[4];
547 out[2 * 8] = workspace2[1] - workspace2[5];
548 out[3 * 8] = workspace2[1] + workspace2[5];
549 out[4 * 8] = workspace2[2] + workspace2[6];
550 out[5 * 8] = workspace2[2] - workspace2[6];
551 out[6 * 8] = workspace2[3] - workspace2[7];
552 out[7 * 8] = workspace2[3] + workspace2[7];
553
554 for (d = 0; d < 8; d++)
555 out[8 * d] >>= 6;
556 } else {
557 int d;
558
559 out[0 * 8] = workspace2[0] + workspace2[4];
560 out[1 * 8] = workspace2[0] - workspace2[4];
561 out[2 * 8] = workspace2[1] - workspace2[5];
562 out[3 * 8] = workspace2[1] + workspace2[5];
563 out[4 * 8] = workspace2[2] + workspace2[6];
564 out[5 * 8] = workspace2[2] - workspace2[6];
565 out[6 * 8] = workspace2[3] - workspace2[7];
566 out[7 * 8] = workspace2[3] + workspace2[7];
567
568 for (d = 0; d < 8; d++) {
569 out[8 * d] >>= 6;
570 out[8 * d] += 128;
571 }
572 }
573 }
574 }
575
576 static void fill_encoder_block(const u8 *input, s16 *dst,
577 unsigned int stride, unsigned int input_step)
578 {
579 int i, j;
580
581 for (i = 0; i < 8; i++) {
582 for (j = 0; j < 8; j++, input += input_step)
583 *dst++ = *input;
584 input += stride - 8 * input_step;
585 }
586 }
587
588 static int var_intra(const s16 *input)
589 {
590 int32_t mean = 0;
591 int32_t ret = 0;
592 const s16 *tmp = input;
593 int i;
594
595 for (i = 0; i < 8 * 8; i++, tmp++)
596 mean += *tmp;
597 mean /= 64;
598 tmp = input;
599 for (i = 0; i < 8 * 8; i++, tmp++)
600 ret += (*tmp - mean) < 0 ? -(*tmp - mean) : (*tmp - mean);
601 return ret;
602 }
603
604 static int var_inter(const s16 *old, const s16 *new)
605 {
606 int32_t ret = 0;
607 int i;
608
609 for (i = 0; i < 8 * 8; i++, old++, new++)
610 ret += (*old - *new) < 0 ? -(*old - *new) : (*old - *new);
611 return ret;
612 }
613
614 static noinline_for_stack int
615 decide_blocktype(const u8 *cur, const u8 *reference, s16 *deltablock,
616 unsigned int stride, unsigned int input_step)
617 {
618 s16 tmp[64];
619 s16 old[64];
620 s16 *work = tmp;
621 unsigned int k, l;
622 int vari;
623 int vard;
624
625 fill_encoder_block(cur, tmp, stride, input_step);
626 fill_encoder_block(reference, old, 8, 1);
627 vari = var_intra(tmp);
628
629 for (k = 0; k < 8; k++) {
630 for (l = 0; l < 8; l++) {
631 *deltablock = *work - *reference;
632 deltablock++;
633 work++;
634 reference++;
635 }
636 }
637 deltablock -= 64;
638 vard = var_inter(old, tmp);
639 return vari <= vard ? IBLOCK : PBLOCK;
640 }
641
642 static void fill_decoder_block(u8 *dst, const s16 *input, int stride,
643 unsigned int dst_step)
644 {
645 int i, j;
646
647 for (i = 0; i < 8; i++) {
648 for (j = 0; j < 8; j++, input++, dst += dst_step) {
649 if (*input < 0)
650 *dst = 0;
651 else if (*input > 255)
652 *dst = 255;
653 else
654 *dst = *input;
655 }
656 dst += stride - (8 * dst_step);
657 }
658 }
659
660 static void add_deltas(s16 *deltas, const u8 *ref, int stride,
661 unsigned int ref_step)
662 {
663 int k, l;
664
665 for (k = 0; k < 8; k++) {
666 for (l = 0; l < 8; l++) {
667 *deltas += *ref;
668 ref += ref_step;
669
670
671
672
673 if (*deltas < 0)
674 *deltas = 0;
675 else if (*deltas > 255)
676 *deltas = 255;
677 deltas++;
678 }
679 ref += stride - (8 * ref_step);
680 }
681 }
682
683 static u32 encode_plane(u8 *input, u8 *refp, __be16 **rlco, __be16 *rlco_max,
684 struct fwht_cframe *cf, u32 height, u32 width,
685 u32 stride, unsigned int input_step,
686 bool is_intra, bool next_is_intra)
687 {
688 u8 *input_start = input;
689 __be16 *rlco_start = *rlco;
690 s16 deltablock[64];
691 __be16 pframe_bit = htons(PFRAME_BIT);
692 u32 encoding = 0;
693 unsigned int last_size = 0;
694 unsigned int i, j;
695
696 width = round_up(width, 8);
697 height = round_up(height, 8);
698
699 for (j = 0; j < height / 8; j++) {
700 input = input_start + j * 8 * stride;
701 for (i = 0; i < width / 8; i++) {
702
703 int blocktype = IBLOCK;
704 unsigned int size;
705
706 if (!is_intra)
707 blocktype = decide_blocktype(input, refp,
708 deltablock, stride, input_step);
709 if (blocktype == IBLOCK) {
710 fwht(input, cf->coeffs, stride, input_step, 1);
711 quantize_intra(cf->coeffs, cf->de_coeffs,
712 cf->i_frame_qp);
713 } else {
714
715 encoding |= FWHT_FRAME_PCODED;
716 fwht16(deltablock, cf->coeffs, 8, 0);
717 quantize_inter(cf->coeffs, cf->de_coeffs,
718 cf->p_frame_qp);
719 }
720 if (!next_is_intra) {
721 ifwht(cf->de_coeffs, cf->de_fwht, blocktype);
722
723 if (blocktype == PBLOCK)
724 add_deltas(cf->de_fwht, refp, 8, 1);
725 fill_decoder_block(refp, cf->de_fwht, 8, 1);
726 }
727
728 input += 8 * input_step;
729 refp += 8 * 8;
730
731 size = rlc(cf->coeffs, *rlco, blocktype);
732 if (last_size == size &&
733 !memcmp(*rlco + 1, *rlco - size + 1, 2 * size - 2)) {
734 __be16 *last_rlco = *rlco - size;
735 s16 hdr = ntohs(*last_rlco);
736
737 if (!((*last_rlco ^ **rlco) & pframe_bit) &&
738 (hdr & DUPS_MASK) < DUPS_MASK)
739 *last_rlco = htons(hdr + 2);
740 else
741 *rlco += size;
742 } else {
743 *rlco += size;
744 }
745 if (*rlco >= rlco_max) {
746 encoding |= FWHT_FRAME_UNENCODED;
747 goto exit_loop;
748 }
749 last_size = size;
750 }
751 }
752
753 exit_loop:
754 if (encoding & FWHT_FRAME_UNENCODED) {
755 u8 *out = (u8 *)rlco_start;
756 u8 *p;
757
758 input = input_start;
759
760
761
762
763
764
765 for (j = 0; j < height; j++) {
766 for (i = 0, p = input; i < width; i++, p += input_step)
767 *out++ = (*p == 0xff) ? 0xfe : *p;
768 input += stride;
769 }
770 *rlco = (__be16 *)out;
771 encoding &= ~FWHT_FRAME_PCODED;
772 }
773 return encoding;
774 }
775
776 u32 fwht_encode_frame(struct fwht_raw_frame *frm,
777 struct fwht_raw_frame *ref_frm,
778 struct fwht_cframe *cf,
779 bool is_intra, bool next_is_intra,
780 unsigned int width, unsigned int height,
781 unsigned int stride, unsigned int chroma_stride)
782 {
783 unsigned int size = height * width;
784 __be16 *rlco = cf->rlc_data;
785 __be16 *rlco_max;
786 u32 encoding;
787
788 rlco_max = rlco + size / 2 - 256;
789 encoding = encode_plane(frm->luma, ref_frm->luma, &rlco, rlco_max, cf,
790 height, width, stride,
791 frm->luma_alpha_step, is_intra, next_is_intra);
792 if (encoding & FWHT_FRAME_UNENCODED)
793 encoding |= FWHT_LUMA_UNENCODED;
794 encoding &= ~FWHT_FRAME_UNENCODED;
795
796 if (frm->components_num >= 3) {
797 u32 chroma_h = height / frm->height_div;
798 u32 chroma_w = width / frm->width_div;
799 unsigned int chroma_size = chroma_h * chroma_w;
800
801 rlco_max = rlco + chroma_size / 2 - 256;
802 encoding |= encode_plane(frm->cb, ref_frm->cb, &rlco, rlco_max,
803 cf, chroma_h, chroma_w,
804 chroma_stride, frm->chroma_step,
805 is_intra, next_is_intra);
806 if (encoding & FWHT_FRAME_UNENCODED)
807 encoding |= FWHT_CB_UNENCODED;
808 encoding &= ~FWHT_FRAME_UNENCODED;
809 rlco_max = rlco + chroma_size / 2 - 256;
810 encoding |= encode_plane(frm->cr, ref_frm->cr, &rlco, rlco_max,
811 cf, chroma_h, chroma_w,
812 chroma_stride, frm->chroma_step,
813 is_intra, next_is_intra);
814 if (encoding & FWHT_FRAME_UNENCODED)
815 encoding |= FWHT_CR_UNENCODED;
816 encoding &= ~FWHT_FRAME_UNENCODED;
817 }
818
819 if (frm->components_num == 4) {
820 rlco_max = rlco + size / 2 - 256;
821 encoding |= encode_plane(frm->alpha, ref_frm->alpha, &rlco,
822 rlco_max, cf, height, width,
823 stride, frm->luma_alpha_step,
824 is_intra, next_is_intra);
825 if (encoding & FWHT_FRAME_UNENCODED)
826 encoding |= FWHT_ALPHA_UNENCODED;
827 encoding &= ~FWHT_FRAME_UNENCODED;
828 }
829
830 cf->size = (rlco - cf->rlc_data) * sizeof(*rlco);
831 return encoding;
832 }
833
834 static bool decode_plane(struct fwht_cframe *cf, const __be16 **rlco,
835 u32 height, u32 width, const u8 *ref, u32 ref_stride,
836 unsigned int ref_step, u8 *dst,
837 unsigned int dst_stride, unsigned int dst_step,
838 bool uncompressed, const __be16 *end_of_rlco_buf)
839 {
840 unsigned int copies = 0;
841 s16 copy[8 * 8];
842 u16 stat;
843 unsigned int i, j;
844 bool is_intra = !ref;
845
846 width = round_up(width, 8);
847 height = round_up(height, 8);
848
849 if (uncompressed) {
850 int i;
851
852 if (end_of_rlco_buf + 1 < *rlco + width * height / 2)
853 return false;
854 for (i = 0; i < height; i++) {
855 memcpy(dst, *rlco, width);
856 dst += dst_stride;
857 *rlco += width / 2;
858 }
859 return true;
860 }
861
862
863
864
865
866
867
868 for (j = 0; j < height / 8; j++) {
869 for (i = 0; i < width / 8; i++) {
870 const u8 *refp = ref + j * 8 * ref_stride +
871 i * 8 * ref_step;
872 u8 *dstp = dst + j * 8 * dst_stride + i * 8 * dst_step;
873
874 if (copies) {
875 memcpy(cf->de_fwht, copy, sizeof(copy));
876 if ((stat & PFRAME_BIT) && !is_intra)
877 add_deltas(cf->de_fwht, refp,
878 ref_stride, ref_step);
879 fill_decoder_block(dstp, cf->de_fwht,
880 dst_stride, dst_step);
881 copies--;
882 continue;
883 }
884
885 stat = derlc(rlco, cf->coeffs, end_of_rlco_buf);
886 if (stat & OVERFLOW_BIT)
887 return false;
888 if ((stat & PFRAME_BIT) && !is_intra)
889 dequantize_inter(cf->coeffs);
890 else
891 dequantize_intra(cf->coeffs);
892
893 ifwht(cf->coeffs, cf->de_fwht,
894 ((stat & PFRAME_BIT) && !is_intra) ? 0 : 1);
895
896 copies = (stat & DUPS_MASK) >> 1;
897 if (copies)
898 memcpy(copy, cf->de_fwht, sizeof(copy));
899 if ((stat & PFRAME_BIT) && !is_intra)
900 add_deltas(cf->de_fwht, refp,
901 ref_stride, ref_step);
902 fill_decoder_block(dstp, cf->de_fwht, dst_stride,
903 dst_step);
904 }
905 }
906 return true;
907 }
908
909 bool fwht_decode_frame(struct fwht_cframe *cf, u32 hdr_flags,
910 unsigned int components_num, unsigned int width,
911 unsigned int height, const struct fwht_raw_frame *ref,
912 unsigned int ref_stride, unsigned int ref_chroma_stride,
913 struct fwht_raw_frame *dst, unsigned int dst_stride,
914 unsigned int dst_chroma_stride)
915 {
916 const __be16 *rlco = cf->rlc_data;
917 const __be16 *end_of_rlco_buf = cf->rlc_data +
918 (cf->size / sizeof(*rlco)) - 1;
919
920 if (!decode_plane(cf, &rlco, height, width, ref->luma, ref_stride,
921 ref->luma_alpha_step, dst->luma, dst_stride,
922 dst->luma_alpha_step,
923 hdr_flags & FWHT_FL_LUMA_IS_UNCOMPRESSED,
924 end_of_rlco_buf))
925 return false;
926
927 if (components_num >= 3) {
928 u32 h = height;
929 u32 w = width;
930
931 if (!(hdr_flags & FWHT_FL_CHROMA_FULL_HEIGHT))
932 h /= 2;
933 if (!(hdr_flags & FWHT_FL_CHROMA_FULL_WIDTH))
934 w /= 2;
935
936 if (!decode_plane(cf, &rlco, h, w, ref->cb, ref_chroma_stride,
937 ref->chroma_step, dst->cb, dst_chroma_stride,
938 dst->chroma_step,
939 hdr_flags & FWHT_FL_CB_IS_UNCOMPRESSED,
940 end_of_rlco_buf))
941 return false;
942 if (!decode_plane(cf, &rlco, h, w, ref->cr, ref_chroma_stride,
943 ref->chroma_step, dst->cr, dst_chroma_stride,
944 dst->chroma_step,
945 hdr_flags & FWHT_FL_CR_IS_UNCOMPRESSED,
946 end_of_rlco_buf))
947 return false;
948 }
949
950 if (components_num == 4)
951 if (!decode_plane(cf, &rlco, height, width, ref->alpha, ref_stride,
952 ref->luma_alpha_step, dst->alpha, dst_stride,
953 dst->luma_alpha_step,
954 hdr_flags & FWHT_FL_ALPHA_IS_UNCOMPRESSED,
955 end_of_rlco_buf))
956 return false;
957 return true;
958 }