Support for 9 and 10-bit encoding
[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 #if !X264_HIGH_BIT_DEPTH
26 // quant of a whole 4x4 block, unrolled 2x and "pre-scheduled"
27 #define QUANT_16_U( idx0, idx1 )                                    \
28 {                                                                   \
29     temp1v = vec_ld((idx0), *dct);                                  \
30     temp2v = vec_ld((idx1), *dct);                                  \
31     mfvA = vec_ld((idx0), mf);                                      \
32     mfvB = vec_ld((idx1), mf);                                      \
33     biasvA = vec_ld((idx0), bias);                                  \
34     biasvB = vec_ld((idx1), bias);                                  \
35     mskA = vec_cmplt(temp1v, zero_s16v);                            \
36     mskB = vec_cmplt(temp2v, zero_s16v);                            \
37     coefvA = (vec_u16_t)vec_max(vec_sub(zero_s16v, temp1v), temp1v);\
38     coefvB = (vec_u16_t)vec_max(vec_sub(zero_s16v, temp2v), temp2v);\
39     coefvA = vec_adds(coefvA, biasvA);                              \
40     coefvB = vec_adds(coefvB, biasvB);                              \
41     multEvenvA = vec_mule(coefvA, mfvA);                            \
42     multOddvA = vec_mulo(coefvA, mfvA);                             \
43     multEvenvB = vec_mule(coefvB, mfvB);                            \
44     multOddvB = vec_mulo(coefvB, mfvB);                             \
45     multEvenvA = vec_sr(multEvenvA, i_qbitsv);                      \
46     multOddvA = vec_sr(multOddvA, i_qbitsv);                        \
47     multEvenvB = vec_sr(multEvenvB, i_qbitsv);                      \
48     multOddvB = vec_sr(multOddvB, i_qbitsv);                        \
49     temp1v = (vec_s16_t) vec_packs(vec_mergeh(multEvenvA, multOddvA), vec_mergel(multEvenvA, multOddvA)); \
50     temp2v = (vec_s16_t) vec_packs(vec_mergeh(multEvenvB, multOddvB), vec_mergel(multEvenvB, multOddvB)); \
51     temp1v = vec_xor(temp1v, mskA);                                 \
52     temp2v = vec_xor(temp2v, mskB);                                 \
53     temp1v = vec_adds(temp1v, vec_and(mskA, one));                  \
54     vec_st(temp1v, (idx0), (int16_t*)dct);                          \
55     temp2v = vec_adds(temp2v, vec_and(mskB, one));                  \
56     nz = vec_or(nz, vec_or(temp1v, temp2v));                        \
57     vec_st(temp2v, (idx1), (int16_t*)dct);                          \
58 }
59
60 int x264_quant_4x4_altivec( int16_t dct[4][4], uint16_t mf[16], uint16_t bias[16] )
61 {
62     LOAD_ZERO;
63     vector bool short mskA;
64     vec_u32_t i_qbitsv;
65     vec_u16_t coefvA;
66     vec_u32_t multEvenvA, multOddvA;
67     vec_u16_t mfvA;
68     vec_u16_t biasvA;
69     vec_s16_t one = vec_splat_s16(1);;
70     vec_s16_t nz = zero_s16v;
71
72     vector bool short mskB;
73     vec_u16_t coefvB;
74     vec_u32_t multEvenvB, multOddvB;
75     vec_u16_t mfvB;
76     vec_u16_t biasvB;
77
78     vec_s16_t temp1v, temp2v;
79
80     vec_u32_u qbits_u;
81     qbits_u.s[0]=16;
82     i_qbitsv = vec_splat(qbits_u.v, 0);
83
84     QUANT_16_U( 0, 16 );
85     return vec_any_ne(nz, zero_s16v);
86 }
87
88 // DC quant of a whole 4x4 block, unrolled 2x and "pre-scheduled"
89 #define QUANT_16_U_DC( idx0, idx1 )                                 \
90 {                                                                   \
91     temp1v = vec_ld((idx0), *dct);                                  \
92     temp2v = vec_ld((idx1), *dct);                                  \
93     mskA = vec_cmplt(temp1v, zero_s16v);                            \
94     mskB = vec_cmplt(temp2v, zero_s16v);                            \
95     coefvA = (vec_u16_t)vec_max(vec_sub(zero_s16v, temp1v), temp1v);\
96     coefvB = (vec_u16_t)vec_max(vec_sub(zero_s16v, temp2v), temp2v);\
97     coefvA = vec_add(coefvA, biasv);                                \
98     coefvB = vec_add(coefvB, biasv);                                \
99     multEvenvA = vec_mule(coefvA, mfv);                             \
100     multOddvA = vec_mulo(coefvA, mfv);                              \
101     multEvenvB = vec_mule(coefvB, mfv);                             \
102     multOddvB = vec_mulo(coefvB, mfv);                              \
103     multEvenvA = vec_sr(multEvenvA, i_qbitsv);                      \
104     multOddvA = vec_sr(multOddvA, i_qbitsv);                        \
105     multEvenvB = vec_sr(multEvenvB, i_qbitsv);                      \
106     multOddvB = vec_sr(multOddvB, i_qbitsv);                        \
107     temp1v = (vec_s16_t) vec_packs(vec_mergeh(multEvenvA, multOddvA), vec_mergel(multEvenvA, multOddvA)); \
108     temp2v = (vec_s16_t) vec_packs(vec_mergeh(multEvenvB, multOddvB), vec_mergel(multEvenvB, multOddvB)); \
109     temp1v = vec_xor(temp1v, mskA);                                 \
110     temp2v = vec_xor(temp2v, mskB);                                 \
111     temp1v = vec_add(temp1v, vec_and(mskA, one));                   \
112     vec_st(temp1v, (idx0), (int16_t*)dct);                          \
113     temp2v = vec_add(temp2v, vec_and(mskB, one));                   \
114     nz = vec_or(nz, vec_or(temp1v, temp2v));                        \
115     vec_st(temp2v, (idx1), (int16_t*)dct);                          \
116 }
117
118 int x264_quant_4x4_dc_altivec( int16_t dct[4][4], int mf, int bias )
119 {
120     LOAD_ZERO;
121     vector bool short mskA;
122     vec_u32_t i_qbitsv;
123     vec_u16_t coefvA;
124     vec_u32_t multEvenvA, multOddvA;
125     vec_s16_t one = vec_splat_s16(1);
126     vec_s16_t nz = zero_s16v;
127
128     vector bool short mskB;
129     vec_u16_t coefvB;
130     vec_u32_t multEvenvB, multOddvB;
131
132     vec_s16_t temp1v, temp2v;
133
134     vec_u16_t mfv;
135     vec_u16_t biasv;
136
137     vec_u16_u mf_u;
138     mf_u.s[0]=mf;
139     mfv = vec_splat( mf_u.v, 0 );
140
141     vec_u32_u qbits_u;
142     qbits_u.s[0]=16;
143     i_qbitsv = vec_splat(qbits_u.v, 0);
144
145     vec_u16_u bias_u;
146     bias_u.s[0]=bias;
147     biasv = vec_splat(bias_u.v, 0);
148
149     QUANT_16_U_DC( 0, 16 );
150     return vec_any_ne(nz, zero_s16v);
151 }
152
153 // DC quant of a whole 2x2 block
154 #define QUANT_4_U_DC( idx0 )                                        \
155 {                                                                   \
156     const vec_u16_t sel = (vec_u16_t) CV(-1,-1,-1,-1,0,0,0,0);      \
157     temp1v = vec_ld((idx0), *dct);                                  \
158     mskA = vec_cmplt(temp1v, zero_s16v);                            \
159     coefvA = (vec_u16_t)vec_max(vec_sub(zero_s16v, temp1v), temp1v);\
160     coefvA = vec_add(coefvA, biasv);                                \
161     multEvenvA = vec_mule(coefvA, mfv);                             \
162     multOddvA = vec_mulo(coefvA, mfv);                              \
163     multEvenvA = vec_sr(multEvenvA, i_qbitsv);                      \
164     multOddvA = vec_sr(multOddvA, i_qbitsv);                        \
165     temp2v = (vec_s16_t) vec_packs(vec_mergeh(multEvenvA, multOddvA), vec_mergel(multEvenvA, multOddvA)); \
166     temp2v = vec_xor(temp2v, mskA);                                 \
167     temp2v = vec_add(temp2v, vec_and(mskA, one));                   \
168     temp1v = vec_sel(temp1v, temp2v, sel);                          \
169     nz = vec_or(nz, temp1v);                                        \
170     vec_st(temp1v, (idx0), (int16_t*)dct);                          \
171 }
172
173 int x264_quant_2x2_dc_altivec( int16_t dct[2][2], int mf, int bias )
174 {
175     LOAD_ZERO;
176     vector bool short mskA;
177     vec_u32_t i_qbitsv;
178     vec_u16_t coefvA;
179     vec_u32_t multEvenvA, multOddvA;
180     vec_s16_t one = vec_splat_s16(1);
181     vec_s16_t nz = zero_s16v;
182
183     vec_s16_t temp1v, temp2v;
184
185     vec_u16_t mfv;
186     vec_u16_t biasv;
187
188     vec_u16_u mf_u;
189     mf_u.s[0]=mf;
190     mfv = vec_splat( mf_u.v, 0 );
191
192     vec_u32_u qbits_u;
193     qbits_u.s[0]=16;
194     i_qbitsv = vec_splat(qbits_u.v, 0);
195
196     vec_u16_u bias_u;
197     bias_u.s[0]=bias;
198     biasv = vec_splat(bias_u.v, 0);
199
200     static const vec_s16_t mask2 = CV(-1, -1, -1, -1,  0, 0, 0, 0);
201     QUANT_4_U_DC(0);
202     return vec_any_ne(vec_and(nz, mask2), zero_s16v);
203 }
204
205 int x264_quant_8x8_altivec( int16_t dct[8][8], uint16_t mf[64], uint16_t bias[64] )
206 {
207     LOAD_ZERO;
208     vector bool short mskA;
209     vec_u32_t i_qbitsv;
210     vec_u16_t coefvA;
211     vec_u32_t multEvenvA, multOddvA;
212     vec_u16_t mfvA;
213     vec_u16_t biasvA;
214     vec_s16_t one = vec_splat_s16(1);;
215     vec_s16_t nz = zero_s16v;
216
217     vector bool short mskB;
218     vec_u16_t coefvB;
219     vec_u32_t multEvenvB, multOddvB;
220     vec_u16_t mfvB;
221     vec_u16_t biasvB;
222
223     vec_s16_t temp1v, temp2v;
224
225     vec_u32_u qbits_u;
226     qbits_u.s[0]=16;
227     i_qbitsv = vec_splat(qbits_u.v, 0);
228
229     for( int i = 0; i < 4; i++ )
230         QUANT_16_U( i*2*16, i*2*16+16 );
231     return vec_any_ne(nz, zero_s16v);
232 }
233
234 #define DEQUANT_SHL()                                                \
235 {                                                                    \
236     dctv = vec_ld(0, dct[y]);                                        \
237     mf1v = vec_ld(0, dequant_mf[i_mf][y]);                           \
238     mf2v = vec_ld(16, dequant_mf[i_mf][y]);                          \
239     mfv  = vec_packs(mf1v, mf2v);                                    \
240                                                                      \
241     multEvenvA = vec_mule(dctv, mfv);                                \
242     multOddvA = vec_mulo(dctv, mfv);                                 \
243     dctv = (vec_s16_t) vec_packs(vec_mergeh(multEvenvA, multOddvA),  \
244                                  vec_mergel(multEvenvA, multOddvA)); \
245     dctv = vec_sl(dctv, i_qbitsv);                                   \
246     vec_st(dctv, 0, dct[y]);                                         \
247 }
248
249 #define DEQUANT_SHR()                                          \
250 {                                                              \
251     dctv = vec_ld(0, dct[y]);                                  \
252     dct1v = vec_mergeh(dctv, dctv);                            \
253     dct2v = vec_mergel(dctv, dctv);                            \
254     mf1v = vec_ld(0, dequant_mf[i_mf][y]);                     \
255     mf2v = vec_ld(16, dequant_mf[i_mf][y]);                    \
256                                                                \
257     multEvenvA = vec_mule(dct1v, (vec_s16_t)mf1v);             \
258     multOddvA = vec_mulo(dct1v, (vec_s16_t)mf1v);              \
259     temp1v = vec_add(vec_sl(multEvenvA, sixteenv), multOddvA); \
260     temp1v = vec_add(temp1v, fv);                              \
261     temp1v = vec_sra(temp1v, i_qbitsv);                        \
262                                                                \
263     multEvenvA = vec_mule(dct2v, (vec_s16_t)mf2v);             \
264     multOddvA = vec_mulo(dct2v, (vec_s16_t)mf2v);              \
265     temp2v = vec_add(vec_sl(multEvenvA, sixteenv), multOddvA); \
266     temp2v = vec_add(temp2v, fv);                              \
267     temp2v = vec_sra(temp2v, i_qbitsv);                        \
268                                                                \
269     dctv = (vec_s16_t)vec_packs(temp1v, temp2v);               \
270     vec_st(dctv, 0, dct[y]);                                   \
271 }
272
273 void x264_dequant_4x4_altivec( int16_t dct[4][4], int dequant_mf[6][4][4], int i_qp )
274 {
275     int i_mf = i_qp%6;
276     int i_qbits = i_qp/6 - 4;
277
278     vec_s16_t dctv;
279     vec_s16_t dct1v, dct2v;
280     vec_s32_t mf1v, mf2v;
281     vec_s16_t mfv;
282     vec_s32_t multEvenvA, multOddvA;
283     vec_s32_t temp1v, temp2v;
284
285     if( i_qbits >= 0 )
286     {
287         vec_u16_t i_qbitsv;
288         vec_u16_u qbits_u;
289         qbits_u.s[0]=i_qbits;
290         i_qbitsv = vec_splat(qbits_u.v, 0);
291
292         for( int y = 0; y < 4; y+=2 )
293             DEQUANT_SHL();
294     }
295     else
296     {
297         const int f = 1 << (-i_qbits-1);
298
299         vec_s32_t fv;
300         vec_u32_u f_u;
301         f_u.s[0]=f;
302         fv = (vec_s32_t)vec_splat(f_u.v, 0);
303
304         vec_u32_t i_qbitsv;
305         vec_u32_u qbits_u;
306         qbits_u.s[0]=-i_qbits;
307         i_qbitsv = vec_splat(qbits_u.v, 0);
308
309         vec_u32_t sixteenv;
310         vec_u32_u sixteen_u;
311         sixteen_u.s[0]=16;
312         sixteenv = vec_splat(sixteen_u.v, 0);
313
314         for( int y = 0; y < 4; y+=2 )
315             DEQUANT_SHR();
316     }
317 }
318
319 void x264_dequant_8x8_altivec( int16_t dct[8][8], int dequant_mf[6][8][8], int i_qp )
320 {
321     int i_mf = i_qp%6;
322     int i_qbits = i_qp/6 - 6;
323
324     vec_s16_t dctv;
325     vec_s16_t dct1v, dct2v;
326     vec_s32_t mf1v, mf2v;
327     vec_s16_t mfv;
328     vec_s32_t multEvenvA, multOddvA;
329     vec_s32_t temp1v, temp2v;
330
331     if( i_qbits >= 0 )
332     {
333         vec_u16_t i_qbitsv;
334         vec_u16_u qbits_u;
335         qbits_u.s[0]=i_qbits;
336         i_qbitsv = vec_splat(qbits_u.v, 0);
337
338         for( int y = 0; y < 8; y++ )
339             DEQUANT_SHL();
340     }
341     else
342     {
343         const int f = 1 << (-i_qbits-1);
344
345         vec_s32_t fv;
346         vec_u32_u f_u;
347         f_u.s[0]=f;
348         fv = (vec_s32_t)vec_splat(f_u.v, 0);
349
350         vec_u32_t i_qbitsv;
351         vec_u32_u qbits_u;
352         qbits_u.s[0]=-i_qbits;
353         i_qbitsv = vec_splat(qbits_u.v, 0);
354
355         vec_u32_t sixteenv;
356         vec_u32_u sixteen_u;
357         sixteen_u.s[0]=16;
358         sixteenv = vec_splat(sixteen_u.v, 0);
359
360         for( int y = 0; y < 8; y++ )
361             DEQUANT_SHR();
362     }
363 }
364 #endif // !X264_HIGH_BIT_DEPTH
365