← 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/bsumsq_sub22.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/bsumsq_sub22.c
 
1
/* bsumsq_sub22.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
 * Total squared difference between bidirection prediction of (8*h)
 
38
 * blocks of 2*2 subsampled pels.
 
39
 *
 
40
 * Iterate through all rows 2 at a time.
 
41
 *
 
42
 * Hints regarding input:
 
43
 *   b) ref is about 50% vector aligned and 50% 8 byte aligned
 
44
 *   c) rowstride is always a multiple of 16
 
45
 *   d) h == 4 or 8
 
46
 *
 
47
 *
 
48
 * for (j = 0; j < h; j++) {
 
49
 *     for (i = 0; i < 8; i++) {
 
50
 *      d = ((p1f[i]+p1b[i]+1)>>1) - p2[i];
 
51
 *      sum += d * d;
 
52
 *     }
 
53
 *     p1f += rowstride;
 
54
 *     p1b += rowstride;
 
55
 *     p2 += rowstride;
 
56
 * }
 
57
 */
 
58
 
 
59
#define BSUMSQ_SUB22_PDECL                                                   \
 
60
  uint8_t *blk1f,                                                            \
 
61
  uint8_t *blk1b,                                                            \
 
62
  uint8_t *blk2,                                                             \
 
63
  int rowstride,                                                             \
 
64
  int h                                                                      \
 
65
 
 
66
#define BSUMSQ_SUB22_ARGS blk1f, blk1b, blk2, rowstride, h
 
67
 
 
68
int bsumsq_sub22_altivec(BSUMSQ_SUB22_PDECL)
 
69
{
 
70
    int i;
 
71
    int lt8B, lt8F;
 
72
    unsigned char *pB, *pF, *pR;
 
73
    vector unsigned char align8x2;
 
74
    vector unsigned char permB, permF, permR;
 
75
    vector unsigned char lB0, lB1, lB2, lB3;
 
76
    vector unsigned char lF0, lF1, lF2, lF3;
 
77
    vector unsigned char lR0, lR1;
 
78
    vector unsigned char B, F, R;
 
79
    vector unsigned short bH, bL, fH, fL;
 
80
    vector unsigned char min;
 
81
    vector unsigned char max;
 
82
    vector unsigned char dif;
 
83
    vector unsigned int sum;
 
84
    vector unsigned char zero;
 
85
    vector unsigned short one;
 
86
    union {
 
87
        vector signed int v;
 
88
        struct {
 
89
            signed int pad[3];
 
90
            signed int sum;
 
91
        } s;
 
92
    } vo;
 
93
 
 
94
#ifdef ALTIVEC_VERIFY
 
95
    if (((unsigned long)blk2 % 8) != 0)
 
96
        mjpeg_error_exit1("bsumsq_sub22: blk2 %% 8 != 0, (0x%X)", blk2);
 
97
 
 
98
    if (NOT_VECTOR_ALIGNED(rowstride))
 
99
        mjpeg_error_exit1("bsumsq_sub22: rowstride %% 16 != 0, (%d)",
 
100
            rowstride);
 
101
 
 
102
    if (h != 4 && h != 8)
 
103
        mjpeg_error_exit1("bsumsq_sub22: h != [4|8], (%d)", h);
 
104
#endif
 
105
 
 
106
    /* 8*h blocks calculated in 8*2 chunks */
 
107
    /* align8x2 = 0x( 00 01 02 03 04 05 06 07 10 11 12 13 14 15 16 17 ) {{{ */
 
108
    align8x2 = vec_lvsl(0, (unsigned char*)0);
 
109
    align8x2 = vec_sld(align8x2, align8x2, 8);
 
110
    permB = vec_lvsr(0, (unsigned char*)0);
 
111
    align8x2 = vec_sld(align8x2, permB, 8);
 
112
    /* }}} */
 
113
 
 
114
 
 
115
    i = (h >> 1) - 1;
 
116
 
 
117
    zero = vec_splat_u8(0);
 
118
    one = vec_splat_u16(1);
 
119
 
 
120
    sum = vec_splat_u32(0);
 
121
 
 
122
    pR = blk2;
 
123
    permR = vec_lvsl(0, pR);
 
124
    permR = vec_splat(permR, 0);
 
125
    permR = vec_add(permR, align8x2);
 
126
 
 
127
    lt8B = (((unsigned long)blk1b & 0xf) <= 8);
 
128
    lt8F = (((unsigned long)blk1f & 0xf) <= 8);
 
129
 
 
130
    if (lt8B && lt8F) {
 
131
        pB = blk1b;
 
132
        pF = blk1f;
 
133
 
 
134
        permB = vec_lvsl(0, pB);
 
135
        permB = vec_splat(permB, 0);
 
136
        permB = vec_add(permB, align8x2);
 
137
 
 
138
        permF = vec_lvsl(0, pF);
 
139
        permF = vec_splat(permF, 0);
 
140
        permF = vec_add(permF, align8x2);
 
141
 
 
142
        lB0 = vec_ld(0, pB);
 
143
        pB += rowstride;
 
144
        lB1 = vec_ld(0, pB);
 
145
 
 
146
        lF0 = vec_ld(0, pF);
 
147
        pF += rowstride;
 
148
        lF1 = vec_ld(0, pF);
 
149
 
 
150
        lR0 = vec_ld(0, pR);
 
151
        pR += rowstride;
 
152
        lR1 = vec_ld(0, pR);
 
153
 
 
154
        B = vec_perm(lB0, lB1, permB);
 
155
        F = vec_perm(lF0, lF1, permF);
 
156
        R = vec_perm(lR0, lR1, permR);
 
157
 
 
158
        do {
 
159
            pB += rowstride;
 
160
            lB0 = vec_ld(0, pB);
 
161
            pB += rowstride;
 
162
            lB1 = vec_ld(0, pB);
 
163
 
 
164
            pF += rowstride;
 
165
            lF0 = vec_ld(0, pF);
 
166
            pF += rowstride;
 
167
            lF1 = vec_ld(0, pF);
 
168
 
 
169
            pR += rowstride;
 
170
            lR0 = vec_ld(0, pR);
 
171
            pR += rowstride;
 
172
            lR1 = vec_ld(0, pR);
 
173
 
 
174
 
 
175
            /* (unsigned short[]) pB[0-7] */
 
176
            bH = vu16(vec_mergeh(zero, B));
 
177
 
 
178
            /* (unsigned short[]) pF[0-7] */
 
179
            fH = vu16(vec_mergeh(zero, F));
 
180
 
 
181
            /* pB[i] + pF[i] */
 
182
            bH = vec_add(bH, fH);
 
183
 
 
184
            /* (unsigned short[]) pB[8-15] */
 
185
            bL = vu16(vec_mergel(zero, B));
 
186
 
 
187
            /* (unsigned short[]) pF[8-15] */
 
188
            fL = vu16(vec_mergel(zero, F));
 
189
 
 
190
            /* pB[i] + pF[i] */
 
191
            bL = vec_add(bL, fL);
 
192
 
 
193
            /* (pB[i]+pF[i]) + 1 */
 
194
            bH = vec_add(bH, one);
 
195
            bL = vec_add(bL, one);
 
196
                                        
 
197
            /* (pB[i]+pF[i]+1) >> 1 */
 
198
            bH = vec_sra(bH, one);
 
199
            bL = vec_sra(bL, one);
 
200
 
 
201
            /* d = abs( ((pB[i]+pF[i]+1)>>1) - pR[i] ) */
 
202
            bH = vu16(vec_packsu(bH, bL));
 
203
            min = vec_min(vu8(bH), R);
 
204
            max = vec_max(vu8(bH), R);
 
205
            dif = vec_sub(max, min);
 
206
                                        
 
207
            /* sum += (d * d) */
 
208
            sum = vec_msum(dif, dif, sum);
 
209
 
 
210
 
 
211
            B = vec_perm(lB0, lB1, permB);
 
212
            F = vec_perm(lF0, lF1, permF);
 
213
            R = vec_perm(lR0, lR1, permR);
 
214
 
 
215
        } while (--i);
 
216
 
 
217
    }
 
218
    else if (lt8B || lt8F)
 
219
    {
 
220
        if (lt8F) {
 
221
            pB = blk1b;
 
222
            pF = blk1f;
 
223
        } else {
 
224
            pB = blk1f;
 
225
            pF = blk1b;
 
226
        }
 
227
 
 
228
        permB = vec_lvsl(0, pB);
 
229
 
 
230
        permF = vec_lvsl(0, pF);
 
231
        permF = vec_splat(permF, 0);
 
232
        permF = vec_add(permF, align8x2);
 
233
 
 
234
        lB0 = vec_ld(0, pB);
 
235
        lB1 = vec_ld(16, pB);
 
236
        pB += rowstride;
 
237
        lB2 = vec_ld(0, pB);
 
238
        lB3 = vec_ld(16, pB);
 
239
 
 
240
        lF0 = vec_ld(0, pF);
 
241
        pF += rowstride;
 
242
        lF1 = vec_ld(0, pF);
 
243
 
 
244
        lR0 = vec_ld(0, pR);
 
245
        pR += rowstride;
 
246
        lR1 = vec_ld(0, pR);
 
247
 
 
248
 
 
249
        lB0 = vec_perm(lB0, lB1, permB);
 
250
        lB2 = vec_perm(lB2, lB3, permB);
 
251
        B = vec_perm(lB0, lB2, align8x2);
 
252
 
 
253
        F = vec_perm(lF0, lF1, permF);
 
254
        R = vec_perm(lR0, lR1, permR);
 
255
 
 
256
        do {
 
257
            pB += rowstride;
 
258
            lB0 = vec_ld(0, pB);
 
259
            lB1 = vec_ld(16, pB);
 
260
            pB += rowstride;
 
261
            lB2 = vec_ld(0, pB);
 
262
            lB3 = vec_ld(16, pB);
 
263
 
 
264
            pF += rowstride;
 
265
            lF0 = vec_ld(0, pF);
 
266
            pF += rowstride;
 
267
            lF1 = vec_ld(0, pF);
 
268
 
 
269
            pR += rowstride;
 
270
            lR0 = vec_ld(0, pR);
 
271
            pR += rowstride;
 
272
            lR1 = vec_ld(0, pR);
 
273
 
 
274
 
 
275
            /* (unsigned short[]) pB[0-7] */
 
276
            bH = vu16(vec_mergeh(zero, B));
 
277
 
 
278
            /* (unsigned short[]) pF[0-7] */
 
279
            fH = vu16(vec_mergeh(zero, F));
 
280
 
 
281
            /* pB[i] + pF[i] */
 
282
            bH = vec_add(bH, fH);
 
283
 
 
284
            /* (unsigned short[]) pB[8-15] */
 
285
            bL = vu16(vec_mergel(zero, B));
 
286
 
 
287
            /* (unsigned short[]) pF[8-15] */
 
288
            fL = vu16(vec_mergel(zero, F));
 
289
 
 
290
            /* pB[i] + pF[i] */
 
291
            bL = vec_add(bL, fL);
 
292
 
 
293
            /* (pB[i]+pF[i]) + 1 */
 
294
            bH = vec_add(bH, one);
 
295
            bL = vec_add(bL, one);
 
296
                                        
 
297
            /* (pB[i]+pF[i]+1) >> 1 */
 
298
            bH = vec_sra(bH, one);
 
299
            bL = vec_sra(bL, one);
 
300
 
 
301
            /* d = abs( ((pB[i]+pF[i]+1)>>1) - pR[i] ) */
 
302
            bH = vu16(vec_packsu(bH, bL));
 
303
            min = vec_min(vu8(bH), R);
 
304
            max = vec_max(vu8(bH), R);
 
305
            dif = vec_sub(max, min);
 
306
                                        
 
307
            /* sum += (d * d) */
 
308
            sum = vec_msum(dif, dif, sum);
 
309
 
 
310
            lB0 = vec_perm(lB0, lB1, permB);
 
311
            lB2 = vec_perm(lB2, lB3, permB);
 
312
            B = vec_perm(lB0, lB2, align8x2);
 
313
 
 
314
            F = vec_perm(lF0, lF1, permF);
 
315
            R = vec_perm(lR0, lR1, permR);
 
316
 
 
317
        } while (--i);
 
318
 
 
319
    } else {
 
320
        pB = blk1b;
 
321
        pF = blk1f;
 
322
 
 
323
        permB = vec_lvsl(0, pB);
 
324
        permF = vec_lvsl(0, pF);
 
325
 
 
326
        lB0 = vec_ld(0, pB);
 
327
        lB1 = vec_ld(16, pB);
 
328
        pB += rowstride;
 
329
        lB2 = vec_ld(0, pB);
 
330
        lB3 = vec_ld(16, pB);
 
331
 
 
332
        lF0 = vec_ld(0, pF);
 
333
        lF1 = vec_ld(16, pF);
 
334
        pF += rowstride;
 
335
        lF2 = vec_ld(0, pF);
 
336
        lF3 = vec_ld(16, pF);
 
337
 
 
338
        lR0 = vec_ld(0, pR);
 
339
        pR += rowstride;
 
340
        lR1 = vec_ld(0, pR);
 
341
 
 
342
        lB0 = vec_perm(lB0, lB1, permB);
 
343
        lB2 = vec_perm(lB2, lB3, permB);
 
344
        B = vec_perm(lB0, lB2, align8x2);
 
345
 
 
346
        lF0 = vec_perm(lF0, lF1, permF);
 
347
        lF2 = vec_perm(lF2, lF3, permF);
 
348
        F = vec_perm(lF0, lF2, align8x2);
 
349
 
 
350
        R = vec_perm(lR0, lR1, permR);
 
351
 
 
352
        do {
 
353
            pB += rowstride;
 
354
            lB0 = vec_ld(0, pB);
 
355
            lB1 = vec_ld(16, pB);
 
356
            pB += rowstride;
 
357
            lB2 = vec_ld(0, pB);
 
358
            lB3 = vec_ld(16, pB);
 
359
 
 
360
            pF += rowstride;
 
361
            lF0 = vec_ld(0, pF);
 
362
            lF1 = vec_ld(16, pF);
 
363
            pF += rowstride;
 
364
            lF2 = vec_ld(0, pF);
 
365
            lF3 = vec_ld(16, pF);
 
366
 
 
367
            pR += rowstride;
 
368
            lR0 = vec_ld(0, pR);
 
369
            pR += rowstride;
 
370
            lR1 = vec_ld(0, pR);
 
371
 
 
372
            /* (unsigned short[]) pB[0-7] */
 
373
            bH = vu16(vec_mergeh(zero, B));
 
374
 
 
375
            /* (unsigned short[]) pF[0-7] */
 
376
            fH = vu16(vec_mergeh(zero, F));
 
377
 
 
378
            /* pB[i] + pF[i] */
 
379
            bH = vec_add(bH, fH);
 
380
 
 
381
            /* (unsigned short[]) pB[8-15] */
 
382
            bL = vu16(vec_mergel(zero, B));
 
383
 
 
384
            /* (unsigned short[]) pF[8-15] */
 
385
            fL = vu16(vec_mergel(zero, F));
 
386
 
 
387
            /* pB[i] + pF[i] */
 
388
            bL = vec_add(bL, fL);
 
389
 
 
390
            /* (pB[i]+pF[i]) + 1 */
 
391
            bH = vec_add(bH, one);
 
392
            bL = vec_add(bL, one);
 
393
 
 
394
            /* (pB[i]+pF[i]+1) >> 1 */
 
395
            bH = vec_sra(bH, one);
 
396
            bL = vec_sra(bL, one);
 
397
 
 
398
            /* d = abs( ((pB[i]+pF[i]+1)>>1) - pR[i] ) */
 
399
            bH = vu16(vec_packsu(bH, bL));
 
400
            min = vec_min(vu8(bH), R);
 
401
            max = vec_max(vu8(bH), R);
 
402
            dif = vec_sub(max, min);
 
403
 
 
404
            /* sum += (d * d) */
 
405
            sum = vec_msum(dif, dif, sum);
 
406
 
 
407
            lB0 = vec_perm(lB0, lB1, permB);
 
408
            lB2 = vec_perm(lB2, lB3, permB);
 
409
            B = vec_perm(lB0, lB2, align8x2);
 
410
 
 
411
            lF0 = vec_perm(lF0, lF1, permF);
 
412
            lF2 = vec_perm(lF2, lF3, permF);
 
413
            F = vec_perm(lF0, lF2, align8x2);
 
414
 
 
415
            R = vec_perm(lR0, lR1, permR);
 
416
        } while (--i);
 
417
    }
 
418
 
 
419
    /* (unsigned short[]) pB[0-7] */
 
420
    bH = vu16(vec_mergeh(zero, B));
 
421
 
 
422
    /* (unsigned short[]) pF[0-7] */
 
423
    fH = vu16(vec_mergeh(zero, F));
 
424
 
 
425
    /* pB[i] + pF[i] */
 
426
    bH = vec_add(bH, fH);
 
427
 
 
428
    /* (unsigned short[]) pB[8-15] */
 
429
    bL = vu16(vec_mergel(zero, B));
 
430
 
 
431
    /* (unsigned short[]) pF[8-15] */
 
432
    fL = vu16(vec_mergel(zero, F));
 
433
 
 
434
    /* pB[i] + pF[i] */
 
435
    bL = vec_add(bL, fL);
 
436
 
 
437
    /* (pB[i]+pF[i]) + 1 */
 
438
    bH = vec_add(bH, one);
 
439
    bL = vec_add(bL, one);
 
440
                                
 
441
    /* (pB[i]+pF[i]+1) >> 1 */
 
442
    bH = vec_sra(bH, one);
 
443
    bL = vec_sra(bL, one);
 
444
 
 
445
    /* d = abs( ((pB[i]+pF[i]+1)>>1) - pR[i] ) */
 
446
    bH = vu16(vec_packsu(bH, bL));
 
447
    min = vec_min(vu8(bH), R);
 
448
    max = vec_max(vu8(bH), R);
 
449
    dif = vec_sub(max, min);
 
450
                                
 
451
    /* sum += d * d */
 
452
    sum = vec_msum(dif, dif, sum);
 
453
 
 
454
    vo.v = vec_sums(vs32(sum), vs32(zero));
 
455
 
 
456
    AMBER_STOP;
 
457
 
 
458
    return vo.s.sum;
 
459
}
 
460
 
 
461
#if ALTIVEC_TEST_FUNCTION(bsumsq_sub22)
 
462
ALTIVEC_TEST(bsumsq_sub22, int, (BSUMSQ_SUB22_PDECL),
 
463
  "blk1f=0x%X, blk1b=0x%X, blk2=0x%X, rowstride=%d, h=%d",
 
464
  BSUMSQ_SUB22_ARGS);
 
465
#endif
 
466
/* vim:set foldmethod=marker foldlevel=0: */