2 * DSP functions for Indeo Video Interactive codecs (Indeo4 and Indeo5)
4 * Copyright (c) 2009-2011 Maxim Poliakovski
6 * This file is part of FFmpeg.
8 * FFmpeg is free software; you can redistribute it and/or
9 * modify it under the terms of the GNU Lesser General Public
10 * License as published by the Free Software Foundation; either
11 * version 2.1 of the License, or (at your option) any later version.
13 * FFmpeg is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16 * Lesser General Public License for more details.
18 * You should have received a copy of the GNU Lesser General Public
19 * License along with FFmpeg; if not, write to the Free Software
20 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
25 * DSP functions (inverse transforms, motion compensation, wavelet recompostions)
26 * for Indeo Video Interactive codecs.
30 #include "ivi_common.h"
33 void ff_ivi_recompose53(const IVIPlaneDesc
*plane
, uint8_t *dst
,
37 int32_t p0
, p1
, p2
, p3
, tmp0
, tmp1
, tmp2
;
38 int32_t b0_1
, b0_2
, b1_1
, b1_2
, b1_3
, b2_1
, b2_2
, b2_3
, b2_4
, b2_5
, b2_6
;
39 int32_t b3_1
, b3_2
, b3_3
, b3_4
, b3_5
, b3_6
, b3_7
, b3_8
, b3_9
;
40 int32_t pitch
, back_pitch
;
41 const short *b0_ptr
, *b1_ptr
, *b2_ptr
, *b3_ptr
;
42 const int num_bands
= 4;
44 /* all bands should have the same pitch */
45 pitch
= plane
->bands
[0].pitch
;
47 /* pixels at the position "y-1" will be set to pixels at the "y" for the 1st iteration */
50 /* get pointers to the wavelet bands */
51 b0_ptr
= plane
->bands
[0].buf
;
52 b1_ptr
= plane
->bands
[1].buf
;
53 b2_ptr
= plane
->bands
[2].buf
;
54 b3_ptr
= plane
->bands
[3].buf
;
56 for (y
= 0; y
< plane
->height
; y
+= 2) {
58 if (y
+2 >= plane
->height
)
60 /* load storage variables with values */
67 b1_1
= b1_ptr
[back_pitch
];
69 b1_3
= b1_1
- b1_2
*6 + b1_ptr
[pitch
];
73 b2_2
= b2_ptr
[0]; // b2[x, y ]
74 b2_3
= b2_2
; // b2[x+1,y ] = b2[x,y]
75 b2_5
= b2_ptr
[pitch
]; // b2[x ,y+1]
76 b2_6
= b2_5
; // b2[x+1,y+1] = b2[x,y+1]
80 b3_2
= b3_ptr
[back_pitch
]; // b3[x ,y-1]
81 b3_3
= b3_2
; // b3[x+1,y-1] = b3[x ,y-1]
82 b3_5
= b3_ptr
[0]; // b3[x ,y ]
83 b3_6
= b3_5
; // b3[x+1,y ] = b3[x ,y ]
84 b3_8
= b3_2
- b3_5
*6 + b3_ptr
[pitch
];
88 for (x
= 0, indx
= 0; x
< plane
->width
; x
+=2, indx
++) {
89 if (x
+2 >= plane
->width
) {
96 /* some values calculated in the previous iterations can */
97 /* be reused in the next ones, so do appropriate copying */
98 b2_1
= b2_2
; // b2[x-1,y ] = b2[x, y ]
99 b2_2
= b2_3
; // b2[x ,y ] = b2[x+1,y ]
100 b2_4
= b2_5
; // b2[x-1,y+1] = b2[x ,y+1]
101 b2_5
= b2_6
; // b2[x ,y+1] = b2[x+1,y+1]
102 b3_1
= b3_2
; // b3[x-1,y-1] = b3[x ,y-1]
103 b3_2
= b3_3
; // b3[x ,y-1] = b3[x+1,y-1]
104 b3_4
= b3_5
; // b3[x-1,y ] = b3[x ,y ]
105 b3_5
= b3_6
; // b3[x ,y ] = b3[x+1,y ]
106 b3_7
= b3_8
; // vert_HPF(x-1)
107 b3_8
= b3_9
; // vert_HPF(x )
109 p0
= p1
= p2
= p3
= 0;
111 /* process the LL-band by applying LPF both vertically and horizontally */
115 b0_1
= b0_ptr
[indx
+1];
116 b0_2
= b0_ptr
[pitch
+indx
+1];
121 p2
= (tmp0
+ tmp2
) << 3;
122 p3
= (tmp1
+ tmp2
+ b0_2
) << 2;
125 /* process the HL-band by applying HPF vertically and LPF horizontally */
129 b1_2
= b1_ptr
[indx
+1];
130 b1_1
= b1_ptr
[back_pitch
+indx
+1];
132 tmp2
= tmp1
- tmp0
*6 + b1_3
;
133 b1_3
= b1_1
- b1_2
*6 + b1_ptr
[pitch
+indx
+1];
135 p0
+= (tmp0
+ tmp1
) << 3;
136 p1
+= (tmp0
+ tmp1
+ b1_1
+ b1_2
) << 2;
138 p3
+= (tmp2
+ b1_3
) << 1;
141 /* process the LH-band by applying LPF vertically and HPF horizontally */
143 b2_3
= b2_ptr
[indx
+1];
144 b2_6
= b2_ptr
[pitch
+indx
+1];
147 tmp1
= b2_1
- b2_2
*6 + b2_3
;
151 p2
+= (tmp0
+ b2_4
+ b2_5
) << 2;
152 p3
+= (tmp1
+ b2_4
- b2_5
*6 + b2_6
) << 1;
155 /* process the HH-band by applying HPF both vertically and horizontally */
157 b3_6
= b3_ptr
[indx
+1]; // b3[x+1,y ]
158 b3_3
= b3_ptr
[back_pitch
+indx
+1]; // b3[x+1,y-1]
164 b3_9
= b3_3
- b3_6
*6 + b3_ptr
[pitch
+indx
+1];
166 p0
+= (tmp0
+ tmp1
) << 2;
167 p1
+= (tmp0
- tmp1
*6 + tmp2
) << 1;
168 p2
+= (b3_7
+ b3_8
) << 1;
169 p3
+= b3_7
- b3_8
*6 + b3_9
;
172 /* output four pixels */
173 dst
[x
] = av_clip_uint8((p0
>> 6) + 128);
174 dst
[x
+1] = av_clip_uint8((p1
>> 6) + 128);
175 dst
[dst_pitch
+x
] = av_clip_uint8((p2
>> 6) + 128);
176 dst
[dst_pitch
+x
+1] = av_clip_uint8((p3
>> 6) + 128);
179 dst
+= dst_pitch
<< 1;
190 void ff_ivi_recompose_haar(const IVIPlaneDesc
*plane
, uint8_t *dst
,
193 int x
, y
, indx
, b0
, b1
, b2
, b3
, p0
, p1
, p2
, p3
;
194 const short *b0_ptr
, *b1_ptr
, *b2_ptr
, *b3_ptr
;
197 /* all bands should have the same pitch */
198 pitch
= plane
->bands
[0].pitch
;
200 /* get pointers to the wavelet bands */
201 b0_ptr
= plane
->bands
[0].buf
;
202 b1_ptr
= plane
->bands
[1].buf
;
203 b2_ptr
= plane
->bands
[2].buf
;
204 b3_ptr
= plane
->bands
[3].buf
;
206 for (y
= 0; y
< plane
->height
; y
+= 2) {
207 for (x
= 0, indx
= 0; x
< plane
->width
; x
+= 2, indx
++) {
208 /* load coefficients */
209 b0
= b0_ptr
[indx
]; //should be: b0 = (num_bands > 0) ? b0_ptr[indx] : 0;
210 b1
= b1_ptr
[indx
]; //should be: b1 = (num_bands > 1) ? b1_ptr[indx] : 0;
211 b2
= b2_ptr
[indx
]; //should be: b2 = (num_bands > 2) ? b2_ptr[indx] : 0;
212 b3
= b3_ptr
[indx
]; //should be: b3 = (num_bands > 3) ? b3_ptr[indx] : 0;
214 /* haar wavelet recomposition */
215 p0
= (b0
+ b1
+ b2
+ b3
+ 2) >> 2;
216 p1
= (b0
+ b1
- b2
- b3
+ 2) >> 2;
217 p2
= (b0
- b1
+ b2
- b3
+ 2) >> 2;
218 p3
= (b0
- b1
- b2
+ b3
+ 2) >> 2;
220 /* bias, convert and output four pixels */
221 dst
[x
] = av_clip_uint8(p0
+ 128);
222 dst
[x
+ 1] = av_clip_uint8(p1
+ 128);
223 dst
[dst_pitch
+ x
] = av_clip_uint8(p2
+ 128);
224 dst
[dst_pitch
+ x
+ 1] = av_clip_uint8(p3
+ 128);
227 dst
+= dst_pitch
<< 1;
236 /** butterfly operation for the inverse Haar transform */
237 #define IVI_HAAR_BFLY(s1, s2, o1, o2, t) \
238 t = ((s1) - (s2)) >> 1;\
239 o1 = ((s1) + (s2)) >> 1;\
242 /** inverse 8-point Haar transform */
243 #define INV_HAAR8(s1, s5, s3, s7, s2, s4, s6, s8,\
244 d1, d2, d3, d4, d5, d6, d7, d8,\
245 t0, t1, t2, t3, t4, t5, t6, t7, t8) {\
246 t1 = (s1) << 1; t5 = (s5) << 1;\
247 IVI_HAAR_BFLY(t1, t5, t1, t5, t0); IVI_HAAR_BFLY(t1, s3, t1, t3, t0);\
248 IVI_HAAR_BFLY(t5, s7, t5, t7, t0); IVI_HAAR_BFLY(t1, s2, t1, t2, t0);\
249 IVI_HAAR_BFLY(t3, s4, t3, t4, t0); IVI_HAAR_BFLY(t5, s6, t5, t6, t0);\
250 IVI_HAAR_BFLY(t7, s8, t7, t8, t0);\
251 d1 = COMPENSATE(t1);\
252 d2 = COMPENSATE(t2);\
253 d3 = COMPENSATE(t3);\
254 d4 = COMPENSATE(t4);\
255 d5 = COMPENSATE(t5);\
256 d6 = COMPENSATE(t6);\
257 d7 = COMPENSATE(t7);\
258 d8 = COMPENSATE(t8); }
260 /** inverse 4-point Haar transform */
261 #define INV_HAAR4(s1, s3, s5, s7, d1, d2, d3, d4, t0, t1, t2, t3, t4) {\
262 IVI_HAAR_BFLY(s1, s3, t0, t1, t4);\
263 IVI_HAAR_BFLY(t0, s5, t2, t3, t4);\
264 d1 = COMPENSATE(t2);\
265 d2 = COMPENSATE(t3);\
266 IVI_HAAR_BFLY(t1, s7, t2, t3, t4);\
267 d3 = COMPENSATE(t2);\
268 d4 = COMPENSATE(t3); }
270 void ff_ivi_inverse_haar_8x8(const int32_t *in
, int16_t *out
, uint32_t pitch
,
271 const uint8_t *flags
)
273 int i
, shift
, sp1
, sp2
, sp3
, sp4
;
277 int t0
, t1
, t2
, t3
, t4
, t5
, t6
, t7
, t8
;
279 /* apply the InvHaar8 to all columns */
280 #define COMPENSATE(x) (x)
283 for (i
= 0; i
< 8; i
++) {
287 sp1
= src
[ 0] << shift
;
288 sp2
= src
[ 8] << shift
;
289 sp3
= src
[16] << shift
;
290 sp4
= src
[24] << shift
;
291 INV_HAAR8( sp1
, sp2
, sp3
, sp4
,
292 src
[32], src
[40], src
[48], src
[56],
293 dst
[ 0], dst
[ 8], dst
[16], dst
[24],
294 dst
[32], dst
[40], dst
[48], dst
[56],
295 t0
, t1
, t2
, t3
, t4
, t5
, t6
, t7
, t8
);
297 dst
[ 0] = dst
[ 8] = dst
[16] = dst
[24] =
298 dst
[32] = dst
[40] = dst
[48] = dst
[56] = 0;
305 /* apply the InvHaar8 to all rows */
306 #define COMPENSATE(x) (x)
308 for (i
= 0; i
< 8; i
++) {
309 if ( !src
[0] && !src
[1] && !src
[2] && !src
[3]
310 && !src
[4] && !src
[5] && !src
[6] && !src
[7]) {
311 memset(out
, 0, 8 * sizeof(out
[0]));
313 INV_HAAR8(src
[0], src
[1], src
[2], src
[3],
314 src
[4], src
[5], src
[6], src
[7],
315 out
[0], out
[1], out
[2], out
[3],
316 out
[4], out
[5], out
[6], out
[7],
317 t0
, t1
, t2
, t3
, t4
, t5
, t6
, t7
, t8
);
325 void ff_ivi_row_haar8(const int32_t *in
, int16_t *out
, uint32_t pitch
,
326 const uint8_t *flags
)
329 int t0
, t1
, t2
, t3
, t4
, t5
, t6
, t7
, t8
;
331 /* apply the InvHaar8 to all rows */
332 #define COMPENSATE(x) (x)
333 for (i
= 0; i
< 8; i
++) {
334 if ( !in
[0] && !in
[1] && !in
[2] && !in
[3]
335 && !in
[4] && !in
[5] && !in
[6] && !in
[7]) {
336 memset(out
, 0, 8 * sizeof(out
[0]));
338 INV_HAAR8(in
[0], in
[1], in
[2], in
[3],
339 in
[4], in
[5], in
[6], in
[7],
340 out
[0], out
[1], out
[2], out
[3],
341 out
[4], out
[5], out
[6], out
[7],
342 t0
, t1
, t2
, t3
, t4
, t5
, t6
, t7
, t8
);
350 void ff_ivi_col_haar8(const int32_t *in
, int16_t *out
, uint32_t pitch
,
351 const uint8_t *flags
)
354 int t0
, t1
, t2
, t3
, t4
, t5
, t6
, t7
, t8
;
356 /* apply the InvHaar8 to all columns */
357 #define COMPENSATE(x) (x)
358 for (i
= 0; i
< 8; i
++) {
360 INV_HAAR8(in
[ 0], in
[ 8], in
[16], in
[24],
361 in
[32], in
[40], in
[48], in
[56],
362 out
[0 * pitch
], out
[1 * pitch
],
363 out
[2 * pitch
], out
[3 * pitch
],
364 out
[4 * pitch
], out
[5 * pitch
],
365 out
[6 * pitch
], out
[7 * pitch
],
366 t0
, t1
, t2
, t3
, t4
, t5
, t6
, t7
, t8
);
368 out
[0 * pitch
] = out
[1 * pitch
] =
369 out
[2 * pitch
] = out
[3 * pitch
] =
370 out
[4 * pitch
] = out
[5 * pitch
] =
371 out
[6 * pitch
] = out
[7 * pitch
] = 0;
379 void ff_ivi_inverse_haar_4x4(const int32_t *in
, int16_t *out
, uint32_t pitch
,
380 const uint8_t *flags
)
382 int i
, shift
, sp1
, sp2
;
386 int t0
, t1
, t2
, t3
, t4
;
388 /* apply the InvHaar4 to all columns */
389 #define COMPENSATE(x) (x)
392 for (i
= 0; i
< 4; i
++) {
396 sp1
= src
[0] << shift
;
397 sp2
= src
[4] << shift
;
398 INV_HAAR4( sp1
, sp2
, src
[8], src
[12],
399 dst
[0], dst
[4], dst
[8], dst
[12],
402 dst
[0] = dst
[4] = dst
[8] = dst
[12] = 0;
409 /* apply the InvHaar8 to all rows */
410 #define COMPENSATE(x) (x)
412 for (i
= 0; i
< 4; i
++) {
413 if (!src
[0] && !src
[1] && !src
[2] && !src
[3]) {
414 memset(out
, 0, 4 * sizeof(out
[0]));
416 INV_HAAR4(src
[0], src
[1], src
[2], src
[3],
417 out
[0], out
[1], out
[2], out
[3],
426 void ff_ivi_row_haar4(const int32_t *in
, int16_t *out
, uint32_t pitch
,
427 const uint8_t *flags
)
430 int t0
, t1
, t2
, t3
, t4
;
432 /* apply the InvHaar4 to all rows */
433 #define COMPENSATE(x) (x)
434 for (i
= 0; i
< 4; i
++) {
435 if (!in
[0] && !in
[1] && !in
[2] && !in
[3]) {
436 memset(out
, 0, 4 * sizeof(out
[0]));
438 INV_HAAR4(in
[0], in
[1], in
[2], in
[3],
439 out
[0], out
[1], out
[2], out
[3],
448 void ff_ivi_col_haar4(const int32_t *in
, int16_t *out
, uint32_t pitch
,
449 const uint8_t *flags
)
452 int t0
, t1
, t2
, t3
, t4
;
454 /* apply the InvHaar8 to all columns */
455 #define COMPENSATE(x) (x)
456 for (i
= 0; i
< 4; i
++) {
458 INV_HAAR4(in
[0], in
[4], in
[8], in
[12],
459 out
[0 * pitch
], out
[1 * pitch
],
460 out
[2 * pitch
], out
[3 * pitch
],
463 out
[0 * pitch
] = out
[1 * pitch
] =
464 out
[2 * pitch
] = out
[3 * pitch
] = 0;
472 void ff_ivi_dc_haar_2d(const int32_t *in
, int16_t *out
, uint32_t pitch
,
478 dc_coeff
= (*in
+ 0) >> 3;
480 for (y
= 0; y
< blk_size
; out
+= pitch
, y
++) {
481 for (x
= 0; x
< blk_size
; x
++)
486 /** butterfly operation for the inverse slant transform */
487 #define IVI_SLANT_BFLY(s1, s2, o1, o2, t) \
492 /** This is a reflection a,b = 1/2, 5/4 for the inverse slant transform */
493 #define IVI_IREFLECT(s1, s2, o1, o2, t) \
494 t = (((s1) + (s2)*2 + 2) >> 2) + (s1);\
495 o2 = (((s1)*2 - (s2) + 2) >> 2) - (s2);\
498 /** This is a reflection a,b = 1/2, 7/8 for the inverse slant transform */
499 #define IVI_SLANT_PART4(s1, s2, o1, o2, t) \
500 t = (s2) + (((s1)*4 - (s2) + 4) >> 3);\
501 o2 = (s1) + ((-(s1) - (s2)*4 + 4) >> 3);\
504 /** inverse slant8 transform */
505 #define IVI_INV_SLANT8(s1, s4, s8, s5, s2, s6, s3, s7,\
506 d1, d2, d3, d4, d5, d6, d7, d8,\
507 t0, t1, t2, t3, t4, t5, t6, t7, t8) {\
508 IVI_SLANT_PART4(s4, s5, t4, t5, t0);\
510 IVI_SLANT_BFLY(s1, t5, t1, t5, t0); IVI_SLANT_BFLY(s2, s6, t2, t6, t0);\
511 IVI_SLANT_BFLY(s7, s3, t7, t3, t0); IVI_SLANT_BFLY(t4, s8, t4, t8, t0);\
513 IVI_SLANT_BFLY(t1, t2, t1, t2, t0); IVI_IREFLECT (t4, t3, t4, t3, t0);\
514 IVI_SLANT_BFLY(t5, t6, t5, t6, t0); IVI_IREFLECT (t8, t7, t8, t7, t0);\
515 IVI_SLANT_BFLY(t1, t4, t1, t4, t0); IVI_SLANT_BFLY(t2, t3, t2, t3, t0);\
516 IVI_SLANT_BFLY(t5, t8, t5, t8, t0); IVI_SLANT_BFLY(t6, t7, t6, t7, t0);\
517 d1 = COMPENSATE(t1);\
518 d2 = COMPENSATE(t2);\
519 d3 = COMPENSATE(t3);\
520 d4 = COMPENSATE(t4);\
521 d5 = COMPENSATE(t5);\
522 d6 = COMPENSATE(t6);\
523 d7 = COMPENSATE(t7);\
524 d8 = COMPENSATE(t8);}
526 /** inverse slant4 transform */
527 #define IVI_INV_SLANT4(s1, s4, s2, s3, d1, d2, d3, d4, t0, t1, t2, t3, t4) {\
528 IVI_SLANT_BFLY(s1, s2, t1, t2, t0); IVI_IREFLECT (s4, s3, t4, t3, t0);\
530 IVI_SLANT_BFLY(t1, t4, t1, t4, t0); IVI_SLANT_BFLY(t2, t3, t2, t3, t0);\
531 d1 = COMPENSATE(t1);\
532 d2 = COMPENSATE(t2);\
533 d3 = COMPENSATE(t3);\
534 d4 = COMPENSATE(t4);}
536 void ff_ivi_inverse_slant_8x8(const int32_t *in
, int16_t *out
, uint32_t pitch
, const uint8_t *flags
)
542 int t0
, t1
, t2
, t3
, t4
, t5
, t6
, t7
, t8
;
544 #define COMPENSATE(x) (x)
547 for (i
= 0; i
< 8; i
++) {
549 IVI_INV_SLANT8(src
[0], src
[8], src
[16], src
[24], src
[32], src
[40], src
[48], src
[56],
550 dst
[0], dst
[8], dst
[16], dst
[24], dst
[32], dst
[40], dst
[48], dst
[56],
551 t0
, t1
, t2
, t3
, t4
, t5
, t6
, t7
, t8
);
553 dst
[0] = dst
[8] = dst
[16] = dst
[24] = dst
[32] = dst
[40] = dst
[48] = dst
[56] = 0;
560 #define COMPENSATE(x) (((x) + 1)>>1)
562 for (i
= 0; i
< 8; i
++) {
563 if (!src
[0] && !src
[1] && !src
[2] && !src
[3] && !src
[4] && !src
[5] && !src
[6] && !src
[7]) {
564 memset(out
, 0, 8*sizeof(out
[0]));
566 IVI_INV_SLANT8(src
[0], src
[1], src
[2], src
[3], src
[4], src
[5], src
[6], src
[7],
567 out
[0], out
[1], out
[2], out
[3], out
[4], out
[5], out
[6], out
[7],
568 t0
, t1
, t2
, t3
, t4
, t5
, t6
, t7
, t8
);
576 void ff_ivi_inverse_slant_4x4(const int32_t *in
, int16_t *out
, uint32_t pitch
, const uint8_t *flags
)
582 int t0
, t1
, t2
, t3
, t4
;
584 #define COMPENSATE(x) (x)
587 for (i
= 0; i
< 4; i
++) {
589 IVI_INV_SLANT4(src
[0], src
[4], src
[8], src
[12],
590 dst
[0], dst
[4], dst
[8], dst
[12],
593 dst
[0] = dst
[4] = dst
[8] = dst
[12] = 0;
600 #define COMPENSATE(x) (((x) + 1)>>1)
602 for (i
= 0; i
< 4; i
++) {
603 if (!src
[0] && !src
[1] && !src
[2] && !src
[3]) {
604 out
[0] = out
[1] = out
[2] = out
[3] = 0;
606 IVI_INV_SLANT4(src
[0], src
[1], src
[2], src
[3],
607 out
[0], out
[1], out
[2], out
[3],
616 void ff_ivi_dc_slant_2d(const int32_t *in
, int16_t *out
, uint32_t pitch
, int blk_size
)
621 dc_coeff
= (*in
+ 1) >> 1;
623 for (y
= 0; y
< blk_size
; out
+= pitch
, y
++) {
624 for (x
= 0; x
< blk_size
; x
++)
629 void ff_ivi_row_slant8(const int32_t *in
, int16_t *out
, uint32_t pitch
, const uint8_t *flags
)
632 int t0
, t1
, t2
, t3
, t4
, t5
, t6
, t7
, t8
;
634 #define COMPENSATE(x) (((x) + 1)>>1)
635 for (i
= 0; i
< 8; i
++) {
636 if (!in
[0] && !in
[1] && !in
[2] && !in
[3] && !in
[4] && !in
[5] && !in
[6] && !in
[7]) {
637 memset(out
, 0, 8*sizeof(out
[0]));
639 IVI_INV_SLANT8( in
[0], in
[1], in
[2], in
[3], in
[4], in
[5], in
[6], in
[7],
640 out
[0], out
[1], out
[2], out
[3], out
[4], out
[5], out
[6], out
[7],
641 t0
, t1
, t2
, t3
, t4
, t5
, t6
, t7
, t8
);
649 void ff_ivi_dc_row_slant(const int32_t *in
, int16_t *out
, uint32_t pitch
, int blk_size
)
654 dc_coeff
= (*in
+ 1) >> 1;
656 for (x
= 0; x
< blk_size
; x
++)
661 for (y
= 1; y
< blk_size
; out
+= pitch
, y
++) {
662 for (x
= 0; x
< blk_size
; x
++)
667 void ff_ivi_col_slant8(const int32_t *in
, int16_t *out
, uint32_t pitch
, const uint8_t *flags
)
669 int i
, row2
, row4
, row8
;
670 int t0
, t1
, t2
, t3
, t4
, t5
, t6
, t7
, t8
;
676 #define COMPENSATE(x) (((x) + 1)>>1)
677 for (i
= 0; i
< 8; i
++) {
679 IVI_INV_SLANT8(in
[0], in
[8], in
[16], in
[24], in
[32], in
[40], in
[48], in
[56],
680 out
[0], out
[pitch
], out
[row2
], out
[row2
+ pitch
], out
[row4
],
681 out
[row4
+ pitch
], out
[row4
+ row2
], out
[row8
- pitch
],
682 t0
, t1
, t2
, t3
, t4
, t5
, t6
, t7
, t8
);
684 out
[0] = out
[pitch
] = out
[row2
] = out
[row2
+ pitch
] = out
[row4
] =
685 out
[row4
+ pitch
] = out
[row4
+ row2
] = out
[row8
- pitch
] = 0;
694 void ff_ivi_dc_col_slant(const int32_t *in
, int16_t *out
, uint32_t pitch
, int blk_size
)
699 dc_coeff
= (*in
+ 1) >> 1;
701 for (y
= 0; y
< blk_size
; out
+= pitch
, y
++) {
703 for (x
= 1; x
< blk_size
; x
++)
708 void ff_ivi_row_slant4(const int32_t *in
, int16_t *out
, uint32_t pitch
, const uint8_t *flags
)
711 int t0
, t1
, t2
, t3
, t4
;
713 #define COMPENSATE(x) (((x) + 1)>>1)
714 for (i
= 0; i
< 4; i
++) {
715 if (!in
[0] && !in
[1] && !in
[2] && !in
[3]) {
716 memset(out
, 0, 4*sizeof(out
[0]));
718 IVI_INV_SLANT4( in
[0], in
[1], in
[2], in
[3],
719 out
[0], out
[1], out
[2], out
[3],
728 void ff_ivi_col_slant4(const int32_t *in
, int16_t *out
, uint32_t pitch
, const uint8_t *flags
)
731 int t0
, t1
, t2
, t3
, t4
;
735 #define COMPENSATE(x) (((x) + 1)>>1)
736 for (i
= 0; i
< 4; i
++) {
738 IVI_INV_SLANT4(in
[0], in
[4], in
[8], in
[12],
739 out
[0], out
[pitch
], out
[row2
], out
[row2
+ pitch
],
742 out
[0] = out
[pitch
] = out
[row2
] = out
[row2
+ pitch
] = 0;
751 void ff_ivi_put_pixels_8x8(const int32_t *in
, int16_t *out
, uint32_t pitch
,
752 const uint8_t *flags
)
756 for (y
= 0; y
< 8; out
+= pitch
, in
+= 8, y
++)
757 for (x
= 0; x
< 8; x
++)
761 void ff_ivi_put_dc_pixel_8x8(const int32_t *in
, int16_t *out
, uint32_t pitch
,
767 memset(out
+ 1, 0, 7*sizeof(out
[0]));
770 for (y
= 1; y
< 8; out
+= pitch
, y
++)
771 memset(out
, 0, 8*sizeof(out
[0]));
774 #define IVI_MC_TEMPLATE(size, suffix, OP) \
775 static void ivi_mc_ ## size ##x## size ## suffix(int16_t *buf, \
777 const int16_t *ref_buf, \
778 uint32_t pitch, int mc_type) \
781 const int16_t *wptr; \
784 case 0: /* fullpel (no interpolation) */ \
785 for (i = 0; i < size; i++, buf += dpitch, ref_buf += pitch) { \
786 for (j = 0; j < size; j++) {\
787 OP(buf[j], ref_buf[j]); \
791 case 1: /* horizontal halfpel interpolation */ \
792 for (i = 0; i < size; i++, buf += dpitch, ref_buf += pitch) \
793 for (j = 0; j < size; j++) \
794 OP(buf[j], (ref_buf[j] + ref_buf[j+1]) >> 1); \
796 case 2: /* vertical halfpel interpolation */ \
797 wptr = ref_buf + pitch; \
798 for (i = 0; i < size; i++, buf += dpitch, wptr += pitch, ref_buf += pitch) \
799 for (j = 0; j < size; j++) \
800 OP(buf[j], (ref_buf[j] + wptr[j]) >> 1); \
802 case 3: /* vertical and horizontal halfpel interpolation */ \
803 wptr = ref_buf + pitch; \
804 for (i = 0; i < size; i++, buf += dpitch, wptr += pitch, ref_buf += pitch) \
805 for (j = 0; j < size; j++) \
806 OP(buf[j], (ref_buf[j] + ref_buf[j+1] + wptr[j] + wptr[j+1]) >> 2); \
811 void ff_ivi_mc_ ## size ##x## size ## suffix(int16_t *buf, const int16_t *ref_buf, \
812 uint32_t pitch, int mc_type) \
814 ivi_mc_ ## size ##x## size ## suffix(buf, pitch, ref_buf, pitch, mc_type); \
817 #define IVI_MC_AVG_TEMPLATE(size, suffix, OP) \
818 void ff_ivi_mc_avg_ ## size ##x## size ## suffix(int16_t *buf, \
819 const int16_t *ref_buf, \
820 const int16_t *ref_buf2, \
822 int mc_type, int mc_type2) \
824 int16_t tmp[size * size]; \
827 ivi_mc_ ## size ##x## size ## _no_delta(tmp, size, ref_buf, pitch, mc_type); \
828 ivi_mc_ ## size ##x## size ## _delta(tmp, size, ref_buf2, pitch, mc_type2); \
829 for (i = 0; i < size; i++, buf += pitch) { \
830 for (j = 0; j < size; j++) {\
831 OP(buf[j], tmp[i * size + j] >> 1); \
836 #define OP_PUT(a, b) (a) = (b)
837 #define OP_ADD(a, b) (a) += (b)
839 IVI_MC_TEMPLATE(8, _no_delta
, OP_PUT
)
840 IVI_MC_TEMPLATE(8, _delta
, OP_ADD
)
841 IVI_MC_TEMPLATE(4, _no_delta
, OP_PUT
)
842 IVI_MC_TEMPLATE(4, _delta
, OP_ADD
)
843 IVI_MC_AVG_TEMPLATE(8, _no_delta
, OP_PUT
)
844 IVI_MC_AVG_TEMPLATE(8, _delta
, OP_ADD
)
845 IVI_MC_AVG_TEMPLATE(4, _no_delta
, OP_PUT
)
846 IVI_MC_AVG_TEMPLATE(4, _delta
, OP_ADD
)