blob: 90a67e910ceeaf54c6cf367550abac1589ed1a1a
1 | /* |
2 | * Chinese AVS video (AVS1-P2, JiZhun profile) decoder. |
3 | * |
4 | * DSP functions |
5 | * |
6 | * Copyright (c) 2006 Stefan Gehrer <stefan.gehrer@gmx.de> |
7 | * |
8 | * This file is part of FFmpeg. |
9 | * |
10 | * FFmpeg is free software; you can redistribute it and/or |
11 | * modify it under the terms of the GNU Lesser General Public |
12 | * License as published by the Free Software Foundation; either |
13 | * version 2.1 of the License, or (at your option) any later version. |
14 | * |
15 | * FFmpeg is distributed in the hope that it will be useful, |
16 | * but WITHOUT ANY WARRANTY; without even the implied warranty of |
17 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
18 | * Lesser General Public License for more details. |
19 | * |
20 | * You should have received a copy of the GNU Lesser General Public |
21 | * License along with FFmpeg; if not, write to the Free Software |
22 | * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA |
23 | */ |
24 | |
25 | #include <stdio.h> |
26 | |
27 | #include "idctdsp.h" |
28 | #include "mathops.h" |
29 | #include "cavsdsp.h" |
30 | #include "libavutil/common.h" |
31 | |
32 | /***************************************************************************** |
33 | * |
34 | * in-loop deblocking filter |
35 | * |
36 | ****************************************************************************/ |
37 | |
38 | #define P2 p0_p[-3*stride] |
39 | #define P1 p0_p[-2*stride] |
40 | #define P0 p0_p[-1*stride] |
41 | #define Q0 p0_p[ 0*stride] |
42 | #define Q1 p0_p[ 1*stride] |
43 | #define Q2 p0_p[ 2*stride] |
44 | |
45 | static inline void loop_filter_l2(uint8_t *p0_p, ptrdiff_t stride, int alpha, int beta) |
46 | { |
47 | int p0 = P0; |
48 | int q0 = Q0; |
49 | |
50 | if(abs(p0-q0)<alpha && abs(P1-p0)<beta && abs(Q1-q0)<beta) { |
51 | int s = p0 + q0 + 2; |
52 | alpha = (alpha>>2) + 2; |
53 | if(abs(P2-p0) < beta && abs(p0-q0) < alpha) { |
54 | P0 = (P1 + p0 + s) >> 2; |
55 | P1 = (2*P1 + s) >> 2; |
56 | } else |
57 | P0 = (2*P1 + s) >> 2; |
58 | if(abs(Q2-q0) < beta && abs(q0-p0) < alpha) { |
59 | Q0 = (Q1 + q0 + s) >> 2; |
60 | Q1 = (2*Q1 + s) >> 2; |
61 | } else |
62 | Q0 = (2*Q1 + s) >> 2; |
63 | } |
64 | } |
65 | |
66 | static inline void loop_filter_l1(uint8_t *p0_p, ptrdiff_t stride, int alpha, int beta, int tc) |
67 | { |
68 | int p0 = P0; |
69 | int q0 = Q0; |
70 | |
71 | if(abs(p0-q0)<alpha && abs(P1-p0)<beta && abs(Q1-q0)<beta) { |
72 | int delta = av_clip(((q0-p0)*3+P1-Q1+4)>>3,-tc, tc); |
73 | P0 = av_clip_uint8(p0+delta); |
74 | Q0 = av_clip_uint8(q0-delta); |
75 | if(abs(P2-p0)<beta) { |
76 | delta = av_clip(((P0-P1)*3+P2-Q0+4)>>3, -tc, tc); |
77 | P1 = av_clip_uint8(P1+delta); |
78 | } |
79 | if(abs(Q2-q0)<beta) { |
80 | delta = av_clip(((Q1-Q0)*3+P0-Q2+4)>>3, -tc, tc); |
81 | Q1 = av_clip_uint8(Q1-delta); |
82 | } |
83 | } |
84 | } |
85 | |
86 | static inline void loop_filter_c2(uint8_t *p0_p, ptrdiff_t stride, int alpha, int beta) |
87 | { |
88 | int p0 = P0; |
89 | int q0 = Q0; |
90 | |
91 | if(abs(p0-q0)<alpha && abs(P1-p0)<beta && abs(Q1-q0)<beta) { |
92 | int s = p0 + q0 + 2; |
93 | alpha = (alpha>>2) + 2; |
94 | if(abs(P2-p0) < beta && abs(p0-q0) < alpha) { |
95 | P0 = (P1 + p0 + s) >> 2; |
96 | } else |
97 | P0 = (2*P1 + s) >> 2; |
98 | if(abs(Q2-q0) < beta && abs(q0-p0) < alpha) { |
99 | Q0 = (Q1 + q0 + s) >> 2; |
100 | } else |
101 | Q0 = (2*Q1 + s) >> 2; |
102 | } |
103 | } |
104 | |
105 | static inline void loop_filter_c1(uint8_t *p0_p, ptrdiff_t stride, int alpha, int beta, |
106 | int tc) |
107 | { |
108 | if(abs(P0-Q0)<alpha && abs(P1-P0)<beta && abs(Q1-Q0)<beta) { |
109 | int delta = av_clip(((Q0-P0)*3+P1-Q1+4)>>3, -tc, tc); |
110 | P0 = av_clip_uint8(P0+delta); |
111 | Q0 = av_clip_uint8(Q0-delta); |
112 | } |
113 | } |
114 | |
115 | #undef P0 |
116 | #undef P1 |
117 | #undef P2 |
118 | #undef Q0 |
119 | #undef Q1 |
120 | #undef Q2 |
121 | |
122 | static void cavs_filter_lv_c(uint8_t *d, ptrdiff_t stride, int alpha, int beta, int tc, |
123 | int bs1, int bs2) |
124 | { |
125 | int i; |
126 | if(bs1==2) |
127 | for(i=0;i<16;i++) |
128 | loop_filter_l2(d + i*stride,1,alpha,beta); |
129 | else { |
130 | if(bs1) |
131 | for(i=0;i<8;i++) |
132 | loop_filter_l1(d + i*stride,1,alpha,beta,tc); |
133 | if (bs2) |
134 | for(i=8;i<16;i++) |
135 | loop_filter_l1(d + i*stride,1,alpha,beta,tc); |
136 | } |
137 | } |
138 | |
139 | static void cavs_filter_lh_c(uint8_t *d, ptrdiff_t stride, int alpha, int beta, int tc, |
140 | int bs1, int bs2) |
141 | { |
142 | int i; |
143 | if(bs1==2) |
144 | for(i=0;i<16;i++) |
145 | loop_filter_l2(d + i,stride,alpha,beta); |
146 | else { |
147 | if(bs1) |
148 | for(i=0;i<8;i++) |
149 | loop_filter_l1(d + i,stride,alpha,beta,tc); |
150 | if (bs2) |
151 | for(i=8;i<16;i++) |
152 | loop_filter_l1(d + i,stride,alpha,beta,tc); |
153 | } |
154 | } |
155 | |
156 | static void cavs_filter_cv_c(uint8_t *d, ptrdiff_t stride, int alpha, int beta, int tc, |
157 | int bs1, int bs2) |
158 | { |
159 | int i; |
160 | if(bs1==2) |
161 | for(i=0;i<8;i++) |
162 | loop_filter_c2(d + i*stride,1,alpha,beta); |
163 | else { |
164 | if(bs1) |
165 | for(i=0;i<4;i++) |
166 | loop_filter_c1(d + i*stride,1,alpha,beta,tc); |
167 | if (bs2) |
168 | for(i=4;i<8;i++) |
169 | loop_filter_c1(d + i*stride,1,alpha,beta,tc); |
170 | } |
171 | } |
172 | |
173 | static void cavs_filter_ch_c(uint8_t *d, ptrdiff_t stride, int alpha, int beta, int tc, |
174 | int bs1, int bs2) |
175 | { |
176 | int i; |
177 | if(bs1==2) |
178 | for(i=0;i<8;i++) |
179 | loop_filter_c2(d + i,stride,alpha,beta); |
180 | else { |
181 | if(bs1) |
182 | for(i=0;i<4;i++) |
183 | loop_filter_c1(d + i,stride,alpha,beta,tc); |
184 | if (bs2) |
185 | for(i=4;i<8;i++) |
186 | loop_filter_c1(d + i,stride,alpha,beta,tc); |
187 | } |
188 | } |
189 | |
190 | /***************************************************************************** |
191 | * |
192 | * inverse transform |
193 | * |
194 | ****************************************************************************/ |
195 | |
196 | static void cavs_idct8_add_c(uint8_t *dst, int16_t *block, ptrdiff_t stride) |
197 | { |
198 | int i; |
199 | int16_t (*src)[8] = (int16_t(*)[8])block; |
200 | |
201 | src[0][0] += 8; |
202 | |
203 | for( i = 0; i < 8; i++ ) { |
204 | const int a0 = 3*src[i][1] - (src[i][7]<<1); |
205 | const int a1 = 3*src[i][3] + (src[i][5]<<1); |
206 | const int a2 = (src[i][3]<<1) - 3*src[i][5]; |
207 | const int a3 = (src[i][1]<<1) + 3*src[i][7]; |
208 | |
209 | const int b4 = ((a0 + a1 + a3)<<1) + a1; |
210 | const int b5 = ((a0 - a1 + a2)<<1) + a0; |
211 | const int b6 = ((a3 - a2 - a1)<<1) + a3; |
212 | const int b7 = ((a0 - a2 - a3)<<1) - a2; |
213 | |
214 | const int a7 = (src[i][2]<<2) - 10*src[i][6]; |
215 | const int a6 = (src[i][6]<<2) + 10*src[i][2]; |
216 | const int a5 = ((src[i][0] - src[i][4]) << 3) + 4; |
217 | const int a4 = ((src[i][0] + src[i][4]) << 3) + 4; |
218 | |
219 | const int b0 = a4 + a6; |
220 | const int b1 = a5 + a7; |
221 | const int b2 = a5 - a7; |
222 | const int b3 = a4 - a6; |
223 | |
224 | src[i][0] = (b0 + b4) >> 3; |
225 | src[i][1] = (b1 + b5) >> 3; |
226 | src[i][2] = (b2 + b6) >> 3; |
227 | src[i][3] = (b3 + b7) >> 3; |
228 | src[i][4] = (b3 - b7) >> 3; |
229 | src[i][5] = (b2 - b6) >> 3; |
230 | src[i][6] = (b1 - b5) >> 3; |
231 | src[i][7] = (b0 - b4) >> 3; |
232 | } |
233 | for( i = 0; i < 8; i++ ) { |
234 | const int a0 = 3*src[1][i] - (src[7][i]<<1); |
235 | const int a1 = 3*src[3][i] + (src[5][i]<<1); |
236 | const int a2 = (src[3][i]<<1) - 3*src[5][i]; |
237 | const int a3 = (src[1][i]<<1) + 3*src[7][i]; |
238 | |
239 | const int b4 = ((a0 + a1 + a3)<<1) + a1; |
240 | const int b5 = ((a0 - a1 + a2)<<1) + a0; |
241 | const int b6 = ((a3 - a2 - a1)<<1) + a3; |
242 | const int b7 = ((a0 - a2 - a3)<<1) - a2; |
243 | |
244 | const int a7 = (src[2][i]<<2) - 10*src[6][i]; |
245 | const int a6 = (src[6][i]<<2) + 10*src[2][i]; |
246 | const int a5 = (src[0][i] - src[4][i]) << 3; |
247 | const int a4 = (src[0][i] + src[4][i]) << 3; |
248 | |
249 | const int b0 = a4 + a6; |
250 | const int b1 = a5 + a7; |
251 | const int b2 = a5 - a7; |
252 | const int b3 = a4 - a6; |
253 | |
254 | dst[i + 0*stride] = av_clip_uint8( dst[i + 0*stride] + ((b0 + b4) >> 7)); |
255 | dst[i + 1*stride] = av_clip_uint8( dst[i + 1*stride] + ((b1 + b5) >> 7)); |
256 | dst[i + 2*stride] = av_clip_uint8( dst[i + 2*stride] + ((b2 + b6) >> 7)); |
257 | dst[i + 3*stride] = av_clip_uint8( dst[i + 3*stride] + ((b3 + b7) >> 7)); |
258 | dst[i + 4*stride] = av_clip_uint8( dst[i + 4*stride] + ((b3 - b7) >> 7)); |
259 | dst[i + 5*stride] = av_clip_uint8( dst[i + 5*stride] + ((b2 - b6) >> 7)); |
260 | dst[i + 6*stride] = av_clip_uint8( dst[i + 6*stride] + ((b1 - b5) >> 7)); |
261 | dst[i + 7*stride] = av_clip_uint8( dst[i + 7*stride] + ((b0 - b4) >> 7)); |
262 | } |
263 | } |
264 | |
265 | /***************************************************************************** |
266 | * |
267 | * motion compensation |
268 | * |
269 | ****************************************************************************/ |
270 | |
271 | #define CAVS_SUBPIX(OPNAME, OP, NAME, A, B, C, D, E, F) \ |
272 | static void OPNAME ## cavs_filt8_h_ ## NAME(uint8_t *dst, const uint8_t *src, ptrdiff_t dstStride, ptrdiff_t srcStride)\ |
273 | { \ |
274 | const int h=8;\ |
275 | const uint8_t *cm = ff_crop_tab + MAX_NEG_CROP;\ |
276 | int i;\ |
277 | for(i=0; i<h; i++)\ |
278 | {\ |
279 | OP(dst[0], A*src[-2] + B*src[-1] + C*src[0] + D*src[1] + E*src[2] + F*src[3]);\ |
280 | OP(dst[1], A*src[-1] + B*src[ 0] + C*src[1] + D*src[2] + E*src[3] + F*src[4]);\ |
281 | OP(dst[2], A*src[ 0] + B*src[ 1] + C*src[2] + D*src[3] + E*src[4] + F*src[5]);\ |
282 | OP(dst[3], A*src[ 1] + B*src[ 2] + C*src[3] + D*src[4] + E*src[5] + F*src[6]);\ |
283 | OP(dst[4], A*src[ 2] + B*src[ 3] + C*src[4] + D*src[5] + E*src[6] + F*src[7]);\ |
284 | OP(dst[5], A*src[ 3] + B*src[ 4] + C*src[5] + D*src[6] + E*src[7] + F*src[8]);\ |
285 | OP(dst[6], A*src[ 4] + B*src[ 5] + C*src[6] + D*src[7] + E*src[8] + F*src[9]);\ |
286 | OP(dst[7], A*src[ 5] + B*src[ 6] + C*src[7] + D*src[8] + E*src[9] + F*src[10]);\ |
287 | dst+=dstStride;\ |
288 | src+=srcStride;\ |
289 | }\ |
290 | }\ |
291 | \ |
292 | static void OPNAME ## cavs_filt8_v_ ## NAME(uint8_t *dst, const uint8_t *src, ptrdiff_t dstStride, ptrdiff_t srcStride)\ |
293 | { \ |
294 | const int w=8;\ |
295 | const uint8_t *cm = ff_crop_tab + MAX_NEG_CROP;\ |
296 | int i;\ |
297 | for(i=0; i<w; i++)\ |
298 | {\ |
299 | const int srcB= src[-2*srcStride];\ |
300 | const int srcA= src[-1*srcStride];\ |
301 | const int src0= src[0 *srcStride];\ |
302 | const int src1= src[1 *srcStride];\ |
303 | const int src2= src[2 *srcStride];\ |
304 | const int src3= src[3 *srcStride];\ |
305 | const int src4= src[4 *srcStride];\ |
306 | const int src5= src[5 *srcStride];\ |
307 | const int src6= src[6 *srcStride];\ |
308 | const int src7= src[7 *srcStride];\ |
309 | const int src8= src[8 *srcStride];\ |
310 | const int src9= src[9 *srcStride];\ |
311 | const int src10= src[10 *srcStride];\ |
312 | OP(dst[0*dstStride], A*srcB + B*srcA + C*src0 + D*src1 + E*src2 + F*src3);\ |
313 | OP(dst[1*dstStride], A*srcA + B*src0 + C*src1 + D*src2 + E*src3 + F*src4);\ |
314 | OP(dst[2*dstStride], A*src0 + B*src1 + C*src2 + D*src3 + E*src4 + F*src5);\ |
315 | OP(dst[3*dstStride], A*src1 + B*src2 + C*src3 + D*src4 + E*src5 + F*src6);\ |
316 | OP(dst[4*dstStride], A*src2 + B*src3 + C*src4 + D*src5 + E*src6 + F*src7);\ |
317 | OP(dst[5*dstStride], A*src3 + B*src4 + C*src5 + D*src6 + E*src7 + F*src8);\ |
318 | OP(dst[6*dstStride], A*src4 + B*src5 + C*src6 + D*src7 + E*src8 + F*src9);\ |
319 | OP(dst[7*dstStride], A*src5 + B*src6 + C*src7 + D*src8 + E*src9 + F*src10);\ |
320 | dst++;\ |
321 | src++;\ |
322 | }\ |
323 | }\ |
324 | \ |
325 | static void OPNAME ## cavs_filt16_v_ ## NAME(uint8_t *dst, const uint8_t *src, ptrdiff_t dstStride, ptrdiff_t srcStride)\ |
326 | { \ |
327 | OPNAME ## cavs_filt8_v_ ## NAME(dst , src , dstStride, srcStride);\ |
328 | OPNAME ## cavs_filt8_v_ ## NAME(dst+8, src+8, dstStride, srcStride);\ |
329 | src += 8*srcStride;\ |
330 | dst += 8*dstStride;\ |
331 | OPNAME ## cavs_filt8_v_ ## NAME(dst , src , dstStride, srcStride);\ |
332 | OPNAME ## cavs_filt8_v_ ## NAME(dst+8, src+8, dstStride, srcStride);\ |
333 | }\ |
334 | \ |
335 | static void OPNAME ## cavs_filt16_h_ ## NAME(uint8_t *dst, const uint8_t *src, ptrdiff_t dstStride, ptrdiff_t srcStride)\ |
336 | { \ |
337 | OPNAME ## cavs_filt8_h_ ## NAME(dst , src , dstStride, srcStride);\ |
338 | OPNAME ## cavs_filt8_h_ ## NAME(dst+8, src+8, dstStride, srcStride);\ |
339 | src += 8*srcStride;\ |
340 | dst += 8*dstStride;\ |
341 | OPNAME ## cavs_filt8_h_ ## NAME(dst , src , dstStride, srcStride);\ |
342 | OPNAME ## cavs_filt8_h_ ## NAME(dst+8, src+8, dstStride, srcStride);\ |
343 | }\ |
344 | |
345 | #define CAVS_SUBPIX_HV(OPNAME, OP, NAME, AH, BH, CH, DH, EH, FH, AV, BV, CV, DV, EV, FV, FULL) \ |
346 | static void OPNAME ## cavs_filt8_hv_ ## NAME(uint8_t *dst, const uint8_t *src1, const uint8_t *src2, ptrdiff_t dstStride, ptrdiff_t srcStride)\ |
347 | { \ |
348 | int16_t temp[8*(8+5)];\ |
349 | int16_t *tmp = temp;\ |
350 | const int h=8;\ |
351 | const int w=8;\ |
352 | const uint8_t *cm = ff_crop_tab + MAX_NEG_CROP;\ |
353 | int i;\ |
354 | src1 -= 2*srcStride;\ |
355 | for(i=0; i<h+5; i++)\ |
356 | {\ |
357 | tmp[0]= AH*src1[-2] + BH*src1[-1] + CH*src1[0] + DH*src1[1] + EH*src1[2] + FH*src1[3];\ |
358 | tmp[1]= AH*src1[-1] + BH*src1[ 0] + CH*src1[1] + DH*src1[2] + EH*src1[3] + FH*src1[4];\ |
359 | tmp[2]= AH*src1[ 0] + BH*src1[ 1] + CH*src1[2] + DH*src1[3] + EH*src1[4] + FH*src1[5];\ |
360 | tmp[3]= AH*src1[ 1] + BH*src1[ 2] + CH*src1[3] + DH*src1[4] + EH*src1[5] + FH*src1[6];\ |
361 | tmp[4]= AH*src1[ 2] + BH*src1[ 3] + CH*src1[4] + DH*src1[5] + EH*src1[6] + FH*src1[7];\ |
362 | tmp[5]= AH*src1[ 3] + BH*src1[ 4] + CH*src1[5] + DH*src1[6] + EH*src1[7] + FH*src1[8];\ |
363 | tmp[6]= AH*src1[ 4] + BH*src1[ 5] + CH*src1[6] + DH*src1[7] + EH*src1[8] + FH*src1[9];\ |
364 | tmp[7]= AH*src1[ 5] + BH*src1[ 6] + CH*src1[7] + DH*src1[8] + EH*src1[9] + FH*src1[10];\ |
365 | tmp+=8;\ |
366 | src1+=srcStride;\ |
367 | }\ |
368 | if(FULL) {\ |
369 | tmp = temp+8*2; \ |
370 | for(i=0; i<w; i++) \ |
371 | { \ |
372 | const int tmpB= tmp[-2*8]; \ |
373 | const int tmpA= tmp[-1*8]; \ |
374 | const int tmp0= tmp[0 *8]; \ |
375 | const int tmp1= tmp[1 *8]; \ |
376 | const int tmp2= tmp[2 *8]; \ |
377 | const int tmp3= tmp[3 *8]; \ |
378 | const int tmp4= tmp[4 *8]; \ |
379 | const int tmp5= tmp[5 *8]; \ |
380 | const int tmp6= tmp[6 *8]; \ |
381 | const int tmp7= tmp[7 *8]; \ |
382 | const int tmp8= tmp[8 *8]; \ |
383 | const int tmp9= tmp[9 *8]; \ |
384 | const int tmp10=tmp[10*8]; \ |
385 | OP(dst[0*dstStride], AV*tmpB + BV*tmpA + CV*tmp0 + DV*tmp1 + EV*tmp2 + FV*tmp3 + 64*src2[0*srcStride]); \ |
386 | OP(dst[1*dstStride], AV*tmpA + BV*tmp0 + CV*tmp1 + DV*tmp2 + EV*tmp3 + FV*tmp4 + 64*src2[1*srcStride]); \ |
387 | OP(dst[2*dstStride], AV*tmp0 + BV*tmp1 + CV*tmp2 + DV*tmp3 + EV*tmp4 + FV*tmp5 + 64*src2[2*srcStride]); \ |
388 | OP(dst[3*dstStride], AV*tmp1 + BV*tmp2 + CV*tmp3 + DV*tmp4 + EV*tmp5 + FV*tmp6 + 64*src2[3*srcStride]); \ |
389 | OP(dst[4*dstStride], AV*tmp2 + BV*tmp3 + CV*tmp4 + DV*tmp5 + EV*tmp6 + FV*tmp7 + 64*src2[4*srcStride]); \ |
390 | OP(dst[5*dstStride], AV*tmp3 + BV*tmp4 + CV*tmp5 + DV*tmp6 + EV*tmp7 + FV*tmp8 + 64*src2[5*srcStride]); \ |
391 | OP(dst[6*dstStride], AV*tmp4 + BV*tmp5 + CV*tmp6 + DV*tmp7 + EV*tmp8 + FV*tmp9 + 64*src2[6*srcStride]); \ |
392 | OP(dst[7*dstStride], AV*tmp5 + BV*tmp6 + CV*tmp7 + DV*tmp8 + EV*tmp9 + FV*tmp10 + 64*src2[7*srcStride]); \ |
393 | dst++; \ |
394 | tmp++; \ |
395 | src2++; \ |
396 | } \ |
397 | } else {\ |
398 | tmp = temp+8*2; \ |
399 | for(i=0; i<w; i++) \ |
400 | { \ |
401 | const int tmpB= tmp[-2*8]; \ |
402 | const int tmpA= tmp[-1*8]; \ |
403 | const int tmp0= tmp[0 *8]; \ |
404 | const int tmp1= tmp[1 *8]; \ |
405 | const int tmp2= tmp[2 *8]; \ |
406 | const int tmp3= tmp[3 *8]; \ |
407 | const int tmp4= tmp[4 *8]; \ |
408 | const int tmp5= tmp[5 *8]; \ |
409 | const int tmp6= tmp[6 *8]; \ |
410 | const int tmp7= tmp[7 *8]; \ |
411 | const int tmp8= tmp[8 *8]; \ |
412 | const int tmp9= tmp[9 *8]; \ |
413 | const int tmp10=tmp[10*8]; \ |
414 | OP(dst[0*dstStride], AV*tmpB + BV*tmpA + CV*tmp0 + DV*tmp1 + EV*tmp2 + FV*tmp3); \ |
415 | OP(dst[1*dstStride], AV*tmpA + BV*tmp0 + CV*tmp1 + DV*tmp2 + EV*tmp3 + FV*tmp4); \ |
416 | OP(dst[2*dstStride], AV*tmp0 + BV*tmp1 + CV*tmp2 + DV*tmp3 + EV*tmp4 + FV*tmp5); \ |
417 | OP(dst[3*dstStride], AV*tmp1 + BV*tmp2 + CV*tmp3 + DV*tmp4 + EV*tmp5 + FV*tmp6); \ |
418 | OP(dst[4*dstStride], AV*tmp2 + BV*tmp3 + CV*tmp4 + DV*tmp5 + EV*tmp6 + FV*tmp7); \ |
419 | OP(dst[5*dstStride], AV*tmp3 + BV*tmp4 + CV*tmp5 + DV*tmp6 + EV*tmp7 + FV*tmp8); \ |
420 | OP(dst[6*dstStride], AV*tmp4 + BV*tmp5 + CV*tmp6 + DV*tmp7 + EV*tmp8 + FV*tmp9); \ |
421 | OP(dst[7*dstStride], AV*tmp5 + BV*tmp6 + CV*tmp7 + DV*tmp8 + EV*tmp9 + FV*tmp10); \ |
422 | dst++; \ |
423 | tmp++; \ |
424 | } \ |
425 | }\ |
426 | }\ |
427 | \ |
428 | static void OPNAME ## cavs_filt16_hv_ ## NAME(uint8_t *dst, const uint8_t *src1, const uint8_t *src2, ptrdiff_t dstStride, ptrdiff_t srcStride)\ |
429 | { \ |
430 | OPNAME ## cavs_filt8_hv_ ## NAME(dst , src1, src2 , dstStride, srcStride); \ |
431 | OPNAME ## cavs_filt8_hv_ ## NAME(dst+8, src1+8, src2+8, dstStride, srcStride); \ |
432 | src1 += 8*srcStride;\ |
433 | src2 += 8*srcStride;\ |
434 | dst += 8*dstStride;\ |
435 | OPNAME ## cavs_filt8_hv_ ## NAME(dst , src1, src2 , dstStride, srcStride); \ |
436 | OPNAME ## cavs_filt8_hv_ ## NAME(dst+8, src1+8, src2+8, dstStride, srcStride); \ |
437 | }\ |
438 | |
439 | #define CAVS_MC(OPNAME, SIZE) \ |
440 | static void OPNAME ## cavs_qpel ## SIZE ## _mc10_c(uint8_t *dst, const uint8_t *src, ptrdiff_t stride)\ |
441 | {\ |
442 | OPNAME ## cavs_filt ## SIZE ## _h_qpel_l(dst, src, stride, stride);\ |
443 | }\ |
444 | \ |
445 | static void OPNAME ## cavs_qpel ## SIZE ## _mc20_c(uint8_t *dst, const uint8_t *src, ptrdiff_t stride)\ |
446 | {\ |
447 | OPNAME ## cavs_filt ## SIZE ## _h_hpel(dst, src, stride, stride);\ |
448 | }\ |
449 | \ |
450 | static void OPNAME ## cavs_qpel ## SIZE ## _mc30_c(uint8_t *dst, const uint8_t *src, ptrdiff_t stride)\ |
451 | {\ |
452 | OPNAME ## cavs_filt ## SIZE ## _h_qpel_r(dst, src, stride, stride);\ |
453 | }\ |
454 | \ |
455 | static void OPNAME ## cavs_qpel ## SIZE ## _mc01_c(uint8_t *dst, const uint8_t *src, ptrdiff_t stride)\ |
456 | {\ |
457 | OPNAME ## cavs_filt ## SIZE ## _v_qpel_l(dst, src, stride, stride);\ |
458 | }\ |
459 | \ |
460 | static void OPNAME ## cavs_qpel ## SIZE ## _mc02_c(uint8_t *dst, const uint8_t *src, ptrdiff_t stride)\ |
461 | {\ |
462 | OPNAME ## cavs_filt ## SIZE ## _v_hpel(dst, src, stride, stride);\ |
463 | }\ |
464 | \ |
465 | static void OPNAME ## cavs_qpel ## SIZE ## _mc03_c(uint8_t *dst, const uint8_t *src, ptrdiff_t stride)\ |
466 | {\ |
467 | OPNAME ## cavs_filt ## SIZE ## _v_qpel_r(dst, src, stride, stride);\ |
468 | }\ |
469 | \ |
470 | static void OPNAME ## cavs_qpel ## SIZE ## _mc22_c(uint8_t *dst, const uint8_t *src, ptrdiff_t stride)\ |
471 | {\ |
472 | OPNAME ## cavs_filt ## SIZE ## _hv_jj(dst, src, NULL, stride, stride); \ |
473 | }\ |
474 | \ |
475 | static void OPNAME ## cavs_qpel ## SIZE ## _mc11_c(uint8_t *dst, const uint8_t *src, ptrdiff_t stride)\ |
476 | {\ |
477 | OPNAME ## cavs_filt ## SIZE ## _hv_egpr(dst, src, src, stride, stride); \ |
478 | }\ |
479 | \ |
480 | static void OPNAME ## cavs_qpel ## SIZE ## _mc13_c(uint8_t *dst, const uint8_t *src, ptrdiff_t stride)\ |
481 | {\ |
482 | OPNAME ## cavs_filt ## SIZE ## _hv_egpr(dst, src, src+stride, stride, stride); \ |
483 | }\ |
484 | \ |
485 | static void OPNAME ## cavs_qpel ## SIZE ## _mc31_c(uint8_t *dst, const uint8_t *src, ptrdiff_t stride)\ |
486 | {\ |
487 | OPNAME ## cavs_filt ## SIZE ## _hv_egpr(dst, src, src+1, stride, stride); \ |
488 | }\ |
489 | \ |
490 | static void OPNAME ## cavs_qpel ## SIZE ## _mc33_c(uint8_t *dst, const uint8_t *src, ptrdiff_t stride)\ |
491 | {\ |
492 | OPNAME ## cavs_filt ## SIZE ## _hv_egpr(dst, src, src+stride+1,stride, stride); \ |
493 | }\ |
494 | \ |
495 | static void OPNAME ## cavs_qpel ## SIZE ## _mc21_c(uint8_t *dst, const uint8_t *src, ptrdiff_t stride)\ |
496 | {\ |
497 | OPNAME ## cavs_filt ## SIZE ## _hv_ff(dst, src, src+stride+1,stride, stride); \ |
498 | }\ |
499 | \ |
500 | static void OPNAME ## cavs_qpel ## SIZE ## _mc12_c(uint8_t *dst, const uint8_t *src, ptrdiff_t stride)\ |
501 | {\ |
502 | OPNAME ## cavs_filt ## SIZE ## _hv_ii(dst, src, src+stride+1,stride, stride); \ |
503 | }\ |
504 | \ |
505 | static void OPNAME ## cavs_qpel ## SIZE ## _mc32_c(uint8_t *dst, const uint8_t *src, ptrdiff_t stride)\ |
506 | {\ |
507 | OPNAME ## cavs_filt ## SIZE ## _hv_kk(dst, src, src+stride+1,stride, stride); \ |
508 | }\ |
509 | \ |
510 | static void OPNAME ## cavs_qpel ## SIZE ## _mc23_c(uint8_t *dst, const uint8_t *src, ptrdiff_t stride)\ |
511 | {\ |
512 | OPNAME ## cavs_filt ## SIZE ## _hv_qq(dst, src, src+stride+1,stride, stride); \ |
513 | }\ |
514 | |
515 | #define op_put1(a, b) a = cm[((b)+4)>>3] |
516 | #define op_put2(a, b) a = cm[((b)+64)>>7] |
517 | #define op_put3(a, b) a = cm[((b)+32)>>6] |
518 | #define op_put4(a, b) a = cm[((b)+512)>>10] |
519 | #define op_avg1(a, b) a = ((a)+cm[((b)+4)>>3] +1)>>1 |
520 | #define op_avg2(a, b) a = ((a)+cm[((b)+64)>>7] +1)>>1 |
521 | #define op_avg3(a, b) a = ((a)+cm[((b)+32)>>6] +1)>>1 |
522 | #define op_avg4(a, b) a = ((a)+cm[((b)+512)>>10]+1)>>1 |
523 | CAVS_SUBPIX(put_ , op_put1, hpel, 0, -1, 5, 5, -1, 0) |
524 | CAVS_SUBPIX(put_ , op_put2, qpel_l, -1, -2, 96, 42, -7, 0) |
525 | CAVS_SUBPIX(put_ , op_put2, qpel_r, 0, -7, 42, 96, -2, -1) |
526 | CAVS_SUBPIX_HV(put_, op_put3, jj, 0, -1, 5, 5, -1, 0, 0, -1, 5, 5, -1, 0, 0) |
527 | CAVS_SUBPIX_HV(put_, op_put4, ff, 0, -1, 5, 5, -1, 0, -1, -2, 96, 42, -7, 0, 0) |
528 | CAVS_SUBPIX_HV(put_, op_put4, ii, -1, -2, 96, 42, -7, 0, 0, -1, 5, 5, -1, 0, 0) |
529 | CAVS_SUBPIX_HV(put_, op_put4, kk, 0, -7, 42, 96, -2, -1, 0, -1, 5, 5, -1, 0, 0) |
530 | CAVS_SUBPIX_HV(put_, op_put4, qq, 0, -1, 5, 5, -1, 0, 0, -7, 42, 96, -2,-1, 0) |
531 | CAVS_SUBPIX_HV(put_, op_put2, egpr, 0, -1, 5, 5, -1, 0, 0, -1, 5, 5, -1, 0, 1) |
532 | CAVS_SUBPIX(avg_ , op_avg1, hpel, 0, -1, 5, 5, -1, 0) |
533 | CAVS_SUBPIX(avg_ , op_avg2, qpel_l, -1, -2, 96, 42, -7, 0) |
534 | CAVS_SUBPIX(avg_ , op_avg2, qpel_r, 0, -7, 42, 96, -2, -1) |
535 | CAVS_SUBPIX_HV(avg_, op_avg3, jj, 0, -1, 5, 5, -1, 0, 0, -1, 5, 5, -1, 0, 0) |
536 | CAVS_SUBPIX_HV(avg_, op_avg4, ff, 0, -1, 5, 5, -1, 0, -1, -2, 96, 42, -7, 0, 0) |
537 | CAVS_SUBPIX_HV(avg_, op_avg4, ii, -1, -2, 96, 42, -7, 0, 0, -1, 5, 5, -1, 0, 0) |
538 | CAVS_SUBPIX_HV(avg_, op_avg4, kk, 0, -7, 42, 96, -2, -1, 0, -1, 5, 5, -1, 0, 0) |
539 | CAVS_SUBPIX_HV(avg_, op_avg4, qq, 0, -1, 5, 5, -1, 0, 0, -7, 42, 96, -2,-1, 0) |
540 | CAVS_SUBPIX_HV(avg_, op_avg2, egpr, 0, -1, 5, 5, -1, 0, 0, -1, 5, 5, -1, 0, 1) |
541 | CAVS_MC(put_, 8) |
542 | CAVS_MC(put_, 16) |
543 | CAVS_MC(avg_, 8) |
544 | CAVS_MC(avg_, 16) |
545 | |
546 | #define put_cavs_qpel8_mc00_c ff_put_pixels8x8_c |
547 | #define avg_cavs_qpel8_mc00_c ff_avg_pixels8x8_c |
548 | #define put_cavs_qpel16_mc00_c ff_put_pixels16x16_c |
549 | #define avg_cavs_qpel16_mc00_c ff_avg_pixels16x16_c |
550 | |
551 | av_cold void ff_cavsdsp_init(CAVSDSPContext* c, AVCodecContext *avctx) { |
552 | #define dspfunc(PFX, IDX, NUM) \ |
553 | c->PFX ## _pixels_tab[IDX][ 0] = PFX ## NUM ## _mc00_c; \ |
554 | c->PFX ## _pixels_tab[IDX][ 1] = PFX ## NUM ## _mc10_c; \ |
555 | c->PFX ## _pixels_tab[IDX][ 2] = PFX ## NUM ## _mc20_c; \ |
556 | c->PFX ## _pixels_tab[IDX][ 3] = PFX ## NUM ## _mc30_c; \ |
557 | c->PFX ## _pixels_tab[IDX][ 4] = PFX ## NUM ## _mc01_c; \ |
558 | c->PFX ## _pixels_tab[IDX][ 5] = PFX ## NUM ## _mc11_c; \ |
559 | c->PFX ## _pixels_tab[IDX][ 6] = PFX ## NUM ## _mc21_c; \ |
560 | c->PFX ## _pixels_tab[IDX][ 7] = PFX ## NUM ## _mc31_c; \ |
561 | c->PFX ## _pixels_tab[IDX][ 8] = PFX ## NUM ## _mc02_c; \ |
562 | c->PFX ## _pixels_tab[IDX][ 9] = PFX ## NUM ## _mc12_c; \ |
563 | c->PFX ## _pixels_tab[IDX][10] = PFX ## NUM ## _mc22_c; \ |
564 | c->PFX ## _pixels_tab[IDX][11] = PFX ## NUM ## _mc32_c; \ |
565 | c->PFX ## _pixels_tab[IDX][12] = PFX ## NUM ## _mc03_c; \ |
566 | c->PFX ## _pixels_tab[IDX][13] = PFX ## NUM ## _mc13_c; \ |
567 | c->PFX ## _pixels_tab[IDX][14] = PFX ## NUM ## _mc23_c; \ |
568 | c->PFX ## _pixels_tab[IDX][15] = PFX ## NUM ## _mc33_c |
569 | dspfunc(put_cavs_qpel, 0, 16); |
570 | dspfunc(put_cavs_qpel, 1, 8); |
571 | dspfunc(avg_cavs_qpel, 0, 16); |
572 | dspfunc(avg_cavs_qpel, 1, 8); |
573 | c->cavs_filter_lv = cavs_filter_lv_c; |
574 | c->cavs_filter_lh = cavs_filter_lh_c; |
575 | c->cavs_filter_cv = cavs_filter_cv_c; |
576 | c->cavs_filter_ch = cavs_filter_ch_c; |
577 | c->cavs_idct8_add = cavs_idct8_add_c; |
578 | c->idct_perm = FF_IDCT_PERM_NONE; |
579 | |
580 | if (ARCH_X86) |
581 | ff_cavsdsp_init_x86(c, avctx); |
582 | } |
583 |