?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
perf tools: Don't clone maps from parent when synthesizing forks
[linux/fpc-iii.git] / drivers / media / platform / vicodec / vicodec-codec.c
blob2d047646f6147e74f04f9cf6ebcd877ac40e554a
1 // SPDX-License-Identifier: GPL-2.0+
2 /*
3 * Copyright 2016 Tom aan de Wiel
4 * Copyright 2018 Cisco Systems, Inc. and/or its affiliates. All rights reserved.
5 *
6 * 8x8 Fast Walsh Hadamard Transform in sequency order based on the paper:
7 *
8 * A Recursive Algorithm for Sequency-Ordered Fast Walsh Transforms,
9 * R.D. Brown, 1977
10 */
11
12 #include <linux/string.h>
13 #include "vicodec-codec.h"
14
15 #define ALL_ZEROS 15
16 #define DEADZONE_WIDTH 20
17
18 static const uint8_t zigzag[64] = {
19 0,
20 1, 8,
21 2, 9, 16,
22 3, 10, 17, 24,
23 4, 11, 18, 25, 32,
24 5, 12, 19, 26, 33, 40,
25 6, 13, 20, 27, 34, 41, 48,
26 7, 14, 21, 28, 35, 42, 49, 56,
27 15, 22, 29, 36, 43, 50, 57,
28 23, 30, 37, 44, 51, 58,
29 31, 38, 45, 52, 59,
30 39, 46, 53, 60,
31 47, 54, 61,
32 55, 62,
33 63,
34 };
35
36
37 static int rlc(const s16 *in, __be16 *output, int blocktype)
38 {
39 s16 block[8 * 8];
40 s16 *wp = block;
41 int i = 0;
42 int x, y;
43 int ret = 0;
44
45 /* read in block from framebuffer */
46 int lastzero_run = 0;
47 int to_encode;
48
49 for (y = 0; y < 8; y++) {
50 for (x = 0; x < 8; x++) {
51 *wp = in[x + y * 8];
52 wp++;
53 }
54 }
55
56 /* keep track of amount of trailing zeros */
57 for (i = 63; i >= 0 && !block[zigzag[i]]; i--)
58 lastzero_run++;
59
60 *output++ = (blocktype == PBLOCK ? htons(PFRAME_BIT) : 0);
61 ret++;
62
63 to_encode = 8 * 8 - (lastzero_run > 14 ? lastzero_run : 0);
64
65 i = 0;
66 while (i < to_encode) {
67 int cnt = 0;
68 int tmp;
69
70 /* count leading zeros */
71 while ((tmp = block[zigzag[i]]) == 0 && cnt < 14) {
72 cnt++;
73 i++;
74 if (i == to_encode) {
75 cnt--;
76 break;
77 }
78 }
79 /* 4 bits for run, 12 for coefficient (quantization by 4) */
80 *output++ = htons((cnt | tmp << 4));
81 i++;
82 ret++;
83 }
84 if (lastzero_run > 14) {
85 *output = htons(ALL_ZEROS | 0);
86 ret++;
87 }
88
89 return ret;
90 }
91
92 /*
93 * This function will worst-case increase rlc_in by 65*2 bytes:
94 * one s16 value for the header and 8 * 8 coefficients of type s16.
95 */
96 static s16 derlc(const __be16 **rlc_in, s16 *dwht_out)
97 {
98 /* header */
99 const __be16 *input = *rlc_in;
100 s16 ret = ntohs(*input++);
101 int dec_count = 0;
102 s16 block[8 * 8 + 16];
103 s16 *wp = block;
104 int i;
105
106 /*
107 * Now de-compress, it expands one byte to up to 15 bytes
108 * (or fills the remainder of the 64 bytes with zeroes if it
109 * is the last byte to expand).
110 *
111 * So block has to be 8 * 8 + 16 bytes, the '+ 16' is to
112 * allow for overflow if the incoming data was malformed.
113 */
114 while (dec_count < 8 * 8) {
115 s16 in = ntohs(*input++);
116 int length = in & 0xf;
117 int coeff = in >> 4;
118
119 /* fill remainder with zeros */
120 if (length == 15) {
121 for (i = 0; i < 64 - dec_count; i++)
122 *wp++ = 0;
123 break;
124 }
125
126 for (i = 0; i < length; i++)
127 *wp++ = 0;
128 *wp++ = coeff;
129 dec_count += length + 1;
130 }
131
132 wp = block;
133
134 for (i = 0; i < 64; i++) {
135 int pos = zigzag[i];
136 int y = pos / 8;
137 int x = pos % 8;
138
139 dwht_out[x + y * 8] = *wp++;
140 }
141 *rlc_in = input;
142 return ret;
143 }
144
145 static const int quant_table[] = {
146 2, 2, 2, 2, 2, 2, 2, 2,
147 2, 2, 2, 2, 2, 2, 2, 2,
148 2, 2, 2, 2, 2, 2, 2, 3,
149 2, 2, 2, 2, 2, 2, 3, 6,
150 2, 2, 2, 2, 2, 3, 6, 6,
151 2, 2, 2, 2, 3, 6, 6, 6,
152 2, 2, 2, 3, 6, 6, 6, 6,
153 2, 2, 3, 6, 6, 6, 6, 8,
154 };
155
156 static const int quant_table_p[] = {
157 3, 3, 3, 3, 3, 3, 3, 3,
158 3, 3, 3, 3, 3, 3, 3, 3,
159 3, 3, 3, 3, 3, 3, 3, 3,
160 3, 3, 3, 3, 3, 3, 3, 6,
161 3, 3, 3, 3, 3, 3, 6, 6,
162 3, 3, 3, 3, 3, 6, 6, 9,
163 3, 3, 3, 3, 6, 6, 9, 9,
164 3, 3, 3, 6, 6, 9, 9, 10,
165 };
166
167 static void quantize_intra(s16 *coeff, s16 *de_coeff)
168 {
169 const int *quant = quant_table;
170 int i, j;
171
172 for (j = 0; j < 8; j++) {
173 for (i = 0; i < 8; i++, quant++, coeff++, de_coeff++) {
174 *coeff >>= *quant;
175 if (*coeff >= -DEADZONE_WIDTH &&
176 *coeff <= DEADZONE_WIDTH)
177 *coeff = *de_coeff = 0;
178 else
179 *de_coeff = *coeff << *quant;
180 }
181 }
182 }
183
184 static void dequantize_intra(s16 *coeff)
185 {
186 const int *quant = quant_table;
187 int i, j;
188
189 for (j = 0; j < 8; j++)
190 for (i = 0; i < 8; i++, quant++, coeff++)
191 *coeff <<= *quant;
192 }
193
194 static void quantize_inter(s16 *coeff, s16 *de_coeff)
195 {
196 const int *quant = quant_table_p;
197 int i, j;
198
199 for (j = 0; j < 8; j++) {
200 for (i = 0; i < 8; i++, quant++, coeff++, de_coeff++) {
201 *coeff >>= *quant;
202 if (*coeff >= -DEADZONE_WIDTH &&
203 *coeff <= DEADZONE_WIDTH)
204 *coeff = *de_coeff = 0;
205 else
206 *de_coeff = *coeff << *quant;
207 }
208 }
209 }
210
211 static void dequantize_inter(s16 *coeff)
212 {
213 const int *quant = quant_table_p;
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 fwht(const u8 *block, s16 *output_block, unsigned int stride,
222 unsigned int input_step, bool intra)
223 {
224 /* we'll need more than 8 bits for the transformed coefficients */
225 s32 workspace1[8], workspace2[8];
226 const u8 *tmp = block;
227 s16 *out = output_block;
228 int add = intra ? 256 : 0;
229 unsigned int i;
230
231 /* stage 1 */
232 stride *= input_step;
233
234 for (i = 0; i < 8; i++, tmp += stride, out += 8) {
235 if (input_step == 1) {
236 workspace1[0] = tmp[0] + tmp[1] - add;
237 workspace1[1] = tmp[0] - tmp[1];
238
239 workspace1[2] = tmp[2] + tmp[3] - add;
240 workspace1[3] = tmp[2] - tmp[3];
241
242 workspace1[4] = tmp[4] + tmp[5] - add;
243 workspace1[5] = tmp[4] - tmp[5];
244
245 workspace1[6] = tmp[6] + tmp[7] - add;
246 workspace1[7] = tmp[6] - tmp[7];
247 } else {
248 workspace1[0] = tmp[0] + tmp[2] - add;
249 workspace1[1] = tmp[0] - tmp[2];
250
251 workspace1[2] = tmp[4] + tmp[6] - add;
252 workspace1[3] = tmp[4] - tmp[6];
253
254 workspace1[4] = tmp[8] + tmp[10] - add;
255 workspace1[5] = tmp[8] - tmp[10];
256
257 workspace1[6] = tmp[12] + tmp[14] - add;
258 workspace1[7] = tmp[12] - tmp[14];
259 }
260
261 /* stage 2 */
262 workspace2[0] = workspace1[0] + workspace1[2];
263 workspace2[1] = workspace1[0] - workspace1[2];
264 workspace2[2] = workspace1[1] - workspace1[3];
265 workspace2[3] = workspace1[1] + workspace1[3];
266
267 workspace2[4] = workspace1[4] + workspace1[6];
268 workspace2[5] = workspace1[4] - workspace1[6];
269 workspace2[6] = workspace1[5] - workspace1[7];
270 workspace2[7] = workspace1[5] + workspace1[7];
271
272 /* stage 3 */
273 out[0] = workspace2[0] + workspace2[4];
274 out[1] = workspace2[0] - workspace2[4];
275 out[2] = workspace2[1] - workspace2[5];
276 out[3] = workspace2[1] + workspace2[5];
277 out[4] = workspace2[2] + workspace2[6];
278 out[5] = workspace2[2] - workspace2[6];
279 out[6] = workspace2[3] - workspace2[7];
280 out[7] = workspace2[3] + workspace2[7];
281 }
282
283 out = output_block;
284
285 for (i = 0; i < 8; i++, out++) {
286 /* stage 1 */
287 workspace1[0] = out[0] + out[1 * 8];
288 workspace1[1] = out[0] - out[1 * 8];
289
290 workspace1[2] = out[2 * 8] + out[3 * 8];
291 workspace1[3] = out[2 * 8] - out[3 * 8];
292
293 workspace1[4] = out[4 * 8] + out[5 * 8];
294 workspace1[5] = out[4 * 8] - out[5 * 8];
295
296 workspace1[6] = out[6 * 8] + out[7 * 8];
297 workspace1[7] = out[6 * 8] - out[7 * 8];
298
299 /* stage 2 */
300 workspace2[0] = workspace1[0] + workspace1[2];
301 workspace2[1] = workspace1[0] - workspace1[2];
302 workspace2[2] = workspace1[1] - workspace1[3];
303 workspace2[3] = workspace1[1] + workspace1[3];
304
305 workspace2[4] = workspace1[4] + workspace1[6];
306 workspace2[5] = workspace1[4] - workspace1[6];
307 workspace2[6] = workspace1[5] - workspace1[7];
308 workspace2[7] = workspace1[5] + workspace1[7];
309 /* stage 3 */
310 out[0 * 8] = workspace2[0] + workspace2[4];
311 out[1 * 8] = workspace2[0] - workspace2[4];
312 out[2 * 8] = workspace2[1] - workspace2[5];
313 out[3 * 8] = workspace2[1] + workspace2[5];
314 out[4 * 8] = workspace2[2] + workspace2[6];
315 out[5 * 8] = workspace2[2] - workspace2[6];
316 out[6 * 8] = workspace2[3] - workspace2[7];
317 out[7 * 8] = workspace2[3] + workspace2[7];
318 }
319 }
320
321 /*
322 * Not the nicest way of doing it, but P-blocks get twice the range of
323 * that of the I-blocks. Therefore we need a type bigger than 8 bits.
324 * Furthermore values can be negative... This is just a version that
325 * works with 16 signed data
326 */
327 static void fwht16(const s16 *block, s16 *output_block, int stride, int intra)
328 {
329 /* we'll need more than 8 bits for the transformed coefficients */
330 s32 workspace1[8], workspace2[8];
331 const s16 *tmp = block;
332 s16 *out = output_block;
333 int i;
334
335 for (i = 0; i < 8; i++, tmp += stride, out += 8) {
336 /* stage 1 */
337 workspace1[0] = tmp[0] + tmp[1];
338 workspace1[1] = tmp[0] - tmp[1];
339
340 workspace1[2] = tmp[2] + tmp[3];
341 workspace1[3] = tmp[2] - tmp[3];
342
343 workspace1[4] = tmp[4] + tmp[5];
344 workspace1[5] = tmp[4] - tmp[5];
345
346 workspace1[6] = tmp[6] + tmp[7];
347 workspace1[7] = tmp[6] - tmp[7];
348
349 /* stage 2 */
350 workspace2[0] = workspace1[0] + workspace1[2];
351 workspace2[1] = workspace1[0] - workspace1[2];
352 workspace2[2] = workspace1[1] - workspace1[3];
353 workspace2[3] = workspace1[1] + workspace1[3];
354
355 workspace2[4] = workspace1[4] + workspace1[6];
356 workspace2[5] = workspace1[4] - workspace1[6];
357 workspace2[6] = workspace1[5] - workspace1[7];
358 workspace2[7] = workspace1[5] + workspace1[7];
359
360 /* stage 3 */
361 out[0] = workspace2[0] + workspace2[4];
362 out[1] = workspace2[0] - workspace2[4];
363 out[2] = workspace2[1] - workspace2[5];
364 out[3] = workspace2[1] + workspace2[5];
365 out[4] = workspace2[2] + workspace2[6];
366 out[5] = workspace2[2] - workspace2[6];
367 out[6] = workspace2[3] - workspace2[7];
368 out[7] = workspace2[3] + workspace2[7];
369 }
370
371 out = output_block;
372
373 for (i = 0; i < 8; i++, out++) {
374 /* stage 1 */
375 workspace1[0] = out[0] + out[1*8];
376 workspace1[1] = out[0] - out[1*8];
377
378 workspace1[2] = out[2*8] + out[3*8];
379 workspace1[3] = out[2*8] - out[3*8];
380
381 workspace1[4] = out[4*8] + out[5*8];
382 workspace1[5] = out[4*8] - out[5*8];
383
384 workspace1[6] = out[6*8] + out[7*8];
385 workspace1[7] = out[6*8] - out[7*8];
386
387 /* stage 2 */
388 workspace2[0] = workspace1[0] + workspace1[2];
389 workspace2[1] = workspace1[0] - workspace1[2];
390 workspace2[2] = workspace1[1] - workspace1[3];
391 workspace2[3] = workspace1[1] + workspace1[3];
392
393 workspace2[4] = workspace1[4] + workspace1[6];
394 workspace2[5] = workspace1[4] - workspace1[6];
395 workspace2[6] = workspace1[5] - workspace1[7];
396 workspace2[7] = workspace1[5] + workspace1[7];
397
398 /* stage 3 */
399 out[0*8] = workspace2[0] + workspace2[4];
400 out[1*8] = workspace2[0] - workspace2[4];
401 out[2*8] = workspace2[1] - workspace2[5];
402 out[3*8] = workspace2[1] + workspace2[5];
403 out[4*8] = workspace2[2] + workspace2[6];
404 out[5*8] = workspace2[2] - workspace2[6];
405 out[6*8] = workspace2[3] - workspace2[7];
406 out[7*8] = workspace2[3] + workspace2[7];
407 }
408 }
409
410 static void ifwht(const s16 *block, s16 *output_block, int intra)
411 {
412 /*
413 * we'll need more than 8 bits for the transformed coefficients
414 * use native unit of cpu
415 */
416 int workspace1[8], workspace2[8];
417 int inter = intra ? 0 : 1;
418 const s16 *tmp = block;
419 s16 *out = output_block;
420 int i;
421
422 for (i = 0; i < 8; i++, tmp += 8, out += 8) {
423 /* stage 1 */
424 workspace1[0] = tmp[0] + tmp[1];
425 workspace1[1] = tmp[0] - tmp[1];
426
427 workspace1[2] = tmp[2] + tmp[3];
428 workspace1[3] = tmp[2] - tmp[3];
429
430 workspace1[4] = tmp[4] + tmp[5];
431 workspace1[5] = tmp[4] - tmp[5];
432
433 workspace1[6] = tmp[6] + tmp[7];
434 workspace1[7] = tmp[6] - tmp[7];
435
436 /* stage 2 */
437 workspace2[0] = workspace1[0] + workspace1[2];
438 workspace2[1] = workspace1[0] - workspace1[2];
439 workspace2[2] = workspace1[1] - workspace1[3];
440 workspace2[3] = workspace1[1] + workspace1[3];
441
442 workspace2[4] = workspace1[4] + workspace1[6];
443 workspace2[5] = workspace1[4] - workspace1[6];
444 workspace2[6] = workspace1[5] - workspace1[7];
445 workspace2[7] = workspace1[5] + workspace1[7];
446
447 /* stage 3 */
448 out[0] = workspace2[0] + workspace2[4];
449 out[1] = workspace2[0] - workspace2[4];
450 out[2] = workspace2[1] - workspace2[5];
451 out[3] = workspace2[1] + workspace2[5];
452 out[4] = workspace2[2] + workspace2[6];
453 out[5] = workspace2[2] - workspace2[6];
454 out[6] = workspace2[3] - workspace2[7];
455 out[7] = workspace2[3] + workspace2[7];
456 }
457
458 out = output_block;
459
460 for (i = 0; i < 8; i++, out++) {
461 /* stage 1 */
462 workspace1[0] = out[0] + out[1 * 8];
463 workspace1[1] = out[0] - out[1 * 8];
464
465 workspace1[2] = out[2 * 8] + out[3 * 8];
466 workspace1[3] = out[2 * 8] - out[3 * 8];
467
468 workspace1[4] = out[4 * 8] + out[5 * 8];
469 workspace1[5] = out[4 * 8] - out[5 * 8];
470
471 workspace1[6] = out[6 * 8] + out[7 * 8];
472 workspace1[7] = out[6 * 8] - out[7 * 8];
473
474 /* stage 2 */
475 workspace2[0] = workspace1[0] + workspace1[2];
476 workspace2[1] = workspace1[0] - workspace1[2];
477 workspace2[2] = workspace1[1] - workspace1[3];
478 workspace2[3] = workspace1[1] + workspace1[3];
479
480 workspace2[4] = workspace1[4] + workspace1[6];
481 workspace2[5] = workspace1[4] - workspace1[6];
482 workspace2[6] = workspace1[5] - workspace1[7];
483 workspace2[7] = workspace1[5] + workspace1[7];
484
485 /* stage 3 */
486 if (inter) {
487 int d;
488
489 out[0 * 8] = workspace2[0] + workspace2[4];
490 out[1 * 8] = workspace2[0] - workspace2[4];
491 out[2 * 8] = workspace2[1] - workspace2[5];
492 out[3 * 8] = workspace2[1] + workspace2[5];
493 out[4 * 8] = workspace2[2] + workspace2[6];
494 out[5 * 8] = workspace2[2] - workspace2[6];
495 out[6 * 8] = workspace2[3] - workspace2[7];
496 out[7 * 8] = workspace2[3] + workspace2[7];
497
498 for (d = 0; d < 8; d++)
499 out[8 * d] >>= 6;
500 } else {
501 int d;
502
503 out[0 * 8] = workspace2[0] + workspace2[4];
504 out[1 * 8] = workspace2[0] - workspace2[4];
505 out[2 * 8] = workspace2[1] - workspace2[5];
506 out[3 * 8] = workspace2[1] + workspace2[5];
507 out[4 * 8] = workspace2[2] + workspace2[6];
508 out[5 * 8] = workspace2[2] - workspace2[6];
509 out[6 * 8] = workspace2[3] - workspace2[7];
510 out[7 * 8] = workspace2[3] + workspace2[7];
511
512 for (d = 0; d < 8; d++) {
513 out[8 * d] >>= 6;
514 out[8 * d] += 128;
515 }
516 }
517 }
518 }
519
520 static void fill_encoder_block(const u8 *input, s16 *dst,
521 unsigned int stride, unsigned int input_step)
522 {
523 int i, j;
524
525 for (i = 0; i < 8; i++) {
526 for (j = 0; j < 8; j++, input += input_step)
527 *dst++ = *input;
528 input += (stride - 8) * input_step;
529 }
530 }
531
532 static int var_intra(const s16 *input)
533 {
534 int32_t mean = 0;
535 int32_t ret = 0;
536 const s16 *tmp = input;
537 int i;
538
539 for (i = 0; i < 8 * 8; i++, tmp++)
540 mean += *tmp;
541 mean /= 64;
542 tmp = input;
543 for (i = 0; i < 8 * 8; i++, tmp++)
544 ret += (*tmp - mean) < 0 ? -(*tmp - mean) : (*tmp - mean);
545 return ret;
546 }
547
548 static int var_inter(const s16 *old, const s16 *new)
549 {
550 int32_t ret = 0;
551 int i;
552
553 for (i = 0; i < 8 * 8; i++, old++, new++)
554 ret += (*old - *new) < 0 ? -(*old - *new) : (*old - *new);
555 return ret;
556 }
557
558 static int decide_blocktype(const u8 *cur, const u8 *reference,
559 s16 *deltablock, unsigned int stride,
560 unsigned int input_step)
561 {
562 s16 tmp[64];
563 s16 old[64];
564 s16 *work = tmp;
565 unsigned int k, l;
566 int vari;
567 int vard;
568
569 fill_encoder_block(cur, tmp, stride, input_step);
570 fill_encoder_block(reference, old, 8, 1);
571 vari = var_intra(tmp);
572
573 for (k = 0; k < 8; k++) {
574 for (l = 0; l < 8; l++) {
575 *deltablock = *work - *reference;
576 deltablock++;
577 work++;
578 reference++;
579 }
580 }
581 deltablock -= 64;
582 vard = var_inter(old, tmp);
583 return vari <= vard ? IBLOCK : PBLOCK;
584 }
585
586 static void fill_decoder_block(u8 *dst, const s16 *input, int stride)
587 {
588 int i, j;
589
590 for (i = 0; i < 8; i++) {
591 for (j = 0; j < 8; j++)
592 *dst++ = *input++;
593 dst += stride - 8;
594 }
595 }
596
597 static void add_deltas(s16 *deltas, const u8 *ref, int stride)
598 {
599 int k, l;
600
601 for (k = 0; k < 8; k++) {
602 for (l = 0; l < 8; l++) {
603 *deltas += *ref++;
604 /*
605 * Due to quantizing, it might possible that the
606 * decoded coefficients are slightly out of range
607 */
608 if (*deltas < 0)
609 *deltas = 0;
610 else if (*deltas > 255)
611 *deltas = 255;
612 deltas++;
613 }
614 ref += stride - 8;
615 }
616 }
617
618 static u32 encode_plane(u8 *input, u8 *refp, __be16 **rlco, __be16 *rlco_max,
619 struct cframe *cf, u32 height, u32 width,
620 unsigned int input_step,
621 bool is_intra, bool next_is_intra)
622 {
623 u8 *input_start = input;
624 __be16 *rlco_start = *rlco;
625 s16 deltablock[64];
626 __be16 pframe_bit = htons(PFRAME_BIT);
627 u32 encoding = 0;
628 unsigned int last_size = 0;
629 unsigned int i, j;
630
631 for (j = 0; j < height / 8; j++) {
632 for (i = 0; i < width / 8; i++) {
633 /* intra code, first frame is always intra coded. */
634 int blocktype = IBLOCK;
635 unsigned int size;
636
637 if (!is_intra)
638 blocktype = decide_blocktype(input, refp,
639 deltablock, width, input_step);
640 if (is_intra || blocktype == IBLOCK) {
641 fwht(input, cf->coeffs, width, input_step, 1);
642 quantize_intra(cf->coeffs, cf->de_coeffs);
643 blocktype = IBLOCK;
644 } else {
645 /* inter code */
646 encoding |= FRAME_PCODED;
647 fwht16(deltablock, cf->coeffs, 8, 0);
648 quantize_inter(cf->coeffs, cf->de_coeffs);
649 }
650 if (!next_is_intra) {
651 ifwht(cf->de_coeffs, cf->de_fwht, blocktype);
652
653 if (blocktype == PBLOCK)
654 add_deltas(cf->de_fwht, refp, 8);
655 fill_decoder_block(refp, cf->de_fwht, 8);
656 }
657
658 input += 8 * input_step;
659 refp += 8 * 8;
660
661 if (encoding & FRAME_UNENCODED)
662 continue;
663
664 size = rlc(cf->coeffs, *rlco, blocktype);
665 if (last_size == size &&
666 !memcmp(*rlco + 1, *rlco - size + 1, 2 * size - 2)) {
667 __be16 *last_rlco = *rlco - size;
668 s16 hdr = ntohs(*last_rlco);
669
670 if (!((*last_rlco ^ **rlco) & pframe_bit) &&
671 (hdr & DUPS_MASK) < DUPS_MASK)
672 *last_rlco = htons(hdr + 2);
673 else
674 *rlco += size;
675 } else {
676 *rlco += size;
677 }
678 if (*rlco >= rlco_max)
679 encoding |= FRAME_UNENCODED;
680 last_size = size;
681 }
682 input += width * 7 * input_step;
683 }
684 if (encoding & FRAME_UNENCODED) {
685 u8 *out = (u8 *)rlco_start;
686
687 input = input_start;
688 /*
689 * The compressed stream should never contain the magic
690 * header, so when we copy the YUV data we replace 0xff
691 * by 0xfe. Since YUV is limited range such values
692 * shouldn't appear anyway.
693 */
694 for (i = 0; i < height * width; i++, input += input_step)
695 *out++ = (*input == 0xff) ? 0xfe : *input;
696 *rlco = (__be16 *)out;
697 }
698 return encoding;
699 }
700
701 u32 encode_frame(struct raw_frame *frm, struct raw_frame *ref_frm,
702 struct cframe *cf, bool is_intra, bool next_is_intra)
703 {
704 unsigned int size = frm->height * frm->width;
705 __be16 *rlco = cf->rlc_data;
706 __be16 *rlco_max;
707 u32 encoding;
708
709 rlco_max = rlco + size / 2 - 256;
710 encoding = encode_plane(frm->luma, ref_frm->luma, &rlco, rlco_max, cf,
711 frm->height, frm->width,
712 1, is_intra, next_is_intra);
713 if (encoding & FRAME_UNENCODED)
714 encoding |= LUMA_UNENCODED;
715 encoding &= ~FRAME_UNENCODED;
716 rlco_max = rlco + size / 8 - 256;
717 encoding |= encode_plane(frm->cb, ref_frm->cb, &rlco, rlco_max, cf,
718 frm->height / 2, frm->width / 2,
719 frm->chroma_step, is_intra, next_is_intra);
720 if (encoding & FRAME_UNENCODED)
721 encoding |= CB_UNENCODED;
722 encoding &= ~FRAME_UNENCODED;
723 rlco_max = rlco + size / 8 - 256;
724 encoding |= encode_plane(frm->cr, ref_frm->cr, &rlco, rlco_max, cf,
725 frm->height / 2, frm->width / 2,
726 frm->chroma_step, is_intra, next_is_intra);
727 if (encoding & FRAME_UNENCODED)
728 encoding |= CR_UNENCODED;
729 encoding &= ~FRAME_UNENCODED;
730 cf->size = (rlco - cf->rlc_data) * sizeof(*rlco);
731 return encoding;
732 }
733
734 static void decode_plane(struct cframe *cf, const __be16 **rlco, u8 *ref,
735 u32 height, u32 width, bool uncompressed)
736 {
737 unsigned int copies = 0;
738 s16 copy[8 * 8];
739 s16 stat;
740 unsigned int i, j;
741
742 if (uncompressed) {
743 memcpy(ref, *rlco, width * height);
744 *rlco += width * height / 2;
745 return;
746 }
747
748 /*
749 * When decoding each macroblock the rlco pointer will be increased
750 * by 65 * 2 bytes worst-case.
751 * To avoid overflow the buffer has to be 65/64th of the actual raw
752 * image size, just in case someone feeds it malicious data.
753 */
754 for (j = 0; j < height / 8; j++) {
755 for (i = 0; i < width / 8; i++) {
756 u8 *refp = ref + j * 8 * width + i * 8;
757
758 if (copies) {
759 memcpy(cf->de_fwht, copy, sizeof(copy));
760 if (stat & PFRAME_BIT)
761 add_deltas(cf->de_fwht, refp, width);
762 fill_decoder_block(refp, cf->de_fwht, width);
763 copies--;
764 continue;
765 }
766
767 stat = derlc(rlco, cf->coeffs);
768
769 if (stat & PFRAME_BIT)
770 dequantize_inter(cf->coeffs);
771 else
772 dequantize_intra(cf->coeffs);
773
774 ifwht(cf->coeffs, cf->de_fwht,
775 (stat & PFRAME_BIT) ? 0 : 1);
776
777 copies = (stat & DUPS_MASK) >> 1;
778 if (copies)
779 memcpy(copy, cf->de_fwht, sizeof(copy));
780 if (stat & PFRAME_BIT)
781 add_deltas(cf->de_fwht, refp, width);
782 fill_decoder_block(refp, cf->de_fwht, width);
783 }
784 }
785 }
786
787 void decode_frame(struct cframe *cf, struct raw_frame *ref, u32 hdr_flags)
788 {
789 const __be16 *rlco = cf->rlc_data;
790
791 decode_plane(cf, &rlco, ref->luma, cf->height, cf->width,
792 hdr_flags & VICODEC_FL_LUMA_IS_UNCOMPRESSED);
793 decode_plane(cf, &rlco, ref->cb, cf->height / 2, cf->width / 2,
794 hdr_flags & VICODEC_FL_CB_IS_UNCOMPRESSED);
795 decode_plane(cf, &rlco, ref->cr, cf->height / 2, cf->width / 2,
796 hdr_flags & VICODEC_FL_CR_IS_UNCOMPRESSED);
797 }
Linux with added FPC-III support