← Back to branch summary

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

« back to all changes in this revision

Viewing changes to libavcodec/hpeldsp_template.c

  • Committer: Package Import Robot
  • Author(s): Reinhard Tartler
  • Date: 2014-08-10 09:45:02 UTC
  • mfrom: (1.1.28) (2.1.45 sid)
  • Revision ID: package-import@ubuntu.com-20140810094502-p8pds4kq0zpig5oq
Tags: 6:11~alpha1-1
http://bugs.debian.org/749164
* New upstream Release v11
  - Fixes Unchecked conversion from double to enum (Closes: #749164)
* Add some post v11_alpha1 patches from upstream
* All SONAMEs bumped because of internal changes, but external API is
  promised to have not changed

Show diffs side-by-side

added added

removed removed

Lines of Context:
libavcodec/hpeldsp_template.c
1
 
/*
2
 
 * Half-pel DSP functions.
3
 
 * Copyright (c) 2000, 2001 Fabrice Bellard
4
 
 * Copyright (c) 2002-2004 Michael Niedermayer <michaelni@gmx.at>
5
 
 *
6
 
 * gmc & q-pel & 32/64 bit based MC by Michael Niedermayer <michaelni@gmx.at>
7
 
 *
8
 
 * This file is part of Libav.
9
 
 *
10
 
 * Libav is free software; you can redistribute it and/or
11
 
 * modify it under the terms of the GNU Lesser General Public
12
 
 * License as published by the Free Software Foundation; either
13
 
 * version 2.1 of the License, or (at your option) any later version.
14
 
 *
15
 
 * Libav is distributed in the hope that it will be useful,
16
 
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
17
 
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
18
 
 * Lesser General Public License for more details.
19
 
 *
20
 
 * You should have received a copy of the GNU Lesser General Public
21
 
 * License along with Libav; if not, write to the Free Software
22
 
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
23
 
 */
24
 
 
25
 
/**
26
 
 * @file
27
 
 * Half-pel DSP functions.
28
 
 */
29
 
 
30
 
#include "bit_depth_template.c"
31
 
 
32
 
#include "hpel_template.c"
33
 
 
34
 
#define PIXOP2(OPNAME, OP) \
35
 
static inline void FUNC(OPNAME ## _no_rnd_pixels8_l2)(uint8_t *dst, const uint8_t *src1, const uint8_t *src2, int dst_stride, \
36
 
                                                int src_stride1, int src_stride2, int h){\
37
 
    int i;\
38
 
    for(i=0; i<h; i++){\
39
 
        pixel4 a,b;\
40
 
        a= AV_RN4P(&src1[i*src_stride1  ]);\
41
 
        b= AV_RN4P(&src2[i*src_stride2  ]);\
42
 
        OP(*((pixel4*)&dst[i*dst_stride  ]), no_rnd_avg_pixel4(a, b));\
43
 
        a= AV_RN4P(&src1[i*src_stride1+4*sizeof(pixel)]);\
44
 
        b= AV_RN4P(&src2[i*src_stride2+4*sizeof(pixel)]);\
45
 
        OP(*((pixel4*)&dst[i*dst_stride+4*sizeof(pixel)]), no_rnd_avg_pixel4(a, b));\
46
 
    }\
47
 
}\
48
 
\
49
 
static inline void FUNCC(OPNAME ## _no_rnd_pixels8_x2)(uint8_t *block, const uint8_t *pixels, ptrdiff_t line_size, int h){\
50
 
    FUNC(OPNAME ## _no_rnd_pixels8_l2)(block, pixels, pixels+sizeof(pixel), line_size, line_size, line_size, h);\
51
 
}\
52
 
\
53
 
static inline void FUNCC(OPNAME ## _pixels8_x2)(uint8_t *block, const uint8_t *pixels, ptrdiff_t line_size, int h){\
54
 
    FUNC(OPNAME ## _pixels8_l2)(block, pixels, pixels+sizeof(pixel), line_size, line_size, line_size, h);\
55
 
}\
56
 
\
57
 
static inline void FUNCC(OPNAME ## _no_rnd_pixels8_y2)(uint8_t *block, const uint8_t *pixels, ptrdiff_t line_size, int h){\
58
 
    FUNC(OPNAME ## _no_rnd_pixels8_l2)(block, pixels, pixels+line_size, line_size, line_size, line_size, h);\
59
 
}\
60
 
\
61
 
static inline void FUNCC(OPNAME ## _pixels8_y2)(uint8_t *block, const uint8_t *pixels, ptrdiff_t line_size, int h){\
62
 
    FUNC(OPNAME ## _pixels8_l2)(block, pixels, pixels+line_size, line_size, line_size, line_size, h);\
63
 
}\
64
 
\
65
 
static inline void FUNCC(OPNAME ## _pixels4_x2)(uint8_t *block, const uint8_t *pixels, ptrdiff_t line_size, int h){\
66
 
    FUNC(OPNAME ## _pixels4_l2)(block, pixels, pixels+sizeof(pixel), line_size, line_size, line_size, h);\
67
 
}\
68
 
\
69
 
static inline void FUNCC(OPNAME ## _pixels4_y2)(uint8_t *block, const uint8_t *pixels, ptrdiff_t line_size, int h){\
70
 
    FUNC(OPNAME ## _pixels4_l2)(block, pixels, pixels+line_size, line_size, line_size, line_size, h);\
71
 
}\
72
 
\
73
 
static inline void FUNCC(OPNAME ## _pixels2_x2)(uint8_t *block, const uint8_t *pixels, ptrdiff_t line_size, int h){\
74
 
    FUNC(OPNAME ## _pixels2_l2)(block, pixels, pixels+sizeof(pixel), line_size, line_size, line_size, h);\
75
 
}\
76
 
\
77
 
static inline void FUNCC(OPNAME ## _pixels2_y2)(uint8_t *block, const uint8_t *pixels, ptrdiff_t line_size, int h){\
78
 
    FUNC(OPNAME ## _pixels2_l2)(block, pixels, pixels+line_size, line_size, line_size, line_size, h);\
79
 
}\
80
 
\
81
 
static inline void FUNCC(OPNAME ## _pixels2_xy2)(uint8_t *_block, const uint8_t *_pixels, ptrdiff_t line_size, int h)\
82
 
{\
83
 
        int i, a0, b0, a1, b1;\
84
 
        pixel *block = (pixel*)_block;\
85
 
        const pixel *pixels = (const pixel*)_pixels;\
86
 
        line_size /= sizeof(pixel);\
87
 
        a0= pixels[0];\
88
 
        b0= pixels[1] + 2;\
89
 
        a0 += b0;\
90
 
        b0 += pixels[2];\
91
 
\
92
 
        pixels+=line_size;\
93
 
        for(i=0; i<h; i+=2){\
94
 
            a1= pixels[0];\
95
 
            b1= pixels[1];\
96
 
            a1 += b1;\
97
 
            b1 += pixels[2];\
98
 
\
99
 
            block[0]= (a1+a0)>>2; /* FIXME non put */\
100
 
            block[1]= (b1+b0)>>2;\
101
 
\
102
 
            pixels+=line_size;\
103
 
            block +=line_size;\
104
 
\
105
 
            a0= pixels[0];\
106
 
            b0= pixels[1] + 2;\
107
 
            a0 += b0;\
108
 
            b0 += pixels[2];\
109
 
\
110
 
            block[0]= (a1+a0)>>2;\
111
 
            block[1]= (b1+b0)>>2;\
112
 
            pixels+=line_size;\
113
 
            block +=line_size;\
114
 
        }\
115
 
}\
116
 
\
117
 
static inline void FUNCC(OPNAME ## _pixels4_xy2)(uint8_t *block, const uint8_t *pixels, ptrdiff_t line_size, int h)\
118
 
{\
119
 
        /* FIXME HIGH BIT DEPTH */\
120
 
        int i;\
121
 
        const uint32_t a= AV_RN32(pixels  );\
122
 
        const uint32_t b= AV_RN32(pixels+1);\
123
 
        uint32_t l0=  (a&0x03030303UL)\
124
 
                    + (b&0x03030303UL)\
125
 
                    + 0x02020202UL;\
126
 
        uint32_t h0= ((a&0xFCFCFCFCUL)>>2)\
127
 
                   + ((b&0xFCFCFCFCUL)>>2);\
128
 
        uint32_t l1,h1;\
129
 
\
130
 
        pixels+=line_size;\
131
 
        for(i=0; i<h; i+=2){\
132
 
            uint32_t a= AV_RN32(pixels  );\
133
 
            uint32_t b= AV_RN32(pixels+1);\
134
 
            l1=  (a&0x03030303UL)\
135
 
               + (b&0x03030303UL);\
136
 
            h1= ((a&0xFCFCFCFCUL)>>2)\
137
 
              + ((b&0xFCFCFCFCUL)>>2);\
138
 
            OP(*((uint32_t*)block), h0+h1+(((l0+l1)>>2)&0x0F0F0F0FUL));\
139
 
            pixels+=line_size;\
140
 
            block +=line_size;\
141
 
            a= AV_RN32(pixels  );\
142
 
            b= AV_RN32(pixels+1);\
143
 
            l0=  (a&0x03030303UL)\
144
 
               + (b&0x03030303UL)\
145
 
               + 0x02020202UL;\
146
 
            h0= ((a&0xFCFCFCFCUL)>>2)\
147
 
              + ((b&0xFCFCFCFCUL)>>2);\
148
 
            OP(*((uint32_t*)block), h0+h1+(((l0+l1)>>2)&0x0F0F0F0FUL));\
149
 
            pixels+=line_size;\
150
 
            block +=line_size;\
151
 
        }\
152
 
}\
153
 
\
154
 
static inline void FUNCC(OPNAME ## _pixels8_xy2)(uint8_t *block, const uint8_t *pixels, ptrdiff_t line_size, int h)\
155
 
{\
156
 
    /* FIXME HIGH BIT DEPTH */\
157
 
    int j;\
158
 
    for(j=0; j<2; j++){\
159
 
        int i;\
160
 
        const uint32_t a= AV_RN32(pixels  );\
161
 
        const uint32_t b= AV_RN32(pixels+1);\
162
 
        uint32_t l0=  (a&0x03030303UL)\
163
 
                    + (b&0x03030303UL)\
164
 
                    + 0x02020202UL;\
165
 
        uint32_t h0= ((a&0xFCFCFCFCUL)>>2)\
166
 
                   + ((b&0xFCFCFCFCUL)>>2);\
167
 
        uint32_t l1,h1;\
168
 
\
169
 
        pixels+=line_size;\
170
 
        for(i=0; i<h; i+=2){\
171
 
            uint32_t a= AV_RN32(pixels  );\
172
 
            uint32_t b= AV_RN32(pixels+1);\
173
 
            l1=  (a&0x03030303UL)\
174
 
               + (b&0x03030303UL);\
175
 
            h1= ((a&0xFCFCFCFCUL)>>2)\
176
 
              + ((b&0xFCFCFCFCUL)>>2);\
177
 
            OP(*((uint32_t*)block), h0+h1+(((l0+l1)>>2)&0x0F0F0F0FUL));\
178
 
            pixels+=line_size;\
179
 
            block +=line_size;\
180
 
            a= AV_RN32(pixels  );\
181
 
            b= AV_RN32(pixels+1);\
182
 
            l0=  (a&0x03030303UL)\
183
 
               + (b&0x03030303UL)\
184
 
               + 0x02020202UL;\
185
 
            h0= ((a&0xFCFCFCFCUL)>>2)\
186
 
              + ((b&0xFCFCFCFCUL)>>2);\
187
 
            OP(*((uint32_t*)block), h0+h1+(((l0+l1)>>2)&0x0F0F0F0FUL));\
188
 
            pixels+=line_size;\
189
 
            block +=line_size;\
190
 
        }\
191
 
        pixels+=4-line_size*(h+1);\
192
 
        block +=4-line_size*h;\
193
 
    }\
194
 
}\
195
 
\
196
 
static inline void FUNCC(OPNAME ## _no_rnd_pixels8_xy2)(uint8_t *block, const uint8_t *pixels, ptrdiff_t line_size, int h)\
197
 
{\
198
 
    /* FIXME HIGH BIT DEPTH */\
199
 
    int j;\
200
 
    for(j=0; j<2; j++){\
201
 
        int i;\
202
 
        const uint32_t a= AV_RN32(pixels  );\
203
 
        const uint32_t b= AV_RN32(pixels+1);\
204
 
        uint32_t l0=  (a&0x03030303UL)\
205
 
                    + (b&0x03030303UL)\
206
 
                    + 0x01010101UL;\
207
 
        uint32_t h0= ((a&0xFCFCFCFCUL)>>2)\
208
 
                   + ((b&0xFCFCFCFCUL)>>2);\
209
 
        uint32_t l1,h1;\
210
 
\
211
 
        pixels+=line_size;\
212
 
        for(i=0; i<h; i+=2){\
213
 
            uint32_t a= AV_RN32(pixels  );\
214
 
            uint32_t b= AV_RN32(pixels+1);\
215
 
            l1=  (a&0x03030303UL)\
216
 
               + (b&0x03030303UL);\
217
 
            h1= ((a&0xFCFCFCFCUL)>>2)\
218
 
              + ((b&0xFCFCFCFCUL)>>2);\
219
 
            OP(*((uint32_t*)block), h0+h1+(((l0+l1)>>2)&0x0F0F0F0FUL));\
220
 
            pixels+=line_size;\
221
 
            block +=line_size;\
222
 
            a= AV_RN32(pixels  );\
223
 
            b= AV_RN32(pixels+1);\
224
 
            l0=  (a&0x03030303UL)\
225
 
               + (b&0x03030303UL)\
226
 
               + 0x01010101UL;\
227
 
            h0= ((a&0xFCFCFCFCUL)>>2)\
228
 
              + ((b&0xFCFCFCFCUL)>>2);\
229
 
            OP(*((uint32_t*)block), h0+h1+(((l0+l1)>>2)&0x0F0F0F0FUL));\
230
 
            pixels+=line_size;\
231
 
            block +=line_size;\
232
 
        }\
233
 
        pixels+=4-line_size*(h+1);\
234
 
        block +=4-line_size*h;\
235
 
    }\
236
 
}\
237
 
\
238
 
CALL_2X_PIXELS(FUNCC(OPNAME ## _pixels16_x2) , FUNCC(OPNAME ## _pixels8_x2) , 8*sizeof(pixel))\
239
 
CALL_2X_PIXELS(FUNCC(OPNAME ## _pixels16_y2) , FUNCC(OPNAME ## _pixels8_y2) , 8*sizeof(pixel))\
240
 
CALL_2X_PIXELS(FUNCC(OPNAME ## _pixels16_xy2), FUNCC(OPNAME ## _pixels8_xy2), 8*sizeof(pixel))\
241
 
av_unused CALL_2X_PIXELS(FUNCC(OPNAME ## _no_rnd_pixels16)    , FUNCC(OPNAME ## _pixels8) , 8*sizeof(pixel))\
242
 
CALL_2X_PIXELS(FUNCC(OPNAME ## _no_rnd_pixels16_x2) , FUNCC(OPNAME ## _no_rnd_pixels8_x2) , 8*sizeof(pixel))\
243
 
CALL_2X_PIXELS(FUNCC(OPNAME ## _no_rnd_pixels16_y2) , FUNCC(OPNAME ## _no_rnd_pixels8_y2) , 8*sizeof(pixel))\
244
 
CALL_2X_PIXELS(FUNCC(OPNAME ## _no_rnd_pixels16_xy2), FUNCC(OPNAME ## _no_rnd_pixels8_xy2), 8*sizeof(pixel))\
245
 
 
246
 
#define op_avg(a, b) a = rnd_avg_pixel4(a, b)
247
 
#define op_put(a, b) a = b
248
 
#if BIT_DEPTH == 8
249
 
#define put_no_rnd_pixels8_8_c put_pixels8_8_c
250
 
PIXOP2(avg, op_avg)
251
 
PIXOP2(put, op_put)
252
 
#endif
253
 
#undef op_avg
254
 
#undef op_put