History

Initial Commit

Ethan Hugg committed 12 years ago

Commit 70e5e621 parent bd509b2308 files · +97095 −-5Browse files

Showing the changes to codec/encoder/core/src/encode_mb_aux.cpp (1 of 308 files). Show all

Unified · Split

codec/encoder/core/src/encode_mb_aux.cpp+608−0
@@ -0,0 +1,608 @@
1+/*!
2+ * \copy
3+ * Copyright (c) 2013, Cisco Systems
4+ * All rights reserved.
5+ *
6+ * Redistribution and use in source and binary forms, with or without
7+ * modification, are permitted provided that the following conditions
8+ * are met:
9+ *
10+ * * Redistributions of source code must retain the above copyright
11+ * notice, this list of conditions and the following disclaimer.
12+ *
13+ * * Redistributions in binary form must reproduce the above copyright
14+ * notice, this list of conditions and the following disclaimer in
15+ * the documentation and/or other materials provided with the
16+ * distribution.
17+ *
18+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
19+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
20+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
21+ * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
22+ * COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
23+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
24+ * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
25+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
26+ * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
27+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
28+ * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
29+ * POSSIBILITY OF SUCH DAMAGE.
30+ *
31+ */
32+
33+#include <string.h>
34+
35+#include "macros.h"
36+#include "ls_defines.h"
37+#include "encode_mb_aux.h"
38+#include "cpu_core.h"
39+#include "as264_common.h"
40+#include "svc_encode_mb.h"
41+namespace WelsSVCEnc {
42+
43+__align16( int16_t, g_kiQuantInterFF[58][8] )=
44+{
45+/* 0*/ { 0, 1, 0, 1, 1, 1, 1, 1 },
46+/* 1*/ { 0, 1, 0, 1, 1, 1, 1, 1 },
47+/* 2*/ { 1, 1, 1, 1, 1, 1, 1, 1 },
48+/* 3*/ { 1, 1, 1, 1, 1, 1, 1, 1 },
49+/* 4*/ { 1, 1, 1, 1, 1, 2, 1, 2 },
50+/* 5*/ { 1, 1, 1, 1, 1, 2, 1, 2 },
51+/* 6*/ { 1, 1, 1, 1, 1, 2, 1, 2 },
52+/* 7*/ { 1, 1, 1, 1, 1, 2, 1, 2 },
53+/* 8*/ { 1, 2, 1, 2, 2, 3, 2, 3 },
54+/* 9*/ { 1, 2, 1, 2, 2, 3, 2, 3 },
55+/*10*/ { 1, 2, 1, 2, 2, 3, 2, 3 },
56+/*11*/ { 1, 2, 1, 2, 2, 4, 2, 4 },
57+/*12*/ { 2, 3, 2, 3, 3, 4, 3, 4 },
58+/*13*/ { 2, 3, 2, 3, 3, 5, 3, 5 },
59+/*14*/ { 2, 3, 2, 3, 3, 5, 3, 5 },
60+/*15*/ { 2, 4, 2, 4, 4, 6, 4, 6 },
61+/*16*/ { 3, 4, 3, 4, 4, 7, 4, 7 },
62+/*17*/ { 3, 5, 3, 5, 5, 8, 5, 8 },
63+/*18*/ { 3, 5, 3, 5, 5, 8, 5, 8 },
64+/*19*/ { 4, 6, 4, 6, 6, 9, 6, 9 },
65+/*20*/ { 4, 7, 4, 7, 7, 10, 7, 10 },
66+/*21*/ { 5, 8, 5, 8, 8, 12, 8, 12 },
67+/*22*/ { 5, 8, 5, 8, 8, 13, 8, 13 },
68+/*23*/ { 6, 10, 6, 10, 10, 15, 10, 15 },
69+/*24*/ { 7, 11, 7, 11, 11, 17, 11, 17 },
70+/*25*/ { 7, 12, 7, 12, 12, 19, 12, 19 },
71+/*26*/ { 9, 13, 9, 13, 13, 21, 13, 21 },
72+/*27*/ { 9, 15, 9, 15, 15, 24, 15, 24 },
73+/*28*/ { 11, 17, 11, 17, 17, 26, 17, 26 },
74+/*29*/ { 12, 19, 12, 19, 19, 30, 19, 30 },
75+/*30*/ { 13, 22, 13, 22, 22, 33, 22, 33 },
76+/*31*/ { 15, 23, 15, 23, 23, 38, 23, 38 },
77+/*32*/ { 17, 27, 17, 27, 27, 42, 27, 42 },
78+/*33*/ { 19, 30, 19, 30, 30, 48, 30, 48 },
79+/*34*/ { 21, 33, 21, 33, 33, 52, 33, 52 },
80+/*35*/ { 24, 38, 24, 38, 38, 60, 38, 60 },
81+/*36*/ { 27, 43, 27, 43, 43, 67, 43, 67 },
82+/*37*/ { 29, 47, 29, 47, 47, 75, 47, 75 },
83+/*38*/ { 35, 53, 35, 53, 53, 83, 53, 83 },
84+/*39*/ { 37, 60, 37, 60, 60, 96, 60, 96 },
85+/*40*/ { 43, 67, 43, 67, 67, 104, 67, 104 },
86+/*41*/ { 48, 77, 48, 77, 77, 121, 77, 121 },
87+/*42*/ { 53, 87, 53, 87, 87, 133, 87, 133 },
88+/*43*/ { 59, 93, 59, 93, 93, 150, 93, 150 },
89+/*44*/ { 69, 107, 69, 107, 107, 167, 107, 167 },
90+/*45*/ { 75, 120, 75, 120, 120, 192, 120, 192 },
91+/*46*/ { 85, 133, 85, 133, 133, 208, 133, 208 },
92+/*47*/ { 96, 153, 96, 153, 153, 242, 153, 242 },
93+/*48*/ { 107, 173, 107, 173, 173, 267, 173, 267 },
94+/*49*/ { 117, 187, 117, 187, 187, 300, 187, 300 },
95+/*50*/ { 139, 213, 139, 213, 213, 333, 213, 333 },
96+/*51*/ { 149, 240, 149, 240, 240, 383, 240, 383 },
97+/* from here below is only for intra */
98+/*46*/ { 171, 267, 171, 267, 267, 417, 267, 417 },
99+/*47*/ { 192, 307, 192, 307, 307, 483, 307, 483 },
100+/*48*/ { 213, 347, 213, 347, 347, 533, 347, 533 },
101+/*49*/ { 235, 373, 235, 373, 373, 600, 373, 600 },
102+/*50*/ { 277, 427, 277, 427, 427, 667, 427, 667 },
103+/*51*/ { 299, 480, 299, 480, 480, 767, 480, 767 },
104+};
105+
106+
107+
108+__align16( int16_t, g_kiQuantMF[52][8]) = {
109+/* 0*/ {26214, 16132, 26214, 16132, 16132, 10486, 16132, 10486 },
110+/* 1*/ {23832, 14980, 23832, 14980, 14980, 9320, 14980, 9320 },
111+/* 2*/ {20164, 13108, 20164, 13108, 13108, 8388, 13108, 8388 },
112+/* 3*/ {18724, 11650, 18724, 11650, 11650, 7294, 11650, 7294 },
113+/* 4*/ {16384, 10486, 16384, 10486, 10486, 6710, 10486, 6710 },
114+/* 5*/ {14564, 9118, 14564, 9118, 9118, 5786, 9118, 5786 },
115+/* 6*/ {13107, 8066, 13107, 8066, 8066, 5243, 8066, 5243 },
116+/* 7*/ {11916, 7490, 11916, 7490, 7490, 4660, 7490, 4660 },
117+/* 8*/ {10082, 6554, 10082, 6554, 6554, 4194, 6554, 4194 },
118+/* 9*/ { 9362, 5825, 9362, 5825, 5825, 3647, 5825, 3647 },
119+/*10*/ { 8192, 5243, 8192, 5243, 5243, 3355, 5243, 3355 },
120+/*11*/ { 7282, 4559, 7282, 4559, 4559, 2893, 4559, 2893 },
121+/*12*/ { 6554, 4033, 6554, 4033, 4033, 2622, 4033, 2622 },
122+/*13*/ { 5958, 3745, 5958, 3745, 3745, 2330, 3745, 2330 },
123+/*14*/ { 5041, 3277, 5041, 3277, 3277, 2097, 3277, 2097 },
124+/*15*/ { 4681, 2913, 4681, 2913, 2913, 1824, 2913, 1824 },
125+/*16*/ { 4096, 2622, 4096, 2622, 2622, 1678, 2622, 1678 },
126+/*17*/ { 3641, 2280, 3641, 2280, 2280, 1447, 2280, 1447 },
127+/*18*/ { 3277, 2017, 3277, 2017, 2017, 1311, 2017, 1311 },
128+/*19*/ { 2979, 1873, 2979, 1873, 1873, 1165, 1873, 1165 },
129+/*20*/ { 2521, 1639, 2521, 1639, 1639, 1049, 1639, 1049 },
130+/*21*/ { 2341, 1456, 2341, 1456, 1456, 912, 1456, 912 },
131+/*22*/ { 2048, 1311, 2048, 1311, 1311, 839, 1311, 839 },
132+/*23*/ { 1821, 1140, 1821, 1140, 1140, 723, 1140, 723 },
133+/*24*/ { 1638, 1008, 1638, 1008, 1008, 655, 1008, 655 },
134+/*25*/ { 1490, 936, 1490, 936, 936, 583, 936, 583 },
135+/*26*/ { 1260, 819, 1260, 819, 819, 524, 819, 524 },
136+/*27*/ { 1170, 728, 1170, 728, 728, 456, 728, 456 },
137+/*28*/ { 1024, 655, 1024, 655, 655, 419, 655, 419 },
138+/*29*/ { 910, 570, 910, 570, 570, 362, 570, 362 },
139+/*30*/ { 819, 504, 819, 504, 504, 328, 504, 328 },
140+/*31*/ { 745, 468, 745, 468, 468, 291, 468, 291 },
141+/*32*/ { 630, 410, 630, 410, 410, 262, 410, 262 },
142+/*33*/ { 585, 364, 585, 364, 364, 228, 364, 228 },
143+/*34*/ { 512, 328, 512, 328, 328, 210, 328, 210 },
144+/*35*/ { 455, 285, 455, 285, 285, 181, 285, 181 },
145+/*36*/ { 410, 252, 410, 252, 252, 164, 252, 164 },
146+/*37*/ { 372, 234, 372, 234, 234, 146, 234, 146 },
147+/*38*/ { 315, 205, 315, 205, 205, 131, 205, 131 },
148+/*39*/ { 293, 182, 293, 182, 182, 114, 182, 114 },
149+/*40*/ { 256, 164, 256, 164, 164, 105, 164, 105 },
150+/*41*/ { 228, 142, 228, 142, 142, 90, 142, 90 },
151+/*42*/ { 205, 126, 205, 126, 126, 82, 126, 82 },
152+/*43*/ { 186, 117, 186, 117, 117, 73, 117, 73 },
153+/*44*/ { 158, 102, 158, 102, 102, 66, 102, 66 },
154+/*45*/ { 146, 91, 146, 91, 91, 57, 91, 57 },
155+/*46*/ { 128, 82, 128, 82, 82, 52, 82, 52 },
156+/*47*/ { 114, 71, 114, 71, 71, 45, 71, 45 },
157+/*48*/ { 102, 63, 102, 63, 63, 41, 63, 41 },
158+/*49*/ { 93, 59, 93, 59, 59, 36, 59, 36 },
159+/*50*/ { 79, 51, 79, 51, 51, 33, 51, 33 },
160+/*51*/ { 73, 46, 73, 46, 46, 28, 46, 28 }
161+};
162+
163+/****************************************************************************
164+ * HDM and Quant functions
165+ ****************************************************************************/
166+#define WELS_ABS_LC(a) ((iSign ^ (int32_t)(a)) - iSign)
167+#define NEW_QUANT(pDct, iFF, iMF) (((iFF)+ WELS_ABS_LC(pDct))*(iMF)) >>16
168+#define WELS_NEW_QUANT(pDct,iFF,iMF) WELS_ABS_LC(NEW_QUANT(pDct, iFF, iMF))
169+void WelsQuant4x4_c(int16_t *pDct, int16_t* pFF, int16_t *pMF)
170+{
171+ int32_t i, j, iSign;
172+ for( i = 0; i < 16; i+=4 )
173+ {
174+ j = i & 0x07;
175+ iSign = WELS_SIGN(pDct[i]);
176+ pDct[i] = WELS_NEW_QUANT(pDct[i], pFF[j], pMF[j]);
177+ iSign = WELS_SIGN(pDct[i+1]);
178+ pDct[i+1] = WELS_NEW_QUANT(pDct[i+1], pFF[j+1], pMF[j+1]);
179+ iSign = WELS_SIGN(pDct[i+2]);
180+ pDct[i+2] = WELS_NEW_QUANT(pDct[i+2], pFF[j+2], pMF[j+2]);
181+ iSign = WELS_SIGN(pDct[i+3]);
182+ pDct[i+3] = WELS_NEW_QUANT(pDct[i+3], pFF[j+3], pMF[j+3]);
183+ }
184+}
185+
186+void WelsQuant4x4Dc_c(int16_t *pDct, int16_t iFF, int16_t iMF)
187+{
188+ int32_t i, iSign;
189+ for(i = 0; i < 16; i+=4)
190+ {
191+ iSign = WELS_SIGN(pDct[i]);
192+ pDct[i] = WELS_NEW_QUANT(pDct[i], iFF, iMF);
193+ iSign = WELS_SIGN(pDct[i+1]);
194+ pDct[i+1] = WELS_NEW_QUANT(pDct[i+1], iFF, iMF);
195+ iSign = WELS_SIGN(pDct[i+2]);
196+ pDct[i+2] = WELS_NEW_QUANT(pDct[i+2], iFF, iMF);
197+ iSign = WELS_SIGN(pDct[i+3]);
198+ pDct[i+3] = WELS_NEW_QUANT(pDct[i+3], iFF, iMF);
199+ }
200+}
201+
202+void WelsQuantFour4x4_c(int16_t *pDct, int16_t* pFF, int16_t *pMF)
203+{
204+ int32_t i, j, iSign;
205+
206+ for( i = 0; i < 64; i+=4 )
207+ {
208+ j = i & 0x07;
209+ iSign = WELS_SIGN(pDct[i]);
210+ pDct[i] = WELS_NEW_QUANT(pDct[i], pFF[j], pMF[j]);
211+ iSign = WELS_SIGN(pDct[i+1]);
212+ pDct[i+1] = WELS_NEW_QUANT(pDct[i+1], pFF[j+1], pMF[j+1]);
213+ iSign = WELS_SIGN(pDct[i+2]);
214+ pDct[i+2] = WELS_NEW_QUANT(pDct[i+2], pFF[j+2], pMF[j+2]);
215+ iSign = WELS_SIGN(pDct[i+3]);
216+ pDct[i+3] = WELS_NEW_QUANT(pDct[i+3], pFF[j+3], pMF[j+3]);
217+ }
218+}
219+
220+void WelsQuantFour4x4Max_c(int16_t *pDct, int16_t* pFF, int16_t *pMF, int16_t *pMax)
221+{
222+ int32_t i, j, k, iSign;
223+ int16_t iMaxAbs;
224+ for( k = 0; k < 4; k++)
225+ {
226+ iMaxAbs = 0;
227+ for( i = 0; i < 16; i++ )
228+ {
229+ j = i & 0x07;
230+ iSign = WELS_SIGN(pDct[i]);
231+ pDct[i] = NEW_QUANT(pDct[i], pFF[j], pMF[j]);
232+ if( iMaxAbs < pDct[i]) iMaxAbs = pDct[i];
233+ pDct[i] = WELS_ABS_LC(pDct[i]);
234+ }
235+ pDct += 16;
236+ pMax[k] = iMaxAbs;
237+ }
238+}
239+
240+int32_t WelsHadamardQuant2x2Skip_c(int16_t *pRs, int16_t iFF, int16_t iMF)
241+{
242+ int16_t pDct[4], s[4];
243+ int16_t iThreshold = ((1<<16)-1)/iMF - iFF;
244+
245+ s[0] = pRs[0] + pRs[32];
246+ s[1] = pRs[0] - pRs[32];
247+ s[2] = pRs[16] + pRs[48];
248+ s[3] = pRs[16] - pRs[48];
249+
250+ pDct[0] = s[0] + s[2];
251+ pDct[1] = s[0] - s[2];
252+ pDct[2] = s[1] + s[3];
253+ pDct[3] = s[1] - s[3];
254+
255+ return ((WELS_ABS(pDct[0]) > iThreshold) || (WELS_ABS(pDct[1]) > iThreshold) || (WELS_ABS(pDct[2]) > iThreshold) || (WELS_ABS(pDct[3]) > iThreshold));
256+}
257+
258+int32_t WelsHadamardQuant2x2_c(int16_t *pRs, const int16_t iFF, int16_t iMF, int16_t * pDct, int16_t * pBlock)
259+{
260+ int16_t s[4];
261+ int32_t iSign, i, iDcNzc = 0;
262+
263+ s[0] = pRs[0] + pRs[32];
264+ s[1] = pRs[0] - pRs[32];
265+ s[2] = pRs[16] + pRs[48];
266+ s[3] = pRs[16] - pRs[48];
267+
268+ pRs[0] = 0;
269+ pRs[16] = 0;
270+ pRs[32] = 0;
271+ pRs[48] = 0;
272+
273+ pDct[0] = s[0] + s[2];
274+ pDct[1] = s[0] - s[2];
275+ pDct[2] = s[1] + s[3];
276+ pDct[3] = s[1] - s[3];
277+
278+ iSign = WELS_SIGN(pDct[0]);
279+ pDct[0] = WELS_NEW_QUANT(pDct[0], iFF, iMF);
280+ iSign = WELS_SIGN(pDct[1]);
281+ pDct[1] = WELS_NEW_QUANT(pDct[1], iFF, iMF);
282+ iSign = WELS_SIGN(pDct[2]);
283+ pDct[2] = WELS_NEW_QUANT(pDct[2], iFF, iMF);
284+ iSign = WELS_SIGN(pDct[3]);
285+ pDct[3] = WELS_NEW_QUANT(pDct[3], iFF, iMF);
286+
287+ ST64( pBlock, LD64(pDct) );
288+
289+ for(i=0; i<4; i++)
290+ iDcNzc += (pBlock[i] != 0);
291+ return iDcNzc;
292+}
293+
294+/* dc value pick up and hdm_4x4 */
295+void WelsHadamardT4Dc_c( int16_t *pLumaDc, int16_t *pDct)
296+{
297+ int32_t p[16], s[4];
298+ int32_t i, iIdx;
299+
300+ for(i = 0 ; i < 16 ; i +=4)
301+ {
302+ iIdx = ((i&0x08) << 4) +((i&0x04) << 3);
303+ s[0] = pDct[iIdx ] + pDct[iIdx+80];
304+ s[3] = pDct[iIdx ] - pDct[iIdx+80];
305+ s[1] = pDct[iIdx+16] + pDct[iIdx+64];
306+ s[2] = pDct[iIdx+16] - pDct[iIdx+64];
307+
308+ p[i ] = s[0] + s[1];
309+ p[i+2] = s[0] - s[1];
310+ p[i+1] = s[3] + s[2];
311+ p[i+3] = s[3] - s[2];
312+ }
313+
314+ for(i = 0 ; i < 4 ; i ++)
315+ {
316+ s[0] = p[i ] + p[i+12];
317+ s[3] = p[i ] - p[i+12];
318+ s[1] = p[i+4] + p[i+ 8];
319+ s[2] = p[i+4] - p[i+ 8];
320+
321+ pLumaDc[i ] = WELS_CLIP3((s[0] + s[1] + 1) >> 1, -32768, 32767);
322+ pLumaDc[i+8 ] = WELS_CLIP3((s[0] - s[1] + 1) >> 1, -32768, 32767);
323+ pLumaDc[i+4 ] = WELS_CLIP3((s[3] + s[2] + 1) >> 1, -32768, 32767);
324+ pLumaDc[i+12] = WELS_CLIP3((s[3] - s[2] + 1) >> 1, -32768, 32767);
325+ }
326+}
327+
328+/****************************************************************************
329+ * DCT functions
330+ ****************************************************************************/
331+void WelsDctT4_c( int16_t *pDct, uint8_t *pPixel1, int32_t iStride1, uint8_t *pPixel2, int32_t iStride2 )
332+{
333+ int16_t i, pData[16], s[4];
334+ for(i = 0 ; i < 16 ; i +=4)
335+ {
336+ const int32_t kiI1= 1 + i;
337+ const int32_t kiI2= 2 + i;
338+ const int32_t kiI3= 3 + i;
339+
340+ pData[i ] = pPixel1[0] - pPixel2[0];
341+ pData[kiI1] = pPixel1[1] - pPixel2[1];
342+ pData[kiI2] = pPixel1[2] - pPixel2[2];
343+ pData[kiI3] = pPixel1[3] - pPixel2[3];
344+
345+ pPixel1 += iStride1;
346+ pPixel2 += iStride2;
347+
348+ /*horizontal transform */
349+ s[0] = pData[i] + pData[kiI3];
350+ s[3] = pData[i] - pData[kiI3];
351+ s[1] = pData[kiI1] + pData[kiI2];
352+ s[2] = pData[kiI1] - pData[kiI2];
353+
354+ pDct[i ] = s[0] + s[1];
355+ pDct[kiI2] = s[0] - s[1];
356+ pDct[kiI1] = (s[3] << 1) + s[2];
357+ pDct[kiI3] = s[3] - (s[2] << 1);
358+ }
359+
360+ /* vertical transform */
361+ for(i = 0 ; i < 4 ; i ++)
362+ {
363+ const int32_t kiI4 = 4 + i;
364+ const int32_t kiI8 = 8 + i;
365+ const int32_t kiI12 = 12 + i;
366+
367+ s[0] = pDct[i ] + pDct[kiI12];
368+ s[3] = pDct[i ] - pDct[kiI12];
369+ s[1] = pDct[kiI4] + pDct[kiI8 ];
370+ s[2] = pDct[kiI4] - pDct[kiI8 ];
371+
372+ pDct[i ] = s[0] + s[1];
373+ pDct[kiI8 ] = s[0] - s[1];
374+ pDct[kiI4 ] = (s[3] << 1) + s[2];
375+ pDct[kiI12] = s[3] - (s[2] << 1);
376+ }
377+}
378+
379+void WelsDctFourT4_c(int16_t *pDct, uint8_t *pPixel1, int32_t iStride1, uint8_t *pPixel2, int32_t iStride2 )
380+{
381+ int32_t stride_1 = iStride1 << 2;
382+ int32_t stride_2 = iStride2 << 2;
383+
384+ WelsDctT4_c( pDct, &pPixel1[0], iStride1, &pPixel2[0], iStride2 );
385+ WelsDctT4_c( pDct + 16, &pPixel1[4], iStride1, &pPixel2[4], iStride2 );
386+ WelsDctT4_c( pDct + 32, &pPixel1[stride_1 ], iStride1, &pPixel2[stride_2 ], iStride2 );
387+ WelsDctT4_c( pDct + 48, &pPixel1[stride_1+4], iStride1, &pPixel2[stride_2+4], iStride2 );
388+}
389+
390+/****************************************************************************
391+ * Scan and Score functions
392+ ****************************************************************************/
393+void WelsScan4x4DcAc_c( int16_t* pLevel, int16_t *pDct )
394+{
395+ ST32( pLevel, LD32(pDct) );
396+ pLevel[2] = pDct[4];
397+ pLevel[3] = pDct[8];
398+ pLevel[4] = pDct[5];
399+ ST32( pLevel+5, LD32(pDct+2) );
400+ pLevel[7] = pDct[6];
401+ pLevel[8] = pDct[9];
402+ ST32( pLevel+9, LD32(pDct+12) );
403+ pLevel[11] = pDct[10];
404+ pLevel[12] = pDct[7];
405+ pLevel[13] = pDct[11];
406+ ST32( pLevel+14, LD32(pDct+14) );
407+}
408+
409+void WelsScan4x4Ac_c( int16_t* pLevel, int16_t* pDct )
410+{
411+ pLevel[0] = pDct[1];
412+ pLevel[1] = pDct[4];
413+ pLevel[2] = pDct[8];
414+ pLevel[3] = pDct[5];
415+ ST32( &pLevel[4], LD32(&pDct[2]) );
416+ pLevel[6] = pDct[6];
417+ pLevel[7] = pDct[9];
418+ ST32( &pLevel[8], LD32(&pDct[12]) );
419+ pLevel[10] = pDct[10];
420+ pLevel[11] = pDct[7];
421+ pLevel[12] = pDct[11];
422+ ST32( &pLevel[13], LD32(&pDct[14]) );
423+ pLevel[15] = 0;
424+}
425+
426+void WelsScan4x4Dc( int16_t* pLevel, int16_t* pDct )
427+{
428+ ST32( pLevel, LD32(pDct) );
429+ pLevel[2] = pDct[4];
430+ pLevel[3] = pDct[8];
431+ pLevel[4] = pDct[5];
432+ ST32( pLevel+5, LD32(pDct+2) );
433+ pLevel[7] = pDct[6];
434+ pLevel[8] = pDct[9];
435+ ST32( pLevel+9, LD32(pDct+12) );
436+ pLevel[11] = pDct[10];
437+ pLevel[12] = pDct[7];
438+ pLevel[13] = pDct[11];
439+ ST32( pLevel+14, LD32(pDct+14) );
440+}
441+
442+//refer to JVT-O079
443+int32_t WelsCalculateSingleCtr4x4_c( int16_t *pDct)
444+{
445+ static const int32_t kiTRunTable[16] = { 3, 2, 2, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
446+
447+ int32_t iSingleCtr = 0;
448+ int32_t iIdx = 15;
449+ int32_t iRun;
450+
451+ while( iIdx >= 0 && pDct[iIdx] == 0 ) --iIdx;
452+
453+ while( iIdx >= 0 )
454+ {
455+ -- iIdx;
456+ iRun = iIdx;
457+ while( iIdx >= 0 && pDct[iIdx] == 0 ) --iIdx;
458+ iRun -= iIdx;
459+ iSingleCtr += kiTRunTable[iRun];
460+ }
461+ return iSingleCtr;
462+}
463+
464+/****************************************************************************
465+ * Copy functions
466+ ****************************************************************************/
467+void WelsCopy4x4( uint8_t* pDst, int32_t iStrideD, uint8_t* pSrc, int32_t iStrideS )
468+{
469+ const int32_t kiSrcStride2 = iStrideS << 1;
470+ const int32_t kiSrcStride3 = iStrideS + kiSrcStride2;
471+ const int32_t kiDstStride2 = iStrideD << 1;
472+ const int32_t kiDstStride3 = iStrideD + kiDstStride2;
473+
474+ ST32( pDst, LD32(pSrc) );
475+ ST32( pDst+iStrideD, LD32(pSrc+iStrideS) );
476+ ST32( pDst+kiDstStride2, LD32(pSrc+kiSrcStride2) );
477+ ST32( pDst+kiDstStride3, LD32(pSrc+kiSrcStride3) );
478+}
479+void WelsCopy8x8_c( uint8_t* pDst, int32_t iStrideD, uint8_t* pSrc, int32_t iStrideS )
480+{
481+ int32_t i;
482+ for( i = 0; i < 4; i++)
483+ {
484+ ST32( pDst, LD32(pSrc )); ST32( pDst + 4 , LD32(pSrc + 4 ));
485+ ST32( pDst + iStrideD, LD32(pSrc + iStrideS)); ST32( pDst + iStrideD + 4 , LD32(pSrc + iStrideS + 4));
486+ pDst += iStrideD << 1;
487+ pSrc += iStrideS << 1;
488+ }
489+}
490+void WelsCopy8x16_c( uint8_t* pDst, int32_t iStrideD, uint8_t* pSrc, int32_t iStrideS )
491+{
492+ int32_t i;
493+ for( i = 0; i < 8; ++i )
494+ {
495+ ST32( pDst, LD32(pSrc )); ST32( pDst + 4 , LD32(pSrc + 4 ));
496+ ST32( pDst + iStrideD, LD32(pSrc + iStrideS)); ST32( pDst + iStrideD + 4 , LD32(pSrc + iStrideS + 4));
497+ pDst += iStrideD << 1;
498+ pSrc += iStrideS << 1;
499+ }
500+}
501+void WelsCopy16x8_c( uint8_t* pDst, int32_t iStrideD, uint8_t* pSrc, int32_t iStrideS )
502+{
503+ int32_t i;
504+ for( i = 0; i < 8; i++)
505+ {
506+ ST32( pDst, LD32(pSrc )); ST32( pDst + 4 , LD32(pSrc + 4 ));
507+ ST32( pDst + 8 ,LD32(pSrc + 8 )); ST32( pDst + 12 , LD32(pSrc + 12));
508+ pDst += iStrideD ;
509+ pSrc += iStrideS;
510+ }
511+}
512+void WelsCopy16x16_c( uint8_t* pDst, int32_t iStrideD, uint8_t* pSrc, int32_t iStrideS )
513+{
514+ int32_t i;
515+ for( i = 0; i < 16; i++)
516+ {
517+ ST32( pDst, LD32(pSrc )); ST32( pDst + 4 , LD32(pSrc + 4 ));
518+ ST32( pDst + 8 ,LD32(pSrc + 8 )); ST32( pDst + 12 , LD32(pSrc + 12));
519+ pDst += iStrideD ;
520+ pSrc += iStrideS;
521+ }
522+}
523+
524+int32_t WelsGetNoneZeroCount_c(int16_t * pLevel)
525+{
526+ int32_t iCnt = 0;
527+ int32_t iIdx = 0;
528+
529+ while (iIdx < 16) {
530+ iCnt += (pLevel[ iIdx] == 0);
531+ iCnt += (pLevel[1+iIdx] == 0);
532+ iCnt += (pLevel[2+iIdx] == 0);
533+ iCnt += (pLevel[3+iIdx] == 0);
534+
535+ iIdx += 4;
536+ }
537+ return (16 - iCnt);
538+}
539+
540+void WelsInitEncodingFuncs( SWelsFuncPtrList *pFuncList, uint32_t uiCpuFlag )
541+{
542+ pFuncList->pfCopy8x8Aligned = WelsCopy8x8_c;
543+ pFuncList->pfCopy16x16Aligned =
544+ pFuncList->pfCopy16x16NotAligned = WelsCopy16x16_c;
545+ pFuncList->pfCopy16x8NotAligned = WelsCopy16x8_c;
546+ pFuncList->pfCopy8x16Aligned = WelsCopy8x16_c;
547+
548+ pFuncList->pfQuantizationHadamard2x2 = WelsHadamardQuant2x2_c;
549+ pFuncList->pfQuantizationHadamard2x2Skip = WelsHadamardQuant2x2Skip_c;
550+ pFuncList->pfTransformHadamard4x4Dc = WelsHadamardT4Dc_c;
551+
552+ pFuncList->pfDctT4 = WelsDctT4_c;
553+ pFuncList->pfDctFourT4 = WelsDctFourT4_c;
554+
555+ pFuncList->pfScan4x4 = WelsScan4x4DcAc_c;
556+ pFuncList->pfScan4x4Ac = WelsScan4x4Ac_c;
557+ pFuncList->pfCalculateSingleCtr4x4 = WelsCalculateSingleCtr4x4_c;
558+
559+ pFuncList->pfGetNoneZeroCount = WelsGetNoneZeroCount_c;
560+
561+ pFuncList->pfQuantization4x4 = WelsQuant4x4_c;
562+ pFuncList->pfQuantizationDc4x4 = WelsQuant4x4Dc_c;
563+ pFuncList->pfQuantizationFour4x4 = WelsQuantFour4x4_c;
564+ pFuncList->pfQuantizationFour4x4Max = WelsQuantFour4x4Max_c;
565+
566+#if defined(X86_ASM)
567+ if ( uiCpuFlag & WELS_CPU_MMXEXT )
568+ {
569+
570+ pFuncList->pfQuantizationHadamard2x2 = WelsHadamardQuant2x2_mmx;
571+ pFuncList->pfQuantizationHadamard2x2Skip = WelsHadamardQuant2x2Skip_mmx;
572+
573+ pFuncList->pfDctT4 = WelsDctT4_mmx;
574+
575+ pFuncList->pfCopy8x8Aligned = WelsCopy8x8_mmx;
576+ pFuncList->pfCopy8x16Aligned = WelsCopy8x16_mmx;
577+ }
578+ if ( uiCpuFlag & WELS_CPU_SSE2 )
579+ {
580+ pFuncList->pfGetNoneZeroCount = WelsGetNoneZeroCount_sse2;
581+ pFuncList->pfTransformHadamard4x4Dc = WelsHadamardT4Dc_sse2;
582+
583+ pFuncList->pfQuantization4x4 = WelsQuant4x4_sse2;
584+ pFuncList->pfQuantizationDc4x4 = WelsQuant4x4Dc_sse2;
585+ pFuncList->pfQuantizationFour4x4 = WelsQuantFour4x4_sse2;
586+ pFuncList->pfQuantizationFour4x4Max = WelsQuantFour4x4Max_sse2;
587+
588+ pFuncList->pfCopy16x16Aligned = WelsCopy16x16_sse2;
589+ pFuncList->pfCopy16x16NotAligned = WelsCopy16x16NotAligned_sse2;
590+ pFuncList->pfCopy16x8NotAligned = WelsCopy16x8NotAligned_sse2;
591+
592+ pFuncList->pfScan4x4 = WelsScan4x4DcAc_sse2;
593+ pFuncList->pfScan4x4Ac = WelsScan4x4Ac_sse2;
594+ pFuncList->pfCalculateSingleCtr4x4 = WelsCalculateSingleCtr4x4_sse2;
595+
596+ pFuncList->pfDctFourT4 = WelsDctFourT4_sse2;
597+ }
598+//#ifndef MACOS
599+ if ( uiCpuFlag & WELS_CPU_SSSE3 )
600+ {
601+ pFuncList->pfScan4x4 = WelsScan4x4DcAc_ssse3;
602+ }
603+
604+//#endif//MACOS
605+
606+#endif//X86_ASM
607+}
608+}

Keyboard shortcuts

General

Show keyboard shortcuts
?
Focus the current search
/

Issues and pull requests

Open filters
f

Issues, pull requests and Inbox

Select next item
j↓
Select previous item
k↑
Open selected item
Enter
Dismiss filters or clear selection
Esc

Repository code

Go to file
t