History

Pretty printed the C++ code with astyle

Ethan Hugg committed 12 years ago

Commit ff6b6691 parent 063709c225 files · +48457 −51954Browse files

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

Unified · Split

codec/encoder/core/src/sample.cpp+489−531
@@ -1,531 +1,489 @@
1/*!1/*!
2 * \copy2 * \copy
3 * Copyright (c) 2009-2013, Cisco Systems3 * Copyright (c) 2009-2013, Cisco Systems
4 * All rights reserved.4 * All rights reserved.
5 *5 *
6 * Redistribution and use in source and binary forms, with or without6 * Redistribution and use in source and binary forms, with or without
7 * modification, are permitted provided that the following conditions7 * modification, are permitted provided that the following conditions
8 * are met:8 * are met:
9 *9 *
10 * * Redistributions of source code must retain the above copyright10 * * Redistributions of source code must retain the above copyright
11 * notice, this list of conditions and the following disclaimer.11 * notice, this list of conditions and the following disclaimer.
12 *12 *
13 * * Redistributions in binary form must reproduce the above copyright13 * * Redistributions in binary form must reproduce the above copyright
14 * notice, this list of conditions and the following disclaimer in14 * notice, this list of conditions and the following disclaimer in
15 * the documentation and/or other materials provided with the15 * the documentation and/or other materials provided with the
16 * distribution.16 * distribution.
17 *17 *
18 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS18 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
19 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT19 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
20 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS20 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
21 * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE21 * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
22 * COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,22 * COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
23 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,23 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
24 * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;24 * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
25 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER25 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
26 * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT26 * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
27 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN27 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
28 * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE28 * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
29 * POSSIBILITY OF SUCH DAMAGE.29 * POSSIBILITY OF SUCH DAMAGE.
30 *30 *
31 *31 *
32 * \file sample.c32 * \file sample.c
33 *33 *
34 * \brief compute SAD and SATD34 * \brief compute SAD and SATD
35 *35 *
36 * \date 2009.06.02 Created36 * \date 2009.06.02 Created
37 *37 *
38 *************************************************************************************38 *************************************************************************************
39 */39 */
40 40
41#include "sample.h"41#include "sample.h"
42#include "macros.h"42#include "macros.h"
43 43
44#include "mc.h"44#include "mc.h"
45#include "cpu_core.h"45#include "cpu_core.h"
46#include "array_stack_align.h"46#include "array_stack_align.h"
47 47
48namespace WelsSVCEnc {48namespace WelsSVCEnc {
49int32_t WelsSampleSad4x4_c( uint8_t* pSample1, int32_t iStride1, uint8_t* pSample2, int32_t iStride2 )49int32_t WelsSampleSad4x4_c (uint8_t* pSample1, int32_t iStride1, uint8_t* pSample2, int32_t iStride2) {
50{50 int32_t iSadSum = 0;
51 int32_t iSadSum = 0;51 int32_t i = 0;
52 int32_t i = 0;52 uint8_t* pSrc1 = pSample1;
53 uint8_t* pSrc1 = pSample1;53 uint8_t* pSrc2 = pSample2;
54 uint8_t* pSrc2 = pSample2;54 for (i = 0; i < 4; i++) {
55 for ( i = 0; i < 4; i++ )55 iSadSum += WELS_ABS ((pSrc1[0] - pSrc2[0]));
56 {56 iSadSum += WELS_ABS ((pSrc1[1] - pSrc2[1]));
57 iSadSum += WELS_ABS( ( pSrc1[0] - pSrc2[0] ) );57 iSadSum += WELS_ABS ((pSrc1[2] - pSrc2[2]));
58 iSadSum += WELS_ABS( ( pSrc1[1] - pSrc2[1] ) );58 iSadSum += WELS_ABS ((pSrc1[3] - pSrc2[3]));
59 iSadSum += WELS_ABS( ( pSrc1[2] - pSrc2[2] ) );59
60 iSadSum += WELS_ABS( ( pSrc1[3] - pSrc2[3] ) );60 pSrc1 += iStride1;
61 61 pSrc2 += iStride2;
62 pSrc1 += iStride1;62 }
63 pSrc2 += iStride2;63
64 }64 return iSadSum;
65 65}
66 return iSadSum;66
67} 67int32_t WelsSampleSad8x8_c (uint8_t* pSample1, int32_t iStride1, uint8_t* pSample2, int32_t iStride2) {
68 68 int32_t iSadSum = 0;
69int32_t WelsSampleSad8x8_c( uint8_t* pSample1, int32_t iStride1, uint8_t* pSample2, int32_t iStride2 )69 int32_t i = 0;
70{70 uint8_t* pSrc1 = pSample1;
71 int32_t iSadSum = 0;71 uint8_t* pSrc2 = pSample2;
72 int32_t i = 0;72 for (i = 0; i < 8; i++) {
73 uint8_t* pSrc1 = pSample1;73 iSadSum += WELS_ABS ((pSrc1[0] - pSrc2[0]));
74 uint8_t* pSrc2 = pSample2;74 iSadSum += WELS_ABS ((pSrc1[1] - pSrc2[1]));
75 for ( i = 0; i < 8; i++ )75 iSadSum += WELS_ABS ((pSrc1[2] - pSrc2[2]));
76 {76 iSadSum += WELS_ABS ((pSrc1[3] - pSrc2[3]));
77 iSadSum += WELS_ABS( ( pSrc1[0] - pSrc2[0] ) );77 iSadSum += WELS_ABS ((pSrc1[4] - pSrc2[4]));
78 iSadSum += WELS_ABS( ( pSrc1[1] - pSrc2[1] ) );78 iSadSum += WELS_ABS ((pSrc1[5] - pSrc2[5]));
79 iSadSum += WELS_ABS( ( pSrc1[2] - pSrc2[2] ) );79 iSadSum += WELS_ABS ((pSrc1[6] - pSrc2[6]));
80 iSadSum += WELS_ABS( ( pSrc1[3] - pSrc2[3] ) );80 iSadSum += WELS_ABS ((pSrc1[7] - pSrc2[7]));
81 iSadSum += WELS_ABS( ( pSrc1[4] - pSrc2[4] ) );81
82 iSadSum += WELS_ABS( ( pSrc1[5] - pSrc2[5] ) );82 pSrc1 += iStride1;
83 iSadSum += WELS_ABS( ( pSrc1[6] - pSrc2[6] ) );83 pSrc2 += iStride2;
84 iSadSum += WELS_ABS( ( pSrc1[7] - pSrc2[7] ) );84 }
85 85
86 pSrc1 += iStride1;86 return iSadSum;
87 pSrc2 += iStride2;87}
88 }88int32_t WelsSampleSad16x8_c (uint8_t* pSample1, int32_t iStride1, uint8_t* pSample2, int32_t iStride2) {
89 89 int32_t iSadSum = 0;
90 return iSadSum;90
91} 91 iSadSum += WelsSampleSad8x8_c (pSample1, iStride1, pSample2, iStride2);
92int32_t WelsSampleSad16x8_c( uint8_t* pSample1, int32_t iStride1, uint8_t* pSample2, int32_t iStride2 )92 iSadSum += WelsSampleSad8x8_c (pSample1 + 8, iStride1, pSample2 + 8, iStride2);
93{93
94 int32_t iSadSum = 0;94 return iSadSum;
95 95}
96 iSadSum += WelsSampleSad8x8_c( pSample1, iStride1, pSample2, iStride2 );96int32_t WelsSampleSad8x16_c (uint8_t* pSample1, int32_t iStride1, uint8_t* pSample2, int32_t iStride2) {
97 iSadSum += WelsSampleSad8x8_c( pSample1 + 8, iStride1, pSample2 + 8, iStride2 );97 int32_t iSadSum = 0;
98 98 iSadSum += WelsSampleSad8x8_c (pSample1, iStride1, pSample2, iStride2);
99 return iSadSum;99 iSadSum += WelsSampleSad8x8_c (pSample1 + (iStride1 << 3), iStride1, pSample2 + (iStride2 << 3), iStride2);
100} 100
101int32_t WelsSampleSad8x16_c( uint8_t* pSample1, int32_t iStride1, uint8_t* pSample2, int32_t iStride2 )101 return iSadSum;
102{102}
103 int32_t iSadSum = 0;103int32_t WelsSampleSad16x16_c (uint8_t* pSample1, int32_t iStride1, uint8_t* pSample2, int32_t iStride2) {
104 iSadSum += WelsSampleSad8x8_c( pSample1, iStride1, pSample2, iStride2 );104 int32_t iSadSum = 0;
105 iSadSum += WelsSampleSad8x8_c( pSample1+(iStride1<<3), iStride1, pSample2+(iStride2<<3), iStride2 );105 iSadSum += WelsSampleSad8x8_c (pSample1, iStride1, pSample2, iStride2);
106 106 iSadSum += WelsSampleSad8x8_c (pSample1 + 8, iStride1, pSample2 + 8, iStride2);
107 return iSadSum;107 iSadSum += WelsSampleSad8x8_c (pSample1 + (iStride1 << 3), iStride1, pSample2 + (iStride2 << 3), iStride2);
108} 108 iSadSum += WelsSampleSad8x8_c (pSample1 + (iStride1 << 3) + 8, iStride1, pSample2 + (iStride2 << 3) + 8, iStride2);
109int32_t WelsSampleSad16x16_c( uint8_t* pSample1, int32_t iStride1, uint8_t* pSample2, int32_t iStride2 )109
110{110 return iSadSum;
111 int32_t iSadSum = 0;111}
112 iSadSum += WelsSampleSad8x8_c( pSample1, iStride1, pSample2, iStride2 );112
113 iSadSum += WelsSampleSad8x8_c( pSample1+8, iStride1, pSample2+8, iStride2 );113int32_t WelsSampleSatd4x4_c (uint8_t* pSample1, int32_t iStride1, uint8_t* pSample2, int32_t iStride2) {
114 iSadSum += WelsSampleSad8x8_c( pSample1+(iStride1<<3), iStride1, pSample2+(iStride2<<3), iStride2 );114 int32_t iSatdSum = 0;
115 iSadSum += WelsSampleSad8x8_c( pSample1+(iStride1<<3)+8, iStride1, pSample2+(iStride2<<3)+8, iStride2 );115 int32_t pSampleMix[4][4] = { 0 };
116 116 int32_t iSample0, iSample1, iSample2, iSample3;
117 return iSadSum;117 int32_t i = 0;
118} 118 uint8_t* pSrc1 = pSample1;
119 119 uint8_t* pSrc2 = pSample2;
120int32_t WelsSampleSatd4x4_c( uint8_t* pSample1, int32_t iStride1, uint8_t* pSample2, int32_t iStride2 )120
121{121 //step 1: get the difference
122 int32_t iSatdSum = 0;122 for (i = 0; i < 4; i++) {
123 int32_t pSampleMix[4][4] = { 0 };123 pSampleMix[i][0] = pSrc1[0] - pSrc2[0];
124 int32_t iSample0, iSample1, iSample2, iSample3;124 pSampleMix[i][1] = pSrc1[1] - pSrc2[1];
125 int32_t i = 0;125 pSampleMix[i][2] = pSrc1[2] - pSrc2[2];
126 uint8_t* pSrc1 = pSample1;126 pSampleMix[i][3] = pSrc1[3] - pSrc2[3];
127 uint8_t* pSrc2 = pSample2;127
128 128 pSrc1 += iStride1;
129 //step 1: get the difference129 pSrc2 += iStride2;
130 for( i = 0; i < 4; i++ )130 }
131 {131
132 pSampleMix[i][0] = pSrc1[0] - pSrc2[0];132 //step 2: horizontal transform
133 pSampleMix[i][1] = pSrc1[1] - pSrc2[1];133 for (i = 0; i < 4; i++) {
134 pSampleMix[i][2] = pSrc1[2] - pSrc2[2];134 iSample0 = pSampleMix[i][0] + pSampleMix[i][2];
135 pSampleMix[i][3] = pSrc1[3] - pSrc2[3];135 iSample1 = pSampleMix[i][1] + pSampleMix[i][3];
136 136 iSample2 = pSampleMix[i][0] - pSampleMix[i][2];
137 pSrc1 += iStride1;137 iSample3 = pSampleMix[i][1] - pSampleMix[i][3];
138 pSrc2 += iStride2;138
139 }139 pSampleMix[i][0] = iSample0 + iSample1;
140 140 pSampleMix[i][1] = iSample2 + iSample3;
141 //step 2: horizontal transform141 pSampleMix[i][2] = iSample2 - iSample3;
142 for ( i = 0; i < 4; i++ )142 pSampleMix[i][3] = iSample0 - iSample1;
143 {143 }
144 iSample0 = pSampleMix[i][0] + pSampleMix[i][2];144
145 iSample1 = pSampleMix[i][1] + pSampleMix[i][3];145 //step 3: vertical transform and get the sum of SATD
146 iSample2 = pSampleMix[i][0] - pSampleMix[i][2];146 for (i = 0; i < 4; i++) {
147 iSample3 = pSampleMix[i][1] - pSampleMix[i][3];147 iSample0 = pSampleMix[0][i] + pSampleMix[2][i];
148 148 iSample1 = pSampleMix[1][i] + pSampleMix[3][i];
149 pSampleMix[i][0] = iSample0 + iSample1; 149 iSample2 = pSampleMix[0][i] - pSampleMix[2][i];
150 pSampleMix[i][1] = iSample2 + iSample3;150 iSample3 = pSampleMix[1][i] - pSampleMix[3][i];
151 pSampleMix[i][2] = iSample2 - iSample3;151
152 pSampleMix[i][3] = iSample0 - iSample1;152 pSampleMix[0][i] = iSample0 + iSample1;
153 }153 pSampleMix[1][i] = iSample2 + iSample3;
154 154 pSampleMix[2][i] = iSample2 - iSample3;
155 //step 3: vertical transform and get the sum of SATD155 pSampleMix[3][i] = iSample0 - iSample1;
156 for ( i = 0; i < 4; i++ )156
157 {157 iSatdSum += (WELS_ABS (pSampleMix[0][i]) + WELS_ABS (pSampleMix[1][i]) + WELS_ABS (pSampleMix[2][i]) + WELS_ABS (
158 iSample0 = pSampleMix[0][i] + pSampleMix[2][i];158 pSampleMix[3][i]));
159 iSample1 = pSampleMix[1][i] + pSampleMix[3][i];159 }
160 iSample2 = pSampleMix[0][i] - pSampleMix[2][i];160
161 iSample3 = pSampleMix[1][i] - pSampleMix[3][i];161 return ((iSatdSum + 1) >> 1);
162 162}
163 pSampleMix[0][i] = iSample0 + iSample1; 163int32_t WelsSampleSatd8x8_c (uint8_t* pSample1, int32_t iStride1, uint8_t* pSample2, int32_t iStride2) {
164 pSampleMix[1][i] = iSample2 + iSample3;164 int32_t iSatdSum = 0;
165 pSampleMix[2][i] = iSample2 - iSample3;165
166 pSampleMix[3][i] = iSample0 - iSample1;166 iSatdSum += WelsSampleSatd4x4_c (pSample1, iStride1, pSample2, iStride2);
167 167 iSatdSum += WelsSampleSatd4x4_c (pSample1 + 4, iStride1, pSample2 + 4, iStride2);
168 iSatdSum += ( WELS_ABS( pSampleMix[0][i] ) + WELS_ABS( pSampleMix[1][i] ) + WELS_ABS( pSampleMix[2][i] ) + WELS_ABS( pSampleMix[3][i] ) );168 iSatdSum += WelsSampleSatd4x4_c (pSample1 + (iStride1 << 2), iStride1, pSample2 + (iStride2 << 2), iStride2);
169 }169 iSatdSum += WelsSampleSatd4x4_c (pSample1 + (iStride1 << 2) + 4, iStride1, pSample2 + (iStride2 << 2) + 4, iStride2);
170 170
171 return ( (iSatdSum+1)>>1 );171 return iSatdSum;
172}172}
173int32_t WelsSampleSatd8x8_c( uint8_t* pSample1, int32_t iStride1, uint8_t* pSample2, int32_t iStride2 )173int32_t WelsSampleSatd16x8_c (uint8_t* pSample1, int32_t iStride1, uint8_t* pSample2, int32_t iStride2) {
174{174 int32_t iSatdSum = 0;
175 int32_t iSatdSum = 0;175
176 176 iSatdSum += WelsSampleSatd8x8_c (pSample1, iStride1, pSample2, iStride2);
177 iSatdSum += WelsSampleSatd4x4_c( pSample1, iStride1, pSample2, iStride2 );177 iSatdSum += WelsSampleSatd8x8_c (pSample1 + 8, iStride1, pSample2 + 8, iStride2);
178 iSatdSum += WelsSampleSatd4x4_c( pSample1+4, iStride1, pSample2+4, iStride2 );178
179 iSatdSum += WelsSampleSatd4x4_c( pSample1+(iStride1<<2), iStride1, pSample2+(iStride2<<2), iStride2 );179 return iSatdSum;
180 iSatdSum += WelsSampleSatd4x4_c( pSample1+(iStride1<<2)+4, iStride1, pSample2+(iStride2<<2)+4, iStride2 );180}
181 181int32_t WelsSampleSatd8x16_c (uint8_t* pSample1, int32_t iStride1, uint8_t* pSample2, int32_t iStride2) {
182 return iSatdSum;182 int32_t iSatdSum = 0;
183}183
184int32_t WelsSampleSatd16x8_c( uint8_t* pSample1, int32_t iStride1, uint8_t* pSample2, int32_t iStride2 )184 iSatdSum += WelsSampleSatd8x8_c (pSample1, iStride1, pSample2, iStride2);
185{185 iSatdSum += WelsSampleSatd8x8_c (pSample1 + (iStride1 << 3), iStride1, pSample2 + (iStride2 << 3), iStride2);
186 int32_t iSatdSum = 0;186
187 187 return iSatdSum;
188 iSatdSum += WelsSampleSatd8x8_c( pSample1, iStride1, pSample2, iStride2 );188}
189 iSatdSum += WelsSampleSatd8x8_c( pSample1+8, iStride1, pSample2+8, iStride2 );189int32_t WelsSampleSatd16x16_c (uint8_t* pSample1, int32_t iStride1, uint8_t* pSample2, int32_t iStride2) {
190 190 int32_t iSatdSum = 0;
191 return iSatdSum;191
192}192 iSatdSum += WelsSampleSatd8x8_c (pSample1, iStride1, pSample2, iStride2);
193int32_t WelsSampleSatd8x16_c( uint8_t* pSample1, int32_t iStride1, uint8_t* pSample2, int32_t iStride2 )193 iSatdSum += WelsSampleSatd8x8_c (pSample1 + 8, iStride1, pSample2 + 8, iStride2);
194{194 iSatdSum += WelsSampleSatd8x8_c (pSample1 + (iStride1 << 3), iStride1, pSample2 + (iStride2 << 3), iStride2);
195 int32_t iSatdSum = 0;195 iSatdSum += WelsSampleSatd8x8_c (pSample1 + (iStride1 << 3) + 8, iStride1, pSample2 + (iStride2 << 3) + 8, iStride2);
196 196
197 iSatdSum += WelsSampleSatd8x8_c( pSample1, iStride1, pSample2, iStride2 );197 return iSatdSum;
198 iSatdSum += WelsSampleSatd8x8_c( pSample1+(iStride1<<3), iStride1, pSample2+(iStride2<<3), iStride2 );198}
199 199
200 return iSatdSum;200
201}201void WelsSampleSadFour16x16_c (uint8_t* iSample1, int32_t iStride1, uint8_t* iSample2, int32_t iStride2,
202int32_t WelsSampleSatd16x16_c( uint8_t* pSample1, int32_t iStride1, uint8_t* pSample2, int32_t iStride2 )202 int32_t* pSad) {
203{203 * (pSad) = WelsSampleSad16x16_c (iSample1, iStride1, (iSample2 - iStride2), iStride2);
204 int32_t iSatdSum = 0;204 * (pSad + 1) = WelsSampleSad16x16_c (iSample1, iStride1, (iSample2 + iStride2), iStride2);
205 205 * (pSad + 2) = WelsSampleSad16x16_c (iSample1, iStride1, (iSample2 - 1), iStride2);
206 iSatdSum += WelsSampleSatd8x8_c( pSample1, iStride1, pSample2, iStride2 );206 * (pSad + 3) = WelsSampleSad16x16_c (iSample1, iStride1, (iSample2 + 1), iStride2);
207 iSatdSum += WelsSampleSatd8x8_c( pSample1+8, iStride1, pSample2+8, iStride2 );207}
208 iSatdSum += WelsSampleSatd8x8_c( pSample1+(iStride1<<3), iStride1, pSample2+(iStride2<<3), iStride2 );208void WelsSampleSadFour16x8_c (uint8_t* iSample1, int32_t iStride1, uint8_t* iSample2, int32_t iStride2, int32_t* pSad) {
209 iSatdSum += WelsSampleSatd8x8_c( pSample1+(iStride1<<3)+8, iStride1, pSample2+(iStride2<<3)+8, iStride2 );209 * (pSad) = WelsSampleSad16x8_c (iSample1, iStride1, (iSample2 - iStride2), iStride2);
210 210 * (pSad + 1) = WelsSampleSad16x8_c (iSample1, iStride1, (iSample2 + iStride2), iStride2);
211 return iSatdSum;211 * (pSad + 2) = WelsSampleSad16x8_c (iSample1, iStride1, (iSample2 - 1), iStride2);
212}212 * (pSad + 3) = WelsSampleSad16x8_c (iSample1, iStride1, (iSample2 + 1), iStride2);
213 213}
214 214void WelsSampleSadFour8x16_c (uint8_t* iSample1, int32_t iStride1, uint8_t* iSample2, int32_t iStride2, int32_t* pSad) {
215void WelsSampleSadFour16x16_c( uint8_t *iSample1, int32_t iStride1, uint8_t *iSample2, int32_t iStride2, int32_t* pSad)215 * (pSad) = WelsSampleSad8x16_c (iSample1, iStride1, (iSample2 - iStride2), iStride2);
216{216 * (pSad + 1) = WelsSampleSad8x16_c (iSample1, iStride1, (iSample2 + iStride2), iStride2);
217 *(pSad) = WelsSampleSad16x16_c(iSample1, iStride1, (iSample2-iStride2), iStride2);217 * (pSad + 2) = WelsSampleSad8x16_c (iSample1, iStride1, (iSample2 - 1), iStride2);
218 *(pSad + 1) = WelsSampleSad16x16_c(iSample1, iStride1, (iSample2+iStride2), iStride2);218 * (pSad + 3) = WelsSampleSad8x16_c (iSample1, iStride1, (iSample2 + 1), iStride2);
219 *(pSad + 2) = WelsSampleSad16x16_c(iSample1, iStride1, (iSample2-1), iStride2);219
220 *(pSad + 3) = WelsSampleSad16x16_c(iSample1, iStride1, (iSample2+1), iStride2);220}
221}221void WelsSampleSadFour8x8_c (uint8_t* iSample1, int32_t iStride1, uint8_t* iSample2, int32_t iStride2, int32_t* pSad) {
222void WelsSampleSadFour16x8_c(uint8_t *iSample1, int32_t iStride1, uint8_t *iSample2, int32_t iStride2, int32_t* pSad)222 * (pSad) = WelsSampleSad8x8_c (iSample1, iStride1, (iSample2 - iStride2), iStride2);
223{223 * (pSad + 1) = WelsSampleSad8x8_c (iSample1, iStride1, (iSample2 + iStride2), iStride2);
224 *(pSad) = WelsSampleSad16x8_c(iSample1, iStride1, (iSample2-iStride2), iStride2);224 * (pSad + 2) = WelsSampleSad8x8_c (iSample1, iStride1, (iSample2 - 1), iStride2);
225 *(pSad + 1) = WelsSampleSad16x8_c(iSample1, iStride1, (iSample2+iStride2), iStride2);225 * (pSad + 3) = WelsSampleSad8x8_c (iSample1, iStride1, (iSample2 + 1), iStride2);
226 *(pSad + 2) = WelsSampleSad16x8_c(iSample1, iStride1, (iSample2-1), iStride2);226}
227 *(pSad + 3) = WelsSampleSad16x8_c(iSample1, iStride1, (iSample2+1), iStride2);227void WelsSampleSadFour4x4_c (uint8_t* iSample1, int32_t iStride1, uint8_t* iSample2, int32_t iStride2, int32_t* pSad) {
228}228 * (pSad) = WelsSampleSad4x4_c (iSample1, iStride1, (iSample2 - iStride2), iStride2);
229void WelsSampleSadFour8x16_c( uint8_t *iSample1, int32_t iStride1, uint8_t *iSample2, int32_t iStride2, int32_t* pSad)229 * (pSad + 1) = WelsSampleSad4x4_c (iSample1, iStride1, (iSample2 + iStride2), iStride2);
230{230 * (pSad + 2) = WelsSampleSad4x4_c (iSample1, iStride1, (iSample2 - 1), iStride2);
231 *(pSad) = WelsSampleSad8x16_c(iSample1, iStride1, (iSample2-iStride2), iStride2);231 * (pSad + 3) = WelsSampleSad4x4_c (iSample1, iStride1, (iSample2 + 1), iStride2);
232 *(pSad + 1) = WelsSampleSad8x16_c(iSample1, iStride1, (iSample2+iStride2), iStride2);232}
233 *(pSad + 2) = WelsSampleSad8x16_c(iSample1, iStride1, (iSample2-1), iStride2);233
234 *(pSad + 3) = WelsSampleSad8x16_c(iSample1, iStride1, (iSample2+1), iStride2);234extern void WelsI4x4LumaPredDc_c (uint8_t* pPred, uint8_t* pRef, const int32_t iStride);
235 235extern void WelsI4x4LumaPredH_c (uint8_t* pPred, uint8_t* pRef, const int32_t iStride);
236}236extern void WelsI4x4LumaPredV_c (uint8_t* pPred, uint8_t* pRef, const int32_t iStride);
237void WelsSampleSadFour8x8_c( uint8_t *iSample1, int32_t iStride1, uint8_t *iSample2, int32_t iStride2, int32_t* pSad)237
238{238int32_t WelsSampleSatdIntra4x4Combined3_c (uint8_t* pDec, int32_t iDecStride, uint8_t* pEnc, int32_t iEncStride,
239 *(pSad) = WelsSampleSad8x8_c(iSample1, iStride1, (iSample2-iStride2), iStride2);239 uint8_t* pDst,
240 *(pSad + 1) = WelsSampleSad8x8_c(iSample1, iStride1, (iSample2+iStride2), iStride2);240 int32_t* pBestMode, int32_t iLambda2, int32_t iLambda1, int32_t iLambda0) {
241 *(pSad + 2) = WelsSampleSad8x8_c(iSample1, iStride1, (iSample2-1), iStride2);241 int32_t iBestMode = -1;
242 *(pSad + 3) = WelsSampleSad8x8_c(iSample1, iStride1, (iSample2+1), iStride2);242 int32_t iCurCost, iBestCost = INT_MAX;
243}243 ENFORCE_STACK_ALIGN_2D (uint8_t, uiLocalBuffer, 3, 16, 16)
244void WelsSampleSadFour4x4_c( uint8_t *iSample1, int32_t iStride1, uint8_t *iSample2, int32_t iStride2, int32_t* pSad)244
245{245 WelsI4x4LumaPredDc_c (uiLocalBuffer[2], pDec, iDecStride);
246 *(pSad) = WelsSampleSad4x4_c(iSample1, iStride1, (iSample2-iStride2), iStride2);246 iCurCost = WelsSampleSatd4x4_c (uiLocalBuffer[2], 4, pEnc, iEncStride) + iLambda2;
247 *(pSad + 1) = WelsSampleSad4x4_c(iSample1, iStride1, (iSample2+iStride2), iStride2);247 if (iCurCost < iBestCost) {
248 *(pSad + 2) = WelsSampleSad4x4_c(iSample1, iStride1, (iSample2-1), iStride2);248 iBestMode = 2;
249 *(pSad + 3) = WelsSampleSad4x4_c(iSample1, iStride1, (iSample2+1), iStride2);249 iBestCost = iCurCost;
250}250 }
251 251
252extern void WelsI4x4LumaPredDc_c(uint8_t *pPred, uint8_t *pRef, const int32_t iStride);252 WelsI4x4LumaPredH_c (uiLocalBuffer[1], pDec, iDecStride);
253extern void WelsI4x4LumaPredH_c(uint8_t *pPred, uint8_t *pRef, const int32_t iStride);253 iCurCost = WelsSampleSatd4x4_c (uiLocalBuffer[1], 4, pEnc, iEncStride) + iLambda1;
254extern void WelsI4x4LumaPredV_c(uint8_t *pPred, uint8_t *pRef, const int32_t iStride);254 if (iCurCost < iBestCost) {
255 255 iBestMode = 1;
256int32_t WelsSampleSatdIntra4x4Combined3_c(uint8_t *pDec, int32_t iDecStride, uint8_t *pEnc, int32_t iEncStride, uint8_t *pDst, 256 iBestCost = iCurCost;
257 int32_t *pBestMode, int32_t iLambda2, int32_t iLambda1, int32_t iLambda0)257 }
258{258 WelsI4x4LumaPredV_c (uiLocalBuffer[0], pDec, iDecStride);
259 int32_t iBestMode = -1;259 iCurCost = WelsSampleSatd4x4_c (uiLocalBuffer[0], 4, pEnc, iEncStride) + iLambda0;
260 int32_t iCurCost, iBestCost = INT_MAX;260 if (iCurCost < iBestCost) {
261 ENFORCE_STACK_ALIGN_2D(uint8_t, uiLocalBuffer, 3, 16, 16)261 iBestMode = 0;
262 262 iBestCost = iCurCost;
263 WelsI4x4LumaPredDc_c(uiLocalBuffer[2], pDec, iDecStride);263 }
264 iCurCost = WelsSampleSatd4x4_c(uiLocalBuffer[2], 4, pEnc, iEncStride) + iLambda2;264
265 if (iCurCost < iBestCost)265 memcpy (pDst, uiLocalBuffer[iBestMode], 16 * sizeof (uint8_t)); // confirmed_safe_unsafe_usage
266 { 266 *pBestMode = iBestMode;
267 iBestMode = 2;267
268 iBestCost = iCurCost;268 return iBestCost;
269 }269}
270 270extern void WelsIChormaPredDc_c (uint8_t* pPred, uint8_t* pRef, const int32_t iStride);
271 WelsI4x4LumaPredH_c(uiLocalBuffer[1], pDec, iDecStride);271extern void WelsIChormaPredH_c (uint8_t* pPred, uint8_t* pRef, const int32_t iStride);
272 iCurCost = WelsSampleSatd4x4_c(uiLocalBuffer[1], 4, pEnc, iEncStride) + iLambda1;272extern void WelsIChormaPredV_c (uint8_t* pPred, uint8_t* pRef, const int32_t iStride);
273 if (iCurCost < iBestCost)273
274 { 274int32_t WelsSampleSatdIntra8x8Combined3_c (uint8_t* pDecCb, int32_t iDecStride, uint8_t* pEncCb, int32_t iEncStride,
275 iBestMode = 1;275 int32_t* pBestMode, int32_t iLambda, uint8_t* pDstChroma, uint8_t* pDecCr, uint8_t* pEncCr) {
276 iBestCost = iCurCost;276 int32_t iBestMode = -1;
277 }277 int32_t iCurCost, iBestCost = INT_MAX;
278 WelsI4x4LumaPredV_c(uiLocalBuffer[0], pDec, iDecStride);278
279 iCurCost = WelsSampleSatd4x4_c(uiLocalBuffer[0], 4, pEnc, iEncStride) + iLambda0;279 WelsIChormaPredV_c (pDstChroma, pDecCb, iDecStride);
280 if (iCurCost < iBestCost)280 WelsIChormaPredV_c (pDstChroma + 64, pDecCr, iDecStride);
281 { 281 iCurCost = WelsSampleSatd8x8_c (pDstChroma, 8, pEncCb, iEncStride);
282 iBestMode = 0;282 iCurCost += WelsSampleSatd8x8_c (pDstChroma + 64, 8, pEncCr, iEncStride) + iLambda * 2;
283 iBestCost = iCurCost;283
284 }284 if (iCurCost < iBestCost) {
285 285 iBestMode = 2;
286 memcpy(pDst, uiLocalBuffer[iBestMode], 16*sizeof(uint8_t)); // confirmed_safe_unsafe_usage286 iBestCost = iCurCost;
287 *pBestMode = iBestMode;287 }
288 288
289 return iBestCost;289 WelsIChormaPredH_c (pDstChroma, pDecCb, iDecStride);
290}290 WelsIChormaPredH_c (pDstChroma + 64, pDecCr, iDecStride);
291extern void WelsIChormaPredDc_c(uint8_t *pPred, uint8_t *pRef, const int32_t iStride);291 iCurCost = WelsSampleSatd8x8_c (pDstChroma, 8, pEncCb, iEncStride);
292extern void WelsIChormaPredH_c(uint8_t *pPred, uint8_t *pRef, const int32_t iStride);292 iCurCost += WelsSampleSatd8x8_c (pDstChroma + 64, 8, pEncCr, iEncStride) + iLambda * 2;
293extern void WelsIChormaPredV_c(uint8_t *pPred, uint8_t *pRef, const int32_t iStride);293 if (iCurCost < iBestCost) {
294 294 iBestMode = 1;
295int32_t WelsSampleSatdIntra8x8Combined3_c(uint8_t *pDecCb, int32_t iDecStride, uint8_t *pEncCb, int32_t iEncStride, 295 iBestCost = iCurCost;
296 int32_t *pBestMode, int32_t iLambda, uint8_t *pDstChroma,uint8_t *pDecCr,uint8_t *pEncCr)296 }
297{297 WelsIChormaPredDc_c (pDstChroma, pDecCb, iDecStride);
298 int32_t iBestMode = -1;298 WelsIChormaPredDc_c (pDstChroma + 64, pDecCr, iDecStride);
299 int32_t iCurCost, iBestCost = INT_MAX;299 iCurCost = WelsSampleSatd8x8_c (pDstChroma, 8, pEncCb, iEncStride);
300 300 iCurCost += WelsSampleSatd8x8_c (pDstChroma + 64, 8, pEncCr, iEncStride);
301 WelsIChormaPredV_c(pDstChroma, pDecCb, iDecStride);301 if (iCurCost < iBestCost) {
302 WelsIChormaPredV_c(pDstChroma+64, pDecCr, iDecStride);302 iBestMode = 0;
303 iCurCost = WelsSampleSatd8x8_c(pDstChroma, 8, pEncCb, iEncStride);303 iBestCost = iCurCost;
304 iCurCost += WelsSampleSatd8x8_c(pDstChroma+64, 8, pEncCr, iEncStride) + iLambda * 2;304 }
305 305
306 if (iCurCost < iBestCost)306 *pBestMode = iBestMode;
307 { 307
308 iBestMode = 2;308 return iBestCost;
309 iBestCost = iCurCost;309
310 }310
311 311}
312 WelsIChormaPredH_c(pDstChroma, pDecCb, iDecStride);312int32_t WelsSampleSadIntra8x8Combined3_c (uint8_t* pDecCb, int32_t iDecStride, uint8_t* pEncCb, int32_t iEncStride,
313 WelsIChormaPredH_c(pDstChroma+64, pDecCr, iDecStride);313 int32_t* pBestMode, int32_t iLambda, uint8_t* pDstChroma, uint8_t* pDecCr, uint8_t* pEncCr) {
314 iCurCost = WelsSampleSatd8x8_c(pDstChroma, 8, pEncCb, iEncStride);314 int32_t iBestMode = -1;
315 iCurCost += WelsSampleSatd8x8_c(pDstChroma+64, 8, pEncCr, iEncStride) + iLambda * 2;315 int32_t iCurCost, iBestCost = INT_MAX;
316 if (iCurCost < iBestCost)316
317 { 317 WelsIChormaPredV_c (pDstChroma, pDecCb, iDecStride);
318 iBestMode = 1;318 WelsIChormaPredV_c (pDstChroma + 64, pDecCr, iDecStride);
319 iBestCost = iCurCost;319 iCurCost = WelsSampleSad8x8_c (pDstChroma, 8, pEncCb, iEncStride);
320 }320 iCurCost += WelsSampleSad8x8_c (pDstChroma + 64, 8, pEncCr, iEncStride) + iLambda * 2;
321 WelsIChormaPredDc_c(pDstChroma, pDecCb, iDecStride);321
322 WelsIChormaPredDc_c(pDstChroma+64, pDecCr, iDecStride);322 if (iCurCost < iBestCost) {
323 iCurCost = WelsSampleSatd8x8_c(pDstChroma, 8, pEncCb, iEncStride);323 iBestMode = 2;
324 iCurCost += WelsSampleSatd8x8_c(pDstChroma+64, 8, pEncCr, iEncStride);324 iBestCost = iCurCost;
325 if (iCurCost < iBestCost)325 }
326 { 326
327 iBestMode = 0;327 WelsIChormaPredH_c (pDstChroma, pDecCb, iDecStride);
328 iBestCost = iCurCost;328 WelsIChormaPredH_c (pDstChroma + 64, pDecCr, iDecStride);
329 }329 iCurCost = WelsSampleSad8x8_c (pDstChroma, 8, pEncCb, iEncStride);
330 330 iCurCost += WelsSampleSad8x8_c (pDstChroma + 64, 8, pEncCr, iEncStride) + iLambda * 2;
331 *pBestMode = iBestMode;331 if (iCurCost < iBestCost) {
332 332 iBestMode = 1;
333 return iBestCost;333 iBestCost = iCurCost;
334 334 }
335 335 WelsIChormaPredDc_c (pDstChroma, pDecCb, iDecStride);
336}336 WelsIChormaPredDc_c (pDstChroma + 64, pDecCr, iDecStride);
337int32_t WelsSampleSadIntra8x8Combined3_c(uint8_t *pDecCb, int32_t iDecStride, uint8_t *pEncCb, int32_t iEncStride, 337 iCurCost = WelsSampleSad8x8_c (pDstChroma, 8, pEncCb, iEncStride);
338 int32_t *pBestMode, int32_t iLambda, uint8_t *pDstChroma,uint8_t *pDecCr,uint8_t *pEncCr)338 iCurCost += WelsSampleSad8x8_c (pDstChroma + 64, 8, pEncCr, iEncStride);
339{339 if (iCurCost < iBestCost) {
340 int32_t iBestMode = -1;340 iBestMode = 0;
341 int32_t iCurCost, iBestCost = INT_MAX;341 iBestCost = iCurCost;
342 342 }
343 WelsIChormaPredV_c(pDstChroma, pDecCb, iDecStride);343
344 WelsIChormaPredV_c(pDstChroma+64, pDecCr, iDecStride);344 *pBestMode = iBestMode;
345 iCurCost = WelsSampleSad8x8_c(pDstChroma, 8, pEncCb, iEncStride);345
346 iCurCost += WelsSampleSad8x8_c(pDstChroma+64, 8, pEncCr, iEncStride) + iLambda * 2;346 return iBestCost;
347 347
348 if (iCurCost < iBestCost)348}
349 { 349
350 iBestMode = 2;350extern void WelsI16x16LumaPredDc_c (uint8_t* pPred, uint8_t* pRef, const int32_t iStride);
351 iBestCost = iCurCost;351extern void WelsI16x16LumaPredH_c (uint8_t* pPred, uint8_t* pRef, const int32_t iStride);
352 }352extern void WelsI16x16LumaPredV_c (uint8_t* pPred, uint8_t* pRef, const int32_t iStride);
353 353
354 WelsIChormaPredH_c(pDstChroma, pDecCb, iDecStride);354int32_t WelsSampleSatdIntra16x16Combined3_c (uint8_t* pDec, int32_t iDecStride, uint8_t* pEnc, int32_t iEncStride,
355 WelsIChormaPredH_c(pDstChroma+64, pDecCr, iDecStride);355 int32_t* pBestMode, int32_t iLambda, uint8_t* pDst) {
356 iCurCost = WelsSampleSad8x8_c(pDstChroma, 8, pEncCb, iEncStride);356 int32_t iBestMode = -1;
357 iCurCost += WelsSampleSad8x8_c(pDstChroma+64, 8, pEncCr, iEncStride) + iLambda * 2;357 int32_t iCurCost, iBestCost = INT_MAX;
358 if (iCurCost < iBestCost)358
359 { 359 WelsI16x16LumaPredV_c (pDst, pDec, iDecStride);
360 iBestMode = 1;360 iCurCost = WelsSampleSatd16x16_c (pDst, 16, pEnc, iEncStride);
361 iBestCost = iCurCost;361
362 }362 if (iCurCost < iBestCost) {
363 WelsIChormaPredDc_c(pDstChroma, pDecCb, iDecStride);363 iBestMode = 0;
364 WelsIChormaPredDc_c(pDstChroma+64, pDecCr, iDecStride);364 iBestCost = iCurCost;
365 iCurCost = WelsSampleSad8x8_c(pDstChroma, 8, pEncCb, iEncStride);365 }
366 iCurCost += WelsSampleSad8x8_c(pDstChroma+64, 8, pEncCr, iEncStride);366
367 if (iCurCost < iBestCost)367 WelsI16x16LumaPredH_c (pDst, pDec, iDecStride);
368 { 368 iCurCost = WelsSampleSatd16x16_c (pDst, 16, pEnc, iEncStride) + iLambda * 2;
369 iBestMode = 0;369 if (iCurCost < iBestCost) {
370 iBestCost = iCurCost;370 iBestMode = 1;
371 }371 iBestCost = iCurCost;
372 372 }
373 *pBestMode = iBestMode;373 WelsI16x16LumaPredDc_c (pDst, pDec, iDecStride);
374 374 iCurCost = WelsSampleSatd16x16_c (pDst, 16, pEnc, iEncStride) + iLambda * 2;
375 return iBestCost;375 if (iCurCost < iBestCost) {
376 376 iBestMode = 2;
377}377 iBestCost = iCurCost;
378 378 }
379extern void WelsI16x16LumaPredDc_c(uint8_t *pPred, uint8_t *pRef, const int32_t iStride);379
380extern void WelsI16x16LumaPredH_c(uint8_t *pPred, uint8_t *pRef, const int32_t iStride);380 *pBestMode = iBestMode;
381extern void WelsI16x16LumaPredV_c(uint8_t *pPred, uint8_t *pRef, const int32_t iStride);381
382 382 return iBestCost;
383int32_t WelsSampleSatdIntra16x16Combined3_c(uint8_t *pDec, int32_t iDecStride, uint8_t *pEnc, int32_t iEncStride, 383
384 int32_t *pBestMode, int32_t iLambda, uint8_t *pDst)384
385{385}
386 int32_t iBestMode = -1;386int32_t WelsSampleSadIntra16x16Combined3_c (uint8_t* pDec, int32_t iDecStride, uint8_t* pEnc, int32_t iEncStride,
387 int32_t iCurCost, iBestCost = INT_MAX;387 int32_t* pBestMode, int32_t iLambda, uint8_t* pDst) {
388 388 int32_t iBestMode = -1;
389 WelsI16x16LumaPredV_c(pDst, pDec, iDecStride);389 int32_t iCurCost, iBestCost = INT_MAX;
390 iCurCost = WelsSampleSatd16x16_c(pDst, 16, pEnc, iEncStride);390
391 391 WelsI16x16LumaPredV_c (pDst, pDec, iDecStride);
392 if (iCurCost < iBestCost)392 iCurCost = WelsSampleSad16x16_c (pDst, 16, pEnc, iEncStride);
393 { 393
394 iBestMode = 0;394 if (iCurCost < iBestCost) {
395 iBestCost = iCurCost;395 iBestMode = 0;
396 }396 iBestCost = iCurCost;
397 397 }
398 WelsI16x16LumaPredH_c(pDst, pDec, iDecStride);398
399 iCurCost = WelsSampleSatd16x16_c(pDst, 16, pEnc, iEncStride) + iLambda * 2;399 WelsI16x16LumaPredH_c (pDst, pDec, iDecStride);
400 if (iCurCost < iBestCost)400 iCurCost = WelsSampleSad16x16_c (pDst, 16, pEnc, iEncStride) + iLambda * 2;
401 { 401 if (iCurCost < iBestCost) {
402 iBestMode = 1;402 iBestMode = 1;
403 iBestCost = iCurCost;403 iBestCost = iCurCost;
404 }404 }
405 WelsI16x16LumaPredDc_c(pDst, pDec, iDecStride);405 WelsI16x16LumaPredDc_c (pDst, pDec, iDecStride);
406 iCurCost = WelsSampleSatd16x16_c(pDst, 16, pEnc, iEncStride) + iLambda * 2;406 iCurCost = WelsSampleSad16x16_c (pDst, 16, pEnc, iEncStride) + iLambda * 2;
407 if (iCurCost < iBestCost)407 if (iCurCost < iBestCost) {
408 { 408 iBestMode = 2;
409 iBestMode = 2;409 iBestCost = iCurCost;
410 iBestCost = iCurCost;410 }
411 }411
412 412 *pBestMode = iBestMode;
413 *pBestMode = iBestMode;413
414 414 return iBestCost;
415 return iBestCost;415
416 416
417 417}
418}418
419int32_t WelsSampleSadIntra16x16Combined3_c(uint8_t *pDec, int32_t iDecStride, uint8_t *pEnc, int32_t iEncStride, 419void WelsInitSampleSadFunc (SWelsFuncPtrList* pFuncList, uint32_t uiCpuFlag) {
420 int32_t *pBestMode, int32_t iLambda, uint8_t *pDst)420 //pfSampleSad init
421{421 pFuncList->sSampleDealingFuncs.pfSampleSad[BLOCK_16x16] = WelsSampleSad16x16_c;
422 int32_t iBestMode = -1;422 pFuncList->sSampleDealingFuncs.pfSampleSad[BLOCK_16x8 ] = WelsSampleSad16x8_c;
423 int32_t iCurCost, iBestCost = INT_MAX;423 pFuncList->sSampleDealingFuncs.pfSampleSad[BLOCK_8x16 ] = WelsSampleSad8x16_c;
424 424 pFuncList->sSampleDealingFuncs.pfSampleSad[BLOCK_8x8 ] = WelsSampleSad8x8_c;
425 WelsI16x16LumaPredV_c(pDst, pDec, iDecStride);425 pFuncList->sSampleDealingFuncs.pfSampleSad[BLOCK_4x4 ] = WelsSampleSad4x4_c;
426 iCurCost = WelsSampleSad16x16_c(pDst, 16, pEnc, iEncStride);426
427 427 //pfSampleSatd init
428 if (iCurCost < iBestCost)428 pFuncList->sSampleDealingFuncs.pfSampleSatd[BLOCK_16x16] = WelsSampleSatd16x16_c;
429 { 429 pFuncList->sSampleDealingFuncs.pfSampleSatd[BLOCK_16x8 ] = WelsSampleSatd16x8_c;
430 iBestMode = 0;430 pFuncList->sSampleDealingFuncs.pfSampleSatd[BLOCK_8x16 ] = WelsSampleSatd8x16_c;
431 iBestCost = iCurCost;431 pFuncList->sSampleDealingFuncs.pfSampleSatd[BLOCK_8x8 ] = WelsSampleSatd8x8_c;
432 }432 pFuncList->sSampleDealingFuncs.pfSampleSatd[BLOCK_4x4 ] = WelsSampleSatd4x4_c;
433 433
434 WelsI16x16LumaPredH_c(pDst, pDec, iDecStride);434 pFuncList->sSampleDealingFuncs.pfSample4Sad[BLOCK_16x16] = WelsSampleSadFour16x16_c;
435 iCurCost = WelsSampleSad16x16_c(pDst, 16, pEnc, iEncStride) + iLambda * 2;435 pFuncList->sSampleDealingFuncs.pfSample4Sad[BLOCK_16x8] = WelsSampleSadFour16x8_c;
436 if (iCurCost < iBestCost)436 pFuncList->sSampleDealingFuncs.pfSample4Sad[BLOCK_8x16] = WelsSampleSadFour8x16_c;
437 { 437 pFuncList->sSampleDealingFuncs.pfSample4Sad[BLOCK_8x8] = WelsSampleSadFour8x8_c;
438 iBestMode = 1;438 pFuncList->sSampleDealingFuncs.pfSample4Sad[BLOCK_4x4] = WelsSampleSadFour4x4_c;
439 iBestCost = iCurCost;439
440 }440 pFuncList->sSampleDealingFuncs.pfIntra4x4Combined3Satd = NULL;
441 WelsI16x16LumaPredDc_c(pDst, pDec, iDecStride);441 pFuncList->sSampleDealingFuncs.pfIntra8x8Combined3Satd = NULL;
442 iCurCost = WelsSampleSad16x16_c(pDst, 16, pEnc, iEncStride) + iLambda * 2;442 pFuncList->sSampleDealingFuncs.pfIntra8x8Combined3Sad = NULL;
443 if (iCurCost < iBestCost)443 pFuncList->sSampleDealingFuncs.pfIntra16x16Combined3Satd = NULL;
444 { 444 pFuncList->sSampleDealingFuncs.pfIntra16x16Combined3Sad = NULL;
445 iBestMode = 2;445
446 iBestCost = iCurCost;446#if defined (X86_ASM)
447 }447 if (uiCpuFlag & WELS_CPU_MMXEXT) {
448 448 pFuncList->sSampleDealingFuncs.pfSampleSad[BLOCK_4x4 ] = WelsSampleSad4x4_mmx;
449 *pBestMode = iBestMode;449 }
450 450
451 return iBestCost;451 if (uiCpuFlag & WELS_CPU_SSE2) {
452 452 pFuncList->sSampleDealingFuncs.pfSampleSad[BLOCK_16x16] = WelsSampleSad16x16_sse2;
453 453 pFuncList->sSampleDealingFuncs.pfSampleSad[BLOCK_16x8 ] = WelsSampleSad16x8_sse2;
454}454 pFuncList->sSampleDealingFuncs.pfSampleSad[BLOCK_8x16] = WelsSampleSad8x16_sse2;
455 455 pFuncList->sSampleDealingFuncs.pfSampleSad[BLOCK_8x8] = WelsSampleSad8x8_sse21;
456void WelsInitSampleSadFunc( SWelsFuncPtrList *pFuncList, uint32_t uiCpuFlag)456
457{457 pFuncList->sSampleDealingFuncs.pfSample4Sad[BLOCK_16x16] = WelsSampleSadFour16x16_sse2;
458 //pfSampleSad init458 pFuncList->sSampleDealingFuncs.pfSample4Sad[BLOCK_16x8] = WelsSampleSadFour16x8_sse2;
459 pFuncList->sSampleDealingFuncs.pfSampleSad[BLOCK_16x16] = WelsSampleSad16x16_c;459 pFuncList->sSampleDealingFuncs.pfSample4Sad[BLOCK_8x16] = WelsSampleSadFour8x16_sse2;
460 pFuncList->sSampleDealingFuncs.pfSampleSad[BLOCK_16x8 ] = WelsSampleSad16x8_c;460 pFuncList->sSampleDealingFuncs.pfSample4Sad[BLOCK_8x8] = WelsSampleSadFour8x8_sse2;
461 pFuncList->sSampleDealingFuncs.pfSampleSad[BLOCK_8x16 ] = WelsSampleSad8x16_c;461 pFuncList->sSampleDealingFuncs.pfSample4Sad[BLOCK_4x4] = WelsSampleSadFour4x4_sse2;
462 pFuncList->sSampleDealingFuncs.pfSampleSad[BLOCK_8x8 ] = WelsSampleSad8x8_c;462
463 pFuncList->sSampleDealingFuncs.pfSampleSad[BLOCK_4x4 ] = WelsSampleSad4x4_c;463 pFuncList->sSampleDealingFuncs.pfSampleSatd[BLOCK_4x4 ] = WelsSampleSatd4x4_sse2;
464 464 pFuncList->sSampleDealingFuncs.pfSampleSatd[BLOCK_8x8 ] = WelsSampleSatd8x8_sse2;
465 //pfSampleSatd init465 pFuncList->sSampleDealingFuncs.pfSampleSatd[BLOCK_8x16 ] = WelsSampleSatd8x16_sse2;
466 pFuncList->sSampleDealingFuncs.pfSampleSatd[BLOCK_16x16] = WelsSampleSatd16x16_c;466 pFuncList->sSampleDealingFuncs.pfSampleSatd[BLOCK_16x8 ] = WelsSampleSatd16x8_sse2;
467 pFuncList->sSampleDealingFuncs.pfSampleSatd[BLOCK_16x8 ] = WelsSampleSatd16x8_c;467 pFuncList->sSampleDealingFuncs.pfSampleSatd[BLOCK_16x16] = WelsSampleSatd16x16_sse2;
468 pFuncList->sSampleDealingFuncs.pfSampleSatd[BLOCK_8x16 ] = WelsSampleSatd8x16_c;468 pFuncList->sSampleDealingFuncs.pfIntra4x4Combined3Satd = WelsSmpleSatdThree4x4_sse2;
469 pFuncList->sSampleDealingFuncs.pfSampleSatd[BLOCK_8x8 ] = WelsSampleSatd8x8_c;469 }
470 pFuncList->sSampleDealingFuncs.pfSampleSatd[BLOCK_4x4 ] = WelsSampleSatd4x4_c;470
471 471 if (uiCpuFlag & WELS_CPU_SSSE3) {
472 pFuncList->sSampleDealingFuncs.pfSample4Sad[BLOCK_16x16] = WelsSampleSadFour16x16_c;472 pFuncList->sSampleDealingFuncs.pfIntra16x16Combined3Sad = WelsIntra16x16Combined3Sad_ssse3;
473 pFuncList->sSampleDealingFuncs.pfSample4Sad[BLOCK_16x8] = WelsSampleSadFour16x8_c;473 }
474 pFuncList->sSampleDealingFuncs.pfSample4Sad[BLOCK_8x16] = WelsSampleSadFour8x16_c;474
475 pFuncList->sSampleDealingFuncs.pfSample4Sad[BLOCK_8x8] = WelsSampleSadFour8x8_c;475 if (uiCpuFlag & WELS_CPU_SSE41) {
476 pFuncList->sSampleDealingFuncs.pfSample4Sad[BLOCK_4x4] = WelsSampleSadFour4x4_c;476 pFuncList->sSampleDealingFuncs.pfSampleSatd[BLOCK_16x16] = WelsSampleSatd16x16_sse41;
477 477 pFuncList->sSampleDealingFuncs.pfSampleSatd[BLOCK_16x8] = WelsSampleSatd16x8_sse41;
478 pFuncList->sSampleDealingFuncs.pfIntra4x4Combined3Satd = NULL;478 pFuncList->sSampleDealingFuncs.pfSampleSatd[BLOCK_8x16] = WelsSampleSatd8x16_sse41;
479 pFuncList->sSampleDealingFuncs.pfIntra8x8Combined3Satd = NULL;479 pFuncList->sSampleDealingFuncs.pfSampleSatd[BLOCK_8x8] = WelsSampleSatd8x8_sse41;
480 pFuncList->sSampleDealingFuncs.pfIntra8x8Combined3Sad = NULL;480 pFuncList->sSampleDealingFuncs.pfSampleSatd[BLOCK_4x4] = WelsSampleSatd4x4_sse41;
481 pFuncList->sSampleDealingFuncs.pfIntra16x16Combined3Satd = NULL;481 pFuncList->sSampleDealingFuncs.pfIntra16x16Combined3Satd = WelsIntra16x16Combined3Satd_sse41;
482 pFuncList->sSampleDealingFuncs.pfIntra16x16Combined3Sad = NULL;482 pFuncList->sSampleDealingFuncs.pfIntra8x8Combined3Satd = WelsIntraChroma8x8Combined3Satd_sse41;
483 483 }
484#if defined (X86_ASM)484
485 if ( uiCpuFlag & WELS_CPU_MMXEXT )485#endif //(X86_ASM)
486 {486
487 pFuncList->sSampleDealingFuncs.pfSampleSad[BLOCK_4x4 ] = WelsSampleSad4x4_mmx;487}
488 } 488
489 489} // namespace WelsSVCEnc
490 if ( uiCpuFlag & WELS_CPU_SSE2 )
491 {
492 pFuncList->sSampleDealingFuncs.pfSampleSad[BLOCK_16x16] = WelsSampleSad16x16_sse2;
493 pFuncList->sSampleDealingFuncs.pfSampleSad[BLOCK_16x8 ] = WelsSampleSad16x8_sse2;
494 pFuncList->sSampleDealingFuncs.pfSampleSad[BLOCK_8x16] = WelsSampleSad8x16_sse2;
495 pFuncList->sSampleDealingFuncs.pfSampleSad[BLOCK_8x8] = WelsSampleSad8x8_sse21;
496
497 pFuncList->sSampleDealingFuncs.pfSample4Sad[BLOCK_16x16] = WelsSampleSadFour16x16_sse2;
498 pFuncList->sSampleDealingFuncs.pfSample4Sad[BLOCK_16x8] = WelsSampleSadFour16x8_sse2;
499 pFuncList->sSampleDealingFuncs.pfSample4Sad[BLOCK_8x16] = WelsSampleSadFour8x16_sse2;
500 pFuncList->sSampleDealingFuncs.pfSample4Sad[BLOCK_8x8] = WelsSampleSadFour8x8_sse2;
501 pFuncList->sSampleDealingFuncs.pfSample4Sad[BLOCK_4x4] = WelsSampleSadFour4x4_sse2;
502
503 pFuncList->sSampleDealingFuncs.pfSampleSatd[BLOCK_4x4 ] = WelsSampleSatd4x4_sse2;
504 pFuncList->sSampleDealingFuncs.pfSampleSatd[BLOCK_8x8 ] = WelsSampleSatd8x8_sse2;
505 pFuncList->sSampleDealingFuncs.pfSampleSatd[BLOCK_8x16 ] = WelsSampleSatd8x16_sse2;
506 pFuncList->sSampleDealingFuncs.pfSampleSatd[BLOCK_16x8 ] = WelsSampleSatd16x8_sse2;
507 pFuncList->sSampleDealingFuncs.pfSampleSatd[BLOCK_16x16] = WelsSampleSatd16x16_sse2;
508 pFuncList->sSampleDealingFuncs.pfIntra4x4Combined3Satd = WelsSmpleSatdThree4x4_sse2;
509 }
510
511 if (uiCpuFlag & WELS_CPU_SSSE3)
512 {
513 pFuncList->sSampleDealingFuncs.pfIntra16x16Combined3Sad = WelsIntra16x16Combined3Sad_ssse3;
514 }
515
516 if( uiCpuFlag & WELS_CPU_SSE41 )
517 {
518 pFuncList->sSampleDealingFuncs.pfSampleSatd[BLOCK_16x16] = WelsSampleSatd16x16_sse41;
519 pFuncList->sSampleDealingFuncs.pfSampleSatd[BLOCK_16x8] = WelsSampleSatd16x8_sse41;
520 pFuncList->sSampleDealingFuncs.pfSampleSatd[BLOCK_8x16] = WelsSampleSatd8x16_sse41;
521 pFuncList->sSampleDealingFuncs.pfSampleSatd[BLOCK_8x8] = WelsSampleSatd8x8_sse41;
522 pFuncList->sSampleDealingFuncs.pfSampleSatd[BLOCK_4x4] = WelsSampleSatd4x4_sse41;
523 pFuncList->sSampleDealingFuncs.pfIntra16x16Combined3Satd = WelsIntra16x16Combined3Satd_sse41;
524 pFuncList->sSampleDealingFuncs.pfIntra8x8Combined3Satd = WelsIntraChroma8x8Combined3Satd_sse41;
525 }
526
527#endif //(X86_ASM)
528
529}
530
531} // namespace WelsSVCEnc

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