← Back to branch summary

~ubuntu-branches/ubuntu/oneiric/mplayer2/oneiric-proposed

« back to all changes in this revision

Viewing changes to ffmpeg-mt/libavcodec/cavsdsp.c

  • Committer: Bazaar Package Importer
  • Author(s): Reinhard Tartler
  • Date: 2011-03-20 22:48:03 UTC
  • Revision ID: james.westby@ubuntu.com-20110320224803-kc2nlrxz6pcphmf1
Tags: upstream-2.0~rc2
Import upstream version 2.0~rc2

Show diffs side-by-side

added added

removed removed

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