← Back to branch summary

~medibuntu-maintainers/mplayer/medibuntu.precise

« back to all changes in this revision

Viewing changes to ffmpeg/libswscale/ppc/swscale_altivec.c

  • Committer: Package Import Robot
  • Author(s): Reinhard Tartler
  • Date: 2012-01-12 22:23:28 UTC
  • mfrom: (0.4.7 sid)
  • mto: This revision was merged to the branch mainline in revision 76.
  • Revision ID: package-import@ubuntu.com-20120112222328-8jqdyodym3p84ygu
Tags: 2:1.0~rc4.dfsg1+svn34540-1
* New upstream snapshot
* upload to unstable

Show diffs side-by-side

added added

removed removed

Lines of Context:
ffmpeg/libswscale/ppc/swscale_altivec.c
36
36
    register int i;
37
37
    vector unsigned int altivec_vectorShiftInt19 =
38
38
        vec_add(vec_splat_u32(10), vec_splat_u32(9));
39
 
    if ((unsigned int)dest % 16) {
 
39
    if ((uintptr_t)dest % 16) {
40
40
        /* badly aligned store, we force store alignment */
41
41
        /* and will handle load misalignment on val w/ vec_perm */
42
42
        vector unsigned char perm1;
43
43
        vector signed int v1;
44
44
        for (i = 0 ; (i < dstW) &&
45
 
            (((unsigned int)dest + i) % 16) ; i++) {
 
45
            (((uintptr_t)dest + i) % 16) ; i++) {
46
46
                int t = val[i] >> 19;
47
47
                dest[i] = (t < 0) ? 0 : ((t > 255) ? 255 : t);
48
48
        }
92
92
    }
93
93
}
94
94
 
 
95
//FIXME remove the usage of scratch buffers.
95
96
static void
96
 
yuv2yuvX_altivec_real(SwsContext *c,
97
 
                      const int16_t *lumFilter, const int16_t **lumSrc,
98
 
                      int lumFilterSize, const int16_t *chrFilter,
99
 
                      const int16_t **chrUSrc, const int16_t **chrVSrc,
100
 
                      int chrFilterSize, const int16_t **alpSrc,
101
 
                      uint8_t *dest, uint8_t *uDest,
102
 
                      uint8_t *vDest, uint8_t *aDest,
103
 
                      int dstW, int chrDstW)
 
97
yuv2planeX_altivec(const int16_t *filter, int filterSize,
 
98
                   const int16_t **src, uint8_t *dest, int dstW,
 
99
                   const uint8_t *dither, int offset)
104
100
{
105
 
    const vector signed int vini = {(1 << 18), (1 << 18), (1 << 18), (1 << 18)};
106
101
    register int i, j;
107
102
    {
108
103
        DECLARE_ALIGNED(16, int, val)[dstW];
109
104
 
110
 
        for (i = 0; i < (dstW -7); i+=4) {
111
 
            vec_st(vini, i << 2, val);
112
 
        }
113
 
        for (; i < dstW; i++) {
114
 
            val[i] = (1 << 18);
115
 
        }
 
105
        for (i=0; i<dstW; i++)
 
106
            val[i] = dither[(i + offset) & 7] << 12;
116
107
 
117
 
        for (j = 0; j < lumFilterSize; j++) {
118
 
            vector signed short l1, vLumFilter = vec_ld(j << 1, lumFilter);
119
 
            vector unsigned char perm, perm0 = vec_lvsl(j << 1, lumFilter);
 
108
        for (j = 0; j < filterSize; j++) {
 
109
            vector signed short l1, vLumFilter = vec_ld(j << 1, filter);
 
110
            vector unsigned char perm, perm0 = vec_lvsl(j << 1, filter);
120
111
            vLumFilter = vec_perm(vLumFilter, vLumFilter, perm0);
121
112
            vLumFilter = vec_splat(vLumFilter, 0); // lumFilter[j] is loaded 8 times in vLumFilter
122
113
 
123
 
            perm = vec_lvsl(0, lumSrc[j]);
124
 
            l1 = vec_ld(0, lumSrc[j]);
 
114
            perm = vec_lvsl(0, src[j]);
 
115
            l1 = vec_ld(0, src[j]);
125
116
 
126
117
            for (i = 0; i < (dstW - 7); i+=8) {
127
118
                int offset = i << 2;
128
 
                vector signed short l2 = vec_ld((i << 1) + 16, lumSrc[j]);
 
119
                vector signed short l2 = vec_ld((i << 1) + 16, src[j]);
129
120
 
130
121
                vector signed int v1 = vec_ld(offset, val);
131
122
                vector signed int v2 = vec_ld(offset + 16, val);
147
138
                l1 = l2;
148
139
            }
149
140
            for ( ; i < dstW; i++) {
150
 
                val[i] += lumSrc[j][i] * lumFilter[j];
 
141
                val[i] += src[j][i] * filter[j];
151
142
            }
152
143
        }
153
144
        altivec_packIntArrayToCharArray(val, dest, dstW);
154
145
    }
155
 
    if (uDest != 0) {
156
 
        DECLARE_ALIGNED(16, int, u)[chrDstW];
157
 
        DECLARE_ALIGNED(16, int, v)[chrDstW];
158
 
 
159
 
        for (i = 0; i < (chrDstW -7); i+=4) {
160
 
            vec_st(vini, i << 2, u);
161
 
            vec_st(vini, i << 2, v);
162
 
        }
163
 
        for (; i < chrDstW; i++) {
164
 
            u[i] = (1 << 18);
165
 
            v[i] = (1 << 18);
166
 
        }
167
 
 
168
 
        for (j = 0; j < chrFilterSize; j++) {
169
 
            vector signed short l1, l1_V, vChrFilter = vec_ld(j << 1, chrFilter);
170
 
            vector unsigned char perm, perm0 = vec_lvsl(j << 1, chrFilter);
171
 
            vChrFilter = vec_perm(vChrFilter, vChrFilter, perm0);
172
 
            vChrFilter = vec_splat(vChrFilter, 0); // chrFilter[j] is loaded 8 times in vChrFilter
173
 
 
174
 
            perm = vec_lvsl(0, chrUSrc[j]);
175
 
            l1 = vec_ld(0, chrUSrc[j]);
176
 
            l1_V = vec_ld(0, chrVSrc[j]);
177
 
 
178
 
            for (i = 0; i < (chrDstW - 7); i+=8) {
179
 
                int offset = i << 2;
180
 
                vector signed short l2 = vec_ld((i << 1) + 16, chrUSrc[j]);
181
 
                vector signed short l2_V = vec_ld((i << 1) + 16, chrVSrc[j]);
182
 
 
183
 
                vector signed int v1 = vec_ld(offset, u);
184
 
                vector signed int v2 = vec_ld(offset + 16, u);
185
 
                vector signed int v1_V = vec_ld(offset, v);
186
 
                vector signed int v2_V = vec_ld(offset + 16, v);
187
 
 
188
 
                vector signed short ls = vec_perm(l1, l2, perm); // chrUSrc[j][i] ... chrUSrc[j][i+7]
189
 
                vector signed short ls_V = vec_perm(l1_V, l2_V, perm); // chrVSrc[j][i] ... chrVSrc[j][i]
190
 
 
191
 
                vector signed int i1 = vec_mule(vChrFilter, ls);
192
 
                vector signed int i2 = vec_mulo(vChrFilter, ls);
193
 
                vector signed int i1_V = vec_mule(vChrFilter, ls_V);
194
 
                vector signed int i2_V = vec_mulo(vChrFilter, ls_V);
195
 
 
196
 
                vector signed int vf1 = vec_mergeh(i1, i2);
197
 
                vector signed int vf2 = vec_mergel(i1, i2); // chrUSrc[j][i] * chrFilter[j] ... chrUSrc[j][i+7] * chrFilter[j]
198
 
                vector signed int vf1_V = vec_mergeh(i1_V, i2_V);
199
 
                vector signed int vf2_V = vec_mergel(i1_V, i2_V); // chrVSrc[j][i] * chrFilter[j] ... chrVSrc[j][i+7] * chrFilter[j]
200
 
 
201
 
                vector signed int vo1 = vec_add(v1, vf1);
202
 
                vector signed int vo2 = vec_add(v2, vf2);
203
 
                vector signed int vo1_V = vec_add(v1_V, vf1_V);
204
 
                vector signed int vo2_V = vec_add(v2_V, vf2_V);
205
 
 
206
 
                vec_st(vo1, offset, u);
207
 
                vec_st(vo2, offset + 16, u);
208
 
                vec_st(vo1_V, offset, v);
209
 
                vec_st(vo2_V, offset + 16, v);
210
 
 
211
 
                l1 = l2;
212
 
                l1_V = l2_V;
213
 
            }
214
 
            for ( ; i < chrDstW; i++) {
215
 
                u[i] += chrUSrc[j][i] * chrFilter[j];
216
 
                v[i] += chrVSrc[j][i] * chrFilter[j];
217
 
            }
218
 
        }
219
 
        altivec_packIntArrayToCharArray(u, uDest, chrDstW);
220
 
        altivec_packIntArrayToCharArray(v, vDest, chrDstW);
221
 
    }
222
146
}
223
147
 
224
 
static void hScale_altivec_real(int16_t *dst, int dstW,
225
 
                                const uint8_t *src, int srcW,
226
 
                                int xInc, const int16_t *filter,
 
148
static void hScale_altivec_real(SwsContext *c, int16_t *dst, int dstW,
 
149
                                const uint8_t *src, const int16_t *filter,
227
150
                                const int16_t *filterPos, int filterSize)
228
151
{
229
152
    register int i;
251
174
        vector unsigned char src_v1, src_vF;
252
175
        vector signed short src_v, filter_v;
253
176
        vector signed int val_vEven, val_s;
254
 
        if ((((int)src + srcPos)% 16) > 12) {
 
177
        if ((((uintptr_t)src + srcPos) % 16) > 12) {
255
178
            src_v1 = vec_ld(srcPos + 16, src);
256
179
        }
257
180
        src_vF = vec_perm(src_v0, src_v1, vec_lvsl(srcPos, src));
290
213
        vector unsigned char src_v1, src_vF;
291
214
        vector signed short src_v, filter_v;
292
215
        vector signed int val_v, val_s;
293
 
        if ((((int)src + srcPos)% 16) > 8) {
 
216
        if ((((uintptr_t)src + srcPos) % 16) > 8) {
294
217
            src_v1 = vec_ld(srcPos + 16, src);
295
218
        }
296
219
        src_vF = vec_perm(src_v0, src_v1, vec_lvsl(srcPos, src));
376
299
            //vector unsigned char src_v0 = vec_ld(srcPos + j, src);
377
300
            vector unsigned char src_v1, src_vF;
378
301
            vector signed short src_v, filter_v1R, filter_v;
379
 
            if ((((int)src + srcPos)% 16) > 8) {
 
302
            if ((((uintptr_t)src + srcPos) % 16) > 8) {
380
303
                src_v1 = vec_ld(srcPos + j + 16, src);
381
304
            }
382
305
            src_vF = vec_perm(src_v0, src_v1, permS);
408
331
    if (!(av_get_cpu_flags() & AV_CPU_FLAG_ALTIVEC))
409
332
        return;
410
333
 
411
 
    c->hScale       = hScale_altivec_real;
412
 
    if (!is16BPS(dstFormat) && !is9_OR_10BPS(dstFormat)) {
413
 
        c->yuv2yuvX     = yuv2yuvX_altivec_real;
 
334
    if (c->srcBpc == 8 && c->dstBpc <= 10) {
 
335
        c->hyScale = c->hcScale = hScale_altivec_real;
 
336
    }
 
337
    if (!is16BPS(dstFormat) && !is9_OR_10BPS(dstFormat) &&
 
338
        dstFormat != PIX_FMT_NV12 && dstFormat != PIX_FMT_NV21 &&
 
339
        !c->alpPixBuf) {
 
340
        c->yuv2planeX = yuv2planeX_altivec;
414
341
    }
415
342
 
416
343
    /* The following list of supported dstFormat values should
417
344
     * match what's found in the body of ff_yuv2packedX_altivec() */
418
 
    if (!(c->flags & (SWS_BITEXACT | SWS_FULL_CHR_H_INT)) && !c->alpPixBuf &&
419
 
        (c->dstFormat==PIX_FMT_ABGR  || c->dstFormat==PIX_FMT_BGRA  ||
420
 
         c->dstFormat==PIX_FMT_BGR24 || c->dstFormat==PIX_FMT_RGB24 ||
421
 
         c->dstFormat==PIX_FMT_RGBA  || c->dstFormat==PIX_FMT_ARGB)) {
422
 
            c->yuv2packedX  = ff_yuv2packedX_altivec;
 
345
    if (!(c->flags & (SWS_BITEXACT | SWS_FULL_CHR_H_INT)) && !c->alpPixBuf) {
 
346
        switch (c->dstFormat) {
 
347
        case PIX_FMT_ABGR:  c->yuv2packedX = ff_yuv2abgr_X_altivec;  break;
 
348
        case PIX_FMT_BGRA:  c->yuv2packedX = ff_yuv2bgra_X_altivec;  break;
 
349
        case PIX_FMT_ARGB:  c->yuv2packedX = ff_yuv2argb_X_altivec;  break;
 
350
        case PIX_FMT_RGBA:  c->yuv2packedX = ff_yuv2rgba_X_altivec;  break;
 
351
        case PIX_FMT_BGR24: c->yuv2packedX = ff_yuv2bgr24_X_altivec; break;
 
352
        case PIX_FMT_RGB24: c->yuv2packedX = ff_yuv2rgb24_X_altivec; break;
423
353
        }
 
354
    }
424
355
}