History

Merge commit '2539cf1c814190a017cb8986b41aa2f949e37fd9'

* commit '2539cf1c814190a017cb8986b41aa2f949e37fd9': hpeldsp_template: K&R formatting cosmetics Conflicts: libavcodec/hpeldsp_template.c

Michael Niedermayer committed 12 years ago

Commit 76d76762 parents 8b66b43 2539cf11 file · +297 −213Browse files

Unified · Split

libavcodec/hpeldsp_template.c+297−213
@@ -1,5 +1,6 @@
1/*1/*
2 * Half-pel DSP functions.2 * Half-pel DSP functions
3 *
3 * Copyright (c) 2000, 2001 Fabrice Bellard4 * Copyright (c) 2000, 2001 Fabrice Bellard
4 * Copyright (c) 2002-2004 Michael Niedermayer <michaelni@gmx.at>5 * Copyright (c) 2002-2004 Michael Niedermayer <michaelni@gmx.at>
5 *6 *
@@ -24,224 +25,307 @@ · 18 unmodified lines
24 25
25/**26/**
26 * @file27 * @file
27 * Half-pel DSP functions.28 * Half-pel DSP functions
28 */29 */
29 30
30#include "bit_depth_template.c"31#include "bit_depth_template.c"
31 32
32#include "hpel_template.c"33#include "hpel_template.c"
33 34
34#define PIXOP2(OPNAME, OP) \35#define PIXOP2(OPNAME, OP) \
35static inline void FUNC(OPNAME ## _no_rnd_pixels8_l2)(uint8_t *dst, const uint8_t *src1, const uint8_t *src2, int dst_stride, \36static inline void FUNC(OPNAME ## _no_rnd_pixels8_l2)(uint8_t *dst, \
36 int src_stride1, int src_stride2, int h){\37 const uint8_t *src1, \
37 int i;\38 const uint8_t *src2, \
38 for(i=0; i<h; i++){\39 int dst_stride, \
39 pixel4 a,b;\40 int src_stride1, \
40 a= AV_RN4P(&src1[i*src_stride1 ]);\41 int src_stride2, \
41 b= AV_RN4P(&src2[i*src_stride2 ]);\42 int h) \
42 OP(*((pixel4*)&dst[i*dst_stride ]), no_rnd_avg_pixel4(a, b));\43{ \
43 a= AV_RN4P(&src1[i*src_stride1+4*sizeof(pixel)]);\44 int i; \
44 b= AV_RN4P(&src2[i*src_stride2+4*sizeof(pixel)]);\45 \
45 OP(*((pixel4*)&dst[i*dst_stride+4*sizeof(pixel)]), no_rnd_avg_pixel4(a, b));\46 for (i = 0; i < h; i++) { \
46 }\47 pixel4 a, b; \
47}\48 a = AV_RN4P(&src1[i * src_stride1]); \
48\49 b = AV_RN4P(&src2[i * src_stride2]); \
49static inline void FUNCC(OPNAME ## _no_rnd_pixels8_x2)(uint8_t *block, const uint8_t *pixels, ptrdiff_t line_size, int h){\50 OP(*((pixel4 *) &dst[i * dst_stride]), \
50 FUNC(OPNAME ## _no_rnd_pixels8_l2)(block, pixels, pixels+sizeof(pixel), line_size, line_size, line_size, h);\51 no_rnd_avg_pixel4(a, b)); \
51}\52 a = AV_RN4P(&src1[i * src_stride1 + 4 * sizeof(pixel)]); \
52\53 b = AV_RN4P(&src2[i * src_stride2 + 4 * sizeof(pixel)]); \
53static inline void FUNCC(OPNAME ## _pixels8_x2)(uint8_t *block, const uint8_t *pixels, ptrdiff_t line_size, int h){\54 OP(*((pixel4 *) &dst[i * dst_stride + 4 * sizeof(pixel)]), \
54 FUNC(OPNAME ## _pixels8_l2)(block, pixels, pixels+sizeof(pixel), line_size, line_size, line_size, h);\55 no_rnd_avg_pixel4(a, b)); \
55}\56 } \
56\57} \
57static inline void FUNCC(OPNAME ## _no_rnd_pixels8_y2)(uint8_t *block, const uint8_t *pixels, ptrdiff_t line_size, int h){\58 \
58 FUNC(OPNAME ## _no_rnd_pixels8_l2)(block, pixels, pixels+line_size, line_size, line_size, line_size, h);\59static inline void FUNCC(OPNAME ## _no_rnd_pixels8_x2)(uint8_t *block, \
59}\60 const uint8_t *pixels, \
60\61 ptrdiff_t line_size, \
61static inline void FUNCC(OPNAME ## _pixels8_y2)(uint8_t *block, const uint8_t *pixels, ptrdiff_t line_size, int h){\62 int h) \
62 FUNC(OPNAME ## _pixels8_l2)(block, pixels, pixels+line_size, line_size, line_size, line_size, h);\63{ \
63}\64 FUNC(OPNAME ## _no_rnd_pixels8_l2)(block, pixels, pixels + sizeof(pixel), \
64\65 line_size, line_size, line_size, h); \
65static inline void FUNCC(OPNAME ## _pixels4_x2)(uint8_t *block, const uint8_t *pixels, ptrdiff_t line_size, int h){\66} \
66 FUNC(OPNAME ## _pixels4_l2)(block, pixels, pixels+sizeof(pixel), line_size, line_size, line_size, h);\67 \
67}\68static inline void FUNCC(OPNAME ## _pixels8_x2)(uint8_t *block, \
68\69 const uint8_t *pixels, \
69static inline void FUNCC(OPNAME ## _pixels4_y2)(uint8_t *block, const uint8_t *pixels, ptrdiff_t line_size, int h){\70 ptrdiff_t line_size, \
70 FUNC(OPNAME ## _pixels4_l2)(block, pixels, pixels+line_size, line_size, line_size, line_size, h);\71 int h) \
71}\72{ \
72\73 FUNC(OPNAME ## _pixels8_l2)(block, pixels, pixels + sizeof(pixel), \
73static inline void FUNCC(OPNAME ## _pixels2_x2)(uint8_t *block, const uint8_t *pixels, ptrdiff_t line_size, int h){\74 line_size, line_size, line_size, h); \
74 FUNC(OPNAME ## _pixels2_l2)(block, pixels, pixels+sizeof(pixel), line_size, line_size, line_size, h);\75} \
75}\76 \
76\77static inline void FUNCC(OPNAME ## _no_rnd_pixels8_y2)(uint8_t *block, \
77static inline void FUNCC(OPNAME ## _pixels2_y2)(uint8_t *block, const uint8_t *pixels, ptrdiff_t line_size, int h){\78 const uint8_t *pixels, \
78 FUNC(OPNAME ## _pixels2_l2)(block, pixels, pixels+line_size, line_size, line_size, line_size, h);\79 ptrdiff_t line_size, \
79}\80 int h) \
80\81{ \
81static inline void FUNCC(OPNAME ## _pixels2_xy2)(uint8_t *_block, const uint8_t *_pixels, ptrdiff_t line_size, int h)\82 FUNC(OPNAME ## _no_rnd_pixels8_l2)(block, pixels, pixels + line_size, \
82{\83 line_size, line_size, line_size, h); \
83 int i, a0, b0, a1, b1;\84} \
84 pixel *block = (pixel*)_block;\85 \
85 const pixel *pixels = (const pixel*)_pixels;\86static inline void FUNCC(OPNAME ## _pixels8_y2)(uint8_t *block, \
86 line_size >>= sizeof(pixel)-1;\87 const uint8_t *pixels, \
87 a0= pixels[0];\88 ptrdiff_t line_size, \
88 b0= pixels[1] + 2;\89 int h) \
89 a0 += b0;\90{ \
90 b0 += pixels[2];\91 FUNC(OPNAME ## _pixels8_l2)(block, pixels, pixels + line_size, \
91\92 line_size, line_size, line_size, h); \
92 pixels+=line_size;\93} \
93 for(i=0; i<h; i+=2){\94 \
94 a1= pixels[0];\95static inline void FUNCC(OPNAME ## _pixels4_x2)(uint8_t *block, \
95 b1= pixels[1];\96 const uint8_t *pixels, \
96 a1 += b1;\97 ptrdiff_t line_size, \
97 b1 += pixels[2];\98 int h) \
98\99{ \
99 block[0]= (a1+a0)>>2; /* FIXME non put */\100 FUNC(OPNAME ## _pixels4_l2)(block, pixels, pixels + sizeof(pixel), \
100 block[1]= (b1+b0)>>2;\101 line_size, line_size, line_size, h); \
101\102} \
102 pixels+=line_size;\103 \
103 block +=line_size;\104static inline void FUNCC(OPNAME ## _pixels4_y2)(uint8_t *block, \
104\105 const uint8_t *pixels, \
105 a0= pixels[0];\106 ptrdiff_t line_size, \
106 b0= pixels[1] + 2;\107 int h) \
107 a0 += b0;\108{ \
108 b0 += pixels[2];\109 FUNC(OPNAME ## _pixels4_l2)(block, pixels, pixels + line_size, \
109\110 line_size, line_size, line_size, h); \
110 block[0]= (a1+a0)>>2;\111} \
111 block[1]= (b1+b0)>>2;\112 \
112 pixels+=line_size;\113static inline void FUNCC(OPNAME ## _pixels2_x2)(uint8_t *block, \
113 block +=line_size;\114 const uint8_t *pixels, \
114 }\115 ptrdiff_t line_size, \
115}\116 int h) \
116\117{ \
117static inline void FUNCC(OPNAME ## _pixels4_xy2)(uint8_t *block, const uint8_t *pixels, ptrdiff_t line_size, int h)\118 FUNC(OPNAME ## _pixels2_l2)(block, pixels, pixels + sizeof(pixel), \
118{\119 line_size, line_size, line_size, h); \
119 /* FIXME HIGH BIT DEPTH */\120} \
120 int i;\121 \
121 const uint32_t a= AV_RN32(pixels );\122static inline void FUNCC(OPNAME ## _pixels2_y2)(uint8_t *block, \
122 const uint32_t b= AV_RN32(pixels+1);\123 const uint8_t *pixels, \
123 uint32_t l0= (a&0x03030303UL)\124 ptrdiff_t line_size, \
124 + (b&0x03030303UL)\125 int h) \
125 + 0x02020202UL;\126{ \
126 uint32_t h0= ((a&0xFCFCFCFCUL)>>2)\127 FUNC(OPNAME ## _pixels2_l2)(block, pixels, pixels + line_size, \
127 + ((b&0xFCFCFCFCUL)>>2);\128 line_size, line_size, line_size, h); \
128 uint32_t l1,h1;\129} \
129\130 \
130 pixels+=line_size;\131static inline void FUNCC(OPNAME ## _pixels2_xy2)(uint8_t *_block, \
131 for(i=0; i<h; i+=2){\132 const uint8_t *_pixels, \
132 uint32_t a= AV_RN32(pixels );\133 ptrdiff_t line_size, \
133 uint32_t b= AV_RN32(pixels+1);\134 int h) \
134 l1= (a&0x03030303UL)\135{ \
135 + (b&0x03030303UL);\136 int i, a0, b0, a1, b1; \
136 h1= ((a&0xFCFCFCFCUL)>>2)\137 pixel *block = (pixel *) _block; \
137 + ((b&0xFCFCFCFCUL)>>2);\138 const pixel *pixels = (const pixel *) _pixels; \
138 OP(*((uint32_t*)block), h0+h1+(((l0+l1)>>2)&0x0F0F0F0FUL));\139 a0 = pixels[0]; \
139 pixels+=line_size;\140 b0 = pixels[1] + 2; \
140 block +=line_size;\141 a0 += b0; \
141 a= AV_RN32(pixels );\142 b0 += pixels[2]; \
142 b= AV_RN32(pixels+1);\143 \
143 l0= (a&0x03030303UL)\144 line_size >>= sizeof(pixel)-1; \
144 + (b&0x03030303UL)\145 pixels += line_size; \
145 + 0x02020202UL;\146 for (i = 0; i < h; i += 2) { \
146 h0= ((a&0xFCFCFCFCUL)>>2)\147 a1 = pixels[0]; \
147 + ((b&0xFCFCFCFCUL)>>2);\148 b1 = pixels[1]; \
148 OP(*((uint32_t*)block), h0+h1+(((l0+l1)>>2)&0x0F0F0F0FUL));\149 a1 += b1; \
149 pixels+=line_size;\150 b1 += pixels[2]; \
150 block +=line_size;\151 \
151 }\152 block[0] = (a1 + a0) >> 2; /* FIXME non put */ \
152}\153 block[1] = (b1 + b0) >> 2; \
153\154 \
154static inline void FUNCC(OPNAME ## _pixels8_xy2)(uint8_t *block, const uint8_t *pixels, ptrdiff_t line_size, int h)\155 pixels += line_size; \
155{\156 block += line_size; \
156 /* FIXME HIGH BIT DEPTH */\157 \
157 int j;\158 a0 = pixels[0]; \
158 for(j=0; j<2; j++){\159 b0 = pixels[1] + 2; \
159 int i;\160 a0 += b0; \
160 const uint32_t a= AV_RN32(pixels );\161 b0 += pixels[2]; \
161 const uint32_t b= AV_RN32(pixels+1);\162 \
162 uint32_t l0= (a&0x03030303UL)\163 block[0] = (a1 + a0) >> 2; \
163 + (b&0x03030303UL)\164 block[1] = (b1 + b0) >> 2; \
164 + 0x02020202UL;\165 pixels += line_size; \
165 uint32_t h0= ((a&0xFCFCFCFCUL)>>2)\166 block += line_size; \
166 + ((b&0xFCFCFCFCUL)>>2);\167 } \
167 uint32_t l1,h1;\168} \
168\169 \
169 pixels+=line_size;\170static inline void FUNCC(OPNAME ## _pixels4_xy2)(uint8_t *block, \
170 for(i=0; i<h; i+=2){\171 const uint8_t *pixels, \
171 uint32_t a= AV_RN32(pixels );\172 ptrdiff_t line_size, \
172 uint32_t b= AV_RN32(pixels+1);\173 int h) \
173 l1= (a&0x03030303UL)\174{ \
174 + (b&0x03030303UL);\175 /* FIXME HIGH BIT DEPTH */ \
175 h1= ((a&0xFCFCFCFCUL)>>2)\176 int i; \
176 + ((b&0xFCFCFCFCUL)>>2);\177 const uint32_t a = AV_RN32(pixels); \
177 OP(*((uint32_t*)block), h0+h1+(((l0+l1)>>2)&0x0F0F0F0FUL));\178 const uint32_t b = AV_RN32(pixels + 1); \
178 pixels+=line_size;\179 uint32_t l0 = (a & 0x03030303UL) + \
179 block +=line_size;\180 (b & 0x03030303UL) + \
180 a= AV_RN32(pixels );\181 0x02020202UL; \
181 b= AV_RN32(pixels+1);\182 uint32_t h0 = ((a & 0xFCFCFCFCUL) >> 2) + \
182 l0= (a&0x03030303UL)\183 ((b & 0xFCFCFCFCUL) >> 2); \
183 + (b&0x03030303UL)\184 uint32_t l1, h1; \
184 + 0x02020202UL;\185 \
185 h0= ((a&0xFCFCFCFCUL)>>2)\186 pixels += line_size; \
186 + ((b&0xFCFCFCFCUL)>>2);\187 for (i = 0; i < h; i += 2) { \
187 OP(*((uint32_t*)block), h0+h1+(((l0+l1)>>2)&0x0F0F0F0FUL));\188 uint32_t a = AV_RN32(pixels); \
188 pixels+=line_size;\189 uint32_t b = AV_RN32(pixels + 1); \
189 block +=line_size;\190 l1 = (a & 0x03030303UL) + \
190 }\191 (b & 0x03030303UL); \
191 pixels+=4-line_size*(h+1);\192 h1 = ((a & 0xFCFCFCFCUL) >> 2) + \
192 block +=4-line_size*h;\193 ((b & 0xFCFCFCFCUL) >> 2); \
193 }\194 OP(*((uint32_t *) block), h0 + h1 + \
194}\195 (((l0 + l1) >> 2) & 0x0F0F0F0FUL)); \
195\196 pixels += line_size; \
196static inline void FUNCC(OPNAME ## _no_rnd_pixels8_xy2)(uint8_t *block, const uint8_t *pixels, ptrdiff_t line_size, int h)\197 block += line_size; \
197{\198 a = AV_RN32(pixels); \
198 /* FIXME HIGH BIT DEPTH */\199 b = AV_RN32(pixels + 1); \
199 int j;\200 l0 = (a & 0x03030303UL) + \
200 for(j=0; j<2; j++){\201 (b & 0x03030303UL) + \
201 int i;\202 0x02020202UL; \
202 const uint32_t a= AV_RN32(pixels );\203 h0 = ((a & 0xFCFCFCFCUL) >> 2) + \
203 const uint32_t b= AV_RN32(pixels+1);\204 ((b & 0xFCFCFCFCUL) >> 2); \
204 uint32_t l0= (a&0x03030303UL)\205 OP(*((uint32_t *) block), h0 + h1 + \
205 + (b&0x03030303UL)\206 (((l0 + l1) >> 2) & 0x0F0F0F0FUL)); \
206 + 0x01010101UL;\207 pixels += line_size; \
207 uint32_t h0= ((a&0xFCFCFCFCUL)>>2)\208 block += line_size; \
208 + ((b&0xFCFCFCFCUL)>>2);\209 } \
209 uint32_t l1,h1;\210} \
210\211 \
211 pixels+=line_size;\212static inline void FUNCC(OPNAME ## _pixels8_xy2)(uint8_t *block, \
212 for(i=0; i<h; i+=2){\213 const uint8_t *pixels, \
213 uint32_t a= AV_RN32(pixels );\214 ptrdiff_t line_size, \
214 uint32_t b= AV_RN32(pixels+1);\215 int h) \
215 l1= (a&0x03030303UL)\216{ \
216 + (b&0x03030303UL);\217 /* FIXME HIGH BIT DEPTH */ \
217 h1= ((a&0xFCFCFCFCUL)>>2)\218 int j; \
218 + ((b&0xFCFCFCFCUL)>>2);\219 \
219 OP(*((uint32_t*)block), h0+h1+(((l0+l1)>>2)&0x0F0F0F0FUL));\220 for (j = 0; j < 2; j++) { \
220 pixels+=line_size;\221 int i; \
221 block +=line_size;\222 const uint32_t a = AV_RN32(pixels); \
222 a= AV_RN32(pixels );\223 const uint32_t b = AV_RN32(pixels + 1); \
223 b= AV_RN32(pixels+1);\224 uint32_t l0 = (a & 0x03030303UL) + \
224 l0= (a&0x03030303UL)\225 (b & 0x03030303UL) + \
225 + (b&0x03030303UL)\226 0x02020202UL; \
226 + 0x01010101UL;\227 uint32_t h0 = ((a & 0xFCFCFCFCUL) >> 2) + \
227 h0= ((a&0xFCFCFCFCUL)>>2)\228 ((b & 0xFCFCFCFCUL) >> 2); \
228 + ((b&0xFCFCFCFCUL)>>2);\229 uint32_t l1, h1; \
229 OP(*((uint32_t*)block), h0+h1+(((l0+l1)>>2)&0x0F0F0F0FUL));\230 \
230 pixels+=line_size;\231 pixels += line_size; \
231 block +=line_size;\232 for (i = 0; i < h; i += 2) { \
232 }\233 uint32_t a = AV_RN32(pixels); \
233 pixels+=4-line_size*(h+1);\234 uint32_t b = AV_RN32(pixels + 1); \
234 block +=4-line_size*h;\235 l1 = (a & 0x03030303UL) + \
235 }\236 (b & 0x03030303UL); \
236}\237 h1 = ((a & 0xFCFCFCFCUL) >> 2) + \
237\238 ((b & 0xFCFCFCFCUL) >> 2); \
238CALL_2X_PIXELS(FUNCC(OPNAME ## _pixels16_x2) , FUNCC(OPNAME ## _pixels8_x2) , 8*sizeof(pixel))\239 OP(*((uint32_t *) block), h0 + h1 + \
239CALL_2X_PIXELS(FUNCC(OPNAME ## _pixels16_y2) , FUNCC(OPNAME ## _pixels8_y2) , 8*sizeof(pixel))\240 (((l0 + l1) >> 2) & 0x0F0F0F0FUL)); \
240CALL_2X_PIXELS(FUNCC(OPNAME ## _pixels16_xy2), FUNCC(OPNAME ## _pixels8_xy2), 8*sizeof(pixel))\241 pixels += line_size; \
241av_unused CALL_2X_PIXELS(FUNCC(OPNAME ## _no_rnd_pixels16) , FUNCC(OPNAME ## _pixels8) , 8*sizeof(pixel))\242 block += line_size; \
242CALL_2X_PIXELS(FUNCC(OPNAME ## _no_rnd_pixels16_x2) , FUNCC(OPNAME ## _no_rnd_pixels8_x2) , 8*sizeof(pixel))\243 a = AV_RN32(pixels); \
243CALL_2X_PIXELS(FUNCC(OPNAME ## _no_rnd_pixels16_y2) , FUNCC(OPNAME ## _no_rnd_pixels8_y2) , 8*sizeof(pixel))\244 b = AV_RN32(pixels + 1); \
244CALL_2X_PIXELS(FUNCC(OPNAME ## _no_rnd_pixels16_xy2), FUNCC(OPNAME ## _no_rnd_pixels8_xy2), 8*sizeof(pixel))\245 l0 = (a & 0x03030303UL) + \
246 (b & 0x03030303UL) + \
247 0x02020202UL; \
248 h0 = ((a & 0xFCFCFCFCUL) >> 2) + \
249 ((b & 0xFCFCFCFCUL) >> 2); \
250 OP(*((uint32_t *) block), h0 + h1 + \
251 (((l0 + l1) >> 2) & 0x0F0F0F0FUL)); \
252 pixels += line_size; \
253 block += line_size; \
254 } \
255 pixels += 4 - line_size * (h + 1); \
256 block += 4 - line_size * h; \
257 } \
258} \
259 \
260static inline void FUNCC(OPNAME ## _no_rnd_pixels8_xy2)(uint8_t *block, \
261 const uint8_t *pixels, \
262 ptrdiff_t line_size, \
263 int h) \
264{ \
265 /* FIXME HIGH BIT DEPTH */ \
266 int j; \
267 \
268 for (j = 0; j < 2; j++) { \
269 int i; \
270 const uint32_t a = AV_RN32(pixels); \
271 const uint32_t b = AV_RN32(pixels + 1); \
272 uint32_t l0 = (a & 0x03030303UL) + \
273 (b & 0x03030303UL) + \
274 0x01010101UL; \
275 uint32_t h0 = ((a & 0xFCFCFCFCUL) >> 2) + \
276 ((b & 0xFCFCFCFCUL) >> 2); \
277 uint32_t l1, h1; \
278 \
279 pixels += line_size; \
280 for (i = 0; i < h; i += 2) { \
281 uint32_t a = AV_RN32(pixels); \
282 uint32_t b = AV_RN32(pixels + 1); \
283 l1 = (a & 0x03030303UL) + \
284 (b & 0x03030303UL); \
285 h1 = ((a & 0xFCFCFCFCUL) >> 2) + \
286 ((b & 0xFCFCFCFCUL) >> 2); \
287 OP(*((uint32_t *) block), h0 + h1 + \
288 (((l0 + l1) >> 2) & 0x0F0F0F0FUL)); \
289 pixels += line_size; \
290 block += line_size; \
291 a = AV_RN32(pixels); \
292 b = AV_RN32(pixels + 1); \
293 l0 = (a & 0x03030303UL) + \
294 (b & 0x03030303UL) + \
295 0x01010101UL; \
296 h0 = ((a & 0xFCFCFCFCUL) >> 2) + \
297 ((b & 0xFCFCFCFCUL) >> 2); \
298 OP(*((uint32_t *) block), h0 + h1 + \
299 (((l0 + l1) >> 2) & 0x0F0F0F0FUL)); \
300 pixels += line_size; \
301 block += line_size; \
302 } \
303 pixels += 4 - line_size * (h + 1); \
304 block += 4 - line_size * h; \
305 } \
306} \
307 \
308CALL_2X_PIXELS(FUNCC(OPNAME ## _pixels16_x2), \
309 FUNCC(OPNAME ## _pixels8_x2), \
310 8 * sizeof(pixel)) \
311CALL_2X_PIXELS(FUNCC(OPNAME ## _pixels16_y2), \
312 FUNCC(OPNAME ## _pixels8_y2), \
313 8 * sizeof(pixel)) \
314CALL_2X_PIXELS(FUNCC(OPNAME ## _pixels16_xy2), \
315 FUNCC(OPNAME ## _pixels8_xy2), \
316 8 * sizeof(pixel)) \
317av_unused CALL_2X_PIXELS(FUNCC(OPNAME ## _no_rnd_pixels16), \
318 FUNCC(OPNAME ## _pixels8), \
319 8 * sizeof(pixel)) \
320CALL_2X_PIXELS(FUNCC(OPNAME ## _no_rnd_pixels16_x2), \
321 FUNCC(OPNAME ## _no_rnd_pixels8_x2), \
322 8 * sizeof(pixel)) \
323CALL_2X_PIXELS(FUNCC(OPNAME ## _no_rnd_pixels16_y2), \
324 FUNCC(OPNAME ## _no_rnd_pixels8_y2), \
325 8 * sizeof(pixel)) \
326CALL_2X_PIXELS(FUNCC(OPNAME ## _no_rnd_pixels16_xy2), \
327 FUNCC(OPNAME ## _no_rnd_pixels8_xy2), \
328 8 * sizeof(pixel)) \
245 329
246#define op_avg(a, b) a = rnd_avg_pixel4(a, b)330#define op_avg(a, b) a = rnd_avg_pixel4(a, b)
247#define op_put(a, b) a = b331#define op_put(a, b) a = b

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