← Back to branch summary

~ubuntu-branches/ubuntu/utopic/libav/utopic-proposed

« back to all changes in this revision

Viewing changes to libavcodec/h264qpel_template.c

  • Committer: Package Import Robot
  • Author(s): Reinhard Tartler, Reinhard Tartler, Rico Tzschichholz
  • Date: 2014-08-30 11:02:45 UTC
  • mfrom: (1.3.47 sid)
  • Revision ID: package-import@ubuntu.com-20140830110245-io3dg7q85wfr7125
Tags: 6:11~beta1-2
[ Reinhard Tartler ]
* Make libavcodec-dev depend on libavresample-dev

[ Rico Tzschichholz ]
* Some fixes and leftovers from soname bumps

Show diffs side-by-side

added added

removed removed

Lines of Context:
libavcodec/h264qpel_template.c
20
20
 */
21
21
 
22
22
#include "libavutil/common.h"
 
23
#include "libavutil/intreadwrite.h"
 
24
 
23
25
#include "bit_depth_template.c"
24
26
#include "hpel_template.c"
 
27
#include "pel_template.c"
25
28
 
26
29
static inline void FUNC(copy_block2)(uint8_t *dst, const uint8_t *src, int dstStride, int srcStride, int h)
27
30
{
72
75
}
73
76
 
74
77
#define H264_LOWPASS(OPNAME, OP, OP2) \
75
 
static av_unused void FUNC(OPNAME ## h264_qpel2_h_lowpass)(uint8_t *_dst, uint8_t *_src, int dstStride, int srcStride){\
 
78
static av_unused void FUNC(OPNAME ## h264_qpel2_h_lowpass)(uint8_t *_dst, const uint8_t *_src, int dstStride, int srcStride){\
76
79
    const int h=2;\
77
80
    INIT_CLIP\
78
81
    int i;\
79
82
    pixel *dst = (pixel*)_dst;\
80
 
    pixel *src = (pixel*)_src;\
 
83
    const pixel *src = (const pixel*)_src;\
81
84
    dstStride /= sizeof(pixel);\
82
85
    srcStride /= sizeof(pixel);\
83
86
    for(i=0; i<h; i++)\
89
92
    }\
90
93
}\
91
94
\
92
 
static av_unused void FUNC(OPNAME ## h264_qpel2_v_lowpass)(uint8_t *_dst, uint8_t *_src, int dstStride, int srcStride){\
 
95
static av_unused void FUNC(OPNAME ## h264_qpel2_v_lowpass)(uint8_t *_dst, const uint8_t *_src, int dstStride, int srcStride){\
93
96
    const int w=2;\
94
97
    INIT_CLIP\
95
98
    int i;\
96
99
    pixel *dst = (pixel*)_dst;\
97
 
    pixel *src = (pixel*)_src;\
 
100
    const pixel *src = (const pixel*)_src;\
98
101
    dstStride /= sizeof(pixel);\
99
102
    srcStride /= sizeof(pixel);\
100
103
    for(i=0; i<w; i++)\
113
116
    }\
114
117
}\
115
118
\
116
 
static av_unused void FUNC(OPNAME ## h264_qpel2_hv_lowpass)(uint8_t *_dst, int16_t *tmp, uint8_t *_src, int dstStride, int tmpStride, int srcStride){\
 
119
static av_unused void FUNC(OPNAME ## h264_qpel2_hv_lowpass)(uint8_t *_dst, int16_t *tmp, const uint8_t *_src, int dstStride, int tmpStride, int srcStride){\
117
120
    const int h=2;\
118
121
    const int w=2;\
119
122
    const int pad = (BIT_DEPTH > 9) ? (-10 * ((1<<BIT_DEPTH)-1)) : 0;\
120
123
    INIT_CLIP\
121
124
    int i;\
122
125
    pixel *dst = (pixel*)_dst;\
123
 
    pixel *src = (pixel*)_src;\
 
126
    const pixel *src = (const pixel*)_src;\
124
127
    dstStride /= sizeof(pixel);\
125
128
    srcStride /= sizeof(pixel);\
126
129
    src -= 2*srcStride;\
147
150
        tmp++;\
148
151
    }\
149
152
}\
150
 
static void FUNC(OPNAME ## h264_qpel4_h_lowpass)(uint8_t *_dst, uint8_t *_src, int dstStride, int srcStride){\
 
153
static void FUNC(OPNAME ## h264_qpel4_h_lowpass)(uint8_t *_dst, const uint8_t *_src, int dstStride, int srcStride){\
151
154
    const int h=4;\
152
155
    INIT_CLIP\
153
156
    int i;\
154
157
    pixel *dst = (pixel*)_dst;\
155
 
    pixel *src = (pixel*)_src;\
 
158
    const pixel *src = (const pixel*)_src;\
156
159
    dstStride /= sizeof(pixel);\
157
160
    srcStride /= sizeof(pixel);\
158
161
    for(i=0; i<h; i++)\
166
169
    }\
167
170
}\
168
171
\
169
 
static void FUNC(OPNAME ## h264_qpel4_v_lowpass)(uint8_t *_dst, uint8_t *_src, int dstStride, int srcStride){\
 
172
static void FUNC(OPNAME ## h264_qpel4_v_lowpass)(uint8_t *_dst, const uint8_t *_src, int dstStride, int srcStride){\
170
173
    const int w=4;\
171
174
    INIT_CLIP\
172
175
    int i;\
173
176
    pixel *dst = (pixel*)_dst;\
174
 
    pixel *src = (pixel*)_src;\
 
177
    const pixel *src = (const pixel*)_src;\
175
178
    dstStride /= sizeof(pixel);\
176
179
    srcStride /= sizeof(pixel);\
177
180
    for(i=0; i<w; i++)\
194
197
    }\
195
198
}\
196
199
\
197
 
static void FUNC(OPNAME ## h264_qpel4_hv_lowpass)(uint8_t *_dst, int16_t *tmp, uint8_t *_src, int dstStride, int tmpStride, int srcStride){\
 
200
static void FUNC(OPNAME ## h264_qpel4_hv_lowpass)(uint8_t *_dst, int16_t *tmp, const uint8_t *_src, int dstStride, int tmpStride, int srcStride){\
198
201
    const int h=4;\
199
202
    const int w=4;\
200
203
    const int pad = (BIT_DEPTH > 9) ? (-10 * ((1<<BIT_DEPTH)-1)) : 0;\
201
204
    INIT_CLIP\
202
205
    int i;\
203
206
    pixel *dst = (pixel*)_dst;\
204
 
    pixel *src = (pixel*)_src;\
 
207
    const pixel *src = (const pixel*)_src;\
205
208
    dstStride /= sizeof(pixel);\
206
209
    srcStride /= sizeof(pixel);\
207
210
    src -= 2*srcStride;\
235
238
    }\
236
239
}\
237
240
\
238
 
static void FUNC(OPNAME ## h264_qpel8_h_lowpass)(uint8_t *_dst, uint8_t *_src, int dstStride, int srcStride){\
 
241
static void FUNC(OPNAME ## h264_qpel8_h_lowpass)(uint8_t *_dst, const uint8_t *_src, int dstStride, int srcStride){\
239
242
    const int h=8;\
240
243
    INIT_CLIP\
241
244
    int i;\
242
245
    pixel *dst = (pixel*)_dst;\
243
 
    pixel *src = (pixel*)_src;\
 
246
    const pixel *src = (const pixel*)_src;\
244
247
    dstStride /= sizeof(pixel);\
245
248
    srcStride /= sizeof(pixel);\
246
249
    for(i=0; i<h; i++)\
258
261
    }\
259
262
}\
260
263
\
261
 
static void FUNC(OPNAME ## h264_qpel8_v_lowpass)(uint8_t *_dst, uint8_t *_src, int dstStride, int srcStride){\
 
264
static void FUNC(OPNAME ## h264_qpel8_v_lowpass)(uint8_t *_dst, const uint8_t *_src, int dstStride, int srcStride){\
262
265
    const int w=8;\
263
266
    INIT_CLIP\
264
267
    int i;\
265
268
    pixel *dst = (pixel*)_dst;\
266
 
    pixel *src = (pixel*)_src;\
 
269
    const pixel *src = (const pixel*)_src;\
267
270
    dstStride /= sizeof(pixel);\
268
271
    srcStride /= sizeof(pixel);\
269
272
    for(i=0; i<w; i++)\
294
297
    }\
295
298
}\
296
299
\
297
 
static void FUNC(OPNAME ## h264_qpel8_hv_lowpass)(uint8_t *_dst, int16_t *tmp, uint8_t *_src, int dstStride, int tmpStride, int srcStride){\
 
300
static void FUNC(OPNAME ## h264_qpel8_hv_lowpass)(uint8_t *_dst, int16_t *tmp, const uint8_t *_src, int dstStride, int tmpStride, int srcStride){\
298
301
    const int h=8;\
299
302
    const int w=8;\
300
303
    const int pad = (BIT_DEPTH > 9) ? (-10 * ((1<<BIT_DEPTH)-1)) : 0;\
301
304
    INIT_CLIP\
302
305
    int i;\
303
306
    pixel *dst = (pixel*)_dst;\
304
 
    pixel *src = (pixel*)_src;\
 
307
    const pixel *src = (const pixel*)_src;\
305
308
    dstStride /= sizeof(pixel);\
306
309
    srcStride /= sizeof(pixel);\
307
310
    src -= 2*srcStride;\
347
350
    }\
348
351
}\
349
352
\
350
 
static void FUNC(OPNAME ## h264_qpel16_v_lowpass)(uint8_t *dst, uint8_t *src, int dstStride, int srcStride){\
351
 
    FUNC(OPNAME ## h264_qpel8_v_lowpass)(dst                , src                , dstStride, srcStride);\
352
 
    FUNC(OPNAME ## h264_qpel8_v_lowpass)(dst+8*sizeof(pixel), src+8*sizeof(pixel), dstStride, srcStride);\
353
 
    src += 8*srcStride;\
354
 
    dst += 8*dstStride;\
355
 
    FUNC(OPNAME ## h264_qpel8_v_lowpass)(dst                , src                , dstStride, srcStride);\
356
 
    FUNC(OPNAME ## h264_qpel8_v_lowpass)(dst+8*sizeof(pixel), src+8*sizeof(pixel), dstStride, srcStride);\
357
 
}\
358
 
\
359
 
static void FUNC(OPNAME ## h264_qpel16_h_lowpass)(uint8_t *dst, uint8_t *src, int dstStride, int srcStride){\
360
 
    FUNC(OPNAME ## h264_qpel8_h_lowpass)(dst                , src                , dstStride, srcStride);\
361
 
    FUNC(OPNAME ## h264_qpel8_h_lowpass)(dst+8*sizeof(pixel), src+8*sizeof(pixel), dstStride, srcStride);\
362
 
    src += 8*srcStride;\
363
 
    dst += 8*dstStride;\
364
 
    FUNC(OPNAME ## h264_qpel8_h_lowpass)(dst                , src                , dstStride, srcStride);\
365
 
    FUNC(OPNAME ## h264_qpel8_h_lowpass)(dst+8*sizeof(pixel), src+8*sizeof(pixel), dstStride, srcStride);\
366
 
}\
367
 
\
368
 
static void FUNC(OPNAME ## h264_qpel16_hv_lowpass)(uint8_t *dst, int16_t *tmp, uint8_t *src, int dstStride, int tmpStride, int srcStride){\
 
353
static void FUNC(OPNAME ## h264_qpel16_v_lowpass)(uint8_t *dst, const uint8_t *src, int dstStride, int srcStride){\
 
354
    FUNC(OPNAME ## h264_qpel8_v_lowpass)(dst                , src                , dstStride, srcStride);\
 
355
    FUNC(OPNAME ## h264_qpel8_v_lowpass)(dst+8*sizeof(pixel), src+8*sizeof(pixel), dstStride, srcStride);\
 
356
    src += 8*srcStride;\
 
357
    dst += 8*dstStride;\
 
358
    FUNC(OPNAME ## h264_qpel8_v_lowpass)(dst                , src                , dstStride, srcStride);\
 
359
    FUNC(OPNAME ## h264_qpel8_v_lowpass)(dst+8*sizeof(pixel), src+8*sizeof(pixel), dstStride, srcStride);\
 
360
}\
 
361
\
 
362
static void FUNC(OPNAME ## h264_qpel16_h_lowpass)(uint8_t *dst, const uint8_t *src, int dstStride, int srcStride){\
 
363
    FUNC(OPNAME ## h264_qpel8_h_lowpass)(dst                , src                , dstStride, srcStride);\
 
364
    FUNC(OPNAME ## h264_qpel8_h_lowpass)(dst+8*sizeof(pixel), src+8*sizeof(pixel), dstStride, srcStride);\
 
365
    src += 8*srcStride;\
 
366
    dst += 8*dstStride;\
 
367
    FUNC(OPNAME ## h264_qpel8_h_lowpass)(dst                , src                , dstStride, srcStride);\
 
368
    FUNC(OPNAME ## h264_qpel8_h_lowpass)(dst+8*sizeof(pixel), src+8*sizeof(pixel), dstStride, srcStride);\
 
369
}\
 
370
\
 
371
static void FUNC(OPNAME ## h264_qpel16_hv_lowpass)(uint8_t *dst, int16_t *tmp, const uint8_t *src, int dstStride, int tmpStride, int srcStride){\
369
372
    FUNC(OPNAME ## h264_qpel8_hv_lowpass)(dst                , tmp  , src                , dstStride, tmpStride, srcStride);\
370
373
    FUNC(OPNAME ## h264_qpel8_hv_lowpass)(dst+8*sizeof(pixel), tmp+8, src+8*sizeof(pixel), dstStride, tmpStride, srcStride);\
371
374
    src += 8*srcStride;\
375
378
}\
376
379
 
377
380
#define H264_MC(OPNAME, SIZE) \
378
 
static av_unused void FUNCC(OPNAME ## h264_qpel ## SIZE ## _mc00)(uint8_t *dst, uint8_t *src, ptrdiff_t stride)\
 
381
static av_unused void FUNCC(OPNAME ## h264_qpel ## SIZE ## _mc00)(uint8_t *dst, const uint8_t *src, ptrdiff_t stride)\
379
382
{\
380
383
    FUNCC(OPNAME ## pixels ## SIZE)(dst, src, stride, SIZE);\
381
384
}\
382
385
\
383
 
static void FUNCC(OPNAME ## h264_qpel ## SIZE ## _mc10)(uint8_t *dst, uint8_t *src, ptrdiff_t stride)\
 
386
static void FUNCC(OPNAME ## h264_qpel ## SIZE ## _mc10)(uint8_t *dst, const uint8_t *src, ptrdiff_t stride)\
384
387
{\
385
388
    uint8_t half[SIZE*SIZE*sizeof(pixel)];\
386
389
    FUNC(put_h264_qpel ## SIZE ## _h_lowpass)(half, src, SIZE*sizeof(pixel), stride);\
387
390
    FUNC(OPNAME ## pixels ## SIZE ## _l2)(dst, src, half, stride, stride, SIZE*sizeof(pixel), SIZE);\
388
391
}\
389
392
\
390
 
static void FUNCC(OPNAME ## h264_qpel ## SIZE ## _mc20)(uint8_t *dst, uint8_t *src, ptrdiff_t stride)\
 
393
static void FUNCC(OPNAME ## h264_qpel ## SIZE ## _mc20)(uint8_t *dst, const uint8_t *src, ptrdiff_t stride)\
391
394
{\
392
395
    FUNC(OPNAME ## h264_qpel ## SIZE ## _h_lowpass)(dst, src, stride, stride);\
393
396
}\
394
397
\
395
 
static void FUNCC(OPNAME ## h264_qpel ## SIZE ## _mc30)(uint8_t *dst, uint8_t *src, ptrdiff_t stride)\
 
398
static void FUNCC(OPNAME ## h264_qpel ## SIZE ## _mc30)(uint8_t *dst, const uint8_t *src, ptrdiff_t stride)\
396
399
{\
397
400
    uint8_t half[SIZE*SIZE*sizeof(pixel)];\
398
401
    FUNC(put_h264_qpel ## SIZE ## _h_lowpass)(half, src, SIZE*sizeof(pixel), stride);\
399
402
    FUNC(OPNAME ## pixels ## SIZE ## _l2)(dst, src+sizeof(pixel), half, stride, stride, SIZE*sizeof(pixel), SIZE);\
400
403
}\
401
404
\
402
 
static void FUNCC(OPNAME ## h264_qpel ## SIZE ## _mc01)(uint8_t *dst, uint8_t *src, ptrdiff_t stride)\
 
405
static void FUNCC(OPNAME ## h264_qpel ## SIZE ## _mc01)(uint8_t *dst, const uint8_t *src, ptrdiff_t stride)\
403
406
{\
404
407
    uint8_t full[SIZE*(SIZE+5)*sizeof(pixel)];\
405
408
    uint8_t * const full_mid= full + SIZE*2*sizeof(pixel);\
409
412
    FUNC(OPNAME ## pixels ## SIZE ## _l2)(dst, full_mid, half, stride, SIZE*sizeof(pixel), SIZE*sizeof(pixel), SIZE);\
410
413
}\
411
414
\
412
 
static void FUNCC(OPNAME ## h264_qpel ## SIZE ## _mc02)(uint8_t *dst, uint8_t *src, ptrdiff_t stride)\
 
415
static void FUNCC(OPNAME ## h264_qpel ## SIZE ## _mc02)(uint8_t *dst, const uint8_t *src, ptrdiff_t stride)\
413
416
{\
414
417
    uint8_t full[SIZE*(SIZE+5)*sizeof(pixel)];\
415
418
    uint8_t * const full_mid= full + SIZE*2*sizeof(pixel);\
417
420
    FUNC(OPNAME ## h264_qpel ## SIZE ## _v_lowpass)(dst, full_mid, stride, SIZE*sizeof(pixel));\
418
421
}\
419
422
\
420
 
static void FUNCC(OPNAME ## h264_qpel ## SIZE ## _mc03)(uint8_t *dst, uint8_t *src, ptrdiff_t stride)\
 
423
static void FUNCC(OPNAME ## h264_qpel ## SIZE ## _mc03)(uint8_t *dst, const uint8_t *src, ptrdiff_t stride)\
421
424
{\
422
425
    uint8_t full[SIZE*(SIZE+5)*sizeof(pixel)];\
423
426
    uint8_t * const full_mid= full + SIZE*2*sizeof(pixel);\
427
430
    FUNC(OPNAME ## pixels ## SIZE ## _l2)(dst, full_mid+SIZE*sizeof(pixel), half, stride, SIZE*sizeof(pixel), SIZE*sizeof(pixel), SIZE);\
428
431
}\
429
432
\
430
 
static void FUNCC(OPNAME ## h264_qpel ## SIZE ## _mc11)(uint8_t *dst, uint8_t *src, ptrdiff_t stride)\
431
 
{\
432
 
    uint8_t full[SIZE*(SIZE+5)*sizeof(pixel)];\
433
 
    uint8_t * const full_mid= full + SIZE*2*sizeof(pixel);\
434
 
    uint8_t halfH[SIZE*SIZE*sizeof(pixel)];\
435
 
    uint8_t halfV[SIZE*SIZE*sizeof(pixel)];\
436
 
    FUNC(put_h264_qpel ## SIZE ## _h_lowpass)(halfH, src, SIZE*sizeof(pixel), stride);\
437
 
    FUNC(copy_block ## SIZE )(full, src - stride*2, SIZE*sizeof(pixel),  stride, SIZE + 5);\
438
 
    FUNC(put_h264_qpel ## SIZE ## _v_lowpass)(halfV, full_mid, SIZE*sizeof(pixel), SIZE*sizeof(pixel));\
439
 
    FUNC(OPNAME ## pixels ## SIZE ## _l2)(dst, halfH, halfV, stride, SIZE*sizeof(pixel), SIZE*sizeof(pixel), SIZE);\
440
 
}\
441
 
\
442
 
static void FUNCC(OPNAME ## h264_qpel ## SIZE ## _mc31)(uint8_t *dst, uint8_t *src, ptrdiff_t stride)\
443
 
{\
444
 
    uint8_t full[SIZE*(SIZE+5)*sizeof(pixel)];\
445
 
    uint8_t * const full_mid= full + SIZE*2*sizeof(pixel);\
446
 
    uint8_t halfH[SIZE*SIZE*sizeof(pixel)];\
447
 
    uint8_t halfV[SIZE*SIZE*sizeof(pixel)];\
448
 
    FUNC(put_h264_qpel ## SIZE ## _h_lowpass)(halfH, src, SIZE*sizeof(pixel), stride);\
449
 
    FUNC(copy_block ## SIZE )(full, src - stride*2 + sizeof(pixel), SIZE*sizeof(pixel),  stride, SIZE + 5);\
450
 
    FUNC(put_h264_qpel ## SIZE ## _v_lowpass)(halfV, full_mid, SIZE*sizeof(pixel), SIZE*sizeof(pixel));\
451
 
    FUNC(OPNAME ## pixels ## SIZE ## _l2)(dst, halfH, halfV, stride, SIZE*sizeof(pixel), SIZE*sizeof(pixel), SIZE);\
452
 
}\
453
 
\
454
 
static void FUNCC(OPNAME ## h264_qpel ## SIZE ## _mc13)(uint8_t *dst, uint8_t *src, ptrdiff_t stride)\
455
 
{\
456
 
    uint8_t full[SIZE*(SIZE+5)*sizeof(pixel)];\
457
 
    uint8_t * const full_mid= full + SIZE*2*sizeof(pixel);\
458
 
    uint8_t halfH[SIZE*SIZE*sizeof(pixel)];\
459
 
    uint8_t halfV[SIZE*SIZE*sizeof(pixel)];\
460
 
    FUNC(put_h264_qpel ## SIZE ## _h_lowpass)(halfH, src + stride, SIZE*sizeof(pixel), stride);\
461
 
    FUNC(copy_block ## SIZE )(full, src - stride*2, SIZE*sizeof(pixel),  stride, SIZE + 5);\
462
 
    FUNC(put_h264_qpel ## SIZE ## _v_lowpass)(halfV, full_mid, SIZE*sizeof(pixel), SIZE*sizeof(pixel));\
463
 
    FUNC(OPNAME ## pixels ## SIZE ## _l2)(dst, halfH, halfV, stride, SIZE*sizeof(pixel), SIZE*sizeof(pixel), SIZE);\
464
 
}\
465
 
\
466
 
static void FUNCC(OPNAME ## h264_qpel ## SIZE ## _mc33)(uint8_t *dst, uint8_t *src, ptrdiff_t stride)\
467
 
{\
468
 
    uint8_t full[SIZE*(SIZE+5)*sizeof(pixel)];\
469
 
    uint8_t * const full_mid= full + SIZE*2*sizeof(pixel);\
470
 
    uint8_t halfH[SIZE*SIZE*sizeof(pixel)];\
471
 
    uint8_t halfV[SIZE*SIZE*sizeof(pixel)];\
472
 
    FUNC(put_h264_qpel ## SIZE ## _h_lowpass)(halfH, src + stride, SIZE*sizeof(pixel), stride);\
473
 
    FUNC(copy_block ## SIZE )(full, src - stride*2 + sizeof(pixel), SIZE*sizeof(pixel),  stride, SIZE + 5);\
474
 
    FUNC(put_h264_qpel ## SIZE ## _v_lowpass)(halfV, full_mid, SIZE*sizeof(pixel), SIZE*sizeof(pixel));\
475
 
    FUNC(OPNAME ## pixels ## SIZE ## _l2)(dst, halfH, halfV, stride, SIZE*sizeof(pixel), SIZE*sizeof(pixel), SIZE);\
476
 
}\
477
 
\
478
 
static void FUNCC(OPNAME ## h264_qpel ## SIZE ## _mc22)(uint8_t *dst, uint8_t *src, ptrdiff_t stride)\
 
433
static void FUNCC(OPNAME ## h264_qpel ## SIZE ## _mc11)(uint8_t *dst, const uint8_t *src, ptrdiff_t stride)\
 
434
{\
 
435
    uint8_t full[SIZE*(SIZE+5)*sizeof(pixel)];\
 
436
    uint8_t * const full_mid= full + SIZE*2*sizeof(pixel);\
 
437
    uint8_t halfH[SIZE*SIZE*sizeof(pixel)];\
 
438
    uint8_t halfV[SIZE*SIZE*sizeof(pixel)];\
 
439
    FUNC(put_h264_qpel ## SIZE ## _h_lowpass)(halfH, src, SIZE*sizeof(pixel), stride);\
 
440
    FUNC(copy_block ## SIZE )(full, src - stride*2, SIZE*sizeof(pixel),  stride, SIZE + 5);\
 
441
    FUNC(put_h264_qpel ## SIZE ## _v_lowpass)(halfV, full_mid, SIZE*sizeof(pixel), SIZE*sizeof(pixel));\
 
442
    FUNC(OPNAME ## pixels ## SIZE ## _l2)(dst, halfH, halfV, stride, SIZE*sizeof(pixel), SIZE*sizeof(pixel), SIZE);\
 
443
}\
 
444
\
 
445
static void FUNCC(OPNAME ## h264_qpel ## SIZE ## _mc31)(uint8_t *dst, const uint8_t *src, ptrdiff_t stride)\
 
446
{\
 
447
    uint8_t full[SIZE*(SIZE+5)*sizeof(pixel)];\
 
448
    uint8_t * const full_mid= full + SIZE*2*sizeof(pixel);\
 
449
    uint8_t halfH[SIZE*SIZE*sizeof(pixel)];\
 
450
    uint8_t halfV[SIZE*SIZE*sizeof(pixel)];\
 
451
    FUNC(put_h264_qpel ## SIZE ## _h_lowpass)(halfH, src, SIZE*sizeof(pixel), stride);\
 
452
    FUNC(copy_block ## SIZE )(full, src - stride*2 + sizeof(pixel), SIZE*sizeof(pixel),  stride, SIZE + 5);\
 
453
    FUNC(put_h264_qpel ## SIZE ## _v_lowpass)(halfV, full_mid, SIZE*sizeof(pixel), SIZE*sizeof(pixel));\
 
454
    FUNC(OPNAME ## pixels ## SIZE ## _l2)(dst, halfH, halfV, stride, SIZE*sizeof(pixel), SIZE*sizeof(pixel), SIZE);\
 
455
}\
 
456
\
 
457
static void FUNCC(OPNAME ## h264_qpel ## SIZE ## _mc13)(uint8_t *dst, const uint8_t *src, ptrdiff_t stride)\
 
458
{\
 
459
    uint8_t full[SIZE*(SIZE+5)*sizeof(pixel)];\
 
460
    uint8_t * const full_mid= full + SIZE*2*sizeof(pixel);\
 
461
    uint8_t halfH[SIZE*SIZE*sizeof(pixel)];\
 
462
    uint8_t halfV[SIZE*SIZE*sizeof(pixel)];\
 
463
    FUNC(put_h264_qpel ## SIZE ## _h_lowpass)(halfH, src + stride, SIZE*sizeof(pixel), stride);\
 
464
    FUNC(copy_block ## SIZE )(full, src - stride*2, SIZE*sizeof(pixel),  stride, SIZE + 5);\
 
465
    FUNC(put_h264_qpel ## SIZE ## _v_lowpass)(halfV, full_mid, SIZE*sizeof(pixel), SIZE*sizeof(pixel));\
 
466
    FUNC(OPNAME ## pixels ## SIZE ## _l2)(dst, halfH, halfV, stride, SIZE*sizeof(pixel), SIZE*sizeof(pixel), SIZE);\
 
467
}\
 
468
\
 
469
static void FUNCC(OPNAME ## h264_qpel ## SIZE ## _mc33)(uint8_t *dst, const uint8_t *src, ptrdiff_t stride)\
 
470
{\
 
471
    uint8_t full[SIZE*(SIZE+5)*sizeof(pixel)];\
 
472
    uint8_t * const full_mid= full + SIZE*2*sizeof(pixel);\
 
473
    uint8_t halfH[SIZE*SIZE*sizeof(pixel)];\
 
474
    uint8_t halfV[SIZE*SIZE*sizeof(pixel)];\
 
475
    FUNC(put_h264_qpel ## SIZE ## _h_lowpass)(halfH, src + stride, SIZE*sizeof(pixel), stride);\
 
476
    FUNC(copy_block ## SIZE )(full, src - stride*2 + sizeof(pixel), SIZE*sizeof(pixel),  stride, SIZE + 5);\
 
477
    FUNC(put_h264_qpel ## SIZE ## _v_lowpass)(halfV, full_mid, SIZE*sizeof(pixel), SIZE*sizeof(pixel));\
 
478
    FUNC(OPNAME ## pixels ## SIZE ## _l2)(dst, halfH, halfV, stride, SIZE*sizeof(pixel), SIZE*sizeof(pixel), SIZE);\
 
479
}\
 
480
\
 
481
static void FUNCC(OPNAME ## h264_qpel ## SIZE ## _mc22)(uint8_t *dst, const uint8_t *src, ptrdiff_t stride)\
479
482
{\
480
483
    int16_t tmp[SIZE*(SIZE+5)*sizeof(pixel)];\
481
484
    FUNC(OPNAME ## h264_qpel ## SIZE ## _hv_lowpass)(dst, tmp, src, stride, SIZE*sizeof(pixel), stride);\
482
485
}\
483
486
\
484
 
static void FUNCC(OPNAME ## h264_qpel ## SIZE ## _mc21)(uint8_t *dst, uint8_t *src, ptrdiff_t stride)\
 
487
static void FUNCC(OPNAME ## h264_qpel ## SIZE ## _mc21)(uint8_t *dst, const uint8_t *src, ptrdiff_t stride)\
485
488
{\
486
489
    int16_t tmp[SIZE*(SIZE+5)*sizeof(pixel)];\
487
490
    uint8_t halfH[SIZE*SIZE*sizeof(pixel)];\
491
494
    FUNC(OPNAME ## pixels ## SIZE ## _l2)(dst, halfH, halfHV, stride, SIZE*sizeof(pixel), SIZE*sizeof(pixel), SIZE);\
492
495
}\
493
496
\
494
 
static void FUNCC(OPNAME ## h264_qpel ## SIZE ## _mc23)(uint8_t *dst, uint8_t *src, ptrdiff_t stride)\
 
497
static void FUNCC(OPNAME ## h264_qpel ## SIZE ## _mc23)(uint8_t *dst, const uint8_t *src, ptrdiff_t stride)\
495
498
{\
496
499
    int16_t tmp[SIZE*(SIZE+5)*sizeof(pixel)];\
497
500
    uint8_t halfH[SIZE*SIZE*sizeof(pixel)];\
501
504
    FUNC(OPNAME ## pixels ## SIZE ## _l2)(dst, halfH, halfHV, stride, SIZE*sizeof(pixel), SIZE*sizeof(pixel), SIZE);\
502
505
}\
503
506
\
504
 
static void FUNCC(OPNAME ## h264_qpel ## SIZE ## _mc12)(uint8_t *dst, uint8_t *src, ptrdiff_t stride)\
 
507
static void FUNCC(OPNAME ## h264_qpel ## SIZE ## _mc12)(uint8_t *dst, const uint8_t *src, ptrdiff_t stride)\
505
508
{\
506
509
    uint8_t full[SIZE*(SIZE+5)*sizeof(pixel)];\
507
510
    uint8_t * const full_mid= full + SIZE*2*sizeof(pixel);\
514
517
    FUNC(OPNAME ## pixels ## SIZE ## _l2)(dst, halfV, halfHV, stride, SIZE*sizeof(pixel), SIZE*sizeof(pixel), SIZE);\
515
518
}\
516
519
\
517
 
static void FUNCC(OPNAME ## h264_qpel ## SIZE ## _mc32)(uint8_t *dst, uint8_t *src, ptrdiff_t stride)\
 
520
static void FUNCC(OPNAME ## h264_qpel ## SIZE ## _mc32)(uint8_t *dst, const uint8_t *src, ptrdiff_t stride)\
518
521
{\
519
522
    uint8_t full[SIZE*(SIZE+5)*sizeof(pixel)];\
520
523
    uint8_t * const full_mid= full + SIZE*2*sizeof(pixel);\