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 @@
11 /*
2− * Half-pel DSP functions.
2+ * Half-pel DSP functions
3+ *
34 * Copyright (c) 2000, 2001 Fabrice Bellard
45 * Copyright (c) 2002-2004 Michael Niedermayer <michaelni@gmx.at>
56 *
@@ -24,224 +25,307 @@ · 18 unmodified lines
2425
2526 /**
2627 * @file
27− * Half-pel DSP functions.
28+ * Half-pel DSP functions
2829 */
2930
3031 #include "bit_depth_template.c"
3132
3233 #include "hpel_template.c"
3334
34−#define PIXOP2(OPNAME, OP) \
35−static inline void FUNC(OPNAME ## _no_rnd_pixels8_l2)(uint8_t *dst, const uint8_t *src1, const uint8_t *src2, int dst_stride, \
36− int src_stride1, int src_stride2, int h){\
37− int i;\
38− for(i=0; i<h; i++){\
39− pixel4 a,b;\
40− a= AV_RN4P(&src1[i*src_stride1 ]);\
41− b= AV_RN4P(&src2[i*src_stride2 ]);\
42− OP(*((pixel4*)&dst[i*dst_stride ]), no_rnd_avg_pixel4(a, b));\
43− a= AV_RN4P(&src1[i*src_stride1+4*sizeof(pixel)]);\
44− b= AV_RN4P(&src2[i*src_stride2+4*sizeof(pixel)]);\
45− OP(*((pixel4*)&dst[i*dst_stride+4*sizeof(pixel)]), no_rnd_avg_pixel4(a, b));\
46− }\
47−}\
48−\
49−static inline void FUNCC(OPNAME ## _no_rnd_pixels8_x2)(uint8_t *block, const uint8_t *pixels, ptrdiff_t line_size, int h){\
50− FUNC(OPNAME ## _no_rnd_pixels8_l2)(block, pixels, pixels+sizeof(pixel), line_size, line_size, line_size, h);\
51−}\
52−\
53−static inline void FUNCC(OPNAME ## _pixels8_x2)(uint8_t *block, const uint8_t *pixels, ptrdiff_t line_size, int h){\
54− FUNC(OPNAME ## _pixels8_l2)(block, pixels, pixels+sizeof(pixel), line_size, line_size, line_size, h);\
55−}\
56−\
57−static inline void FUNCC(OPNAME ## _no_rnd_pixels8_y2)(uint8_t *block, const uint8_t *pixels, ptrdiff_t line_size, int h){\
58− FUNC(OPNAME ## _no_rnd_pixels8_l2)(block, pixels, pixels+line_size, line_size, line_size, line_size, h);\
59−}\
60−\
61−static inline void FUNCC(OPNAME ## _pixels8_y2)(uint8_t *block, const uint8_t *pixels, ptrdiff_t line_size, int h){\
62− FUNC(OPNAME ## _pixels8_l2)(block, pixels, pixels+line_size, line_size, line_size, line_size, h);\
63−}\
64−\
65−static inline void FUNCC(OPNAME ## _pixels4_x2)(uint8_t *block, const uint8_t *pixels, ptrdiff_t line_size, int h){\
66− FUNC(OPNAME ## _pixels4_l2)(block, pixels, pixels+sizeof(pixel), line_size, line_size, line_size, h);\
67−}\
68−\
69−static inline void FUNCC(OPNAME ## _pixels4_y2)(uint8_t *block, const uint8_t *pixels, ptrdiff_t line_size, int h){\
70− FUNC(OPNAME ## _pixels4_l2)(block, pixels, pixels+line_size, line_size, line_size, line_size, h);\
71−}\
72−\
73−static inline void FUNCC(OPNAME ## _pixels2_x2)(uint8_t *block, const uint8_t *pixels, ptrdiff_t line_size, int h){\
74− FUNC(OPNAME ## _pixels2_l2)(block, pixels, pixels+sizeof(pixel), line_size, line_size, line_size, h);\
75−}\
76−\
77−static inline void FUNCC(OPNAME ## _pixels2_y2)(uint8_t *block, const uint8_t *pixels, ptrdiff_t line_size, int h){\
78− FUNC(OPNAME ## _pixels2_l2)(block, pixels, pixels+line_size, line_size, line_size, line_size, h);\
79−}\
80−\
81−static inline void FUNCC(OPNAME ## _pixels2_xy2)(uint8_t *_block, const uint8_t *_pixels, ptrdiff_t line_size, int h)\
82−{\
83− int i, a0, b0, a1, b1;\
84− pixel *block = (pixel*)_block;\
85− const pixel *pixels = (const pixel*)_pixels;\
86− line_size >>= sizeof(pixel)-1;\
87− a0= pixels[0];\
88− b0= pixels[1] + 2;\
89− a0 += b0;\
90− b0 += pixels[2];\
91−\
92− pixels+=line_size;\
93− for(i=0; i<h; i+=2){\
94− a1= pixels[0];\
95− b1= pixels[1];\
96− a1 += b1;\
97− b1 += pixels[2];\
98−\
99− block[0]= (a1+a0)>>2; /* FIXME non put */\
100− block[1]= (b1+b0)>>2;\
101−\
102− pixels+=line_size;\
103− block +=line_size;\
104−\
105− a0= pixels[0];\
106− b0= pixels[1] + 2;\
107− a0 += b0;\
108− b0 += pixels[2];\
109−\
110− block[0]= (a1+a0)>>2;\
111− block[1]= (b1+b0)>>2;\
112− pixels+=line_size;\
113− block +=line_size;\
114− }\
115−}\
116−\
117−static inline void FUNCC(OPNAME ## _pixels4_xy2)(uint8_t *block, const uint8_t *pixels, ptrdiff_t line_size, int h)\
118−{\
119− /* FIXME HIGH BIT DEPTH */\
120− int i;\
121− const uint32_t a= AV_RN32(pixels );\
122− const uint32_t b= AV_RN32(pixels+1);\
123− uint32_t l0= (a&0x03030303UL)\
124− + (b&0x03030303UL)\
125− + 0x02020202UL;\
126− uint32_t h0= ((a&0xFCFCFCFCUL)>>2)\
127− + ((b&0xFCFCFCFCUL)>>2);\
128− uint32_t l1,h1;\
129−\
130− pixels+=line_size;\
131− for(i=0; i<h; i+=2){\
132− uint32_t a= AV_RN32(pixels );\
133− uint32_t b= AV_RN32(pixels+1);\
134− l1= (a&0x03030303UL)\
135− + (b&0x03030303UL);\
136− h1= ((a&0xFCFCFCFCUL)>>2)\
137− + ((b&0xFCFCFCFCUL)>>2);\
138− OP(*((uint32_t*)block), h0+h1+(((l0+l1)>>2)&0x0F0F0F0FUL));\
139− pixels+=line_size;\
140− block +=line_size;\
141− a= AV_RN32(pixels );\
142− b= AV_RN32(pixels+1);\
143− l0= (a&0x03030303UL)\
144− + (b&0x03030303UL)\
145− + 0x02020202UL;\
146− h0= ((a&0xFCFCFCFCUL)>>2)\
147− + ((b&0xFCFCFCFCUL)>>2);\
148− OP(*((uint32_t*)block), h0+h1+(((l0+l1)>>2)&0x0F0F0F0FUL));\
149− pixels+=line_size;\
150− block +=line_size;\
151− }\
152−}\
153−\
154−static inline void FUNCC(OPNAME ## _pixels8_xy2)(uint8_t *block, const uint8_t *pixels, ptrdiff_t line_size, int h)\
155−{\
156− /* FIXME HIGH BIT DEPTH */\
157− int j;\
158− for(j=0; j<2; j++){\
159− int i;\
160− const uint32_t a= AV_RN32(pixels );\
161− const uint32_t b= AV_RN32(pixels+1);\
162− uint32_t l0= (a&0x03030303UL)\
163− + (b&0x03030303UL)\
164− + 0x02020202UL;\
165− uint32_t h0= ((a&0xFCFCFCFCUL)>>2)\
166− + ((b&0xFCFCFCFCUL)>>2);\
167− uint32_t l1,h1;\
168−\
169− pixels+=line_size;\
170− for(i=0; i<h; i+=2){\
171− uint32_t a= AV_RN32(pixels );\
172− uint32_t b= AV_RN32(pixels+1);\
173− l1= (a&0x03030303UL)\
174− + (b&0x03030303UL);\
175− h1= ((a&0xFCFCFCFCUL)>>2)\
176− + ((b&0xFCFCFCFCUL)>>2);\
177− OP(*((uint32_t*)block), h0+h1+(((l0+l1)>>2)&0x0F0F0F0FUL));\
178− pixels+=line_size;\
179− block +=line_size;\
180− a= AV_RN32(pixels );\
181− b= AV_RN32(pixels+1);\
182− l0= (a&0x03030303UL)\
183− + (b&0x03030303UL)\
184− + 0x02020202UL;\
185− h0= ((a&0xFCFCFCFCUL)>>2)\
186− + ((b&0xFCFCFCFCUL)>>2);\
187− OP(*((uint32_t*)block), h0+h1+(((l0+l1)>>2)&0x0F0F0F0FUL));\
188− pixels+=line_size;\
189− block +=line_size;\
190− }\
191− pixels+=4-line_size*(h+1);\
192− block +=4-line_size*h;\
193− }\
194−}\
195−\
196−static inline void FUNCC(OPNAME ## _no_rnd_pixels8_xy2)(uint8_t *block, const uint8_t *pixels, ptrdiff_t line_size, int h)\
197−{\
198− /* FIXME HIGH BIT DEPTH */\
199− int j;\
200− for(j=0; j<2; j++){\
201− int i;\
202− const uint32_t a= AV_RN32(pixels );\
203− const uint32_t b= AV_RN32(pixels+1);\
204− uint32_t l0= (a&0x03030303UL)\
205− + (b&0x03030303UL)\
206− + 0x01010101UL;\
207− uint32_t h0= ((a&0xFCFCFCFCUL)>>2)\
208− + ((b&0xFCFCFCFCUL)>>2);\
209− uint32_t l1,h1;\
210−\
211− pixels+=line_size;\
212− for(i=0; i<h; i+=2){\
213− uint32_t a= AV_RN32(pixels );\
214− uint32_t b= AV_RN32(pixels+1);\
215− l1= (a&0x03030303UL)\
216− + (b&0x03030303UL);\
217− h1= ((a&0xFCFCFCFCUL)>>2)\
218− + ((b&0xFCFCFCFCUL)>>2);\
219− OP(*((uint32_t*)block), h0+h1+(((l0+l1)>>2)&0x0F0F0F0FUL));\
220− pixels+=line_size;\
221− block +=line_size;\
222− a= AV_RN32(pixels );\
223− b= AV_RN32(pixels+1);\
224− l0= (a&0x03030303UL)\
225− + (b&0x03030303UL)\
226− + 0x01010101UL;\
227− h0= ((a&0xFCFCFCFCUL)>>2)\
228− + ((b&0xFCFCFCFCUL)>>2);\
229− OP(*((uint32_t*)block), h0+h1+(((l0+l1)>>2)&0x0F0F0F0FUL));\
230− pixels+=line_size;\
231− block +=line_size;\
232− }\
233− pixels+=4-line_size*(h+1);\
234− block +=4-line_size*h;\
235− }\
236−}\
237−\
238−CALL_2X_PIXELS(FUNCC(OPNAME ## _pixels16_x2) , FUNCC(OPNAME ## _pixels8_x2) , 8*sizeof(pixel))\
239−CALL_2X_PIXELS(FUNCC(OPNAME ## _pixels16_y2) , FUNCC(OPNAME ## _pixels8_y2) , 8*sizeof(pixel))\
240−CALL_2X_PIXELS(FUNCC(OPNAME ## _pixels16_xy2), FUNCC(OPNAME ## _pixels8_xy2), 8*sizeof(pixel))\
241−av_unused CALL_2X_PIXELS(FUNCC(OPNAME ## _no_rnd_pixels16) , FUNCC(OPNAME ## _pixels8) , 8*sizeof(pixel))\
242−CALL_2X_PIXELS(FUNCC(OPNAME ## _no_rnd_pixels16_x2) , FUNCC(OPNAME ## _no_rnd_pixels8_x2) , 8*sizeof(pixel))\
243−CALL_2X_PIXELS(FUNCC(OPNAME ## _no_rnd_pixels16_y2) , FUNCC(OPNAME ## _no_rnd_pixels8_y2) , 8*sizeof(pixel))\
244−CALL_2X_PIXELS(FUNCC(OPNAME ## _no_rnd_pixels16_xy2), FUNCC(OPNAME ## _no_rnd_pixels8_xy2), 8*sizeof(pixel))\
35+#define PIXOP2(OPNAME, OP) \
36+static inline void FUNC(OPNAME ## _no_rnd_pixels8_l2)(uint8_t *dst, \
37+ const uint8_t *src1, \
38+ const uint8_t *src2, \
39+ int dst_stride, \
40+ int src_stride1, \
41+ int src_stride2, \
42+ int h) \
43+{ \
44+ int i; \
45+ \
46+ for (i = 0; i < h; i++) { \
47+ pixel4 a, b; \
48+ a = AV_RN4P(&src1[i * src_stride1]); \
49+ b = AV_RN4P(&src2[i * src_stride2]); \
50+ OP(*((pixel4 *) &dst[i * dst_stride]), \
51+ no_rnd_avg_pixel4(a, b)); \
52+ a = AV_RN4P(&src1[i * src_stride1 + 4 * sizeof(pixel)]); \
53+ b = AV_RN4P(&src2[i * src_stride2 + 4 * sizeof(pixel)]); \
54+ OP(*((pixel4 *) &dst[i * dst_stride + 4 * sizeof(pixel)]), \
55+ no_rnd_avg_pixel4(a, b)); \
56+ } \
57+} \
58+ \
59+static inline void FUNCC(OPNAME ## _no_rnd_pixels8_x2)(uint8_t *block, \
60+ const uint8_t *pixels, \
61+ ptrdiff_t line_size, \
62+ int h) \
63+{ \
64+ FUNC(OPNAME ## _no_rnd_pixels8_l2)(block, pixels, pixels + sizeof(pixel), \
65+ line_size, line_size, line_size, h); \
66+} \
67+ \
68+static inline void FUNCC(OPNAME ## _pixels8_x2)(uint8_t *block, \
69+ const uint8_t *pixels, \
70+ ptrdiff_t line_size, \
71+ int h) \
72+{ \
73+ FUNC(OPNAME ## _pixels8_l2)(block, pixels, pixels + sizeof(pixel), \
74+ line_size, line_size, line_size, h); \
75+} \
76+ \
77+static inline void FUNCC(OPNAME ## _no_rnd_pixels8_y2)(uint8_t *block, \
78+ const uint8_t *pixels, \
79+ ptrdiff_t line_size, \
80+ int h) \
81+{ \
82+ FUNC(OPNAME ## _no_rnd_pixels8_l2)(block, pixels, pixels + line_size, \
83+ line_size, line_size, line_size, h); \
84+} \
85+ \
86+static inline void FUNCC(OPNAME ## _pixels8_y2)(uint8_t *block, \
87+ const uint8_t *pixels, \
88+ ptrdiff_t line_size, \
89+ int h) \
90+{ \
91+ FUNC(OPNAME ## _pixels8_l2)(block, pixels, pixels + line_size, \
92+ line_size, line_size, line_size, h); \
93+} \
94+ \
95+static inline void FUNCC(OPNAME ## _pixels4_x2)(uint8_t *block, \
96+ const uint8_t *pixels, \
97+ ptrdiff_t line_size, \
98+ int h) \
99+{ \
100+ FUNC(OPNAME ## _pixels4_l2)(block, pixels, pixels + sizeof(pixel), \
101+ line_size, line_size, line_size, h); \
102+} \
103+ \
104+static inline void FUNCC(OPNAME ## _pixels4_y2)(uint8_t *block, \
105+ const uint8_t *pixels, \
106+ ptrdiff_t line_size, \
107+ int h) \
108+{ \
109+ FUNC(OPNAME ## _pixels4_l2)(block, pixels, pixels + line_size, \
110+ line_size, line_size, line_size, h); \
111+} \
112+ \
113+static inline void FUNCC(OPNAME ## _pixels2_x2)(uint8_t *block, \
114+ const uint8_t *pixels, \
115+ ptrdiff_t line_size, \
116+ int h) \
117+{ \
118+ FUNC(OPNAME ## _pixels2_l2)(block, pixels, pixels + sizeof(pixel), \
119+ line_size, line_size, line_size, h); \
120+} \
121+ \
122+static inline void FUNCC(OPNAME ## _pixels2_y2)(uint8_t *block, \
123+ const uint8_t *pixels, \
124+ ptrdiff_t line_size, \
125+ int h) \
126+{ \
127+ FUNC(OPNAME ## _pixels2_l2)(block, pixels, pixels + line_size, \
128+ line_size, line_size, line_size, h); \
129+} \
130+ \
131+static inline void FUNCC(OPNAME ## _pixels2_xy2)(uint8_t *_block, \
132+ const uint8_t *_pixels, \
133+ ptrdiff_t line_size, \
134+ int h) \
135+{ \
136+ int i, a0, b0, a1, b1; \
137+ pixel *block = (pixel *) _block; \
138+ const pixel *pixels = (const pixel *) _pixels; \
139+ a0 = pixels[0]; \
140+ b0 = pixels[1] + 2; \
141+ a0 += b0; \
142+ b0 += pixels[2]; \
143+ \
144+ line_size >>= sizeof(pixel)-1; \
145+ pixels += line_size; \
146+ for (i = 0; i < h; i += 2) { \
147+ a1 = pixels[0]; \
148+ b1 = pixels[1]; \
149+ a1 += b1; \
150+ b1 += pixels[2]; \
151+ \
152+ block[0] = (a1 + a0) >> 2; /* FIXME non put */ \
153+ block[1] = (b1 + b0) >> 2; \
154+ \
155+ pixels += line_size; \
156+ block += line_size; \
157+ \
158+ a0 = pixels[0]; \
159+ b0 = pixels[1] + 2; \
160+ a0 += b0; \
161+ b0 += pixels[2]; \
162+ \
163+ block[0] = (a1 + a0) >> 2; \
164+ block[1] = (b1 + b0) >> 2; \
165+ pixels += line_size; \
166+ block += line_size; \
167+ } \
168+} \
169+ \
170+static inline void FUNCC(OPNAME ## _pixels4_xy2)(uint8_t *block, \
171+ const uint8_t *pixels, \
172+ ptrdiff_t line_size, \
173+ int h) \
174+{ \
175+ /* FIXME HIGH BIT DEPTH */ \
176+ int i; \
177+ const uint32_t a = AV_RN32(pixels); \
178+ const uint32_t b = AV_RN32(pixels + 1); \
179+ uint32_t l0 = (a & 0x03030303UL) + \
180+ (b & 0x03030303UL) + \
181+ 0x02020202UL; \
182+ uint32_t h0 = ((a & 0xFCFCFCFCUL) >> 2) + \
183+ ((b & 0xFCFCFCFCUL) >> 2); \
184+ uint32_t l1, h1; \
185+ \
186+ pixels += line_size; \
187+ for (i = 0; i < h; i += 2) { \
188+ uint32_t a = AV_RN32(pixels); \
189+ uint32_t b = AV_RN32(pixels + 1); \
190+ l1 = (a & 0x03030303UL) + \
191+ (b & 0x03030303UL); \
192+ h1 = ((a & 0xFCFCFCFCUL) >> 2) + \
193+ ((b & 0xFCFCFCFCUL) >> 2); \
194+ OP(*((uint32_t *) block), h0 + h1 + \
195+ (((l0 + l1) >> 2) & 0x0F0F0F0FUL)); \
196+ pixels += line_size; \
197+ block += line_size; \
198+ a = AV_RN32(pixels); \
199+ b = AV_RN32(pixels + 1); \
200+ l0 = (a & 0x03030303UL) + \
201+ (b & 0x03030303UL) + \
202+ 0x02020202UL; \
203+ h0 = ((a & 0xFCFCFCFCUL) >> 2) + \
204+ ((b & 0xFCFCFCFCUL) >> 2); \
205+ OP(*((uint32_t *) block), h0 + h1 + \
206+ (((l0 + l1) >> 2) & 0x0F0F0F0FUL)); \
207+ pixels += line_size; \
208+ block += line_size; \
209+ } \
210+} \
211+ \
212+static inline void FUNCC(OPNAME ## _pixels8_xy2)(uint8_t *block, \
213+ const uint8_t *pixels, \
214+ ptrdiff_t line_size, \
215+ int h) \
216+{ \
217+ /* FIXME HIGH BIT DEPTH */ \
218+ int j; \
219+ \
220+ for (j = 0; j < 2; j++) { \
221+ int i; \
222+ const uint32_t a = AV_RN32(pixels); \
223+ const uint32_t b = AV_RN32(pixels + 1); \
224+ uint32_t l0 = (a & 0x03030303UL) + \
225+ (b & 0x03030303UL) + \
226+ 0x02020202UL; \
227+ uint32_t h0 = ((a & 0xFCFCFCFCUL) >> 2) + \
228+ ((b & 0xFCFCFCFCUL) >> 2); \
229+ uint32_t l1, h1; \
230+ \
231+ pixels += line_size; \
232+ for (i = 0; i < h; i += 2) { \
233+ uint32_t a = AV_RN32(pixels); \
234+ uint32_t b = AV_RN32(pixels + 1); \
235+ l1 = (a & 0x03030303UL) + \
236+ (b & 0x03030303UL); \
237+ h1 = ((a & 0xFCFCFCFCUL) >> 2) + \
238+ ((b & 0xFCFCFCFCUL) >> 2); \
239+ OP(*((uint32_t *) block), h0 + h1 + \
240+ (((l0 + l1) >> 2) & 0x0F0F0F0FUL)); \
241+ pixels += line_size; \
242+ block += line_size; \
243+ a = AV_RN32(pixels); \
244+ b = AV_RN32(pixels + 1); \
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+ \
260+static 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+ \
308+CALL_2X_PIXELS(FUNCC(OPNAME ## _pixels16_x2), \
309+ FUNCC(OPNAME ## _pixels8_x2), \
310+ 8 * sizeof(pixel)) \
311+CALL_2X_PIXELS(FUNCC(OPNAME ## _pixels16_y2), \
312+ FUNCC(OPNAME ## _pixels8_y2), \
313+ 8 * sizeof(pixel)) \
314+CALL_2X_PIXELS(FUNCC(OPNAME ## _pixels16_xy2), \
315+ FUNCC(OPNAME ## _pixels8_xy2), \
316+ 8 * sizeof(pixel)) \
317+av_unused CALL_2X_PIXELS(FUNCC(OPNAME ## _no_rnd_pixels16), \
318+ FUNCC(OPNAME ## _pixels8), \
319+ 8 * sizeof(pixel)) \
320+CALL_2X_PIXELS(FUNCC(OPNAME ## _no_rnd_pixels16_x2), \
321+ FUNCC(OPNAME ## _no_rnd_pixels8_x2), \
322+ 8 * sizeof(pixel)) \
323+CALL_2X_PIXELS(FUNCC(OPNAME ## _no_rnd_pixels16_y2), \
324+ FUNCC(OPNAME ## _no_rnd_pixels8_y2), \
325+ 8 * sizeof(pixel)) \
326+CALL_2X_PIXELS(FUNCC(OPNAME ## _no_rnd_pixels16_xy2), \
327+ FUNCC(OPNAME ## _no_rnd_pixels8_xy2), \
328+ 8 * sizeof(pixel)) \
245329
246330 #define op_avg(a, b) a = rnd_avg_pixel4(a, b)
247331 #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