build: Generalize yasm/nasm-related variable names
[ffmpeg.git] / libavcodec / simple_idct_template.c
1 /*
2  * Simple IDCT
3  *
4  * Copyright (c) 2001 Michael Niedermayer <michaelni@gmx.at>
5  *
6  * This file is part of Libav.
7  *
8  * Libav 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.
12  *
13  * Libav 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.
17  *
18  * You should have received a copy of the GNU Lesser General Public
19  * License along with Libav; if not, write to the Free Software
20  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
21  */
22
23 /**
24  * @file
25  * simpleidct in C.
26  */
27
28 /* Based upon some commented-out C code from mpeg2dec (idct_mmx.c
29  * written by Aaron Holtzman <aholtzma@ess.engr.uvic.ca>). */
30
31 #include "simple_idct.h"
32
33 #include "bit_depth_template.c"
34
35 #undef W1
36 #undef W2
37 #undef W3
38 #undef W4
39 #undef W5
40 #undef W6
41 #undef W7
42 #undef ROW_SHIFT
43 #undef COL_SHIFT
44 #undef DC_SHIFT
45 #undef MUL
46 #undef MAC
47
48 #if BIT_DEPTH == 8
49
50 #define W1  22725  //cos(i*M_PI/16)*sqrt(2)*(1<<14) + 0.5
51 #define W2  21407  //cos(i*M_PI/16)*sqrt(2)*(1<<14) + 0.5
52 #define W3  19266  //cos(i*M_PI/16)*sqrt(2)*(1<<14) + 0.5
53 #define W4  16383  //cos(i*M_PI/16)*sqrt(2)*(1<<14) + 0.5
54 #define W5  12873  //cos(i*M_PI/16)*sqrt(2)*(1<<14) + 0.5
55 #define W6  8867   //cos(i*M_PI/16)*sqrt(2)*(1<<14) + 0.5
56 #define W7  4520   //cos(i*M_PI/16)*sqrt(2)*(1<<14) + 0.5
57
58 #define ROW_SHIFT 11
59 #define COL_SHIFT 20
60 #define DC_SHIFT 3
61
62 #define MUL(a, b)    MUL16(a, b)
63 #define MAC(a, b, c) MAC16(a, b, c)
64
65 #elif BIT_DEPTH == 10
66
67 #define W1 90901
68 #define W2 85627
69 #define W3 77062
70 #define W4 65535
71 #define W5 51491
72 #define W6 35468
73 #define W7 18081
74
75 #define ROW_SHIFT 15
76 #define COL_SHIFT 20
77 #define DC_SHIFT 1
78
79 #define MUL(a, b)    ((a) * (b))
80 #define MAC(a, b, c) ((a) += (b) * (c))
81
82 #else
83
84 #error "Unsupported bitdepth"
85
86 #endif
87
88 static inline void FUNC(idctRowCondDC)(int16_t *row, int extra_shift)
89 {
90     int a0, a1, a2, a3, b0, b1, b2, b3;
91
92 #if HAVE_FAST_64BIT
93 #define ROW0_MASK (0xffffLL << 48 * HAVE_BIGENDIAN)
94     if (((AV_RN64A(row) & ~ROW0_MASK) | AV_RN64A(row+4)) == 0) {
95         uint64_t temp;
96         if (DC_SHIFT - extra_shift > 0) {
97             temp = (row[0] * (1 << (DC_SHIFT - extra_shift))) & 0xffff;
98         } else {
99             temp = (row[0] >> (extra_shift - DC_SHIFT)) & 0xffff;
100         }
101         temp += temp * (1 << 16);
102         temp += temp * ((uint64_t) 1 << 32);
103         AV_WN64A(row, temp);
104         AV_WN64A(row + 4, temp);
105         return;
106     }
107 #else
108     if (!(AV_RN32A(row+2) |
109           AV_RN32A(row+4) |
110           AV_RN32A(row+6) |
111           row[1])) {
112         uint32_t temp;
113         if (DC_SHIFT - extra_shift > 0) {
114             temp = (row[0] * (1 << (DC_SHIFT - extra_shift))) & 0xffff;
115         } else {
116             temp = (row[0] >> (extra_shift - DC_SHIFT)) & 0xffff;
117         }
118         temp += temp * (1 << 16);
119         AV_WN32A(row, temp);
120         AV_WN32A(row+2, temp);
121         AV_WN32A(row+4, temp);
122         AV_WN32A(row+6, temp);
123         return;
124     }
125 #endif
126
127     a0 = (W4 * row[0]) + (1 << (ROW_SHIFT - 1));
128     a1 = a0;
129     a2 = a0;
130     a3 = a0;
131
132     a0 += W2 * row[2];
133     a1 += W6 * row[2];
134     a2 -= W6 * row[2];
135     a3 -= W2 * row[2];
136
137     b0 = MUL(W1, row[1]);
138     MAC(b0, W3, row[3]);
139     b1 = MUL(W3, row[1]);
140     MAC(b1, -W7, row[3]);
141     b2 = MUL(W5, row[1]);
142     MAC(b2, -W1, row[3]);
143     b3 = MUL(W7, row[1]);
144     MAC(b3, -W5, row[3]);
145
146     if (AV_RN64A(row + 4)) {
147         a0 +=   W4*row[4] + W6*row[6];
148         a1 += - W4*row[4] - W2*row[6];
149         a2 += - W4*row[4] + W2*row[6];
150         a3 +=   W4*row[4] - W6*row[6];
151
152         MAC(b0,  W5, row[5]);
153         MAC(b0,  W7, row[7]);
154
155         MAC(b1, -W1, row[5]);
156         MAC(b1, -W5, row[7]);
157
158         MAC(b2,  W7, row[5]);
159         MAC(b2,  W3, row[7]);
160
161         MAC(b3,  W3, row[5]);
162         MAC(b3, -W1, row[7]);
163     }
164
165     row[0] = (a0 + b0) >> (ROW_SHIFT + extra_shift);
166     row[7] = (a0 - b0) >> (ROW_SHIFT + extra_shift);
167     row[1] = (a1 + b1) >> (ROW_SHIFT + extra_shift);
168     row[6] = (a1 - b1) >> (ROW_SHIFT + extra_shift);
169     row[2] = (a2 + b2) >> (ROW_SHIFT + extra_shift);
170     row[5] = (a2 - b2) >> (ROW_SHIFT + extra_shift);
171     row[3] = (a3 + b3) >> (ROW_SHIFT + extra_shift);
172     row[4] = (a3 - b3) >> (ROW_SHIFT + extra_shift);
173 }
174
175 #define IDCT_COLS do {                                  \
176         a0 = W4 * (col[8*0] + ((1<<(COL_SHIFT-1))/W4)); \
177         a1 = a0;                                        \
178         a2 = a0;                                        \
179         a3 = a0;                                        \
180                                                         \
181         a0 +=  W2*col[8*2];                             \
182         a1 +=  W6*col[8*2];                             \
183         a2 += -W6*col[8*2];                             \
184         a3 += -W2*col[8*2];                             \
185                                                         \
186         b0 = MUL(W1, col[8*1]);                         \
187         b1 = MUL(W3, col[8*1]);                         \
188         b2 = MUL(W5, col[8*1]);                         \
189         b3 = MUL(W7, col[8*1]);                         \
190                                                         \
191         MAC(b0,  W3, col[8*3]);                         \
192         MAC(b1, -W7, col[8*3]);                         \
193         MAC(b2, -W1, col[8*3]);                         \
194         MAC(b3, -W5, col[8*3]);                         \
195                                                         \
196         if (col[8*4]) {                                 \
197             a0 +=  W4*col[8*4];                         \
198             a1 += -W4*col[8*4];                         \
199             a2 += -W4*col[8*4];                         \
200             a3 +=  W4*col[8*4];                         \
201         }                                               \
202                                                         \
203         if (col[8*5]) {                                 \
204             MAC(b0,  W5, col[8*5]);                     \
205             MAC(b1, -W1, col[8*5]);                     \
206             MAC(b2,  W7, col[8*5]);                     \
207             MAC(b3,  W3, col[8*5]);                     \
208         }                                               \
209                                                         \
210         if (col[8*6]) {                                 \
211             a0 +=  W6*col[8*6];                         \
212             a1 += -W2*col[8*6];                         \
213             a2 +=  W2*col[8*6];                         \
214             a3 += -W6*col[8*6];                         \
215         }                                               \
216                                                         \
217         if (col[8*7]) {                                 \
218             MAC(b0,  W7, col[8*7]);                     \
219             MAC(b1, -W5, col[8*7]);                     \
220             MAC(b2,  W3, col[8*7]);                     \
221             MAC(b3, -W1, col[8*7]);                     \
222         }                                               \
223     } while (0)
224
225 static inline void FUNC(idctSparseColPut)(pixel *dest, ptrdiff_t line_size,
226                                           int16_t *col)
227 {
228     int a0, a1, a2, a3, b0, b1, b2, b3;
229
230     IDCT_COLS;
231
232     dest[0] = av_clip_pixel((a0 + b0) >> COL_SHIFT);
233     dest += line_size;
234     dest[0] = av_clip_pixel((a1 + b1) >> COL_SHIFT);
235     dest += line_size;
236     dest[0] = av_clip_pixel((a2 + b2) >> COL_SHIFT);
237     dest += line_size;
238     dest[0] = av_clip_pixel((a3 + b3) >> COL_SHIFT);
239     dest += line_size;
240     dest[0] = av_clip_pixel((a3 - b3) >> COL_SHIFT);
241     dest += line_size;
242     dest[0] = av_clip_pixel((a2 - b2) >> COL_SHIFT);
243     dest += line_size;
244     dest[0] = av_clip_pixel((a1 - b1) >> COL_SHIFT);
245     dest += line_size;
246     dest[0] = av_clip_pixel((a0 - b0) >> COL_SHIFT);
247 }
248
249 static inline void FUNC(idctSparseColAdd)(pixel *dest, ptrdiff_t line_size,
250                                           int16_t *col)
251 {
252     int a0, a1, a2, a3, b0, b1, b2, b3;
253
254     IDCT_COLS;
255
256     dest[0] = av_clip_pixel(dest[0] + ((a0 + b0) >> COL_SHIFT));
257     dest += line_size;
258     dest[0] = av_clip_pixel(dest[0] + ((a1 + b1) >> COL_SHIFT));
259     dest += line_size;
260     dest[0] = av_clip_pixel(dest[0] + ((a2 + b2) >> COL_SHIFT));
261     dest += line_size;
262     dest[0] = av_clip_pixel(dest[0] + ((a3 + b3) >> COL_SHIFT));
263     dest += line_size;
264     dest[0] = av_clip_pixel(dest[0] + ((a3 - b3) >> COL_SHIFT));
265     dest += line_size;
266     dest[0] = av_clip_pixel(dest[0] + ((a2 - b2) >> COL_SHIFT));
267     dest += line_size;
268     dest[0] = av_clip_pixel(dest[0] + ((a1 - b1) >> COL_SHIFT));
269     dest += line_size;
270     dest[0] = av_clip_pixel(dest[0] + ((a0 - b0) >> COL_SHIFT));
271 }
272
273 static inline void FUNC(idctSparseCol)(int16_t *col)
274 {
275     int a0, a1, a2, a3, b0, b1, b2, b3;
276
277     IDCT_COLS;
278
279     col[0 ] = ((a0 + b0) >> COL_SHIFT);
280     col[8 ] = ((a1 + b1) >> COL_SHIFT);
281     col[16] = ((a2 + b2) >> COL_SHIFT);
282     col[24] = ((a3 + b3) >> COL_SHIFT);
283     col[32] = ((a3 - b3) >> COL_SHIFT);
284     col[40] = ((a2 - b2) >> COL_SHIFT);
285     col[48] = ((a1 - b1) >> COL_SHIFT);
286     col[56] = ((a0 - b0) >> COL_SHIFT);
287 }
288
289 void FUNC(ff_simple_idct_put)(uint8_t *dest_, ptrdiff_t line_size, int16_t *block)
290 {
291     pixel *dest = (pixel *)dest_;
292     int i;
293
294     line_size /= sizeof(pixel);
295
296     for (i = 0; i < 8; i++)
297         FUNC(idctRowCondDC)(block + i*8, 0);
298
299     for (i = 0; i < 8; i++)
300         FUNC(idctSparseColPut)(dest + i, line_size, block + i);
301 }
302
303 void FUNC(ff_simple_idct_add)(uint8_t *dest_, ptrdiff_t line_size, int16_t *block)
304 {
305     pixel *dest = (pixel *)dest_;
306     int i;
307
308     line_size /= sizeof(pixel);
309
310     for (i = 0; i < 8; i++)
311         FUNC(idctRowCondDC)(block + i*8, 0);
312
313     for (i = 0; i < 8; i++)
314         FUNC(idctSparseColAdd)(dest + i, line_size, block + i);
315 }
316
317 void FUNC(ff_simple_idct)(int16_t *block)
318 {
319     int i;
320
321     for (i = 0; i < 8; i++)
322         FUNC(idctRowCondDC)(block + i*8, 0);
323
324     for (i = 0; i < 8; i++)
325         FUNC(idctSparseCol)(block + i);
326 }