← Back to branch summary

~ubuntu-branches/debian/experimental/libav/experimental

« back to all changes in this revision

Viewing changes to libavcodec/vp3dsp.c

  • Committer: Package Import Robot
  • Author(s): Reinhard Tartler
  • Date: 2014-08-10 09:45:02 UTC
  • mfrom: (1.3.14)
  • mto: (1.3.16)
  • mto: This revision was merged to the branch mainline in revision 41.
  • Revision ID: package-import@ubuntu.com-20140810094502-mmdupdml8tixclg2
Tags: upstream-11~alpha1
Import upstream version 11~alpha1

Show diffs side-by-side

added added

removed removed

Lines of Context:
libavcodec/vp3dsp.c
25
25
 */
26
26
 
27
27
#include "libavutil/attributes.h"
 
28
#include "libavutil/intreadwrite.h"
28
29
#include "libavutil/common.h"
 
30
#include "libavutil/intreadwrite.h"
 
31
 
29
32
#include "avcodec.h"
30
 
#include "dsputil.h"
31
33
#include "rnd_avg.h"
32
34
#include "vp3dsp.h"
33
35
 
40
42
#define xC6S2 25080
41
43
#define xC7S1 12785
42
44
 
43
 
#define M(a,b) (((a) * (b))>>16)
 
45
#define M(a, b) (((a) * (b)) >> 16)
44
46
 
45
 
static av_always_inline void idct(uint8_t *dst, int stride, int16_t *input, int type)
 
47
static av_always_inline void idct(uint8_t *dst, int stride,
 
48
                                  int16_t *input, int type)
46
49
{
47
50
    int16_t *ip = input;
48
51
 
54
57
    /* Inverse DCT on the rows now */
55
58
    for (i = 0; i < 8; i++) {
56
59
        /* Check for non-zero values */
57
 
        if ( ip[0 * 8] | ip[1 * 8] | ip[2 * 8] | ip[3 * 8] |
58
 
             ip[4 * 8] | ip[5 * 8] | ip[6 * 8] | ip[7 * 8] ) {
 
60
        if (ip[0 * 8] | ip[1 * 8] | ip[2 * 8] | ip[3 * 8] |
 
61
            ip[4 * 8] | ip[5 * 8] | ip[6 * 8] | ip[7 * 8]) {
59
62
            A = M(xC1S7, ip[1 * 8]) + M(xC7S1, ip[7 * 8]);
60
63
            B = M(xC7S1, ip[1 * 8]) - M(xC1S7, ip[7 * 8]);
61
64
            C = M(xC3S5, ip[3 * 8]) + M(xC5S3, ip[5 * 8]);
83
86
            Hd = Bd + H;
84
87
 
85
88
            /*  Final sequence of operations over-write original inputs. */
86
 
            ip[0 * 8] = Gd + Cd ;
87
 
            ip[7 * 8] = Gd - Cd ;
 
89
            ip[0 * 8] = Gd + Cd;
 
90
            ip[7 * 8] = Gd - Cd;
88
91
 
89
92
            ip[1 * 8] = Add + Hd;
90
93
            ip[2 * 8] = Add - Hd;
91
94
 
92
 
            ip[3 * 8] = Ed + Dd ;
93
 
            ip[4 * 8] = Ed - Dd ;
 
95
            ip[3 * 8] = Ed + Dd;
 
96
            ip[4 * 8] = Ed - Dd;
94
97
 
95
98
            ip[5 * 8] = Fd + Bdd;
96
99
            ip[6 * 8] = Fd - Bdd;
101
104
 
102
105
    ip = input;
103
106
 
104
 
    for ( i = 0; i < 8; i++) {
 
107
    for (i = 0; i < 8; i++) {
105
108
        /* Check for non-zero values (bitwise or faster than ||) */
106
 
        if ( ip[1] | ip[2] | ip[3] |
107
 
             ip[4] | ip[5] | ip[6] | ip[7] ) {
108
 
 
 
109
        if (ip[1] | ip[2] | ip[3] |
 
110
            ip[4] | ip[5] | ip[6] | ip[7]) {
109
111
            A = M(xC1S7, ip[1]) + M(xC7S1, ip[7]);
110
112
            B = M(xC7S1, ip[1]) - M(xC1S7, ip[7]);
111
113
            C = M(xC3S5, ip[3]) + M(xC5S3, ip[5]);
120
122
            E = M(xC4S4, (ip[0] + ip[4])) + 8;
121
123
            F = M(xC4S4, (ip[0] - ip[4])) + 8;
122
124
 
123
 
            if(type==1){  //HACK
124
 
                E += 16*128;
125
 
                F += 16*128;
 
125
            if (type == 1) { // HACK
 
126
                E += 16 * 128;
 
127
                F += 16 * 128;
126
128
            }
127
129
 
128
130
            G = M(xC2S6, ip[2]) + M(xC6S2, ip[6]);
139
141
 
140
142
            /* Final sequence of operations over-write original inputs. */
141
143
            if (type == 1) {
142
 
                dst[0*stride] = av_clip_uint8((Gd + Cd )  >> 4);
143
 
                dst[7*stride] = av_clip_uint8((Gd - Cd )  >> 4);
144
 
 
145
 
                dst[1*stride] = av_clip_uint8((Add + Hd ) >> 4);
146
 
                dst[2*stride] = av_clip_uint8((Add - Hd ) >> 4);
147
 
 
148
 
                dst[3*stride] = av_clip_uint8((Ed + Dd )  >> 4);
149
 
                dst[4*stride] = av_clip_uint8((Ed - Dd )  >> 4);
150
 
 
151
 
                dst[5*stride] = av_clip_uint8((Fd + Bdd ) >> 4);
152
 
                dst[6*stride] = av_clip_uint8((Fd - Bdd ) >> 4);
153
 
            }else{
154
 
                dst[0*stride] = av_clip_uint8(dst[0*stride] + ((Gd + Cd )  >> 4));
155
 
                dst[7*stride] = av_clip_uint8(dst[7*stride] + ((Gd - Cd )  >> 4));
156
 
 
157
 
                dst[1*stride] = av_clip_uint8(dst[1*stride] + ((Add + Hd ) >> 4));
158
 
                dst[2*stride] = av_clip_uint8(dst[2*stride] + ((Add - Hd ) >> 4));
159
 
 
160
 
                dst[3*stride] = av_clip_uint8(dst[3*stride] + ((Ed + Dd )  >> 4));
161
 
                dst[4*stride] = av_clip_uint8(dst[4*stride] + ((Ed - Dd )  >> 4));
162
 
 
163
 
                dst[5*stride] = av_clip_uint8(dst[5*stride] + ((Fd + Bdd ) >> 4));
164
 
                dst[6*stride] = av_clip_uint8(dst[6*stride] + ((Fd - Bdd ) >> 4));
 
144
                dst[0 * stride] = av_clip_uint8((Gd + Cd) >> 4);
 
145
                dst[7 * stride] = av_clip_uint8((Gd - Cd) >> 4);
 
146
 
 
147
                dst[1 * stride] = av_clip_uint8((Add + Hd) >> 4);
 
148
                dst[2 * stride] = av_clip_uint8((Add - Hd) >> 4);
 
149
 
 
150
                dst[3 * stride] = av_clip_uint8((Ed + Dd) >> 4);
 
151
                dst[4 * stride] = av_clip_uint8((Ed - Dd) >> 4);
 
152
 
 
153
                dst[5 * stride] = av_clip_uint8((Fd + Bdd) >> 4);
 
154
                dst[6 * stride] = av_clip_uint8((Fd - Bdd) >> 4);
 
155
            } else {
 
156
                dst[0 * stride] = av_clip_uint8(dst[0 * stride] + ((Gd + Cd) >> 4));
 
157
                dst[7 * stride] = av_clip_uint8(dst[7 * stride] + ((Gd - Cd) >> 4));
 
158
 
 
159
                dst[1 * stride] = av_clip_uint8(dst[1 * stride] + ((Add + Hd) >> 4));
 
160
                dst[2 * stride] = av_clip_uint8(dst[2 * stride] + ((Add - Hd) >> 4));
 
161
 
 
162
                dst[3 * stride] = av_clip_uint8(dst[3 * stride] + ((Ed + Dd) >> 4));
 
163
                dst[4 * stride] = av_clip_uint8(dst[4 * stride] + ((Ed - Dd) >> 4));
 
164
 
 
165
                dst[5 * stride] = av_clip_uint8(dst[5 * stride] + ((Fd + Bdd) >> 4));
 
166
                dst[6 * stride] = av_clip_uint8(dst[6 * stride] + ((Fd - Bdd) >> 4));
165
167
            }
166
 
 
167
168
        } else {
168
169
            if (type == 1) {
169
 
                dst[0*stride]=
170
 
                dst[1*stride]=
171
 
                dst[2*stride]=
172
 
                dst[3*stride]=
173
 
                dst[4*stride]=
174
 
                dst[5*stride]=
175
 
                dst[6*stride]=
176
 
                dst[7*stride]= av_clip_uint8(128 + ((xC4S4 * ip[0] + (IdctAdjustBeforeShift<<16))>>20));
177
 
            }else{
178
 
                if(ip[0]){
179
 
                    int v= ((xC4S4 * ip[0] + (IdctAdjustBeforeShift<<16))>>20);
180
 
                    dst[0*stride] = av_clip_uint8(dst[0*stride] + v);
181
 
                    dst[1*stride] = av_clip_uint8(dst[1*stride] + v);
182
 
                    dst[2*stride] = av_clip_uint8(dst[2*stride] + v);
183
 
                    dst[3*stride] = av_clip_uint8(dst[3*stride] + v);
184
 
                    dst[4*stride] = av_clip_uint8(dst[4*stride] + v);
185
 
                    dst[5*stride] = av_clip_uint8(dst[5*stride] + v);
186
 
                    dst[6*stride] = av_clip_uint8(dst[6*stride] + v);
187
 
                    dst[7*stride] = av_clip_uint8(dst[7*stride] + v);
 
170
                dst[0*stride] =
 
171
                dst[1*stride] =
 
172
                dst[2*stride] =
 
173
                dst[3*stride] =
 
174
                dst[4*stride] =
 
175
                dst[5*stride] =
 
176
                dst[6*stride] =
 
177
                dst[7*stride] = av_clip_uint8(128 + ((xC4S4 * ip[0] + (IdctAdjustBeforeShift << 16)) >> 20));
 
178
            } else {
 
179
                if (ip[0]) {
 
180
                    int v = (xC4S4 * ip[0] + (IdctAdjustBeforeShift << 16)) >> 20;
 
181
                    dst[0 * stride] = av_clip_uint8(dst[0 * stride] + v);
 
182
                    dst[1 * stride] = av_clip_uint8(dst[1 * stride] + v);
 
183
                    dst[2 * stride] = av_clip_uint8(dst[2 * stride] + v);
 
184
                    dst[3 * stride] = av_clip_uint8(dst[3 * stride] + v);
 
185
                    dst[4 * stride] = av_clip_uint8(dst[4 * stride] + v);
 
186
                    dst[5 * stride] = av_clip_uint8(dst[5 * stride] + v);
 
187
                    dst[6 * stride] = av_clip_uint8(dst[6 * stride] + v);
 
188
                    dst[7 * stride] = av_clip_uint8(dst[7 * stride] + v);
188
189
                }
189
190
            }
190
191
        }
194
195
    }
195
196
}
196
197
 
197
 
static void vp3_idct_put_c(uint8_t *dest/*align 8*/, int line_size,
198
 
                           int16_t *block/*align 16*/)
 
198
static void vp3_idct_put_c(uint8_t *dest /* align 8 */, int line_size,
 
199
                           int16_t *block /* align 16 */)
199
200
{
200
201
    idct(dest, line_size, block, 1);
201
202
    memset(block, 0, sizeof(*block) * 64);
202
203
}
203
204
 
204
 
static void vp3_idct_add_c(uint8_t *dest/*align 8*/, int line_size,
205
 
                           int16_t *block/*align 16*/)
 
205
static void vp3_idct_add_c(uint8_t *dest /* align 8 */, int line_size,
 
206
                           int16_t *block /* align 16 */)
206
207
{
207
208
    idct(dest, line_size, block, 2);
208
209
    memset(block, 0, sizeof(*block) * 64);
209
210
}
210
211
 
211
 
static void vp3_idct_dc_add_c(uint8_t *dest/*align 8*/, int line_size,
212
 
                              int16_t *block/*align 16*/)
 
212
static void vp3_idct_dc_add_c(uint8_t *dest /* align 8 */, int line_size,
 
213
                              int16_t *block /* align 16 */)
213
214
{
214
215
    int i, dc = (block[0] + 15) >> 5;
215
216
 
216
 
    for(i = 0; i < 8; i++){
 
217
    for (i = 0; i < 8; i++) {
217
218
        dest[0] = av_clip_uint8(dest[0] + dc);
218
219
        dest[1] = av_clip_uint8(dest[1] + dc);
219
220
        dest[2] = av_clip_uint8(dest[2] + dc);
222
223
        dest[5] = av_clip_uint8(dest[5] + dc);
223
224
        dest[6] = av_clip_uint8(dest[6] + dc);
224
225
        dest[7] = av_clip_uint8(dest[7] + dc);
225
 
        dest += line_size;
 
226
        dest   += line_size;
226
227
    }
227
228
    block[0] = 0;
228
229
}
232
233
{
233
234
    unsigned char *end;
234
235
    int filter_value;
235
 
    const int nstride= -stride;
 
236
    const int nstride = -stride;
236
237
 
237
 
    for (end= first_pixel + 8; first_pixel < end; first_pixel++) {
238
 
        filter_value =
239
 
            (first_pixel[2 * nstride] - first_pixel[ stride])
240
 
         +3*(first_pixel[0          ] - first_pixel[nstride]);
 
238
    for (end = first_pixel + 8; first_pixel < end; first_pixel++) {
 
239
        filter_value = (first_pixel[2 * nstride] - first_pixel[stride]) +
 
240
                       (first_pixel[0] - first_pixel[nstride]) * 3;
241
241
        filter_value = bounding_values[(filter_value + 4) >> 3];
 
242
 
242
243
        first_pixel[nstride] = av_clip_uint8(first_pixel[nstride] + filter_value);
243
 
        first_pixel[0] = av_clip_uint8(first_pixel[0] - filter_value);
 
244
        first_pixel[0]       = av_clip_uint8(first_pixel[0] - filter_value);
244
245
    }
245
246
}
246
247
 
250
251
    unsigned char *end;
251
252
    int filter_value;
252
253
 
253
 
    for (end= first_pixel + 8*stride; first_pixel != end; first_pixel += stride) {
254
 
        filter_value =
255
 
            (first_pixel[-2] - first_pixel[ 1])
256
 
         +3*(first_pixel[ 0] - first_pixel[-1]);
 
254
    for (end = first_pixel + 8 * stride; first_pixel != end; first_pixel += stride) {
 
255
        filter_value = (first_pixel[-2] - first_pixel[1]) +
 
256
                       (first_pixel[ 0] - first_pixel[-1]) * 3;
257
257
        filter_value = bounding_values[(filter_value + 4) >> 3];
 
258
 
258
259
        first_pixel[-1] = av_clip_uint8(first_pixel[-1] + filter_value);
259
260
        first_pixel[ 0] = av_clip_uint8(first_pixel[ 0] - filter_value);
260
261
    }
289
290
 
290
291
    if (ARCH_ARM)
291
292
        ff_vp3dsp_init_arm(c, flags);
292
 
    if (ARCH_BFIN)
293
 
        ff_vp3dsp_init_bfin(c, flags);
294
293
    if (ARCH_PPC)
295
294
        ff_vp3dsp_init_ppc(c, flags);
296
295
    if (ARCH_X86)