← Back to branch summary

~ubuntu-branches/ubuntu/hardy/avidemux/hardy

« back to all changes in this revision

Viewing changes to avidemux/ADM_libraries/ADM_libmpeg2enc/altivec/sumsq.c

  • Committer: Bazaar Package Importer
  • Author(s): Matvey Kozhev
  • Date: 2007-12-18 13:53:04 UTC
  • mfrom: (1.1.7 upstream)
  • Revision ID: james.westby@ubuntu.com-20071218135304-cdqec2lg2bglyz15
Tags: 1:2.4~preview3-0.0ubuntu1
https://launchpad.net/bugs/163287
https://launchpad.net/bugs/126572
https://launchpad.net/bugs/138854
* Upload to Ubuntu. (LP: #163287, LP: #126572)
* debian/changelog: re-added Ubuntu releases.
* debian/control:
  - Require debhelper >= 5.0.51 (for dh_icons) and imagemagick.
  - Build-depend on libsdl1.2-dev instead of libsdl-dev.
  - Build against newer libx264-dev. (LP: #138854)
  - Removed libamrnb-dev, not in Ubuntu yet.
* debian/rules:
  - Install all icon sizes, using convert (upstream installs none).
  - Added missing calls to dh_installmenu, dh_installman, dh_icons and
    dh_desktop.
* debian/menu, debian/avidemux-qt.menu:
  - Corrected package and executable names.
* debian/avidemux-common.install: Install icons.
* debian/avidemux.common.manpages: Install man/avidemux.1.
* debian/links, debian/avidemux-cli.links, debian/avidemux-gtk.links:
  - Link manpages to avidemux.1.gz.
* debian/install, debian/avidemux-qt.install, debian/avidemux-gtk.desktop,
  debian/avidemux-qt.desktop: Install desktop files.

Show diffs side-by-side

added added

removed removed

Lines of Context:
avidemux/ADM_libraries/ADM_libmpeg2enc/altivec/sumsq.c
 
1
/* sumsq.c, this file is part of the
 
2
 * AltiVec optimized library for MJPEG tools MPEG-1/2 Video Encoder
 
3
 * Copyright (C) 2002  James Klicman <james@klicman.org>
 
4
 *
 
5
 * This library is free software; you can redistribute it and/or modify
 
6
 * it under the terms of the GNU General Public License as published by
 
7
 * the Free Software Foundation; either version 2 of the License, or
 
8
 * (at your option) any later version.
 
9
 *
 
10
 * This program is distributed in the hope that it will be useful,
 
11
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 
12
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 
13
 * GNU General Public License for more details.
 
14
 *
 
15
 * You should have received a copy of the GNU General Public License
 
16
 * along with this program; if not, write to the Free Software
 
17
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 
18
 */
 
19
 
 
20
#ifdef HAVE_CONFIG_H
 
21
#include <config.h>
 
22
#endif
 
23
 
 
24
#include "altivec_motion.h"
 
25
#include "vectorize.h"
 
26
#include "../mjpeg_logging.h"
 
27
 
 
28
/* #define AMBER_ENABLE */
 
29
#include "amber.h"
 
30
 
 
31
#ifdef HAVE_ALTIVEC_H
 
32
/* include last to ensure AltiVec type semantics, especially for bool. */
 
33
#include <altivec.h>
 
34
#endif
 
35
 
 
36
/*
 
37
 * Input requirements:
 
38
 *   b) blk2 is always vector aligned
 
39
 *   c) rowstride is a multiple of 16
 
40
 *   d) h is either 8 or 16
 
41
 */
 
42
 
 
43
#define SUMSQ_PDECL \
 
44
  uint8_t *blk1,    \
 
45
  uint8_t *blk2,    \
 
46
  int rowstride,    \
 
47
  int hx,           \
 
48
  int hy,           \
 
49
  int h             \
 
50
 
 
51
#define SUMSQ_ARGS blk1, blk2, rowstride, hx, hy, h
 
52
 
 
53
 
 
54
/*
 
55
 * for (j = 0; j < h; j++) {
 
56
 *     for (i = 0; i < 16; i++) {
 
57
 *         d = blk[i] - ref[i];
 
58
 *         sum += d * d;
 
59
 *     }
 
60
 * }
 
61
 */
 
62
static int sumsq_00(SUMSQ_PDECL) /* {{{ */
 
63
{
 
64
    int i;
 
65
    unsigned char *pblk1, *pblk2;
 
66
    vector unsigned char blk1A, blk2A, blk1B, blk2B;
 
67
    vector unsigned char blk1A0, blk1B0;
 
68
    vector unsigned char blk1A1, blk1B1;
 
69
    vector unsigned char minA, minB;
 
70
    vector unsigned char maxA, maxB;
 
71
    vector unsigned char difA, difB;
 
72
    vector unsigned int sum;
 
73
    vector signed int zero;
 
74
    vector unsigned char perm;
 
75
    union {
 
76
        vector signed int v;
 
77
        struct {
 
78
            signed int pad[3];
 
79
            signed int sum;
 
80
        } s;
 
81
    } vo;
 
82
 
 
83
 
 
84
    pblk1 = blk1;
 
85
    pblk2 = blk2;
 
86
    i = (h >> 1) - 1;
 
87
 
 
88
    zero = vec_splat_s32(0);
 
89
    sum = vec_splat_u32(0);
 
90
 
 
91
 
 
92
    if (VECTOR_ALIGNED(pblk1)) {
 
93
 
 
94
        blk1A = vec_ld(0, pblk1);
 
95
        pblk1 += rowstride;
 
96
        blk1B = vec_ld(0, pblk1);
 
97
 
 
98
        blk2A = vec_ld(0, pblk2);
 
99
        pblk2 += rowstride;
 
100
        blk2B = vec_ld(0, pblk2);
 
101
 
 
102
        do {
 
103
            maxA = vec_max(blk1A, blk2A);
 
104
            minA = vec_min(blk1A, blk2A);
 
105
 
 
106
            pblk1 += rowstride;
 
107
            blk1A = vec_ld(0, pblk1);
 
108
            pblk2 += rowstride;
 
109
            blk2A = vec_ld(0, pblk2);
 
110
 
 
111
            difA = vec_sub(maxA, minA);
 
112
            sum = vec_msum(difA, difA, sum);
 
113
 
 
114
            maxB = vec_max(blk1B, blk2B);
 
115
            minB = vec_min(blk1B, blk2B);
 
116
 
 
117
            pblk1 += rowstride;
 
118
            blk1B = vec_ld(0, pblk1);
 
119
            pblk2 += rowstride;
 
120
            blk2B = vec_ld(0, pblk2);
 
121
 
 
122
            difB = vec_sub(maxB, minB);
 
123
            sum = vec_msum(difB, difB, sum);
 
124
        } while (--i);
 
125
 
 
126
    } else {
 
127
 
 
128
        perm = vec_lvsl(0, pblk1);
 
129
 
 
130
        blk1A0 = vec_ld(0, pblk1);
 
131
        blk1A1 = vec_ld(16, pblk1);
 
132
        pblk1 += rowstride;
 
133
        blk1B0 = vec_ld(0, pblk1);
 
134
        blk1B1 = vec_ld(16, pblk1);
 
135
 
 
136
        blk2A = vec_ld(0, pblk2);
 
137
        pblk2 += rowstride;
 
138
        blk2B = vec_ld(0, pblk2);
 
139
 
 
140
        do {
 
141
            blk1A = vec_perm(blk1A0, blk1A1, perm);
 
142
 
 
143
            pblk1 += rowstride;
 
144
            blk1A0 = vec_ld(0, pblk1);
 
145
            blk1A1 = vec_ld(16, pblk1);
 
146
 
 
147
            maxA = vec_max(blk1A, blk2A);
 
148
            minA = vec_min(blk1A, blk2A);
 
149
 
 
150
            pblk2 += rowstride;
 
151
            blk2A = vec_ld(0, pblk2);
 
152
 
 
153
            difA = vec_sub(maxA, minA);
 
154
            sum = vec_msum(difA, difA, sum);
 
155
 
 
156
 
 
157
            blk1B = vec_perm(blk1B0, blk1B1, perm);
 
158
            pblk1 += rowstride;
 
159
            blk1B0 = vec_ld(0, pblk1);
 
160
            blk1B1 = vec_ld(16, pblk1);
 
161
 
 
162
            maxB = vec_max(blk1B, blk2B);
 
163
            minB = vec_min(blk1B, blk2B);
 
164
 
 
165
            pblk2 += rowstride;
 
166
            blk2B = vec_ld(0, pblk2);
 
167
 
 
168
            difB = vec_sub(maxB, minB);
 
169
            sum = vec_msum(difB, difB, sum);
 
170
        } while (--i);
 
171
 
 
172
        blk1A = vec_perm(blk1A0, blk1A1, perm);
 
173
        blk1B = vec_perm(blk1B0, blk1B1, perm);
 
174
 
 
175
    }
 
176
 
 
177
    maxA = vec_max(blk1A, blk2A);
 
178
    minA = vec_min(blk1A, blk2A);
 
179
    difA = vec_sub(maxA, minA);
 
180
    sum = vec_msum(difA, difA, sum);
 
181
 
 
182
    maxB = vec_max(blk1B, blk2B);
 
183
    minB = vec_min(blk1B, blk2B);
 
184
    difB = vec_sub(maxB, minB);
 
185
    sum = vec_msum(difB, difB, sum);
 
186
 
 
187
    vo.v = vec_sums(vs32(sum), zero);
 
188
 
 
189
    AMBER_STOP;
 
190
 
 
191
    return vo.s.sum;
 
192
} /* }}} */
 
193
 
 
194
/*
 
195
 * s = rowstride
 
196
 * for (j = 0; j < h; j++) {
 
197
 *     for (i = 0; i < 16; i++) {
 
198
 *      d = ((int)(p1[i]+p1[i+1]+1)>>1) - p2[i];
 
199
 *      sum += d * d;
 
200
 *     }
 
201
 *     p1 += s;
 
202
 *     p2 += s;
 
203
 * }
 
204
 */
 
205
static int sumsq_10(SUMSQ_PDECL) /* {{{ */
 
206
{
 
207
    int i;
 
208
    unsigned char *pB, *pR;
 
209
    vector unsigned char l0, l1, l2, l3, lR, lB0, lB1, perm0, perm1;
 
210
    vector unsigned short b0H, b0L, b1H, b1L;
 
211
    vector unsigned short bH, bL;
 
212
    vector unsigned char max, min, dif;
 
213
    vector unsigned int sum;
 
214
    vector unsigned char zero;
 
215
    vector unsigned short one;
 
216
    union {
 
217
        vector signed int v;
 
218
        struct {
 
219
            signed int pad[3];
 
220
            signed int sum;
 
221
        } s;
 
222
    } vo;
 
223
 
 
224
#define ISAD() /* {{{ */                                                     \
 
225
    /* pB[i] + pB[i+1] */                                                    \
 
226
    bH = vec_add(b0H, b1H);                                                  \
 
227
    bL = vec_add(b0L, b1L);                                                  \
 
228
                                                                             \
 
229
    /* (pB[i]+pB[i+1]) + 1 */                                                \
 
230
    bH = vec_add(bH, one);                                                   \
 
231
    bL = vec_add(bL, one);                                                   \
 
232
                                                                             \
 
233
    /* (pB[i]+pB[i+1]+1) >> 1 */                                             \
 
234
    bH = vec_sra(bH, one);                                                   \
 
235
    bL = vec_sra(bL, one);                                                   \
 
236
                                                                             \
 
237
    /* d = abs( ((pB[i]+pB[i+1]+1)>>1) - pR[i] ) */                          \
 
238
    bH = vu16(vec_packsu(bH, bL));                                            \
 
239
    min = vec_min(vu8(bH), lR);                                              \
 
240
    max = vec_max(vu8(bH), lR);                                              \
 
241
    dif = vec_sub(max, min);                                                 \
 
242
                                                                             \
 
243
    /* sum += d * d */                                                       \
 
244
    sum = vec_msum(dif, dif, sum);                                           \
 
245
    /* }}} */
 
246
 
 
247
    pB = blk1,
 
248
    pR = blk2;
 
249
 
 
250
    l0 = vec_ld(0, pB);
 
251
    l1 = vec_ld(16, pB);
 
252
 
 
253
    pB += rowstride;
 
254
    l2 = vec_ld(0, pB);
 
255
    l3 = vec_ld(16, pB);
 
256
 
 
257
    lR = vec_ld(0, pR);
 
258
 
 
259
    /* initialize constants */
 
260
    zero = vec_splat_u8(0);
 
261
    one = vec_splat_u16(1);
 
262
 
 
263
    sum = vec_splat_u32(0);
 
264
 
 
265
 
 
266
    perm0 = vec_lvsl(0, pB);
 
267
    perm1 = vec_splat_u8(1);
 
268
    perm1 = vec_add(perm0, perm1);
 
269
 
 
270
 
 
271
    i = (h >> 1) - 1;
 
272
    do { /* while (--i) */
 
273
 
 
274
        lB0 = vec_perm(l0, l1, perm0);
 
275
        lB1 = vec_perm(l0, l1, perm1);
 
276
 
 
277
        pB += rowstride;
 
278
        l0 = vec_ld(0, pB);
 
279
        l1 = vec_ld(16, pB);
 
280
 
 
281
        /* (unsigned short[]) pB[0-7] */
 
282
        b0H = vu16(vec_mergeh(zero, lB0));
 
283
 
 
284
        /* (unsigned short[]) pB[8-15] */
 
285
        b0L = vu16(vec_mergel(zero, lB0));
 
286
 
 
287
        /* (unsigned short[]) pB[1-8] */
 
288
        b1H = vu16(vec_mergeh(zero, lB1));
 
289
 
 
290
        /* (unsigned short[]) pB[9-16] */
 
291
        b1L = vu16(vec_mergel(zero, lB1));
 
292
 
 
293
        ISAD();
 
294
 
 
295
        pR += rowstride;
 
296
        lR = vec_ld(0, pR);
 
297
 
 
298
        lB0 = vec_perm(l2, l3, perm0);
 
299
        lB1 = vec_perm(l2, l3, perm1);
 
300
 
 
301
        pB += rowstride;
 
302
        l2 = vec_ld(0, pB);
 
303
        l3 = vec_ld(16, pB);
 
304
 
 
305
        /* (unsigned short[]) pB[0-7] */
 
306
        b0H = vu16(vec_mergeh(zero, lB0));
 
307
 
 
308
        /* (unsigned short[]) pB[8-15] */
 
309
        b0L = vu16(vec_mergel(zero, lB0));
 
310
 
 
311
        /* (unsigned short[]) pB[1-8] */
 
312
        b1H = vu16(vec_mergeh(zero, lB1));
 
313
 
 
314
        /* (unsigned short[]) pB[9-16] */
 
315
        b1L = vu16(vec_mergel(zero, lB1));
 
316
 
 
317
        ISAD();
 
318
 
 
319
        pR += rowstride;
 
320
        lR = vec_ld(0, pR);
 
321
 
 
322
    } while (--i);
 
323
 
 
324
    lB0 = vec_perm(l0, l1, perm0);
 
325
    lB1 = vec_perm(l0, l1, perm1);
 
326
 
 
327
    /* (unsigned short[]) pB[0-7] */
 
328
    b0H = vu16(vec_mergeh(zero, lB0));
 
329
 
 
330
    /* (unsigned short[]) pB[8-15] */
 
331
    b0L = vu16(vec_mergel(zero, lB0));
 
332
 
 
333
    /* (unsigned short[]) pB[1-8] */
 
334
    b1H = vu16(vec_mergeh(zero, lB1));
 
335
 
 
336
    /* (unsigned short[]) pB[9-16] */
 
337
    b1L = vu16(vec_mergel(zero, lB1));
 
338
 
 
339
    ISAD();
 
340
 
 
341
    pR += rowstride;
 
342
    lR = vec_ld(0, pR);
 
343
 
 
344
    lB0 = vec_perm(l2, l3, perm0);
 
345
    lB1 = vec_perm(l2, l3, perm1);
 
346
 
 
347
    /* (unsigned short[]) pB[0-7] */
 
348
    b0H = vu16(vec_mergeh(zero, lB0));
 
349
 
 
350
    /* (unsigned short[]) pB[8-15] */
 
351
    b0L = vu16(vec_mergel(zero, lB0));
 
352
 
 
353
    /* (unsigned short[]) pB[1-8] */
 
354
    b1H = vu16(vec_mergeh(zero, lB1));
 
355
 
 
356
    /* (unsigned short[]) pB[9-16] */
 
357
    b1L = vu16(vec_mergel(zero, lB1));
 
358
 
 
359
    ISAD();
 
360
 
 
361
    vo.v = vec_sums(vs32(sum), vs32(zero));
 
362
 
 
363
    return vo.s.sum;
 
364
 
 
365
#undef ISAD
 
366
} /* }}} */
 
367
 
 
368
 
 
369
/*
 
370
 * s = rowstride
 
371
 * for (j = 0; j < h; j++) {
 
372
 *     for (i = 0; i < 16; i++) {
 
373
 *      d = ((int)(p1[i]+p1[i+s]+1)>>1) - p2[i];
 
374
 *      sum += d * d;
 
375
 *     }
 
376
 *     p1 += s;
 
377
 *     p2 += s;
 
378
 * }
 
379
 */
 
380
static int sumsq_01(SUMSQ_PDECL) /* {{{ */
 
381
{
 
382
    int i;
 
383
    unsigned char *pB, *pR;
 
384
    vector unsigned char l0, l1, lR, lB0, lB1, perm;
 
385
    vector unsigned short b0H, b0L, b1H, b1L;
 
386
    vector unsigned short bH, bL;
 
387
    vector unsigned char max, min, dif;
 
388
    vector unsigned int sum;
 
389
    vector unsigned char zero;
 
390
    vector unsigned short one;
 
391
    union {
 
392
        vector signed int v;
 
393
        struct {
 
394
            signed int pad[3];
 
395
            signed int sum;
 
396
        } s;
 
397
    } vo;
 
398
 
 
399
 
 
400
#define ISAD() /* {{{ */                                                     \
 
401
    /* pB[i] + pB[i+s] */                                                    \
 
402
    bH = vec_add(b0H, b1H);                                                  \
 
403
    bL = vec_add(b0L, b1L);                                                  \
 
404
                                                                             \
 
405
    /* (pB[i]+pB[i+s]) + 1 */                                                \
 
406
    bH = vec_add(bH, one);                                                   \
 
407
    bL = vec_add(bL, one);                                                   \
 
408
                                                                             \
 
409
    /* (pB[i]+pB[i+s]+1) >> 1 */                                             \
 
410
    bH = vec_sra(bH, one);                                                   \
 
411
    bL = vec_sra(bL, one);                                                   \
 
412
                                                                             \
 
413
    /* d = abs( ((pB[i]+pB[i+s]+1)>>1) - pR[i] ) */                          \
 
414
    bH = vu16(vec_packsu(bH, bL));                                            \
 
415
    min = vec_min(vu8(bH), lR);                                              \
 
416
    max = vec_max(vu8(bH), lR);                                              \
 
417
    dif = vec_sub(max, min);                                                 \
 
418
                                                                             \
 
419
    /* sum += d * d */                                                       \
 
420
    sum = vec_msum(dif, dif, sum);                                           \
 
421
    /* }}} */
 
422
 
 
423
    pB = blk1,
 
424
    pR = blk2;
 
425
 
 
426
    /* initialize constants */
 
427
    zero = vec_splat_u8(0);
 
428
    one = vec_splat_u16(1);
 
429
 
 
430
    sum = vec_splat_u32(0);
 
431
 
 
432
    i = (h >> 1) - 1;
 
433
 
 
434
    lB0 = vec_ld(0, pB);
 
435
 
 
436
    if (VECTOR_ALIGNED(pB)) {
 
437
 
 
438
        /* lB0 = vec_ld(0, pB); */
 
439
        pB += rowstride;
 
440
        lB1 = vec_ld(0, pB);
 
441
        pB += rowstride;
 
442
        l0 = vec_ld(0, pB);
 
443
 
 
444
        lR = vec_ld(0, pR);
 
445
 
 
446
        /* (unsigned short[]) pB[0-7] */
 
447
        b0H = vu16(vec_mergeh(zero, lB0));
 
448
 
 
449
        /* (unsigned short[]) pB[8-15] */
 
450
        b0L = vu16(vec_mergel(zero, lB0));
 
451
 
 
452
        /* (unsigned short[]) pB+s[0-7] */
 
453
        b1H = vu16(vec_mergeh(zero, lB1));
 
454
 
 
455
        /* (unsigned short[]) pB+s[8-15] */
 
456
        b1L = vu16(vec_mergel(zero, lB1));
 
457
 
 
458
        lB0 = vec_sld(l0, l0, 0);
 
459
 
 
460
        do { /* while (--i) */
 
461
            pB += rowstride;
 
462
            lB1 = vec_ld(0, pB);
 
463
 
 
464
            ISAD();
 
465
 
 
466
            /* start loading next lR */
 
467
            pR += rowstride;
 
468
            lR = vec_ld(0, pR);
 
469
 
 
470
            /* (unsigned short[]) pB[0-7] */
 
471
            b0H = vu16(vec_mergeh(zero, lB0));
 
472
 
 
473
            /* (unsigned short[]) pB[8-15] */
 
474
            b0L = vu16(vec_mergel(zero, lB0));
 
475
 
 
476
            pB += rowstride;
 
477
            lB0 = vec_ld(0, pB);
 
478
 
 
479
            ISAD();
 
480
 
 
481
            /* start loading next lR */
 
482
            pR += rowstride;
 
483
            lR = vec_ld(0, pR);
 
484
 
 
485
            /* (unsigned short[]) pB[0-7] */
 
486
            b1H = vu16(vec_mergeh(zero, lB1));
 
487
 
 
488
            /* (unsigned short[]) pB[8-15] */
 
489
            b1L = vu16(vec_mergel(zero, lB1));
 
490
 
 
491
 
 
492
        } while (--i);
 
493
 
 
494
        ISAD();
 
495
 
 
496
        pR += rowstride;
 
497
        lR = vec_ld(0, pR);
 
498
 
 
499
    } else {
 
500
 
 
501
        perm = vec_lvsl(0, pB);
 
502
 
 
503
        /* lB0 = vec_ld(0, pB); */
 
504
        l0 = vec_ld(16, pB);
 
505
 
 
506
        pB += rowstride;
 
507
        lB1  = vec_ld(0, pB);
 
508
        l1 = vec_ld(16, pB);
 
509
 
 
510
        lR = vec_ld(0, pR);
 
511
 
 
512
        lB0 = vec_perm(lB0, l0, perm);
 
513
        lB1 = vec_perm(lB1, l1, perm);
 
514
 
 
515
        /* (unsigned short[]) pB[0-7] */
 
516
        b0H = vu16(vec_mergeh(zero, lB0));
 
517
 
 
518
        /* (unsigned short[]) pB[8-15] */
 
519
        b0L = vu16(vec_mergel(zero, lB0));
 
520
 
 
521
        /* (unsigned short[]) pB+s[0-7] */
 
522
        b1H = vu16(vec_mergeh(zero, lB1));
 
523
 
 
524
        /* (unsigned short[]) pB+s[8-15] */
 
525
        b1L = vu16(vec_mergel(zero, lB1));
 
526
 
 
527
        pB += rowstride;
 
528
        l0 = vec_ld(0, pB);
 
529
        l1 = vec_ld(16, pB);
 
530
 
 
531
        do { /* while (--i) */
 
532
 
 
533
            ISAD();
 
534
 
 
535
            lB0 = vec_perm(l0, l1, perm);
 
536
 
 
537
            pB += rowstride;
 
538
            l0 = vec_ld(0, pB);
 
539
            l1 = vec_ld(16, pB);
 
540
 
 
541
            /* (unsigned short[]) pB[0-7] */
 
542
            b0H = vu16(vec_mergeh(zero, lB0));
 
543
 
 
544
            /* (unsigned short[]) pB[8-15] */
 
545
            b0L = vu16(vec_mergel(zero, lB0));
 
546
 
 
547
            /* start loading next lR */
 
548
            pR += rowstride;
 
549
            lR = vec_ld(0, pR);
 
550
 
 
551
            ISAD();
 
552
 
 
553
            lB1 = vec_perm(l0, l1, perm);
 
554
 
 
555
            pB += rowstride;
 
556
            l0 = vec_ld(0, pB);
 
557
            l1 = vec_ld(16, pB);
 
558
 
 
559
            /* (unsigned short[]) pB[0-7] */
 
560
            b1H = vu16(vec_mergeh(zero, lB1));
 
561
 
 
562
            /* (unsigned short[]) pB[8-15] */
 
563
            b1L = vu16(vec_mergel(zero, lB1));
 
564
 
 
565
 
 
566
            /* start loading next lR */
 
567
            pR += rowstride;
 
568
            lR = vec_ld(0, pR);
 
569
 
 
570
        } while (--i);
 
571
 
 
572
        ISAD();
 
573
 
 
574
        pR += rowstride;
 
575
        lR = vec_ld(0, pR);
 
576
 
 
577
        lB0 = vec_perm(l0, l1, perm);
 
578
    }
 
579
 
 
580
 
 
581
    /* (unsigned short[]) pB[0-7] */
 
582
    b0H = vu16(vec_mergeh(zero, lB0));
 
583
 
 
584
    /* (unsigned short[]) pB[8-15] */
 
585
    b0L = vu16(vec_mergel(zero, lB0));
 
586
 
 
587
    ISAD();
 
588
 
 
589
    vo.v = vec_sums(vs32(sum), vs32(zero));
 
590
 
 
591
    return vo.s.sum;
 
592
 
 
593
#undef ISAD
 
594
} /* }}} */
 
595
 
 
596
 
 
597
/*
 
598
 * s = rowstride
 
599
 * for (j = 0; j < h; j++) {
 
600
 *     for (i = 0; i < 16; i++)
 
601
 *         d = ((int)(pB[i]+pB[i+1]+pB[i+s]+pB[i+s+1]+2)>>2) - pR[i];
 
602
 *         sum += d * d;
 
603
 *     pB += s;
 
604
 *     pR += s;
 
605
 * }
 
606
 */
 
607
static int sumsq_11(SUMSQ_PDECL) /* {{{ */
 
608
{
 
609
    int i;
 
610
    unsigned char *pB, *pR;
 
611
    vector unsigned char l0, l1, l2, l3, lR, lB0, lB1, lB2, lB3, perm, perm1;
 
612
    vector unsigned short b0H, b0L, b1H, b1L, b2H, b2L, b3H, b3L;
 
613
    vector unsigned short bH, bL;
 
614
    vector unsigned char zero;
 
615
    vector unsigned short two;
 
616
    vector unsigned char max, min, dif;
 
617
    vector unsigned int sum;
 
618
    union {
 
619
        vector signed int v;
 
620
        struct {
 
621
            signed int pad[3];
 
622
            signed int sum;
 
623
        } s;
 
624
    } vo;
 
625
 
 
626
 
 
627
    pB = blk1,
 
628
    pR = blk2;
 
629
 
 
630
    /* start loading first blocks */
 
631
    l0 = vec_ld(0, pB);
 
632
    l1 = vec_ld(16, pB);
 
633
    pB += rowstride;
 
634
    l2 = vec_ld(0, pB);
 
635
    l3 = vec_ld(16, pB);
 
636
 
 
637
    /* initialize constants */
 
638
    zero = vec_splat_u8(0);
 
639
    two  = vec_splat_u16(2);
 
640
 
 
641
    sum = vec_splat_u32(0);
 
642
 
 
643
 
 
644
    perm = vec_lvsl(0, blk1);
 
645
    perm1 = vec_splat_u8(1);
 
646
    perm1 = vec_add(perm, perm1);
 
647
 
 
648
    /* permute 1st set of loaded blocks  */
 
649
    lB0 = vec_perm(l0, l1, perm);
 
650
    lB1 = vec_perm(l0, l1, perm1);
 
651
 
 
652
    /* start loading 3rd set */
 
653
    pB += rowstride;
 
654
    l0 = vec_ld(0, pB);
 
655
    l1 = vec_ld(16, pB);
 
656
 
 
657
    /* permute 2nd set of loaded blocks  */
 
658
    lB2 = vec_perm(l2, l3, perm);
 
659
    lB3 = vec_perm(l2, l3, perm1);
 
660
 
 
661
    /* start loading lR */
 
662
    lR = vec_ld(0, pR);
 
663
 
 
664
    /* (unsigned short[]) pB[0-7] */
 
665
    b0H = vu16(vec_mergeh(zero, lB0));
 
666
 
 
667
    /* (unsigned short[]) pB[8-15] */
 
668
    b0L = vu16(vec_mergel(zero, lB0));
 
669
 
 
670
    /* (unsigned short[]) pB[1-8] */
 
671
    b1H = vu16(vec_mergeh(zero, lB1));
 
672
 
 
673
    /* (unsigned short[]) pB[9-16] */
 
674
    b1L = vu16(vec_mergel(zero, lB1));
 
675
 
 
676
    /* (unsigned short[]) pB+s[0-7] */
 
677
    b2H = vu16(vec_mergeh(zero, lB2));
 
678
                        
 
679
    /* (unsigned short[]) pB+s[8-15] */
 
680
    b2L = vu16(vec_mergel(zero, lB2));
 
681
                        
 
682
    /* (unsigned short[]) pB+s[1-8] */
 
683
    b3H = vu16(vec_mergeh(zero, lB3));
 
684
                        
 
685
    /* (unsigned short[]) pB+s[9-16] */
 
686
    b3L = vu16(vec_mergel(zero, lB3));
 
687
 
 
688
#define ISUMSQ(b0H,b0L,b1H,b1L,b2H,b2L,b3H,b3L) /* {{{ */                    \
 
689
    /* pB[i] + pB[i+1] */                                                    \
 
690
    bH = vec_add(b0H, b1H);                                                  \
 
691
    bL = vec_add(b0L, b1L);                                                  \
 
692
                                                                             \
 
693
    /* (pB[i]+pB[i+1]) + pB[i+s] */                                          \
 
694
    bH = vec_add(bH, b2H);                                                   \
 
695
    bL = vec_add(bL, b2L);                                                   \
 
696
                                                                             \
 
697
    /* (pB[i]+pB[i+1]+pB[i+s]) + pB[i+s+1] */                                \
 
698
    bH = vec_add(bH, b3H);                                                   \
 
699
    bL = vec_add(bL, b3L);                                                   \
 
700
                                                                             \
 
701
    /* (pB[i]+pB[i+1]+pB[i+s]+pB[i+s+1]) + 2 */                              \
 
702
    bH = vec_add(bH, two);                                                   \
 
703
    bL = vec_add(bL, two);                                                   \
 
704
                                                                             \
 
705
    /* (pB[i]+pB[i+1]+pB[i+s]+pB[i+s+1]+2) >> 2 */                           \
 
706
    bH = vec_sra(bH, two);                                                   \
 
707
    bL = vec_sra(bL, two);                                                   \
 
708
                                                                             \
 
709
    /* absolute value is used increase parallelism, x16 instead of x8 */     \
 
710
    /* d = abs( ((int)(pB[i]+pB[i+1]+pB[i+s]+pB[i+s+1]+2)>>2) - pR[i] ) */   \
 
711
    bH = vu16(vec_packsu(bH, bL));                                            \
 
712
    min = vec_min(vu8(bH), lR);                                              \
 
713
    max = vec_max(vu8(bH), lR);                                              \
 
714
    dif = vec_sub(max, min);                                                 \
 
715
                                                                             \
 
716
    /* sum += d * d; */                                                      \
 
717
    sum = vec_msum(dif, dif, sum);                                           \
 
718
    /* }}} */
 
719
 
 
720
 
 
721
    i = (h >> 1) - 1;
 
722
    do {
 
723
        ISUMSQ(b0H,b0L,b1H,b1L,b2H,b2L,b3H,b3L);
 
724
                                
 
725
 
 
726
        /* start loading next lR */
 
727
        pR += rowstride;
 
728
        lR = vec_ld(0, pR);
 
729
                                
 
730
        /* perm loaded set */
 
731
        lB0 = vec_perm(l0, l1, perm);
 
732
        lB1 = vec_perm(l0, l1, perm1);
 
733
 
 
734
        /* start loading next set */
 
735
        pB += rowstride;
 
736
        l0 = vec_ld(0, pB);
 
737
        l1 = vec_ld(16, pB);
 
738
                                
 
739
 
 
740
        /* (unsigned short[]) pB[0-7] */
 
741
        b0H = vu16(vec_mergeh(zero, lB0));
 
742
 
 
743
        /* (unsigned short[]) pB[8-15] */
 
744
        b0L = vu16(vec_mergel(zero, lB0));
 
745
 
 
746
        /* (unsigned short[]) pB[1-8] */
 
747
        b1H = vu16(vec_mergeh(zero, lB1));
 
748
 
 
749
        /* (unsigned short[]) pB[9-16] */
 
750
        b1L = vu16(vec_mergel(zero, lB1));
 
751
 
 
752
        ISUMSQ(b2H,b2L,b3H,b3L,b0H,b0L,b1H,b1L);
 
753
 
 
754
 
 
755
        /* start loading next lR */
 
756
        pR += rowstride;
 
757
        lR = vec_ld(0, pR);
 
758
                                
 
759
        /* perm loaded set */
 
760
        lB2 = vec_perm(l0, l1, perm);
 
761
        lB3 = vec_perm(l0, l1, perm1);
 
762
 
 
763
        /* start loading next set */
 
764
        pB += rowstride;
 
765
        l0 = vec_ld(0, pB);
 
766
        l1 = vec_ld(16, pB);
 
767
 
 
768
                                        
 
769
        /* (unsigned short[]) pB+s[0-7] */
 
770
        b2H = vu16(vec_mergeh(zero, lB2));
 
771
 
 
772
        /* (unsigned short[]) pB+s[8-15] */
 
773
        b2L = vu16(vec_mergel(zero, lB2));
 
774
 
 
775
        /* (unsigned short[]) pB+s[1-8] */
 
776
        b3H = vu16(vec_mergeh(zero, lB3));
 
777
 
 
778
        /* (unsigned short[]) pB+s[9-16] */
 
779
        b3L = vu16(vec_mergel(zero, lB3));
 
780
    } while (--i);
 
781
 
 
782
    ISUMSQ(b0H,b0L,b1H,b1L,b2H,b2L,b3H,b3L);
 
783
 
 
784
    pR += rowstride;
 
785
    lR = vec_ld(0, pR);
 
786
                        
 
787
    lB0 = vec_perm(l0, l1, perm);
 
788
    lB1 = vec_perm(l0, l1, perm1);
 
789
                        
 
790
    /* (unsigned short[]) pB[0-7] */
 
791
    b0H = vu16(vec_mergeh(zero, lB0));
 
792
 
 
793
    /* (unsigned short[]) pB[8-15] */
 
794
    b0L = vu16(vec_mergel(zero, lB0));
 
795
 
 
796
    /* (unsigned short[]) pB[1-8] */
 
797
    b1H = vu16(vec_mergeh(zero, lB1));
 
798
 
 
799
    /* (unsigned short[]) pB[9-16] */
 
800
    b1L = vu16(vec_mergel(zero, lB1));
 
801
 
 
802
    ISUMSQ(b2H,b2L,b3H,b3L,b0H,b0L,b1H,b1L);
 
803
 
 
804
    vo.v = vec_sums(vs32(sum), vs32(zero));
 
805
 
 
806
    return vo.s.sum;
 
807
 
 
808
#undef ISUMSQ
 
809
} /* }}} */
 
810
 
 
811
int sumsq_altivec(SUMSQ_PDECL)
 
812
{
 
813
    int sumsq;
 
814
 
 
815
#ifdef ALTIVEC_VERIFY
 
816
    if (NOT_VECTOR_ALIGNED(blk2))
 
817
        mjpeg_error_exit1("sumsq: blk2 %% 16 != 0, (%d)", blk2);
 
818
 
 
819
    if (NOT_VECTOR_ALIGNED(rowstride))
 
820
        mjpeg_error_exit1("sumsq: rowstride %% 16 != 0, (%d)", rowstride);
 
821
 
 
822
    if (h != 8 && h != 16)
 
823
        mjpeg_error_exit1("sumsq: h != [8|16], (%d)", h);
 
824
#endif
 
825
 
 
826
    AMBER_START;
 
827
 
 
828
    if (hx == 0) {
 
829
        if (hy == 0)
 
830
            sumsq = sumsq_00(SUMSQ_ARGS);
 
831
        else
 
832
            sumsq = sumsq_01(SUMSQ_ARGS);
 
833
    } else {
 
834
        if (hy == 0)
 
835
            sumsq = sumsq_10(SUMSQ_ARGS);
 
836
        else
 
837
            sumsq = sumsq_11(SUMSQ_ARGS);
 
838
    }
 
839
 
 
840
    AMBER_STOP;
 
841
 
 
842
    return sumsq;
 
843
}
 
844
 
 
845
#if ALTIVEC_TEST_FUNCTION(sumsq)
 
846
ALTIVEC_TEST(sumsq, int, (SUMSQ_PDECL),
 
847
  "blk1=0x%x, blk2=0x%x, rowstride=%d, hx=%d, hy=%d, h=%d",
 
848
  SUMSQ_ARGS);
 
849
#endif
 
850
/* vim:set foldmethod=marker foldlevel=0: */