Massive cosmetic and syntax cleanup
[x262.git] / common / ppc / quant.c
1 /*****************************************************************************
2 * quant.c: h264 encoder
3 *****************************************************************************
4 * Copyright (C) 2007 Guillaume Poirier <gpoirier@mplayerhq.hu>
5 *
6 * This program is free software; you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License as published by
8 * the Free Software Foundation; either version 2 of the License, or
9 * (at your option) any later version.
10 *
11 * This program is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14 * GNU General Public License for more details.
15 *
16 * You should have received a copy of the GNU General Public License
17 * along with this program; if not, write to the Free Software
18 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02111, USA.
19 *****************************************************************************/
20
21 #include "common/common.h"
22 #include "ppccommon.h"
23 #include "quant.h"            
24
25 // quant of a whole 4x4 block, unrolled 2x and "pre-scheduled"
26 #define QUANT_16_U( idx0, idx1 )                                    \
27 {                                                                   \
28     temp1v = vec_ld((idx0), *dct);                                  \
29     temp2v = vec_ld((idx1), *dct);                                  \
30     mfvA = vec_ld((idx0), mf);                                      \
31     mfvB = vec_ld((idx1), mf);                                      \
32     biasvA = vec_ld((idx0), bias);                                  \
33     biasvB = vec_ld((idx1), bias);                                  \
34     mskA = vec_cmplt(temp1v, zero_s16v);                            \
35     mskB = vec_cmplt(temp2v, zero_s16v);                            \
36     coefvA = (vec_u16_t)vec_max(vec_sub(zero_s16v, temp1v), temp1v);\
37     coefvB = (vec_u16_t)vec_max(vec_sub(zero_s16v, temp2v), temp2v);\
38     coefvA = vec_adds(coefvA, biasvA);                              \
39     coefvB = vec_adds(coefvB, biasvB);                              \
40     multEvenvA = vec_mule(coefvA, mfvA);                            \
41     multOddvA = vec_mulo(coefvA, mfvA);                             \
42     multEvenvB = vec_mule(coefvB, mfvB);                            \
43     multOddvB = vec_mulo(coefvB, mfvB);                             \
44     multEvenvA = vec_sr(multEvenvA, i_qbitsv);                      \
45     multOddvA = vec_sr(multOddvA, i_qbitsv);                        \
46     multEvenvB = vec_sr(multEvenvB, i_qbitsv);                      \
47     multOddvB = vec_sr(multOddvB, i_qbitsv);                        \
48     temp1v = (vec_s16_t) vec_packs(vec_mergeh(multEvenvA, multOddvA), vec_mergel(multEvenvA, multOddvA)); \
49     temp2v = (vec_s16_t) vec_packs(vec_mergeh(multEvenvB, multOddvB), vec_mergel(multEvenvB, multOddvB)); \
50     temp1v = vec_xor(temp1v, mskA);                                 \
51     temp2v = vec_xor(temp2v, mskB);                                 \
52     temp1v = vec_adds(temp1v, vec_and(mskA, one));                  \
53     vec_st(temp1v, (idx0), (int16_t*)dct);                          \
54     temp2v = vec_adds(temp2v, vec_and(mskB, one));                  \
55     nz = vec_or(nz, vec_or(temp1v, temp2v));                        \
56     vec_st(temp2v, (idx1), (int16_t*)dct);                          \
57 }
58                 
59 int x264_quant_4x4_altivec( int16_t dct[4][4], uint16_t mf[16], uint16_t bias[16] )
60 {
61     LOAD_ZERO;
62     vector bool short mskA;
63     vec_u32_t i_qbitsv;
64     vec_u16_t coefvA;
65     vec_u32_t multEvenvA, multOddvA;
66     vec_u16_t mfvA;
67     vec_u16_t biasvA;
68     vec_s16_t one = vec_splat_s16(1);;
69     vec_s16_t nz = zero_s16v;
70
71     vector bool short mskB;
72     vec_u16_t coefvB;
73     vec_u32_t multEvenvB, multOddvB;
74     vec_u16_t mfvB;
75     vec_u16_t biasvB;
76
77     vec_s16_t temp1v, temp2v;
78
79     vec_u32_u qbits_u;
80     qbits_u.s[0]=16;
81     i_qbitsv = vec_splat(qbits_u.v, 0);
82
83     QUANT_16_U( 0, 16 );
84     return vec_any_ne(nz, zero_s16v);
85 }
86
87 // DC quant of a whole 4x4 block, unrolled 2x and "pre-scheduled"
88 #define QUANT_16_U_DC( idx0, idx1 )                                 \
89 {                                                                   \
90     temp1v = vec_ld((idx0), *dct);                                  \
91     temp2v = vec_ld((idx1), *dct);                                  \
92     mskA = vec_cmplt(temp1v, zero_s16v);                            \
93     mskB = vec_cmplt(temp2v, zero_s16v);                            \
94     coefvA = (vec_u16_t)vec_max(vec_sub(zero_s16v, temp1v), temp1v);\
95     coefvB = (vec_u16_t)vec_max(vec_sub(zero_s16v, temp2v), temp2v);\
96     coefvA = vec_add(coefvA, biasv);                                \
97     coefvB = vec_add(coefvB, biasv);                                \
98     multEvenvA = vec_mule(coefvA, mfv);                             \
99     multOddvA = vec_mulo(coefvA, mfv);                              \
100     multEvenvB = vec_mule(coefvB, mfv);                             \
101     multOddvB = vec_mulo(coefvB, mfv);                              \
102     multEvenvA = vec_sr(multEvenvA, i_qbitsv);                      \
103     multOddvA = vec_sr(multOddvA, i_qbitsv);                        \
104     multEvenvB = vec_sr(multEvenvB, i_qbitsv);                      \
105     multOddvB = vec_sr(multOddvB, i_qbitsv);                        \
106     temp1v = (vec_s16_t) vec_packs(vec_mergeh(multEvenvA, multOddvA), vec_mergel(multEvenvA, multOddvA)); \
107     temp2v = (vec_s16_t) vec_packs(vec_mergeh(multEvenvB, multOddvB), vec_mergel(multEvenvB, multOddvB)); \
108     temp1v = vec_xor(temp1v, mskA);                                 \
109     temp2v = vec_xor(temp2v, mskB);                                 \
110     temp1v = vec_add(temp1v, vec_and(mskA, one));                   \
111     vec_st(temp1v, (idx0), (int16_t*)dct);                          \
112     temp2v = vec_add(temp2v, vec_and(mskB, one));                   \
113     nz = vec_or(nz, vec_or(temp1v, temp2v));                        \
114     vec_st(temp2v, (idx1), (int16_t*)dct);                          \
115 }
116
117 int x264_quant_4x4_dc_altivec( int16_t dct[4][4], int mf, int bias )
118 {
119     LOAD_ZERO;
120     vector bool short mskA;
121     vec_u32_t i_qbitsv;
122     vec_u16_t coefvA;
123     vec_u32_t multEvenvA, multOddvA;
124     vec_s16_t one = vec_splat_s16(1);
125     vec_s16_t nz = zero_s16v;
126
127     vector bool short mskB;
128     vec_u16_t coefvB;
129     vec_u32_t multEvenvB, multOddvB;
130
131     vec_s16_t temp1v, temp2v;
132
133     vec_u16_t mfv;
134     vec_u16_t biasv;
135
136     vec_u16_u mf_u;
137     mf_u.s[0]=mf;
138     mfv = vec_splat( mf_u.v, 0 );
139
140     vec_u32_u qbits_u;
141     qbits_u.s[0]=16;
142     i_qbitsv = vec_splat(qbits_u.v, 0);
143
144     vec_u16_u bias_u;
145     bias_u.s[0]=bias;
146     biasv = vec_splat(bias_u.v, 0);
147
148     QUANT_16_U_DC( 0, 16 );
149     return vec_any_ne(nz, zero_s16v);
150 }
151
152 // DC quant of a whole 2x2 block
153 #define QUANT_4_U_DC( idx0 )                                        \
154 {                                                                   \
155     const vec_u16_t sel = (vec_u16_t) CV(-1,-1,-1,-1,0,0,0,0);      \
156     temp1v = vec_ld((idx0), *dct);                                  \
157     mskA = vec_cmplt(temp1v, zero_s16v);                            \
158     coefvA = (vec_u16_t)vec_max(vec_sub(zero_s16v, temp1v), temp1v);\
159     coefvA = vec_add(coefvA, biasv);                                \
160     multEvenvA = vec_mule(coefvA, mfv);                             \
161     multOddvA = vec_mulo(coefvA, mfv);                              \
162     multEvenvA = vec_sr(multEvenvA, i_qbitsv);                      \
163     multOddvA = vec_sr(multOddvA, i_qbitsv);                        \
164     temp2v = (vec_s16_t) vec_packs(vec_mergeh(multEvenvA, multOddvA), vec_mergel(multEvenvA, multOddvA)); \
165     temp2v = vec_xor(temp2v, mskA);                                 \
166     temp2v = vec_add(temp2v, vec_and(mskA, one));                   \
167     temp1v = vec_sel(temp1v, temp2v, sel);                          \
168     nz = vec_or(nz, temp1v);                                        \
169     vec_st(temp1v, (idx0), (int16_t*)dct);                          \
170 }
171
172 int x264_quant_2x2_dc_altivec( int16_t dct[2][2], int mf, int bias )
173 {
174     LOAD_ZERO;
175     vector bool short mskA;
176     vec_u32_t i_qbitsv;
177     vec_u16_t coefvA;
178     vec_u32_t multEvenvA, multOddvA;
179     vec_s16_t one = vec_splat_s16(1);
180     vec_s16_t nz = zero_s16v;
181
182     vec_s16_t temp1v, temp2v;
183
184     vec_u16_t mfv;
185     vec_u16_t biasv;
186
187     vec_u16_u mf_u;
188     mf_u.s[0]=mf;
189     mfv = vec_splat( mf_u.v, 0 );
190
191     vec_u32_u qbits_u;
192     qbits_u.s[0]=16;
193     i_qbitsv = vec_splat(qbits_u.v, 0);
194
195     vec_u16_u bias_u;
196     bias_u.s[0]=bias;
197     biasv = vec_splat(bias_u.v, 0);
198
199     static const vec_s16_t mask2 = CV(-1, -1, -1, -1,  0, 0, 0, 0);
200     QUANT_4_U_DC(0);
201     return vec_any_ne(vec_and(nz, mask2), zero_s16v);
202 }
203
204 int x264_quant_8x8_altivec( int16_t dct[8][8], uint16_t mf[64], uint16_t bias[64] )
205 {
206     LOAD_ZERO;
207     vector bool short mskA;
208     vec_u32_t i_qbitsv;
209     vec_u16_t coefvA;
210     vec_u32_t multEvenvA, multOddvA;
211     vec_u16_t mfvA;
212     vec_u16_t biasvA;
213     vec_s16_t one = vec_splat_s16(1);;
214     vec_s16_t nz = zero_s16v;
215
216     vector bool short mskB;
217     vec_u16_t coefvB;
218     vec_u32_t multEvenvB, multOddvB;
219     vec_u16_t mfvB;
220     vec_u16_t biasvB;
221
222     vec_s16_t temp1v, temp2v;
223     
224     vec_u32_u qbits_u;
225     qbits_u.s[0]=16;
226     i_qbitsv = vec_splat(qbits_u.v, 0);
227
228     for( int i = 0; i < 4; i++ )
229         QUANT_16_U( i*2*16, i*2*16+16 );
230     return vec_any_ne(nz, zero_s16v);
231 }
232
233 #define DEQUANT_SHL()                                                \
234 {                                                                    \
235     dctv = vec_ld(0, dct[y]);                                        \
236     mf1v = vec_ld(0, dequant_mf[i_mf][y]);                           \
237     mf2v = vec_ld(16, dequant_mf[i_mf][y]);                          \
238     mfv  = vec_packs(mf1v, mf2v);                                    \
239                                                                      \
240     multEvenvA = vec_mule(dctv, mfv);                                \
241     multOddvA = vec_mulo(dctv, mfv);                                 \
242     dctv = (vec_s16_t) vec_packs(vec_mergeh(multEvenvA, multOddvA),  \
243                                  vec_mergel(multEvenvA, multOddvA)); \
244     dctv = vec_sl(dctv, i_qbitsv);                                   \
245     vec_st(dctv, 0, dct[y]);                                         \
246 }
247
248 #define DEQUANT_SHR()                                          \
249 {                                                              \
250     dctv = vec_ld(0, dct[y]);                                  \
251     dct1v = vec_mergeh(dctv, dctv);                            \
252     dct2v = vec_mergel(dctv, dctv);                            \
253     mf1v = vec_ld(0, dequant_mf[i_mf][y]);                     \
254     mf2v = vec_ld(16, dequant_mf[i_mf][y]);                    \
255                                                                \
256     multEvenvA = vec_mule(dct1v, (vec_s16_t)mf1v);             \
257     multOddvA = vec_mulo(dct1v, (vec_s16_t)mf1v);              \
258     temp1v = vec_add(vec_sl(multEvenvA, sixteenv), multOddvA); \
259     temp1v = vec_add(temp1v, fv);                              \
260     temp1v = vec_sra(temp1v, i_qbitsv);                        \
261                                                                \
262     multEvenvA = vec_mule(dct2v, (vec_s16_t)mf2v);             \
263     multOddvA = vec_mulo(dct2v, (vec_s16_t)mf2v);              \
264     temp2v = vec_add(vec_sl(multEvenvA, sixteenv), multOddvA); \
265     temp2v = vec_add(temp2v, fv);                              \
266     temp2v = vec_sra(temp2v, i_qbitsv);                        \
267                                                                \
268     dctv = (vec_s16_t)vec_packs(temp1v, temp2v);               \
269     vec_st(dctv, 0, dct[y]);                                   \
270 }
271
272 void x264_dequant_4x4_altivec( int16_t dct[4][4], int dequant_mf[6][4][4], int i_qp )
273 {
274     int i_mf = i_qp%6;
275     int i_qbits = i_qp/6 - 4;
276
277     vec_s16_t dctv;
278     vec_s16_t dct1v, dct2v;
279     vec_s32_t mf1v, mf2v;
280     vec_s16_t mfv;
281     vec_s32_t multEvenvA, multOddvA;
282     vec_s32_t temp1v, temp2v;
283
284     if( i_qbits >= 0 )
285     {
286         vec_u16_t i_qbitsv;
287         vec_u16_u qbits_u;
288         qbits_u.s[0]=i_qbits;
289         i_qbitsv = vec_splat(qbits_u.v, 0);
290
291         for( int y = 0; y < 4; y+=2 )
292             DEQUANT_SHL();
293     }
294     else
295     {
296         const int f = 1 << (-i_qbits-1);
297
298         vec_s32_t fv;
299         vec_u32_u f_u;
300         f_u.s[0]=f;
301         fv = (vec_s32_t)vec_splat(f_u.v, 0);
302
303         vec_u32_t i_qbitsv;
304         vec_u32_u qbits_u;
305         qbits_u.s[0]=-i_qbits;
306         i_qbitsv = vec_splat(qbits_u.v, 0);
307
308         vec_u32_t sixteenv;
309         vec_u32_u sixteen_u;
310         sixteen_u.s[0]=16;
311         sixteenv = vec_splat(sixteen_u.v, 0);
312
313         for( int y = 0; y < 4; y+=2 )
314             DEQUANT_SHR();
315     }
316 }
317
318 void x264_dequant_8x8_altivec( int16_t dct[8][8], int dequant_mf[6][8][8], int i_qp )
319 {
320     int i_mf = i_qp%6;
321     int i_qbits = i_qp/6 - 6;
322
323     vec_s16_t dctv;
324     vec_s16_t dct1v, dct2v;
325     vec_s32_t mf1v, mf2v;
326     vec_s16_t mfv;
327     vec_s32_t multEvenvA, multOddvA;
328     vec_s32_t temp1v, temp2v;
329
330     if( i_qbits >= 0 )
331     {
332         vec_u16_t i_qbitsv;
333         vec_u16_u qbits_u;
334         qbits_u.s[0]=i_qbits;
335         i_qbitsv = vec_splat(qbits_u.v, 0);
336
337         for( int y = 0; y < 8; y++ )
338             DEQUANT_SHL();
339     }
340     else
341     {
342         const int f = 1 << (-i_qbits-1);
343
344         vec_s32_t fv;
345         vec_u32_u f_u;
346         f_u.s[0]=f;
347         fv = (vec_s32_t)vec_splat(f_u.v, 0);
348
349         vec_u32_t i_qbitsv;
350         vec_u32_u qbits_u;
351         qbits_u.s[0]=-i_qbits;
352         i_qbitsv = vec_splat(qbits_u.v, 0);
353
354         vec_u32_t sixteenv;
355         vec_u32_u sixteen_u;
356         sixteen_u.s[0]=16;
357         sixteenv = vec_splat(sixteen_u.v, 0);
358
359         for( int y = 0; y < 8; y++ )
360             DEQUANT_SHR();
361     }
362 }
363