Commit | Line | Data |
---|---|---|
72b9787e JB |
1 | /***************************************************************************** |
2 | * Copyright (C) 2013 x265 project | |
3 | * | |
4 | * Authors: Deepthi Devaki <deepthidevaki@multicorewareinc.com>, | |
5 | * Rajesh Paulraj <rajesh@multicorewareinc.com> | |
6 | * Praveen Kumar Tiwari <praveen@multicorewareinc.com> | |
7 | * | |
8 | * This program is free software; you can redistribute it and/or modify | |
9 | * it under the terms of the GNU General Public License as published by | |
10 | * the Free Software Foundation; either version 2 of the License, or | |
11 | * (at your option) any later version. | |
12 | * | |
13 | * This program is distributed in the hope that it will be useful, | |
14 | * but WITHOUT ANY WARRANTY; without even the implied warranty of | |
15 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |
16 | * GNU General Public License for more details. | |
17 | * | |
18 | * You should have received a copy of the GNU General Public License | |
19 | * along with this program; if not, write to the Free Software | |
20 | * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02111, USA. | |
21 | * | |
22 | * This program is also available under a commercial proprietary license. | |
23 | * For more information, contact us at license @ x265.com. | |
24 | *****************************************************************************/ | |
25 | ||
26 | #include "common.h" | |
27 | #include "primitives.h" | |
28 | #include "x265.h" | |
29 | ||
30 | using namespace x265; | |
31 | ||
32 | #if _MSC_VER | |
33 | #pragma warning(disable: 4127) // conditional expression is constant, typical for templated functions | |
34 | #endif | |
35 | ||
36 | namespace { | |
37 | template<int dstStride> | |
b53f7c52 | 38 | void filterConvertPelToShort_c(const pixel* src, intptr_t srcStride, int16_t* dst, int width, int height) |
72b9787e JB |
39 | { |
40 | int shift = IF_INTERNAL_PREC - X265_DEPTH; | |
41 | int row, col; | |
42 | ||
43 | for (row = 0; row < height; row++) | |
44 | { | |
45 | for (col = 0; col < width; col++) | |
46 | { | |
47 | int16_t val = src[col] << shift; | |
48 | dst[col] = val - (int16_t)IF_INTERNAL_OFFS; | |
49 | } | |
50 | ||
51 | src += srcStride; | |
52 | dst += dstStride; | |
53 | } | |
54 | } | |
55 | ||
56 | void extendCURowColBorder(pixel* txt, intptr_t stride, int width, int height, int marginX) | |
57 | { | |
58 | for (int y = 0; y < height; y++) | |
59 | { | |
60 | #if HIGH_BIT_DEPTH | |
61 | for (int x = 0; x < marginX; x++) | |
62 | { | |
63 | txt[-marginX + x] = txt[0]; | |
64 | txt[width + x] = txt[width - 1]; | |
65 | } | |
66 | ||
67 | #else | |
68 | ::memset(txt - marginX, txt[0], marginX); | |
69 | ::memset(txt + width, txt[width - 1], marginX); | |
70 | #endif | |
71 | ||
72 | txt += stride; | |
73 | } | |
74 | } | |
75 | ||
76 | template<int N, int width, int height> | |
b53f7c52 | 77 | void interp_horiz_pp_c(const pixel* src, intptr_t srcStride, pixel* dst, intptr_t dstStride, int coeffIdx) |
72b9787e | 78 | { |
b53f7c52 | 79 | const int16_t* coeff = (N == 4) ? g_chromaFilter[coeffIdx] : g_lumaFilter[coeffIdx]; |
72b9787e JB |
80 | int headRoom = IF_FILTER_PREC; |
81 | int offset = (1 << (headRoom - 1)); | |
82 | uint16_t maxVal = (1 << X265_DEPTH) - 1; | |
83 | int cStride = 1; | |
84 | ||
85 | src -= (N / 2 - 1) * cStride; | |
86 | ||
87 | int row, col; | |
88 | for (row = 0; row < height; row++) | |
89 | { | |
90 | for (col = 0; col < width; col++) | |
91 | { | |
92 | int sum; | |
93 | ||
94 | sum = src[col + 0 * cStride] * coeff[0]; | |
95 | sum += src[col + 1 * cStride] * coeff[1]; | |
96 | sum += src[col + 2 * cStride] * coeff[2]; | |
97 | sum += src[col + 3 * cStride] * coeff[3]; | |
98 | if (N == 8) | |
99 | { | |
100 | sum += src[col + 4 * cStride] * coeff[4]; | |
101 | sum += src[col + 5 * cStride] * coeff[5]; | |
102 | sum += src[col + 6 * cStride] * coeff[6]; | |
103 | sum += src[col + 7 * cStride] * coeff[7]; | |
104 | } | |
105 | int16_t val = (int16_t)((sum + offset) >> headRoom); | |
106 | ||
107 | if (val < 0) val = 0; | |
108 | if (val > maxVal) val = maxVal; | |
109 | dst[col] = (pixel)val; | |
110 | } | |
111 | ||
112 | src += srcStride; | |
113 | dst += dstStride; | |
114 | } | |
115 | } | |
116 | ||
117 | template<int N, int width, int height> | |
b53f7c52 | 118 | void interp_horiz_ps_c(const pixel* src, intptr_t srcStride, int16_t* dst, intptr_t dstStride, int coeffIdx, int isRowExt) |
72b9787e | 119 | { |
b53f7c52 | 120 | const int16_t* coeff = (N == 4) ? g_chromaFilter[coeffIdx] : g_lumaFilter[coeffIdx]; |
72b9787e JB |
121 | int headRoom = IF_INTERNAL_PREC - X265_DEPTH; |
122 | int shift = IF_FILTER_PREC - headRoom; | |
123 | int offset = -IF_INTERNAL_OFFS << shift; | |
124 | int blkheight = height; | |
125 | ||
126 | src -= N / 2 - 1; | |
127 | ||
128 | if (isRowExt) | |
129 | { | |
130 | src -= (N / 2 - 1) * srcStride; | |
131 | blkheight += N - 1; | |
132 | } | |
133 | ||
134 | int row, col; | |
135 | for (row = 0; row < blkheight; row++) | |
136 | { | |
137 | for (col = 0; col < width; col++) | |
138 | { | |
139 | int sum; | |
140 | ||
141 | sum = src[col + 0] * coeff[0]; | |
142 | sum += src[col + 1] * coeff[1]; | |
143 | sum += src[col + 2] * coeff[2]; | |
144 | sum += src[col + 3] * coeff[3]; | |
145 | if (N == 8) | |
146 | { | |
147 | sum += src[col + 4] * coeff[4]; | |
148 | sum += src[col + 5] * coeff[5]; | |
149 | sum += src[col + 6] * coeff[6]; | |
150 | sum += src[col + 7] * coeff[7]; | |
151 | } | |
152 | ||
153 | int16_t val = (int16_t)((sum + offset) >> shift); | |
154 | dst[col] = val; | |
155 | } | |
156 | ||
157 | src += srcStride; | |
158 | dst += dstStride; | |
159 | } | |
160 | } | |
161 | ||
162 | template<int N, int width, int height> | |
b53f7c52 | 163 | void interp_vert_pp_c(const pixel* src, intptr_t srcStride, pixel* dst, intptr_t dstStride, int coeffIdx) |
72b9787e | 164 | { |
b53f7c52 | 165 | const int16_t* c = (N == 4) ? g_chromaFilter[coeffIdx] : g_lumaFilter[coeffIdx]; |
72b9787e JB |
166 | int shift = IF_FILTER_PREC; |
167 | int offset = 1 << (shift - 1); | |
168 | uint16_t maxVal = (1 << X265_DEPTH) - 1; | |
169 | ||
170 | src -= (N / 2 - 1) * srcStride; | |
171 | ||
172 | int row, col; | |
173 | for (row = 0; row < height; row++) | |
174 | { | |
175 | for (col = 0; col < width; col++) | |
176 | { | |
177 | int sum; | |
178 | ||
179 | sum = src[col + 0 * srcStride] * c[0]; | |
180 | sum += src[col + 1 * srcStride] * c[1]; | |
181 | sum += src[col + 2 * srcStride] * c[2]; | |
182 | sum += src[col + 3 * srcStride] * c[3]; | |
183 | if (N == 8) | |
184 | { | |
185 | sum += src[col + 4 * srcStride] * c[4]; | |
186 | sum += src[col + 5 * srcStride] * c[5]; | |
187 | sum += src[col + 6 * srcStride] * c[6]; | |
188 | sum += src[col + 7 * srcStride] * c[7]; | |
189 | } | |
190 | ||
191 | int16_t val = (int16_t)((sum + offset) >> shift); | |
192 | val = (val < 0) ? 0 : val; | |
193 | val = (val > maxVal) ? maxVal : val; | |
194 | ||
195 | dst[col] = (pixel)val; | |
196 | } | |
197 | ||
198 | src += srcStride; | |
199 | dst += dstStride; | |
200 | } | |
201 | } | |
202 | ||
203 | template<int N, int width, int height> | |
b53f7c52 | 204 | void interp_vert_ps_c(const pixel* src, intptr_t srcStride, int16_t* dst, intptr_t dstStride, int coeffIdx) |
72b9787e | 205 | { |
b53f7c52 | 206 | const int16_t* c = (N == 4) ? g_chromaFilter[coeffIdx] : g_lumaFilter[coeffIdx]; |
72b9787e JB |
207 | int headRoom = IF_INTERNAL_PREC - X265_DEPTH; |
208 | int shift = IF_FILTER_PREC - headRoom; | |
209 | int offset = -IF_INTERNAL_OFFS << shift; | |
210 | ||
211 | src -= (N / 2 - 1) * srcStride; | |
212 | ||
213 | int row, col; | |
214 | for (row = 0; row < height; row++) | |
215 | { | |
216 | for (col = 0; col < width; col++) | |
217 | { | |
218 | int sum; | |
219 | ||
220 | sum = src[col + 0 * srcStride] * c[0]; | |
221 | sum += src[col + 1 * srcStride] * c[1]; | |
222 | sum += src[col + 2 * srcStride] * c[2]; | |
223 | sum += src[col + 3 * srcStride] * c[3]; | |
224 | if (N == 8) | |
225 | { | |
226 | sum += src[col + 4 * srcStride] * c[4]; | |
227 | sum += src[col + 5 * srcStride] * c[5]; | |
228 | sum += src[col + 6 * srcStride] * c[6]; | |
229 | sum += src[col + 7 * srcStride] * c[7]; | |
230 | } | |
231 | ||
232 | int16_t val = (int16_t)((sum + offset) >> shift); | |
233 | dst[col] = val; | |
234 | } | |
235 | ||
236 | src += srcStride; | |
237 | dst += dstStride; | |
238 | } | |
239 | } | |
240 | ||
241 | template<int N, int width, int height> | |
b53f7c52 | 242 | void interp_vert_sp_c(const int16_t* src, intptr_t srcStride, pixel* dst, intptr_t dstStride, int coeffIdx) |
72b9787e JB |
243 | { |
244 | int headRoom = IF_INTERNAL_PREC - X265_DEPTH; | |
245 | int shift = IF_FILTER_PREC + headRoom; | |
246 | int offset = (1 << (shift - 1)) + (IF_INTERNAL_OFFS << IF_FILTER_PREC); | |
247 | uint16_t maxVal = (1 << X265_DEPTH) - 1; | |
b53f7c52 | 248 | const int16_t* coeff = (N == 8 ? g_lumaFilter[coeffIdx] : g_chromaFilter[coeffIdx]); |
72b9787e JB |
249 | |
250 | src -= (N / 2 - 1) * srcStride; | |
251 | ||
252 | int row, col; | |
253 | for (row = 0; row < height; row++) | |
254 | { | |
255 | for (col = 0; col < width; col++) | |
256 | { | |
257 | int sum; | |
258 | ||
259 | sum = src[col + 0 * srcStride] * coeff[0]; | |
260 | sum += src[col + 1 * srcStride] * coeff[1]; | |
261 | sum += src[col + 2 * srcStride] * coeff[2]; | |
262 | sum += src[col + 3 * srcStride] * coeff[3]; | |
263 | if (N == 8) | |
264 | { | |
265 | sum += src[col + 4 * srcStride] * coeff[4]; | |
266 | sum += src[col + 5 * srcStride] * coeff[5]; | |
267 | sum += src[col + 6 * srcStride] * coeff[6]; | |
268 | sum += src[col + 7 * srcStride] * coeff[7]; | |
269 | } | |
270 | ||
271 | int16_t val = (int16_t)((sum + offset) >> shift); | |
272 | ||
273 | val = (val < 0) ? 0 : val; | |
274 | val = (val > maxVal) ? maxVal : val; | |
275 | ||
276 | dst[col] = (pixel)val; | |
277 | } | |
278 | ||
279 | src += srcStride; | |
280 | dst += dstStride; | |
281 | } | |
282 | } | |
283 | ||
284 | template<int N, int width, int height> | |
b53f7c52 | 285 | void interp_vert_ss_c(const int16_t* src, intptr_t srcStride, int16_t* dst, intptr_t dstStride, int coeffIdx) |
72b9787e | 286 | { |
b53f7c52 | 287 | const int16_t* c = (N == 8 ? g_lumaFilter[coeffIdx] : g_chromaFilter[coeffIdx]); |
72b9787e JB |
288 | int shift = IF_FILTER_PREC; |
289 | int row, col; | |
290 | ||
291 | src -= (N / 2 - 1) * srcStride; | |
292 | for (row = 0; row < height; row++) | |
293 | { | |
294 | for (col = 0; col < width; col++) | |
295 | { | |
296 | int sum; | |
297 | ||
298 | sum = src[col + 0 * srcStride] * c[0]; | |
299 | sum += src[col + 1 * srcStride] * c[1]; | |
300 | sum += src[col + 2 * srcStride] * c[2]; | |
301 | sum += src[col + 3 * srcStride] * c[3]; | |
302 | if (N == 8) | |
303 | { | |
304 | sum += src[col + 4 * srcStride] * c[4]; | |
305 | sum += src[col + 5 * srcStride] * c[5]; | |
306 | sum += src[col + 6 * srcStride] * c[6]; | |
307 | sum += src[col + 7 * srcStride] * c[7]; | |
308 | } | |
309 | ||
310 | int16_t val = (int16_t)((sum) >> shift); | |
311 | dst[col] = val; | |
312 | } | |
313 | ||
314 | src += srcStride; | |
315 | dst += dstStride; | |
316 | } | |
317 | } | |
318 | ||
319 | template<int N> | |
b53f7c52 | 320 | void filterVertical_sp_c(const int16_t* src, intptr_t srcStride, pixel* dst, intptr_t dstStride, int width, int height, int coeffIdx) |
72b9787e JB |
321 | { |
322 | int headRoom = IF_INTERNAL_PREC - X265_DEPTH; | |
323 | int shift = IF_FILTER_PREC + headRoom; | |
324 | int offset = (1 << (shift - 1)) + (IF_INTERNAL_OFFS << IF_FILTER_PREC); | |
325 | uint16_t maxVal = (1 << X265_DEPTH) - 1; | |
b53f7c52 | 326 | const int16_t* coeff = (N == 8 ? g_lumaFilter[coeffIdx] : g_chromaFilter[coeffIdx]); |
72b9787e JB |
327 | |
328 | src -= (N / 2 - 1) * srcStride; | |
329 | ||
330 | int row, col; | |
331 | for (row = 0; row < height; row++) | |
332 | { | |
333 | for (col = 0; col < width; col++) | |
334 | { | |
335 | int sum; | |
336 | ||
337 | sum = src[col + 0 * srcStride] * coeff[0]; | |
338 | sum += src[col + 1 * srcStride] * coeff[1]; | |
339 | sum += src[col + 2 * srcStride] * coeff[2]; | |
340 | sum += src[col + 3 * srcStride] * coeff[3]; | |
341 | if (N == 8) | |
342 | { | |
343 | sum += src[col + 4 * srcStride] * coeff[4]; | |
344 | sum += src[col + 5 * srcStride] * coeff[5]; | |
345 | sum += src[col + 6 * srcStride] * coeff[6]; | |
346 | sum += src[col + 7 * srcStride] * coeff[7]; | |
347 | } | |
348 | ||
349 | int16_t val = (int16_t)((sum + offset) >> shift); | |
350 | ||
351 | val = (val < 0) ? 0 : val; | |
352 | val = (val > maxVal) ? maxVal : val; | |
353 | ||
354 | dst[col] = (pixel)val; | |
355 | } | |
356 | ||
357 | src += srcStride; | |
358 | dst += dstStride; | |
359 | } | |
360 | } | |
361 | ||
362 | template<int N, int width, int height> | |
b53f7c52 | 363 | void interp_hv_pp_c(const pixel* src, intptr_t srcStride, pixel* dst, intptr_t dstStride, int idxX, int idxY) |
72b9787e JB |
364 | { |
365 | short immedVals[(64 + 8) * (64 + 8)]; | |
366 | ||
367 | interp_horiz_ps_c<N, width, height>(src, srcStride, immedVals, width, idxX, 1); | |
368 | filterVertical_sp_c<N>(immedVals + 3 * width, width, dst, dstStride, width, height, idxY); | |
369 | } | |
370 | } | |
371 | ||
372 | namespace x265 { | |
373 | // x265 private namespace | |
374 | ||
375 | #define CHROMA_420(W, H) \ | |
376 | p.chroma[X265_CSP_I420].filter_hpp[CHROMA_ ## W ## x ## H] = interp_horiz_pp_c<4, W, H>; \ | |
377 | p.chroma[X265_CSP_I420].filter_hps[CHROMA_ ## W ## x ## H] = interp_horiz_ps_c<4, W, H>; \ | |
378 | p.chroma[X265_CSP_I420].filter_vpp[CHROMA_ ## W ## x ## H] = interp_vert_pp_c<4, W, H>; \ | |
379 | p.chroma[X265_CSP_I420].filter_vps[CHROMA_ ## W ## x ## H] = interp_vert_ps_c<4, W, H>; \ | |
380 | p.chroma[X265_CSP_I420].filter_vsp[CHROMA_ ## W ## x ## H] = interp_vert_sp_c<4, W, H>; \ | |
381 | p.chroma[X265_CSP_I420].filter_vss[CHROMA_ ## W ## x ## H] = interp_vert_ss_c<4, W, H>; | |
382 | ||
383 | #define CHROMA_422(W, H) \ | |
384 | p.chroma[X265_CSP_I422].filter_hpp[CHROMA422_ ## W ## x ## H] = interp_horiz_pp_c<4, W, H>; \ | |
385 | p.chroma[X265_CSP_I422].filter_hps[CHROMA422_ ## W ## x ## H] = interp_horiz_ps_c<4, W, H>; \ | |
386 | p.chroma[X265_CSP_I422].filter_vpp[CHROMA422_ ## W ## x ## H] = interp_vert_pp_c<4, W, H>; \ | |
387 | p.chroma[X265_CSP_I422].filter_vps[CHROMA422_ ## W ## x ## H] = interp_vert_ps_c<4, W, H>; \ | |
388 | p.chroma[X265_CSP_I422].filter_vsp[CHROMA422_ ## W ## x ## H] = interp_vert_sp_c<4, W, H>; \ | |
389 | p.chroma[X265_CSP_I422].filter_vss[CHROMA422_ ## W ## x ## H] = interp_vert_ss_c<4, W, H>; | |
390 | ||
391 | #define CHROMA_444(W, H) \ | |
392 | p.chroma[X265_CSP_I444].filter_hpp[LUMA_ ## W ## x ## H] = interp_horiz_pp_c<4, W, H>; \ | |
393 | p.chroma[X265_CSP_I444].filter_hps[LUMA_ ## W ## x ## H] = interp_horiz_ps_c<4, W, H>; \ | |
394 | p.chroma[X265_CSP_I444].filter_vpp[LUMA_ ## W ## x ## H] = interp_vert_pp_c<4, W, H>; \ | |
395 | p.chroma[X265_CSP_I444].filter_vps[LUMA_ ## W ## x ## H] = interp_vert_ps_c<4, W, H>; \ | |
396 | p.chroma[X265_CSP_I444].filter_vsp[LUMA_ ## W ## x ## H] = interp_vert_sp_c<4, W, H>; \ | |
397 | p.chroma[X265_CSP_I444].filter_vss[LUMA_ ## W ## x ## H] = interp_vert_ss_c<4, W, H>; | |
398 | ||
399 | #define LUMA(W, H) \ | |
400 | p.luma_hpp[LUMA_ ## W ## x ## H] = interp_horiz_pp_c<8, W, H>; \ | |
401 | p.luma_hps[LUMA_ ## W ## x ## H] = interp_horiz_ps_c<8, W, H>; \ | |
402 | p.luma_vpp[LUMA_ ## W ## x ## H] = interp_vert_pp_c<8, W, H>; \ | |
403 | p.luma_vps[LUMA_ ## W ## x ## H] = interp_vert_ps_c<8, W, H>; \ | |
404 | p.luma_vsp[LUMA_ ## W ## x ## H] = interp_vert_sp_c<8, W, H>; \ | |
405 | p.luma_vss[LUMA_ ## W ## x ## H] = interp_vert_ss_c<8, W, H>; \ | |
406 | p.luma_hvpp[LUMA_ ## W ## x ## H] = interp_hv_pp_c<8, W, H>; | |
407 | ||
408 | void Setup_C_IPFilterPrimitives(EncoderPrimitives& p) | |
409 | { | |
410 | LUMA(4, 4); | |
411 | LUMA(8, 8); | |
412 | CHROMA_420(4, 4); | |
413 | LUMA(4, 8); | |
414 | CHROMA_420(2, 4); | |
415 | LUMA(8, 4); | |
416 | CHROMA_420(4, 2); | |
417 | LUMA(16, 16); | |
418 | CHROMA_420(8, 8); | |
419 | LUMA(16, 8); | |
420 | CHROMA_420(8, 4); | |
421 | LUMA(8, 16); | |
422 | CHROMA_420(4, 8); | |
423 | LUMA(16, 12); | |
424 | CHROMA_420(8, 6); | |
425 | LUMA(12, 16); | |
426 | CHROMA_420(6, 8); | |
427 | LUMA(16, 4); | |
428 | CHROMA_420(8, 2); | |
429 | LUMA(4, 16); | |
430 | CHROMA_420(2, 8); | |
431 | LUMA(32, 32); | |
432 | CHROMA_420(16, 16); | |
433 | LUMA(32, 16); | |
434 | CHROMA_420(16, 8); | |
435 | LUMA(16, 32); | |
436 | CHROMA_420(8, 16); | |
437 | LUMA(32, 24); | |
438 | CHROMA_420(16, 12); | |
439 | LUMA(24, 32); | |
440 | CHROMA_420(12, 16); | |
441 | LUMA(32, 8); | |
442 | CHROMA_420(16, 4); | |
443 | LUMA(8, 32); | |
444 | CHROMA_420(4, 16); | |
445 | LUMA(64, 64); | |
446 | CHROMA_420(32, 32); | |
447 | LUMA(64, 32); | |
448 | CHROMA_420(32, 16); | |
449 | LUMA(32, 64); | |
450 | CHROMA_420(16, 32); | |
451 | LUMA(64, 48); | |
452 | CHROMA_420(32, 24); | |
453 | LUMA(48, 64); | |
454 | CHROMA_420(24, 32); | |
455 | LUMA(64, 16); | |
456 | CHROMA_420(32, 8); | |
457 | LUMA(16, 64); | |
458 | CHROMA_420(8, 32); | |
459 | ||
460 | CHROMA_422(4, 8); | |
461 | CHROMA_422(4, 4); | |
462 | CHROMA_422(2, 8); | |
463 | CHROMA_422(8, 16); | |
464 | CHROMA_422(8, 8); | |
465 | CHROMA_422(4, 16); | |
466 | CHROMA_422(8, 12); | |
467 | CHROMA_422(6, 16); | |
468 | CHROMA_422(8, 4); | |
469 | CHROMA_422(2, 16); | |
470 | CHROMA_422(16, 32); | |
471 | CHROMA_422(16, 16); | |
472 | CHROMA_422(8, 32); | |
473 | CHROMA_422(16, 24); | |
474 | CHROMA_422(12, 32); | |
475 | CHROMA_422(16, 8); | |
476 | CHROMA_422(4, 32); | |
477 | CHROMA_422(32, 64); | |
478 | CHROMA_422(32, 32); | |
479 | CHROMA_422(16, 64); | |
480 | CHROMA_422(32, 48); | |
481 | CHROMA_422(24, 64); | |
482 | CHROMA_422(32, 16); | |
483 | CHROMA_422(8, 64); | |
484 | ||
485 | CHROMA_444(4, 4); | |
486 | CHROMA_444(8, 8); | |
487 | CHROMA_444(4, 8); | |
488 | CHROMA_444(8, 4); | |
489 | CHROMA_444(16, 16); | |
490 | CHROMA_444(16, 8); | |
491 | CHROMA_444(8, 16); | |
492 | CHROMA_444(16, 12); | |
493 | CHROMA_444(12, 16); | |
494 | CHROMA_444(16, 4); | |
495 | CHROMA_444(4, 16); | |
496 | CHROMA_444(32, 32); | |
497 | CHROMA_444(32, 16); | |
498 | CHROMA_444(16, 32); | |
499 | CHROMA_444(32, 24); | |
500 | CHROMA_444(24, 32); | |
501 | CHROMA_444(32, 8); | |
502 | CHROMA_444(8, 32); | |
503 | CHROMA_444(64, 64); | |
504 | CHROMA_444(64, 32); | |
505 | CHROMA_444(32, 64); | |
506 | CHROMA_444(64, 48); | |
507 | CHROMA_444(48, 64); | |
508 | CHROMA_444(64, 16); | |
509 | CHROMA_444(16, 64); | |
510 | p.luma_p2s = filterConvertPelToShort_c<MAX_CU_SIZE>; | |
511 | ||
b53f7c52 JB |
512 | p.chroma[X265_CSP_I444].p2s = filterConvertPelToShort_c<MAX_CU_SIZE>; |
513 | p.chroma[X265_CSP_I420].p2s = filterConvertPelToShort_c<MAX_CU_SIZE / 2>; | |
514 | p.chroma[X265_CSP_I422].p2s = filterConvertPelToShort_c<MAX_CU_SIZE / 2>; | |
72b9787e JB |
515 | |
516 | p.extendRowBorder = extendCURowColBorder; | |
517 | } | |
518 | } |