← Back to branch summary

~ubuntu-branches/ubuntu/vivid/libav/vivid

« back to all changes in this revision

Viewing changes to libswscale/rgb2rgb_template.c

  • Committer: Package Import Robot
  • Author(s): Reinhard Tartler
  • Date: 2013-10-22 23:24:08 UTC
  • mfrom: (1.3.36 sid)
  • Revision ID: package-import@ubuntu.com-20131022232408-b8tvvn4pyzri9mi3
Tags: 6:9.10-1ubuntu1
https://launchpad.net/bugs/1243235
https://launchpad.net/bugs/1180288
https://launchpad.net/bugs/1242802
* Build all -extra flavors from this source package, as libav got demoted
  from main to universe, cf LP: #1243235
* Simplify debian/rules to follow exactly the code that debian executes
* New upstream (LP: #1180288) fixes lots of security issues (LP: #1242802)
* Merge from unstable, remaining changes:
  - build-depend on libtiff5-dev rather than libtiff4-dev,
    avoids FTBFS caused by imlib
  - follow the regular debian codepaths

Show diffs side-by-side

added added

removed removed

Lines of Context:
libswscale/rgb2rgb_template.c
26
26
 
27
27
#include <stddef.h>
28
28
 
29
 
static inline void rgb24tobgr32_c(const uint8_t *src, uint8_t *dst, int src_size)
 
29
static inline void rgb24tobgr32_c(const uint8_t *src, uint8_t *dst,
 
30
                                  int src_size)
30
31
{
31
 
    uint8_t *dest = dst;
32
 
    const uint8_t *s = src;
33
 
    const uint8_t *end;
34
 
    end = s + src_size;
 
32
    uint8_t *dest      = dst;
 
33
    const uint8_t *s   = src;
 
34
    const uint8_t *end = s + src_size;
35
35
 
36
36
    while (s < end) {
37
37
#if HAVE_BIGENDIAN
38
 
        /* RGB24 (= R,G,B) -> RGB32 (= A,B,G,R) */
39
 
        *dest++ = 255;
40
 
        *dest++ = s[2];
41
 
        *dest++ = s[1];
42
 
        *dest++ = s[0];
43
 
        s+=3;
 
38
        /* RGB24 (= R, G, B) -> RGB32 (= A, B, G, R) */
 
39
        *dest++  = 255;
 
40
        *dest++  = s[2];
 
41
        *dest++  = s[1];
 
42
        *dest++  = s[0];
 
43
        s       += 3;
44
44
#else
45
 
        *dest++ = *s++;
46
 
        *dest++ = *s++;
47
 
        *dest++ = *s++;
48
 
        *dest++ = 255;
 
45
        *dest++  = *s++;
 
46
        *dest++  = *s++;
 
47
        *dest++  = *s++;
 
48
        *dest++  = 255;
49
49
#endif
50
50
    }
51
51
}
52
52
 
53
 
static inline void rgb32tobgr24_c(const uint8_t *src, uint8_t *dst, int src_size)
 
53
static inline void rgb32tobgr24_c(const uint8_t *src, uint8_t *dst,
 
54
                                  int src_size)
54
55
{
55
 
    uint8_t *dest = dst;
56
 
    const uint8_t *s = src;
57
 
    const uint8_t *end;
58
 
 
59
 
    end = s + src_size;
 
56
    uint8_t *dest      = dst;
 
57
    const uint8_t *s   = src;
 
58
    const uint8_t *end = s + src_size;
60
59
 
61
60
    while (s < end) {
62
61
#if HAVE_BIGENDIAN
63
 
        /* RGB32 (= A,B,G,R) -> RGB24 (= R,G,B) */
 
62
        /* RGB32 (= A, B, G, R) -> RGB24 (= R, G, B) */
64
63
        s++;
65
 
        dest[2] = *s++;
66
 
        dest[1] = *s++;
67
 
        dest[0] = *s++;
68
 
        dest += 3;
 
64
        dest[2]  = *s++;
 
65
        dest[1]  = *s++;
 
66
        dest[0]  = *s++;
 
67
        dest    += 3;
69
68
#else
70
 
        *dest++ = *s++;
71
 
        *dest++ = *s++;
72
 
        *dest++ = *s++;
 
69
        *dest++  = *s++;
 
70
        *dest++  = *s++;
 
71
        *dest++  = *s++;
73
72
        s++;
74
73
#endif
75
74
    }
76
75
}
77
76
 
78
77
/*
79
 
 original by Strepto/Astral
80
 
 ported to gcc & bugfixed: A'rpi
81
 
 MMX2, 3DNOW optimization by Nick Kurshev
82
 
 32-bit C version, and and&add trick by Michael Niedermayer
83
 
*/
 
78
 * original by Strepto/Astral
 
79
 * ported to gcc & bugfixed: A'rpi
 
80
 * MMXEXT, 3DNOW optimization by Nick Kurshev
 
81
 * 32-bit C version, and and&add trick by Michael Niedermayer
 
82
 */
84
83
static inline void rgb15to16_c(const uint8_t *src, uint8_t *dst, int src_size)
85
84
{
86
 
    register const uint8_t* s=src;
87
 
    register uint8_t* d=dst;
88
 
    register const uint8_t *end;
89
 
    const uint8_t *mm_end;
90
 
    end = s + src_size;
91
 
    mm_end = end - 3;
 
85
    register uint8_t *d         = dst;
 
86
    register const uint8_t *s   = src;
 
87
    register const uint8_t *end = s + src_size;
 
88
    const uint8_t *mm_end       = end - 3;
 
89
 
92
90
    while (s < mm_end) {
93
 
        register unsigned x= *((const uint32_t *)s);
94
 
        *((uint32_t *)d) = (x&0x7FFF7FFF) + (x&0x7FE07FE0);
95
 
        d+=4;
96
 
        s+=4;
 
91
        register unsigned x = *((const uint32_t *)s);
 
92
        *((uint32_t *)d)    = (x & 0x7FFF7FFF) + (x & 0x7FE07FE0);
 
93
        d += 4;
 
94
        s += 4;
97
95
    }
98
96
    if (s < end) {
99
 
        register unsigned short x= *((const uint16_t *)s);
100
 
        *((uint16_t *)d) = (x&0x7FFF) + (x&0x7FE0);
 
97
        register unsigned short x = *((const uint16_t *)s);
 
98
        *((uint16_t *)d)          = (x & 0x7FFF) + (x & 0x7FE0);
101
99
    }
102
100
}
103
101
 
104
102
static inline void rgb16to15_c(const uint8_t *src, uint8_t *dst, int src_size)
105
103
{
106
 
    register const uint8_t* s=src;
107
 
    register uint8_t* d=dst;
108
 
    register const uint8_t *end;
109
 
    const uint8_t *mm_end;
110
 
    end = s + src_size;
 
104
    register uint8_t *d         = dst;
 
105
    register const uint8_t *s   = src;
 
106
    register const uint8_t *end = s + src_size;
 
107
    const uint8_t *mm_end       = end - 3;
111
108
 
112
 
    mm_end = end - 3;
113
109
    while (s < mm_end) {
114
 
        register uint32_t x= *((const uint32_t*)s);
115
 
        *((uint32_t *)d) = ((x>>1)&0x7FE07FE0) | (x&0x001F001F);
116
 
        s+=4;
117
 
        d+=4;
 
110
        register uint32_t x  = *((const uint32_t *)s);
 
111
        *((uint32_t *)d)     = ((x >> 1) & 0x7FE07FE0) | (x & 0x001F001F);
 
112
        s                   += 4;
 
113
        d                   += 4;
118
114
    }
119
115
    if (s < end) {
120
 
        register uint16_t x= *((const uint16_t*)s);
121
 
        *((uint16_t *)d) = ((x>>1)&0x7FE0) | (x&0x001F);
 
116
        register uint16_t x = *((const uint16_t *)s);
 
117
        *((uint16_t *)d)    = ((x >> 1) & 0x7FE0) | (x & 0x001F);
122
118
    }
123
119
}
124
120
 
125
121
static inline void rgb32to16_c(const uint8_t *src, uint8_t *dst, int src_size)
126
122
{
127
 
    const uint8_t *s = src;
128
 
    const uint8_t *end;
129
 
    uint16_t *d = (uint16_t *)dst;
130
 
    end = s + src_size;
 
123
    uint16_t *d        = (uint16_t *)dst;
 
124
    const uint8_t *s   = src;
 
125
    const uint8_t *end = s + src_size;
131
126
 
132
127
    while (s < end) {
133
 
        register int rgb = *(const uint32_t*)s; s += 4;
134
 
        *d++ = ((rgb&0xFF)>>3) + ((rgb&0xFC00)>>5) + ((rgb&0xF80000)>>8);
 
128
        register int rgb  = *(const uint32_t *)s;
 
129
        s                += 4;
 
130
        *d++              = ((rgb & 0xFF)     >> 3) +
 
131
                            ((rgb & 0xFC00)   >> 5) +
 
132
                            ((rgb & 0xF80000) >> 8);
135
133
    }
136
134
}
137
135
 
138
 
static inline void rgb32tobgr16_c(const uint8_t *src, uint8_t *dst, int src_size)
 
136
static inline void rgb32tobgr16_c(const uint8_t *src, uint8_t *dst,
 
137
                                  int src_size)
139
138
{
140
 
    const uint8_t *s = src;
141
 
    const uint8_t *end;
142
 
    uint16_t *d = (uint16_t *)dst;
143
 
    end = s + src_size;
 
139
    uint16_t *d        = (uint16_t *)dst;
 
140
    const uint8_t *s   = src;
 
141
    const uint8_t *end = s + src_size;
 
142
 
144
143
    while (s < end) {
145
 
        register int rgb = *(const uint32_t*)s; s += 4;
146
 
        *d++ = ((rgb&0xF8)<<8) + ((rgb&0xFC00)>>5) + ((rgb&0xF80000)>>19);
 
144
        register int rgb  = *(const uint32_t *)s;
 
145
        s                += 4;
 
146
        *d++              = ((rgb & 0xF8)     << 8) +
 
147
                            ((rgb & 0xFC00)   >> 5) +
 
148
                            ((rgb & 0xF80000) >> 19);
147
149
    }
148
150
}
149
151
 
150
152
static inline void rgb32to15_c(const uint8_t *src, uint8_t *dst, int src_size)
151
153
{
152
 
    const uint8_t *s = src;
153
 
    const uint8_t *end;
154
 
    uint16_t *d = (uint16_t *)dst;
155
 
    end = s + src_size;
156
 
    while (s < end) {
157
 
        register int rgb = *(const uint32_t*)s; s += 4;
158
 
        *d++ = ((rgb&0xFF)>>3) + ((rgb&0xF800)>>6) + ((rgb&0xF80000)>>9);
159
 
    }
160
 
}
161
 
 
162
 
static inline void rgb32tobgr15_c(const uint8_t *src, uint8_t *dst, int src_size)
163
 
{
164
 
    const uint8_t *s = src;
165
 
    const uint8_t *end;
166
 
    uint16_t *d = (uint16_t *)dst;
167
 
    end = s + src_size;
168
 
    while (s < end) {
169
 
        register int rgb = *(const uint32_t*)s; s += 4;
170
 
        *d++ = ((rgb&0xF8)<<7) + ((rgb&0xF800)>>6) + ((rgb&0xF80000)>>19);
171
 
    }
172
 
}
173
 
 
174
 
static inline void rgb24tobgr16_c(const uint8_t *src, uint8_t *dst, int src_size)
175
 
{
176
 
    const uint8_t *s = src;
177
 
    const uint8_t *end;
178
 
    uint16_t *d = (uint16_t *)dst;
179
 
    end = s + src_size;
 
154
    uint16_t *d        = (uint16_t *)dst;
 
155
    const uint8_t *s   = src;
 
156
    const uint8_t *end = s + src_size;
 
157
 
 
158
    while (s < end) {
 
159
        register int rgb  = *(const uint32_t *)s;
 
160
        s                += 4;
 
161
        *d++              = ((rgb & 0xFF)     >> 3) +
 
162
                            ((rgb & 0xF800)   >> 6) +
 
163
                            ((rgb & 0xF80000) >> 9);
 
164
    }
 
165
}
 
166
 
 
167
static inline void rgb32tobgr15_c(const uint8_t *src, uint8_t *dst,
 
168
                                  int src_size)
 
169
{
 
170
    uint16_t *d        = (uint16_t *)dst;
 
171
    const uint8_t *s   = src;
 
172
    const uint8_t *end = s + src_size;
 
173
 
 
174
    while (s < end) {
 
175
        register int rgb  = *(const uint32_t *)s;
 
176
        s                += 4;
 
177
        *d++              = ((rgb & 0xF8)     <<  7) +
 
178
                            ((rgb & 0xF800)   >>  6) +
 
179
                            ((rgb & 0xF80000) >> 19);
 
180
    }
 
181
}
 
182
 
 
183
static inline void rgb24tobgr16_c(const uint8_t *src, uint8_t *dst,
 
184
                                  int src_size)
 
185
{
 
186
    uint16_t *d        = (uint16_t *)dst;
 
187
    const uint8_t *s   = src;
 
188
    const uint8_t *end = s + src_size;
 
189
 
180
190
    while (s < end) {
181
191
        const int b = *s++;
182
192
        const int g = *s++;
183
193
        const int r = *s++;
184
 
        *d++ = (b>>3) | ((g&0xFC)<<3) | ((r&0xF8)<<8);
 
194
        *d++        = (b >> 3) | ((g & 0xFC) << 3) | ((r & 0xF8) << 8);
185
195
    }
186
196
}
187
197
 
188
198
static inline void rgb24to16_c(const uint8_t *src, uint8_t *dst, int src_size)
189
199
{
190
 
    const uint8_t *s = src;
191
 
    const uint8_t *end;
192
 
    uint16_t *d = (uint16_t *)dst;
193
 
    end = s + src_size;
 
200
    uint16_t *d        = (uint16_t *)dst;
 
201
    const uint8_t *s   = src;
 
202
    const uint8_t *end = s + src_size;
 
203
 
194
204
    while (s < end) {
195
205
        const int r = *s++;
196
206
        const int g = *s++;
197
207
        const int b = *s++;
198
 
        *d++ = (b>>3) | ((g&0xFC)<<3) | ((r&0xF8)<<8);
 
208
        *d++        = (b >> 3) | ((g & 0xFC) << 3) | ((r & 0xF8) << 8);
199
209
    }
200
210
}
201
211
 
202
 
static inline void rgb24tobgr15_c(const uint8_t *src, uint8_t *dst, int src_size)
 
212
static inline void rgb24tobgr15_c(const uint8_t *src, uint8_t *dst,
 
213
                                  int src_size)
203
214
{
204
 
    const uint8_t *s = src;
205
 
    const uint8_t *end;
206
 
    uint16_t *d = (uint16_t *)dst;
207
 
    end = s + src_size;
 
215
    uint16_t *d        = (uint16_t *)dst;
 
216
    const uint8_t *s   = src;
 
217
    const uint8_t *end = s + src_size;
 
218
 
208
219
    while (s < end) {
209
220
        const int b = *s++;
210
221
        const int g = *s++;
211
222
        const int r = *s++;
212
 
        *d++ = (b>>3) | ((g&0xF8)<<2) | ((r&0xF8)<<7);
 
223
        *d++        = (b >> 3) | ((g & 0xF8) << 2) | ((r & 0xF8) << 7);
213
224
    }
214
225
}
215
226
 
216
227
static inline void rgb24to15_c(const uint8_t *src, uint8_t *dst, int src_size)
217
228
{
218
 
    const uint8_t *s = src;
219
 
    const uint8_t *end;
220
 
    uint16_t *d = (uint16_t *)dst;
221
 
    end = s + src_size;
 
229
    uint16_t *d        = (uint16_t *)dst;
 
230
    const uint8_t *s   = src;
 
231
    const uint8_t *end = s + src_size;
 
232
 
222
233
    while (s < end) {
223
234
        const int r = *s++;
224
235
        const int g = *s++;
225
236
        const int b = *s++;
226
 
        *d++ = (b>>3) | ((g&0xF8)<<2) | ((r&0xF8)<<7);
 
237
        *d++        = (b >> 3) | ((g & 0xF8) << 2) | ((r & 0xF8) << 7);
227
238
    }
228
239
}
229
240
 
230
241
/*
231
 
  I use less accurate approximation here by simply left-shifting the input
232
 
  value and filling the low order bits with zeroes. This method improves PNG
233
 
  compression but this scheme cannot reproduce white exactly, since it does
234
 
  not generate an all-ones maximum value; the net effect is to darken the
235
 
  image slightly.
236
 
 
237
 
  The better method should be "left bit replication":
238
 
 
239
 
   4 3 2 1 0
240
 
   ---------
241
 
   1 1 0 1 1
242
 
 
243
 
   7 6 5 4 3  2 1 0
244
 
   ----------------
245
 
   1 1 0 1 1  1 1 0
246
 
   |=======|  |===|
247
 
       |      leftmost bits repeated to fill open bits
248
 
       |
249
 
   original bits
250
 
*/
251
 
static inline void rgb15tobgr24_c(const uint8_t *src, uint8_t *dst, int src_size)
 
242
 * I use less accurate approximation here by simply left-shifting the input
 
243
 * value and filling the low order bits with zeroes. This method improves PNG
 
244
 * compression but this scheme cannot reproduce white exactly, since it does
 
245
 * not generate an all-ones maximum value; the net effect is to darken the
 
246
 * image slightly.
 
247
 *
 
248
 * The better method should be "left bit replication":
 
249
 *
 
250
 *  4 3 2 1 0
 
251
 *  ---------
 
252
 *  1 1 0 1 1
 
253
 *
 
254
 *  7 6 5 4 3  2 1 0
 
255
 *  ----------------
 
256
 *  1 1 0 1 1  1 1 0
 
257
 *  |=======|  |===|
 
258
 *      |      leftmost bits repeated to fill open bits
 
259
 *      |
 
260
 *  original bits
 
261
 */
 
262
static inline void rgb15tobgr24_c(const uint8_t *src, uint8_t *dst,
 
263
                                  int src_size)
252
264
{
253
 
    const uint16_t *end;
254
 
    uint8_t *d = dst;
255
 
    const uint16_t *s = (const uint16_t*)src;
256
 
    end = s + src_size/2;
 
265
    uint8_t *d          = dst;
 
266
    const uint16_t *s   = (const uint16_t *)src;
 
267
    const uint16_t *end = s + src_size / 2;
 
268
 
257
269
    while (s < end) {
258
 
        register uint16_t bgr;
259
 
        bgr = *s++;
260
 
        *d++ = (bgr&0x1F)<<3;
261
 
        *d++ = (bgr&0x3E0)>>2;
262
 
        *d++ = (bgr&0x7C00)>>7;
 
270
        register uint16_t bgr = *s++;
 
271
        *d++ = (bgr & 0x1F)   << 3;
 
272
        *d++ = (bgr & 0x3E0)  >> 2;
 
273
        *d++ = (bgr & 0x7C00) >> 7;
263
274
    }
264
275
}
265
276
 
266
 
static inline void rgb16tobgr24_c(const uint8_t *src, uint8_t *dst, int src_size)
 
277
static inline void rgb16tobgr24_c(const uint8_t *src, uint8_t *dst,
 
278
                                  int src_size)
267
279
{
268
 
    const uint16_t *end;
269
 
    uint8_t *d = (uint8_t *)dst;
270
 
    const uint16_t *s = (const uint16_t *)src;
271
 
    end = s + src_size/2;
 
280
    uint8_t *d          = (uint8_t *)dst;
 
281
    const uint16_t *s   = (const uint16_t *)src;
 
282
    const uint16_t *end = s + src_size / 2;
 
283
 
272
284
    while (s < end) {
273
 
        register uint16_t bgr;
274
 
        bgr = *s++;
275
 
        *d++ = (bgr&0x1F)<<3;
276
 
        *d++ = (bgr&0x7E0)>>3;
277
 
        *d++ = (bgr&0xF800)>>8;
 
285
        register uint16_t bgr = *s++;
 
286
        *d++ = (bgr & 0x1F)   << 3;
 
287
        *d++ = (bgr & 0x7E0)  >> 3;
 
288
        *d++ = (bgr & 0xF800) >> 8;
278
289
    }
279
290
}
280
291
 
281
292
static inline void rgb15to32_c(const uint8_t *src, uint8_t *dst, int src_size)
282
293
{
283
 
    const uint16_t *end;
284
 
    uint8_t *d = dst;
285
 
    const uint16_t *s = (const uint16_t *)src;
286
 
    end = s + src_size/2;
 
294
    uint8_t *d          = dst;
 
295
    const uint16_t *s   = (const uint16_t *)src;
 
296
    const uint16_t *end = s + src_size / 2;
 
297
 
287
298
    while (s < end) {
288
 
        register uint16_t bgr;
289
 
        bgr = *s++;
 
299
        register uint16_t bgr = *s++;
290
300
#if HAVE_BIGENDIAN
291
301
        *d++ = 255;
292
 
        *d++ = (bgr&0x7C00)>>7;
293
 
        *d++ = (bgr&0x3E0)>>2;
294
 
        *d++ = (bgr&0x1F)<<3;
 
302
        *d++ = (bgr & 0x7C00) >> 7;
 
303
        *d++ = (bgr & 0x3E0)  >> 2;
 
304
        *d++ = (bgr & 0x1F)   << 3;
295
305
#else
296
 
        *d++ = (bgr&0x1F)<<3;
297
 
        *d++ = (bgr&0x3E0)>>2;
298
 
        *d++ = (bgr&0x7C00)>>7;
 
306
        *d++ = (bgr & 0x1F)   << 3;
 
307
        *d++ = (bgr & 0x3E0)  >> 2;
 
308
        *d++ = (bgr & 0x7C00) >> 7;
299
309
        *d++ = 255;
300
310
#endif
301
311
    }
303
313
 
304
314
static inline void rgb16to32_c(const uint8_t *src, uint8_t *dst, int src_size)
305
315
{
306
 
    const uint16_t *end;
307
 
    uint8_t *d = dst;
308
 
    const uint16_t *s = (const uint16_t*)src;
309
 
    end = s + src_size/2;
 
316
    uint8_t *d          = dst;
 
317
    const uint16_t *s   = (const uint16_t *)src;
 
318
    const uint16_t *end = s + src_size / 2;
 
319
 
310
320
    while (s < end) {
311
 
        register uint16_t bgr;
312
 
        bgr = *s++;
 
321
        register uint16_t bgr = *s++;
313
322
#if HAVE_BIGENDIAN
314
323
        *d++ = 255;
315
 
        *d++ = (bgr&0xF800)>>8;
316
 
        *d++ = (bgr&0x7E0)>>3;
317
 
        *d++ = (bgr&0x1F)<<3;
 
324
        *d++ = (bgr & 0xF800) >> 8;
 
325
        *d++ = (bgr & 0x7E0)  >> 3;
 
326
        *d++ = (bgr & 0x1F)   << 3;
318
327
#else
319
 
        *d++ = (bgr&0x1F)<<3;
320
 
        *d++ = (bgr&0x7E0)>>3;
321
 
        *d++ = (bgr&0xF800)>>8;
 
328
        *d++ = (bgr & 0x1F)   << 3;
 
329
        *d++ = (bgr & 0x7E0)  >> 3;
 
330
        *d++ = (bgr & 0xF800) >> 8;
322
331
        *d++ = 255;
323
332
#endif
324
333
    }
325
334
}
326
335
 
327
 
static inline void shuffle_bytes_2103_c(const uint8_t *src, uint8_t *dst, int src_size)
 
336
static inline void shuffle_bytes_2103_c(const uint8_t *src, uint8_t *dst,
 
337
                                        int src_size)
328
338
{
329
 
    int idx = 15 - src_size;
330
 
    const uint8_t *s = src-idx;
331
 
    uint8_t *d = dst-idx;
332
 
    for (; idx<15; idx+=4) {
333
 
        register int v = *(const uint32_t *)&s[idx], g = v & 0xff00ff00;
334
 
        v &= 0xff00ff;
335
 
        *(uint32_t *)&d[idx] = (v>>16) + g + (v<<16);
 
339
    int idx          = 15  - src_size;
 
340
    const uint8_t *s = src - idx;
 
341
    uint8_t *d       = dst - idx;
 
342
 
 
343
    for (; idx < 15; idx += 4) {
 
344
        register int v        = *(const uint32_t *)&s[idx], g = v & 0xff00ff00;
 
345
        v                    &= 0xff00ff;
 
346
        *(uint32_t *)&d[idx]  = (v >> 16) + g + (v << 16);
336
347
    }
337
348
}
338
349
 
339
350
static inline void rgb24tobgr24_c(const uint8_t *src, uint8_t *dst, int src_size)
340
351
{
341
352
    unsigned i;
342
 
    for (i=0; i<src_size; i+=3) {
343
 
        register uint8_t x;
344
 
        x          = src[i + 2];
345
 
        dst[i + 1] = src[i + 1];
346
 
        dst[i + 2] = src[i + 0];
347
 
        dst[i + 0] = x;
 
353
 
 
354
    for (i = 0; i < src_size; i += 3) {
 
355
        register uint8_t x = src[i + 2];
 
356
        dst[i + 1]         = src[i + 1];
 
357
        dst[i + 2]         = src[i + 0];
 
358
        dst[i + 0]         = x;
348
359
    }
349
360
}
350
361
 
354
365
                                     int lumStride, int chromStride,
355
366
                                     int dstStride, int vertLumPerChroma)
356
367
{
357
 
    int y;
 
368
    int y, i;
358
369
    const int chromWidth = width >> 1;
359
 
    for (y=0; y<height; y++) {
 
370
 
 
371
    for (y = 0; y < height; y++) {
360
372
#if HAVE_FAST_64BIT
361
 
        int i;
362
 
        uint64_t *ldst = (uint64_t *) dst;
 
373
        uint64_t *ldst = (uint64_t *)dst;
363
374
        const uint8_t *yc = ysrc, *uc = usrc, *vc = vsrc;
364
375
        for (i = 0; i < chromWidth; i += 2) {
365
 
            uint64_t k, l;
366
 
            k = yc[0] + (uc[0] << 8) +
367
 
                (yc[1] << 16) + (vc[0] << 24);
368
 
            l = yc[2] + (uc[1] << 8) +
369
 
                (yc[3] << 16) + (vc[1] << 24);
 
376
            uint64_t k = yc[0] + (uc[0] << 8) +
 
377
                         (yc[1] << 16) + (vc[0] << 24);
 
378
            uint64_t l = yc[2] + (uc[1] << 8) +
 
379
                         (yc[3] << 16) + (vc[1] << 24);
370
380
            *ldst++ = k + (l << 32);
371
 
            yc += 4;
372
 
            uc += 2;
373
 
            vc += 2;
 
381
            yc     += 4;
 
382
            uc     += 2;
 
383
            vc     += 2;
374
384
        }
375
385
 
376
386
#else
377
 
        int i, *idst = (int32_t *) dst;
 
387
        int *idst = (int32_t *)dst;
378
388
        const uint8_t *yc = ysrc, *uc = usrc, *vc = vsrc;
 
389
 
379
390
        for (i = 0; i < chromWidth; i++) {
380
391
#if HAVE_BIGENDIAN
381
 
            *idst++ = (yc[0] << 24)+ (uc[0] << 16) +
382
 
                (yc[1] << 8) + (vc[0] << 0);
 
392
            *idst++ = (yc[0] << 24) + (uc[0] << 16) +
 
393
                      (yc[1] <<  8) + (vc[0] <<  0);
383
394
#else
384
395
            *idst++ = yc[0] + (uc[0] << 8) +
385
 
                (yc[1] << 16) + (vc[0] << 24);
 
396
                      (yc[1] << 16) + (vc[0] << 24);
386
397
#endif
387
398
            yc += 2;
388
399
            uc++;
389
400
            vc++;
390
401
        }
391
402
#endif
392
 
        if ((y&(vertLumPerChroma-1)) == vertLumPerChroma-1) {
 
403
        if ((y & (vertLumPerChroma - 1)) == vertLumPerChroma - 1) {
393
404
            usrc += chromStride;
394
405
            vsrc += chromStride;
395
406
        }
404
415
 */
405
416
static inline void yv12toyuy2_c(const uint8_t *ysrc, const uint8_t *usrc,
406
417
                                const uint8_t *vsrc, uint8_t *dst,
407
 
                                int width, int height,
408
 
                                int lumStride, int chromStride,
409
 
                                int dstStride)
 
418
                                int width, int height, int lumStride,
 
419
                                int chromStride, int dstStride)
410
420
{
411
421
    //FIXME interpolate chroma
412
422
    yuvPlanartoyuy2_c(ysrc, usrc, vsrc, dst, width, height, lumStride,
419
429
                                     int lumStride, int chromStride,
420
430
                                     int dstStride, int vertLumPerChroma)
421
431
{
422
 
    int y;
 
432
    int y, i;
423
433
    const int chromWidth = width >> 1;
424
 
    for (y=0; y<height; y++) {
 
434
 
 
435
    for (y = 0; y < height; y++) {
425
436
#if HAVE_FAST_64BIT
426
 
        int i;
427
 
        uint64_t *ldst = (uint64_t *) dst;
 
437
        uint64_t *ldst = (uint64_t *)dst;
428
438
        const uint8_t *yc = ysrc, *uc = usrc, *vc = vsrc;
429
439
        for (i = 0; i < chromWidth; i += 2) {
430
 
            uint64_t k, l;
431
 
            k = uc[0] + (yc[0] << 8) +
432
 
                (vc[0] << 16) + (yc[1] << 24);
433
 
            l = uc[1] + (yc[2] << 8) +
434
 
                (vc[1] << 16) + (yc[3] << 24);
 
440
            uint64_t k = uc[0] + (yc[0] << 8) +
 
441
                         (vc[0] << 16) + (yc[1] << 24);
 
442
            uint64_t l = uc[1] + (yc[2] << 8) +
 
443
                         (vc[1] << 16) + (yc[3] << 24);
435
444
            *ldst++ = k + (l << 32);
436
 
            yc += 4;
437
 
            uc += 2;
438
 
            vc += 2;
 
445
            yc     += 4;
 
446
            uc     += 2;
 
447
            vc     += 2;
439
448
        }
440
449
 
441
450
#else
442
 
        int i, *idst = (int32_t *) dst;
 
451
        int *idst = (int32_t *)dst;
443
452
        const uint8_t *yc = ysrc, *uc = usrc, *vc = vsrc;
 
453
 
444
454
        for (i = 0; i < chromWidth; i++) {
445
455
#if HAVE_BIGENDIAN
446
 
            *idst++ = (uc[0] << 24)+ (yc[0] << 16) +
447
 
                (vc[0] << 8) + (yc[1] << 0);
 
456
            *idst++ = (uc[0] << 24) + (yc[0] << 16) +
 
457
                      (vc[0] <<  8) + (yc[1] <<  0);
448
458
#else
449
459
            *idst++ = uc[0] + (yc[0] << 8) +
450
 
               (vc[0] << 16) + (yc[1] << 24);
 
460
                      (vc[0] << 16) + (yc[1] << 24);
451
461
#endif
452
462
            yc += 2;
453
463
            uc++;
454
464
            vc++;
455
465
        }
456
466
#endif
457
 
        if ((y&(vertLumPerChroma-1)) == vertLumPerChroma-1) {
 
467
        if ((y & (vertLumPerChroma - 1)) == vertLumPerChroma - 1) {
458
468
            usrc += chromStride;
459
469
            vsrc += chromStride;
460
470
        }
461
471
        ysrc += lumStride;
462
 
        dst += dstStride;
 
472
        dst  += dstStride;
463
473
    }
464
474
}
465
475
 
469
479
 */
470
480
static inline void yv12touyvy_c(const uint8_t *ysrc, const uint8_t *usrc,
471
481
                                const uint8_t *vsrc, uint8_t *dst,
472
 
                                int width, int height,
473
 
                                int lumStride, int chromStride,
474
 
                                int dstStride)
 
482
                                int width, int height, int lumStride,
 
483
                                int chromStride, int dstStride)
475
484
{
476
485
    //FIXME interpolate chroma
477
486
    yuvPlanartouyvy_c(ysrc, usrc, vsrc, dst, width, height, lumStride,
483
492
 */
484
493
static inline void yuv422ptouyvy_c(const uint8_t *ysrc, const uint8_t *usrc,
485
494
                                   const uint8_t *vsrc, uint8_t *dst,
486
 
                                   int width, int height,
487
 
                                   int lumStride, int chromStride,
488
 
                                   int dstStride)
 
495
                                   int width, int height, int lumStride,
 
496
                                   int chromStride, int dstStride)
489
497
{
490
498
    yuvPlanartouyvy_c(ysrc, usrc, vsrc, dst, width, height, lumStride,
491
499
                      chromStride, dstStride, 1);
496
504
 */
497
505
static inline void yuv422ptoyuy2_c(const uint8_t *ysrc, const uint8_t *usrc,
498
506
                                   const uint8_t *vsrc, uint8_t *dst,
499
 
                                   int width, int height,
500
 
                                   int lumStride, int chromStride,
501
 
                                   int dstStride)
 
507
                                   int width, int height, int lumStride,
 
508
                                   int chromStride, int dstStride)
502
509
{
503
510
    yuvPlanartoyuy2_c(ysrc, usrc, vsrc, dst, width, height, lumStride,
504
511
                      chromStride, dstStride, 1);
510
517
 */
511
518
static inline void yuy2toyv12_c(const uint8_t *src, uint8_t *ydst,
512
519
                                uint8_t *udst, uint8_t *vdst,
513
 
                                int width, int height,
514
 
                                int lumStride, int chromStride,
515
 
                                int srcStride)
 
520
                                int width, int height, int lumStride,
 
521
                                int chromStride, int srcStride)
516
522
{
517
523
    int y;
518
524
    const int chromWidth = width >> 1;
519
 
    for (y=0; y<height; y+=2) {
 
525
 
 
526
    for (y = 0; y < height; y += 2) {
520
527
        int i;
521
 
        for (i=0; i<chromWidth; i++) {
522
 
            ydst[2*i+0]     = src[4*i+0];
523
 
            udst[i]     = src[4*i+1];
524
 
            ydst[2*i+1]     = src[4*i+2];
525
 
            vdst[i]     = src[4*i+3];
 
528
        for (i = 0; i < chromWidth; i++) {
 
529
            ydst[2 * i + 0] = src[4 * i + 0];
 
530
            udst[i]         = src[4 * i + 1];
 
531
            ydst[2 * i + 1] = src[4 * i + 2];
 
532
            vdst[i]         = src[4 * i + 3];
526
533
        }
527
534
        ydst += lumStride;
528
535
        src  += srcStride;
529
536
 
530
 
        for (i=0; i<chromWidth; i++) {
531
 
            ydst[2*i+0]     = src[4*i+0];
532
 
            ydst[2*i+1]     = src[4*i+2];
 
537
        for (i = 0; i < chromWidth; i++) {
 
538
            ydst[2 * i + 0] = src[4 * i + 0];
 
539
            ydst[2 * i + 1] = src[4 * i + 2];
533
540
        }
534
541
        udst += chromStride;
535
542
        vdst += chromStride;
541
548
static inline void planar2x_c(const uint8_t *src, uint8_t *dst, int srcWidth,
542
549
                              int srcHeight, int srcStride, int dstStride)
543
550
{
544
 
    int x,y;
 
551
    int x, y;
545
552
 
546
 
    dst[0]= src[0];
 
553
    dst[0] = src[0];
547
554
 
548
555
    // first line
549
 
    for (x=0; x<srcWidth-1; x++) {
550
 
        dst[2*x+1]= (3*src[x] +   src[x+1])>>2;
551
 
        dst[2*x+2]= (  src[x] + 3*src[x+1])>>2;
 
556
    for (x = 0; x < srcWidth - 1; x++) {
 
557
        dst[2 * x + 1] = (3 * src[x] + src[x + 1]) >> 2;
 
558
        dst[2 * x + 2] = (src[x] + 3 * src[x + 1]) >> 2;
552
559
    }
553
 
    dst[2*srcWidth-1]= src[srcWidth-1];
554
 
 
555
 
    dst+= dstStride;
556
 
 
557
 
    for (y=1; y<srcHeight; y++) {
 
560
    dst[2 * srcWidth - 1] = src[srcWidth - 1];
 
561
 
 
562
    dst += dstStride;
 
563
 
 
564
    for (y = 1; y < srcHeight; y++) {
558
565
        const int mmxSize = 1;
559
566
 
560
 
        dst[0        ]= (3*src[0] +   src[srcStride])>>2;
561
 
        dst[dstStride]= (  src[0] + 3*src[srcStride])>>2;
 
567
        dst[0]         = (src[0] * 3 + src[srcStride]) >> 2;
 
568
        dst[dstStride] = (src[0] + 3 * src[srcStride]) >> 2;
562
569
 
563
 
        for (x=mmxSize-1; x<srcWidth-1; x++) {
564
 
            dst[2*x          +1]= (3*src[x+0] +   src[x+srcStride+1])>>2;
565
 
            dst[2*x+dstStride+2]= (  src[x+0] + 3*src[x+srcStride+1])>>2;
566
 
            dst[2*x+dstStride+1]= (  src[x+1] + 3*src[x+srcStride  ])>>2;
567
 
            dst[2*x          +2]= (3*src[x+1] +   src[x+srcStride  ])>>2;
 
570
        for (x = mmxSize - 1; x < srcWidth - 1; x++) {
 
571
            dst[2 * x + 1]             = (src[x + 0] * 3 + src[x + srcStride + 1]) >> 2;
 
572
            dst[2 * x + dstStride + 2] = (src[x + 0] + 3 * src[x + srcStride + 1]) >> 2;
 
573
            dst[2 * x + dstStride + 1] = (src[x + 1] + 3 * src[x + srcStride])     >> 2;
 
574
            dst[2 * x + 2]             = (src[x + 1] * 3 + src[x + srcStride])     >> 2;
568
575
        }
569
 
        dst[srcWidth*2 -1            ]= (3*src[srcWidth-1] +   src[srcWidth-1 + srcStride])>>2;
570
 
        dst[srcWidth*2 -1 + dstStride]= (  src[srcWidth-1] + 3*src[srcWidth-1 + srcStride])>>2;
 
576
        dst[srcWidth * 2 - 1]             = (src[srcWidth - 1] * 3 + src[srcWidth - 1 + srcStride]) >> 2;
 
577
        dst[srcWidth * 2 - 1 + dstStride] = (src[srcWidth - 1] + 3 * src[srcWidth - 1 + srcStride]) >> 2;
571
578
 
572
 
        dst+=dstStride*2;
573
 
        src+=srcStride;
 
579
        dst += dstStride * 2;
 
580
        src += srcStride;
574
581
    }
575
582
 
576
583
    // last line
577
 
    dst[0]= src[0];
 
584
    dst[0] = src[0];
578
585
 
579
 
    for (x=0; x<srcWidth-1; x++) {
580
 
        dst[2*x+1]= (3*src[x] +   src[x+1])>>2;
581
 
        dst[2*x+2]= (  src[x] + 3*src[x+1])>>2;
 
586
    for (x = 0; x < srcWidth - 1; x++) {
 
587
        dst[2 * x + 1] = (src[x] * 3 + src[x + 1]) >> 2;
 
588
        dst[2 * x + 2] = (src[x] + 3 * src[x + 1]) >> 2;
582
589
    }
583
 
    dst[2*srcWidth-1]= src[srcWidth-1];
 
590
    dst[2 * srcWidth - 1] = src[srcWidth - 1];
584
591
}
585
592
 
586
593
/**
591
598
 */
592
599
static inline void uyvytoyv12_c(const uint8_t *src, uint8_t *ydst,
593
600
                                uint8_t *udst, uint8_t *vdst,
594
 
                                int width, int height,
595
 
                                int lumStride, int chromStride,
596
 
                                int srcStride)
 
601
                                int width, int height, int lumStride,
 
602
                                int chromStride, int srcStride)
597
603
{
598
604
    int y;
599
605
    const int chromWidth = width >> 1;
600
 
    for (y=0; y<height; y+=2) {
 
606
 
 
607
    for (y = 0; y < height; y += 2) {
601
608
        int i;
602
 
        for (i=0; i<chromWidth; i++) {
603
 
            udst[i]     = src[4*i+0];
604
 
            ydst[2*i+0] = src[4*i+1];
605
 
            vdst[i]     = src[4*i+2];
606
 
            ydst[2*i+1] = src[4*i+3];
 
609
        for (i = 0; i < chromWidth; i++) {
 
610
            udst[i]         = src[4 * i + 0];
 
611
            ydst[2 * i + 0] = src[4 * i + 1];
 
612
            vdst[i]         = src[4 * i + 2];
 
613
            ydst[2 * i + 1] = src[4 * i + 3];
607
614
        }
608
615
        ydst += lumStride;
609
616
        src  += srcStride;
610
617
 
611
 
        for (i=0; i<chromWidth; i++) {
612
 
            ydst[2*i+0] = src[4*i+1];
613
 
            ydst[2*i+1] = src[4*i+3];
 
618
        for (i = 0; i < chromWidth; i++) {
 
619
            ydst[2 * i + 0] = src[4 * i + 1];
 
620
            ydst[2 * i + 1] = src[4 * i + 3];
614
621
        }
615
622
        udst += chromStride;
616
623
        vdst += chromStride;
632
639
{
633
640
    int y;
634
641
    const int chromWidth = width >> 1;
635
 
    y=0;
636
 
    for (; y<height; y+=2) {
 
642
 
 
643
    for (y = 0; y < height; y += 2) {
637
644
        int i;
638
 
        for (i=0; i<chromWidth; i++) {
639
 
            unsigned int b = src[6*i+0];
640
 
            unsigned int g = src[6*i+1];
641
 
            unsigned int r = src[6*i+2];
 
645
        for (i = 0; i < chromWidth; i++) {
 
646
            unsigned int b = src[6 * i + 0];
 
647
            unsigned int g = src[6 * i + 1];
 
648
            unsigned int r = src[6 * i + 2];
642
649
 
643
 
            unsigned int Y  =  ((RY*r + GY*g + BY*b)>>RGB2YUV_SHIFT) + 16;
644
 
            unsigned int V  =  ((RV*r + GV*g + BV*b)>>RGB2YUV_SHIFT) + 128;
645
 
            unsigned int U  =  ((RU*r + GU*g + BU*b)>>RGB2YUV_SHIFT) + 128;
 
650
            unsigned int Y = ((RY * r + GY * g + BY * b) >> RGB2YUV_SHIFT) +  16;
 
651
            unsigned int V = ((RV * r + GV * g + BV * b) >> RGB2YUV_SHIFT) + 128;
 
652
            unsigned int U = ((RU * r + GU * g + BU * b) >> RGB2YUV_SHIFT) + 128;
646
653
 
647
654
            udst[i]     = U;
648
655
            vdst[i]     = V;
649
 
            ydst[2*i]   = Y;
650
 
 
651
 
            b = src[6*i+3];
652
 
            g = src[6*i+4];
653
 
            r = src[6*i+5];
654
 
 
655
 
            Y  =  ((RY*r + GY*g + BY*b)>>RGB2YUV_SHIFT) + 16;
656
 
            ydst[2*i+1]     = Y;
 
656
            ydst[2 * i] = Y;
 
657
 
 
658
            b = src[6 * i + 3];
 
659
            g = src[6 * i + 4];
 
660
            r = src[6 * i + 5];
 
661
 
 
662
            Y = ((RY * r + GY * g + BY * b) >> RGB2YUV_SHIFT) + 16;
 
663
            ydst[2 * i + 1] = Y;
657
664
        }
658
665
        ydst += lumStride;
659
666
        src  += srcStride;
660
667
 
661
 
        for (i=0; i<chromWidth; i++) {
662
 
            unsigned int b = src[6*i+0];
663
 
            unsigned int g = src[6*i+1];
664
 
            unsigned int r = src[6*i+2];
665
 
 
666
 
            unsigned int Y  =  ((RY*r + GY*g + BY*b)>>RGB2YUV_SHIFT) + 16;
667
 
 
668
 
            ydst[2*i]     = Y;
669
 
 
670
 
            b = src[6*i+3];
671
 
            g = src[6*i+4];
672
 
            r = src[6*i+5];
673
 
 
674
 
            Y  =  ((RY*r + GY*g + BY*b)>>RGB2YUV_SHIFT) + 16;
675
 
            ydst[2*i+1]     = Y;
 
668
        for (i = 0; i < chromWidth; i++) {
 
669
            unsigned int b = src[6 * i + 0];
 
670
            unsigned int g = src[6 * i + 1];
 
671
            unsigned int r = src[6 * i + 2];
 
672
 
 
673
            unsigned int Y = ((RY * r + GY * g + BY * b) >> RGB2YUV_SHIFT) + 16;
 
674
 
 
675
            ydst[2 * i] = Y;
 
676
 
 
677
            b = src[6 * i + 3];
 
678
            g = src[6 * i + 4];
 
679
            r = src[6 * i + 5];
 
680
 
 
681
            Y = ((RY * r + GY * g + BY * b) >> RGB2YUV_SHIFT) + 16;
 
682
            ydst[2 * i + 1] = Y;
676
683
        }
677
684
        udst += chromStride;
678
685
        vdst += chromStride;
682
689
}
683
690
 
684
691
static void interleaveBytes_c(const uint8_t *src1, const uint8_t *src2,
685
 
                              uint8_t *dest, int width,
686
 
                              int height, int src1Stride,
687
 
                              int src2Stride, int dstStride)
 
692
                              uint8_t *dest, int width, int height,
 
693
                              int src1Stride, int src2Stride, int dstStride)
688
694
{
689
695
    int h;
690
696
 
691
 
    for (h=0; h < height; h++) {
 
697
    for (h = 0; h < height; h++) {
692
698
        int w;
693
 
        for (w=0; w < width; w++) {
694
 
            dest[2*w+0] = src1[w];
695
 
            dest[2*w+1] = src2[w];
 
699
        for (w = 0; w < width; w++) {
 
700
            dest[2 * w + 0] = src1[w];
 
701
            dest[2 * w + 1] = src2[w];
696
702
        }
697
703
        dest += dstStride;
698
704
        src1 += src1Stride;
706
712
                                 int srcStride1, int srcStride2,
707
713
                                 int dstStride1, int dstStride2)
708
714
{
709
 
    int y;
710
 
    int x,w,h;
711
 
    w=width/2; h=height/2;
712
 
    for (y=0;y<h;y++) {
713
 
        const uint8_t* s1=src1+srcStride1*(y>>1);
714
 
        uint8_t* d=dst1+dstStride1*y;
715
 
        x=0;
716
 
        for (;x<w;x++) d[2*x]=d[2*x+1]=s1[x];
 
715
    int x, y;
 
716
    int w = width  / 2;
 
717
    int h = height / 2;
 
718
 
 
719
    for (y = 0; y < h; y++) {
 
720
        const uint8_t *s1 = src1 + srcStride1 * (y >> 1);
 
721
        uint8_t *d        = dst1 + dstStride1 *  y;
 
722
        for (x = 0; x < w; x++)
 
723
            d[2 * x] = d[2 * x + 1] = s1[x];
717
724
    }
718
 
    for (y=0;y<h;y++) {
719
 
        const uint8_t* s2=src2+srcStride2*(y>>1);
720
 
        uint8_t* d=dst2+dstStride2*y;
721
 
        x=0;
722
 
        for (;x<w;x++) d[2*x]=d[2*x+1]=s2[x];
 
725
    for (y = 0; y < h; y++) {
 
726
        const uint8_t *s2 = src2 + srcStride2 * (y >> 1);
 
727
        uint8_t *d        = dst2 + dstStride2 *  y;
 
728
        for (x = 0; x < w; x++)
 
729
            d[2 * x] = d[2 * x + 1] = s2[x];
723
730
    }
724
731
}
725
732
 
729
736
                                  int srcStride1, int srcStride2,
730
737
                                  int srcStride3, int dstStride)
731
738
{
732
 
    int x;
733
 
    int y,w,h;
734
 
    w=width/2; h=height;
735
 
    for (y=0;y<h;y++) {
736
 
        const uint8_t* yp=src1+srcStride1*y;
737
 
        const uint8_t* up=src2+srcStride2*(y>>2);
738
 
        const uint8_t* vp=src3+srcStride3*(y>>2);
739
 
        uint8_t* d=dst+dstStride*y;
740
 
        x=0;
741
 
        for (; x<w; x++) {
742
 
            const int x2 = x<<2;
743
 
            d[8*x+0] = yp[x2];
744
 
            d[8*x+1] = up[x];
745
 
            d[8*x+2] = yp[x2+1];
746
 
            d[8*x+3] = vp[x];
747
 
            d[8*x+4] = yp[x2+2];
748
 
            d[8*x+5] = up[x];
749
 
            d[8*x+6] = yp[x2+3];
750
 
            d[8*x+7] = vp[x];
 
739
    int x, y;
 
740
    int w = width / 2;
 
741
    int h = height;
 
742
 
 
743
    for (y = 0; y < h; y++) {
 
744
        const uint8_t *yp = src1 + srcStride1 *  y;
 
745
        const uint8_t *up = src2 + srcStride2 * (y >> 2);
 
746
        const uint8_t *vp = src3 + srcStride3 * (y >> 2);
 
747
        uint8_t *d        = dst  + dstStride  *  y;
 
748
        for (x = 0; x < w; x++) {
 
749
            const int x2 = x << 2;
 
750
            d[8 * x + 0] = yp[x2];
 
751
            d[8 * x + 1] = up[x];
 
752
            d[8 * x + 2] = yp[x2 + 1];
 
753
            d[8 * x + 3] = vp[x];
 
754
            d[8 * x + 4] = yp[x2 + 2];
 
755
            d[8 * x + 5] = up[x];
 
756
            d[8 * x + 6] = yp[x2 + 3];
 
757
            d[8 * x + 7] = vp[x];
751
758
        }
752
759
    }
753
760
}
754
761
 
755
762
static void extract_even_c(const uint8_t *src, uint8_t *dst, int count)
756
763
{
757
 
    dst +=   count;
758
 
    src += 2*count;
759
 
    count= - count;
760
 
 
761
 
    while(count<0) {
762
 
        dst[count]= src[2*count];
 
764
    dst   +=  count;
 
765
    src   +=  count * 2;
 
766
    count  = -count;
 
767
    while (count < 0) {
 
768
        dst[count] = src[2 * count];
763
769
        count++;
764
770
    }
765
771
}
767
773
static void extract_even2_c(const uint8_t *src, uint8_t *dst0, uint8_t *dst1,
768
774
                            int count)
769
775
{
770
 
    dst0+=   count;
771
 
    dst1+=   count;
772
 
    src += 4*count;
773
 
    count= - count;
774
 
    while(count<0) {
775
 
        dst0[count]= src[4*count+0];
776
 
        dst1[count]= src[4*count+2];
 
776
    dst0  +=  count;
 
777
    dst1  +=  count;
 
778
    src   +=  count * 4;
 
779
    count  = -count;
 
780
    while (count < 0) {
 
781
        dst0[count] = src[4 * count + 0];
 
782
        dst1[count] = src[4 * count + 2];
777
783
        count++;
778
784
    }
779
785
}
781
787
static void extract_even2avg_c(const uint8_t *src0, const uint8_t *src1,
782
788
                               uint8_t *dst0, uint8_t *dst1, int count)
783
789
{
784
 
    dst0 +=   count;
785
 
    dst1 +=   count;
786
 
    src0 += 4*count;
787
 
    src1 += 4*count;
788
 
    count= - count;
789
 
    while(count<0) {
790
 
        dst0[count]= (src0[4*count+0]+src1[4*count+0])>>1;
791
 
        dst1[count]= (src0[4*count+2]+src1[4*count+2])>>1;
 
790
    dst0  +=  count;
 
791
    dst1  +=  count;
 
792
    src0  +=  count * 4;
 
793
    src1  +=  count * 4;
 
794
    count  = -count;
 
795
    while (count < 0) {
 
796
        dst0[count] = (src0[4 * count + 0] + src1[4 * count + 0]) >> 1;
 
797
        dst1[count] = (src0[4 * count + 2] + src1[4 * count + 2]) >> 1;
792
798
        count++;
793
799
    }
794
800
}
796
802
static void extract_odd2_c(const uint8_t *src, uint8_t *dst0, uint8_t *dst1,
797
803
                           int count)
798
804
{
799
 
    dst0+=   count;
800
 
    dst1+=   count;
801
 
    src += 4*count;
802
 
    count= - count;
 
805
    dst0  +=  count;
 
806
    dst1  +=  count;
 
807
    src   +=  count * 4;
 
808
    count  = -count;
803
809
    src++;
804
 
    while(count<0) {
805
 
        dst0[count]= src[4*count+0];
806
 
        dst1[count]= src[4*count+2];
 
810
    while (count < 0) {
 
811
        dst0[count] = src[4 * count + 0];
 
812
        dst1[count] = src[4 * count + 2];
807
813
        count++;
808
814
    }
809
815
}
811
817
static void extract_odd2avg_c(const uint8_t *src0, const uint8_t *src1,
812
818
                              uint8_t *dst0, uint8_t *dst1, int count)
813
819
{
814
 
    dst0 +=   count;
815
 
    dst1 +=   count;
816
 
    src0 += 4*count;
817
 
    src1 += 4*count;
818
 
    count= - count;
 
820
    dst0  +=  count;
 
821
    dst1  +=  count;
 
822
    src0  +=  count * 4;
 
823
    src1  +=  count * 4;
 
824
    count  = -count;
819
825
    src0++;
820
826
    src1++;
821
 
    while(count<0) {
822
 
        dst0[count]= (src0[4*count+0]+src1[4*count+0])>>1;
823
 
        dst1[count]= (src0[4*count+2]+src1[4*count+2])>>1;
 
827
    while (count < 0) {
 
828
        dst0[count] = (src0[4 * count + 0] + src1[4 * count + 0]) >> 1;
 
829
        dst1[count] = (src0[4 * count + 2] + src1[4 * count + 2]) >> 1;
824
830
        count++;
825
831
    }
826
832
}
830
836
                           int lumStride, int chromStride, int srcStride)
831
837
{
832
838
    int y;
833
 
    const int chromWidth= -((-width)>>1);
 
839
    const int chromWidth = -((-width) >> 1);
834
840
 
835
 
    for (y=0; y<height; y++) {
 
841
    for (y = 0; y < height; y++) {
836
842
        extract_even_c(src, ydst, width);
837
 
        if(y&1) {
 
843
        if (y & 1) {
838
844
            extract_odd2avg_c(src - srcStride, src, udst, vdst, chromWidth);
839
 
            udst+= chromStride;
840
 
            vdst+= chromStride;
 
845
            udst += chromStride;
 
846
            vdst += chromStride;
841
847
        }
842
848
 
843
 
        src += srcStride;
844
 
        ydst+= lumStride;
 
849
        src  += srcStride;
 
850
        ydst += lumStride;
845
851
    }
846
852
}
847
853
 
850
856
                           int lumStride, int chromStride, int srcStride)
851
857
{
852
858
    int y;
853
 
    const int chromWidth= -((-width)>>1);
 
859
    const int chromWidth = -((-width) >> 1);
854
860
 
855
 
    for (y=0; y<height; y++) {
 
861
    for (y = 0; y < height; y++) {
856
862
        extract_even_c(src, ydst, width);
857
863
        extract_odd2_c(src, udst, vdst, chromWidth);
858
864
 
859
 
        src += srcStride;
860
 
        ydst+= lumStride;
861
 
        udst+= chromStride;
862
 
        vdst+= chromStride;
 
865
        src  += srcStride;
 
866
        ydst += lumStride;
 
867
        udst += chromStride;
 
868
        vdst += chromStride;
863
869
    }
864
870
}
865
871
 
868
874
                           int lumStride, int chromStride, int srcStride)
869
875
{
870
876
    int y;
871
 
    const int chromWidth= -((-width)>>1);
 
877
    const int chromWidth = -((-width) >> 1);
872
878
 
873
 
    for (y=0; y<height; y++) {
 
879
    for (y = 0; y < height; y++) {
874
880
        extract_even_c(src + 1, ydst, width);
875
 
        if(y&1) {
 
881
        if (y & 1) {
876
882
            extract_even2avg_c(src - srcStride, src, udst, vdst, chromWidth);
877
 
            udst+= chromStride;
878
 
            vdst+= chromStride;
 
883
            udst += chromStride;
 
884
            vdst += chromStride;
879
885
        }
880
886
 
881
 
        src += srcStride;
882
 
        ydst+= lumStride;
 
887
        src  += srcStride;
 
888
        ydst += lumStride;
883
889
    }
884
890
}
885
891
 
888
894
                           int lumStride, int chromStride, int srcStride)
889
895
{
890
896
    int y;
891
 
    const int chromWidth= -((-width)>>1);
 
897
    const int chromWidth = -((-width) >> 1);
892
898
 
893
 
    for (y=0; y<height; y++) {
 
899
    for (y = 0; y < height; y++) {
894
900
        extract_even_c(src + 1, ydst, width);
895
901
        extract_even2_c(src, udst, vdst, chromWidth);
896
902
 
897
 
        src += srcStride;
898
 
        ydst+= lumStride;
899
 
        udst+= chromStride;
900
 
        vdst+= chromStride;
 
903
        src  += srcStride;
 
904
        ydst += lumStride;
 
905
        udst += chromStride;
 
906
        vdst += chromStride;
901
907
    }
902
908
}
903
909