← Back to branch summary

~ubuntu-branches/ubuntu/trusty/libav/trusty-proposed

« back to all changes in this revision

Viewing changes to libswscale/rgb2rgb.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.c
22
22
 * License along with Libav; if not, write to the Free Software
23
23
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
24
24
 */
 
25
 
25
26
#include <inttypes.h>
 
27
 
 
28
#include "libavutil/attributes.h"
 
29
#include "libavutil/bswap.h"
26
30
#include "config.h"
27
 
#include "libavutil/bswap.h"
28
31
#include "rgb2rgb.h"
29
32
#include "swscale.h"
30
33
#include "swscale_internal.h"
31
34
 
 
35
void (*rgb32tobgr24)(const uint8_t *src, uint8_t *dst, int src_size);
 
36
void (*rgb32tobgr16)(const uint8_t *src, uint8_t *dst, int src_size);
 
37
void (*rgb32tobgr15)(const uint8_t *src, uint8_t *dst, int src_size);
32
38
void (*rgb24tobgr32)(const uint8_t *src, uint8_t *dst, int src_size);
 
39
void (*rgb24tobgr24)(const uint8_t *src, uint8_t *dst, int src_size);
33
40
void (*rgb24tobgr16)(const uint8_t *src, uint8_t *dst, int src_size);
34
41
void (*rgb24tobgr15)(const uint8_t *src, uint8_t *dst, int src_size);
35
 
void (*rgb32tobgr24)(const uint8_t *src, uint8_t *dst, int src_size);
 
42
void (*rgb16tobgr24)(const uint8_t *src, uint8_t *dst, int src_size);
 
43
void (*rgb15tobgr24)(const uint8_t *src, uint8_t *dst, int src_size);
 
44
 
36
45
void (*rgb32to16)(const uint8_t *src, uint8_t *dst, int src_size);
37
46
void (*rgb32to15)(const uint8_t *src, uint8_t *dst, int src_size);
 
47
void (*rgb24to16)(const uint8_t *src, uint8_t *dst, int src_size);
 
48
void (*rgb24to15)(const uint8_t *src, uint8_t *dst, int src_size);
 
49
void (*rgb16to32)(const uint8_t *src, uint8_t *dst, int src_size);
 
50
void (*rgb16to15)(const uint8_t *src, uint8_t *dst, int src_size);
38
51
void (*rgb15to16)(const uint8_t *src, uint8_t *dst, int src_size);
39
 
void (*rgb15tobgr24)(const uint8_t *src, uint8_t *dst, int src_size);
40
52
void (*rgb15to32)(const uint8_t *src, uint8_t *dst, int src_size);
41
 
void (*rgb16to15)(const uint8_t *src, uint8_t *dst, int src_size);
42
 
void (*rgb16tobgr24)(const uint8_t *src, uint8_t *dst, int src_size);
43
 
void (*rgb16to32)(const uint8_t *src, uint8_t *dst, int src_size);
44
 
void (*rgb24tobgr24)(const uint8_t *src, uint8_t *dst, int src_size);
45
 
void (*rgb24to16)(const uint8_t *src, uint8_t *dst, int src_size);
46
 
void (*rgb24to15)(const uint8_t *src, uint8_t *dst, int src_size);
 
53
 
47
54
void (*shuffle_bytes_2103)(const uint8_t *src, uint8_t *dst, int src_size);
48
 
void (*rgb32tobgr16)(const uint8_t *src, uint8_t *dst, int src_size);
49
 
void (*rgb32tobgr15)(const uint8_t *src, uint8_t *dst, int src_size);
50
55
 
51
 
void (*yv12toyuy2)(const uint8_t *ysrc, const uint8_t *usrc, const uint8_t *vsrc, uint8_t *dst,
52
 
                   int width, int height,
53
 
                   int lumStride, int chromStride, int dstStride);
54
 
void (*yv12touyvy)(const uint8_t *ysrc, const uint8_t *usrc, const uint8_t *vsrc, uint8_t *dst,
55
 
                   int width, int height,
56
 
                   int lumStride, int chromStride, int dstStride);
57
 
void (*yuv422ptoyuy2)(const uint8_t *ysrc, const uint8_t *usrc, const uint8_t *vsrc, uint8_t *dst,
58
 
                      int width, int height,
59
 
                      int lumStride, int chromStride, int dstStride);
60
 
void (*yuv422ptouyvy)(const uint8_t *ysrc, const uint8_t *usrc, const uint8_t *vsrc, uint8_t *dst,
61
 
                      int width, int height,
62
 
                      int lumStride, int chromStride, int dstStride);
63
 
void (*yuy2toyv12)(const uint8_t *src, uint8_t *ydst, uint8_t *udst, uint8_t *vdst,
 
56
void (*yv12toyuy2)(const uint8_t *ysrc, const uint8_t *usrc,
 
57
                   const uint8_t *vsrc, uint8_t *dst,
 
58
                   int width, int height,
 
59
                   int lumStride, int chromStride, int dstStride);
 
60
void (*yv12touyvy)(const uint8_t *ysrc, const uint8_t *usrc,
 
61
                   const uint8_t *vsrc, uint8_t *dst,
 
62
                   int width, int height,
 
63
                   int lumStride, int chromStride, int dstStride);
 
64
void (*yuv422ptoyuy2)(const uint8_t *ysrc, const uint8_t *usrc,
 
65
                      const uint8_t *vsrc, uint8_t *dst,
 
66
                      int width, int height,
 
67
                      int lumStride, int chromStride, int dstStride);
 
68
void (*yuv422ptouyvy)(const uint8_t *ysrc, const uint8_t *usrc,
 
69
                      const uint8_t *vsrc, uint8_t *dst,
 
70
                      int width, int height,
 
71
                      int lumStride, int chromStride, int dstStride);
 
72
void (*yuy2toyv12)(const uint8_t *src, uint8_t *ydst,
 
73
                   uint8_t *udst, uint8_t *vdst,
64
74
                   int width, int height,
65
75
                   int lumStride, int chromStride, int srcStride);
66
 
void (*rgb24toyv12)(const uint8_t *src, uint8_t *ydst, uint8_t *udst, uint8_t *vdst,
 
76
void (*rgb24toyv12)(const uint8_t *src, uint8_t *ydst,
 
77
                    uint8_t *udst, uint8_t *vdst,
67
78
                    int width, int height,
68
79
                    int lumStride, int chromStride, int srcStride);
69
80
void (*planar2x)(const uint8_t *src, uint8_t *dst, int width, int height,
76
87
                    int width, int height,
77
88
                    int srcStride1, int srcStride2,
78
89
                    int dstStride1, int dstStride2);
79
 
void (*yvu9_to_yuy2)(const uint8_t *src1, const uint8_t *src2, const uint8_t *src3,
80
 
                     uint8_t *dst,
 
90
void (*yvu9_to_yuy2)(const uint8_t *src1, const uint8_t *src2,
 
91
                     const uint8_t *src3, uint8_t *dst,
81
92
                     int width, int height,
82
93
                     int srcStride1, int srcStride2,
83
94
                     int srcStride3, int dstStride);
84
 
void (*uyvytoyuv420)(uint8_t *ydst, uint8_t *udst, uint8_t *vdst, const uint8_t *src,
85
 
                     int width, int height,
86
 
                     int lumStride, int chromStride, int srcStride);
87
 
void (*uyvytoyuv422)(uint8_t *ydst, uint8_t *udst, uint8_t *vdst, const uint8_t *src,
88
 
                     int width, int height,
89
 
                     int lumStride, int chromStride, int srcStride);
90
 
void (*yuyvtoyuv420)(uint8_t *ydst, uint8_t *udst, uint8_t *vdst, const uint8_t *src,
91
 
                     int width, int height,
92
 
                     int lumStride, int chromStride, int srcStride);
93
 
void (*yuyvtoyuv422)(uint8_t *ydst, uint8_t *udst, uint8_t *vdst, const uint8_t *src,
94
 
                     int width, int height,
 
95
void (*uyvytoyuv420)(uint8_t *ydst, uint8_t *udst, uint8_t *vdst,
 
96
                     const uint8_t *src, int width, int height,
 
97
                     int lumStride, int chromStride, int srcStride);
 
98
void (*uyvytoyuv422)(uint8_t *ydst, uint8_t *udst, uint8_t *vdst,
 
99
                     const uint8_t *src, int width, int height,
 
100
                     int lumStride, int chromStride, int srcStride);
 
101
void (*yuyvtoyuv420)(uint8_t *ydst, uint8_t *udst, uint8_t *vdst,
 
102
                     const uint8_t *src, int width, int height,
 
103
                     int lumStride, int chromStride, int srcStride);
 
104
void (*yuyvtoyuv422)(uint8_t *ydst, uint8_t *udst, uint8_t *vdst,
 
105
                     const uint8_t *src, int width, int height,
95
106
                     int lumStride, int chromStride, int srcStride);
96
107
 
97
108
#define RGB2YUV_SHIFT 8
98
 
#define BY ((int)( 0.098*(1<<RGB2YUV_SHIFT)+0.5))
99
 
#define BV ((int)(-0.071*(1<<RGB2YUV_SHIFT)+0.5))
100
 
#define BU ((int)( 0.439*(1<<RGB2YUV_SHIFT)+0.5))
101
 
#define GY ((int)( 0.504*(1<<RGB2YUV_SHIFT)+0.5))
102
 
#define GV ((int)(-0.368*(1<<RGB2YUV_SHIFT)+0.5))
103
 
#define GU ((int)(-0.291*(1<<RGB2YUV_SHIFT)+0.5))
104
 
#define RY ((int)( 0.257*(1<<RGB2YUV_SHIFT)+0.5))
105
 
#define RV ((int)( 0.439*(1<<RGB2YUV_SHIFT)+0.5))
106
 
#define RU ((int)(-0.148*(1<<RGB2YUV_SHIFT)+0.5))
 
109
#define BY ((int)( 0.098 * (1 << RGB2YUV_SHIFT) + 0.5))
 
110
#define BV ((int)(-0.071 * (1 << RGB2YUV_SHIFT) + 0.5))
 
111
#define BU ((int)( 0.439 * (1 << RGB2YUV_SHIFT) + 0.5))
 
112
#define GY ((int)( 0.504 * (1 << RGB2YUV_SHIFT) + 0.5))
 
113
#define GV ((int)(-0.368 * (1 << RGB2YUV_SHIFT) + 0.5))
 
114
#define GU ((int)(-0.291 * (1 << RGB2YUV_SHIFT) + 0.5))
 
115
#define RY ((int)( 0.257 * (1 << RGB2YUV_SHIFT) + 0.5))
 
116
#define RV ((int)( 0.439 * (1 << RGB2YUV_SHIFT) + 0.5))
 
117
#define RU ((int)(-0.148 * (1 << RGB2YUV_SHIFT) + 0.5))
107
118
 
108
119
//plain C versions
109
120
#include "rgb2rgb_template.c"
110
121
 
111
 
 
112
122
/*
113
 
 RGB15->RGB16 original by Strepto/Astral
114
 
 ported to gcc & bugfixed : A'rpi
115
 
 MMX2, 3DNOW optimization by Nick Kurshev
116
 
 32-bit C version, and and&add trick by Michael Niedermayer
117
 
*/
 
123
 * RGB15->RGB16 original by Strepto/Astral
 
124
 * ported to gcc & bugfixed : A'rpi
 
125
 * MMXEXT, 3DNOW optimization by Nick Kurshev
 
126
 * 32-bit C version, and and&add trick by Michael Niedermayer
 
127
 */
118
128
 
119
 
void sws_rgb2rgb_init(void)
 
129
av_cold void sws_rgb2rgb_init(void)
120
130
{
121
131
    rgb2rgb_init_c();
122
132
    if (HAVE_MMX)
125
135
 
126
136
void rgb32to24(const uint8_t *src, uint8_t *dst, int src_size)
127
137
{
128
 
    int i;
129
 
    int num_pixels = src_size >> 2;
130
 
    for (i=0; i<num_pixels; i++) {
 
138
    int i, num_pixels = src_size >> 2;
 
139
 
 
140
    for (i = 0; i < num_pixels; i++) {
131
141
#if HAVE_BIGENDIAN
132
142
        /* RGB32 (= A,B,G,R) -> BGR24 (= B,G,R) */
133
 
        dst[3*i + 0] = src[4*i + 1];
134
 
        dst[3*i + 1] = src[4*i + 2];
135
 
        dst[3*i + 2] = src[4*i + 3];
 
143
        dst[3 * i + 0] = src[4 * i + 1];
 
144
        dst[3 * i + 1] = src[4 * i + 2];
 
145
        dst[3 * i + 2] = src[4 * i + 3];
136
146
#else
137
 
        dst[3*i + 0] = src[4*i + 2];
138
 
        dst[3*i + 1] = src[4*i + 1];
139
 
        dst[3*i + 2] = src[4*i + 0];
 
147
        dst[3 * i + 0] = src[4 * i + 2];
 
148
        dst[3 * i + 1] = src[4 * i + 1];
 
149
        dst[3 * i + 2] = src[4 * i + 0];
140
150
#endif
141
151
    }
142
152
}
144
154
void rgb24to32(const uint8_t *src, uint8_t *dst, int src_size)
145
155
{
146
156
    int i;
147
 
    for (i=0; 3*i<src_size; i++) {
 
157
 
 
158
    for (i = 0; 3 * i < src_size; i++) {
148
159
#if HAVE_BIGENDIAN
149
 
        /* RGB24 (= R,G,B) -> BGR32 (= A,R,G,B) */
150
 
        dst[4*i + 0] = 255;
151
 
        dst[4*i + 1] = src[3*i + 0];
152
 
        dst[4*i + 2] = src[3*i + 1];
153
 
        dst[4*i + 3] = src[3*i + 2];
 
160
        /* RGB24 (= R, G, B) -> BGR32 (= A, R, G, B) */
 
161
        dst[4 * i + 0] = 255;
 
162
        dst[4 * i + 1] = src[3 * i + 0];
 
163
        dst[4 * i + 2] = src[3 * i + 1];
 
164
        dst[4 * i + 3] = src[3 * i + 2];
154
165
#else
155
 
        dst[4*i + 0] = src[3*i + 2];
156
 
        dst[4*i + 1] = src[3*i + 1];
157
 
        dst[4*i + 2] = src[3*i + 0];
158
 
        dst[4*i + 3] = 255;
 
166
        dst[4 * i + 0] = src[3 * i + 2];
 
167
        dst[4 * i + 1] = src[3 * i + 1];
 
168
        dst[4 * i + 2] = src[3 * i + 0];
 
169
        dst[4 * i + 3] = 255;
159
170
#endif
160
171
    }
161
172
}
162
173
 
163
174
void rgb16tobgr32(const uint8_t *src, uint8_t *dst, int src_size)
164
175
{
165
 
    const uint16_t *end;
166
 
    uint8_t *d = dst;
167
 
    const uint16_t *s = (const uint16_t *)src;
168
 
    end = s + src_size/2;
 
176
    uint8_t *d          = dst;
 
177
    const uint16_t *s   = (const uint16_t *)src;
 
178
    const uint16_t *end = s + src_size / 2;
 
179
 
169
180
    while (s < end) {
170
 
        register uint16_t bgr;
171
 
        bgr = *s++;
 
181
        register uint16_t bgr = *s++;
172
182
#if HAVE_BIGENDIAN
173
183
        *d++ = 255;
174
 
        *d++ = (bgr&0x1F)<<3;
175
 
        *d++ = (bgr&0x7E0)>>3;
176
 
        *d++ = (bgr&0xF800)>>8;
 
184
        *d++ = (bgr & 0x1F)   << 3;
 
185
        *d++ = (bgr & 0x7E0)  >> 3;
 
186
        *d++ = (bgr & 0xF800) >> 8;
177
187
#else
178
 
        *d++ = (bgr&0xF800)>>8;
179
 
        *d++ = (bgr&0x7E0)>>3;
180
 
        *d++ = (bgr&0x1F)<<3;
 
188
        *d++ = (bgr & 0xF800) >> 8;
 
189
        *d++ = (bgr & 0x7E0)  >> 3;
 
190
        *d++ = (bgr & 0x1F)   << 3;
181
191
        *d++ = 255;
182
192
#endif
183
193
    }
185
195
 
186
196
void rgb12to15(const uint8_t *src, uint8_t *dst, int src_size)
187
197
{
188
 
    const uint16_t *end;
189
 
    uint16_t *d = (uint16_t *)dst;
190
 
    const uint16_t *s = (const uint16_t *)src;
191
198
    uint16_t rgb, r, g, b;
192
 
    end = s + src_size / 2;
 
199
    uint16_t *d         = (uint16_t *)dst;
 
200
    const uint16_t *s   = (const uint16_t *)src;
 
201
    const uint16_t *end = s + src_size / 2;
 
202
 
193
203
    while (s < end) {
194
 
        rgb = *s++;
195
 
        r = rgb & 0xF00;
196
 
        g = rgb & 0x0F0;
197
 
        b = rgb & 0x00F;
198
 
        r = (r << 3) | ((r & 0x800) >> 1);
199
 
        g = (g << 2) | ((g & 0x080) >> 2);
200
 
        b = (b << 1) | ( b          >> 3);
 
204
        rgb  = *s++;
 
205
        r    = rgb & 0xF00;
 
206
        g    = rgb & 0x0F0;
 
207
        b    = rgb & 0x00F;
 
208
        r    = (r << 3) | ((r & 0x800) >> 1);
 
209
        g    = (g << 2) | ((g & 0x080) >> 2);
 
210
        b    = (b << 1) | ( b          >> 3);
201
211
        *d++ = r | g | b;
202
212
    }
203
213
}
204
214
 
205
215
void rgb16to24(const uint8_t *src, uint8_t *dst, int src_size)
206
216
{
207
 
    const uint16_t *end;
208
 
    uint8_t *d = dst;
209
 
    const uint16_t *s = (const uint16_t *)src;
210
 
    end = s + src_size/2;
 
217
    uint8_t *d          = dst;
 
218
    const uint16_t *s   = (const uint16_t *)src;
 
219
    const uint16_t *end = s + src_size / 2;
 
220
 
211
221
    while (s < end) {
212
 
        register uint16_t bgr;
213
 
        bgr = *s++;
214
 
        *d++ = (bgr&0xF800)>>8;
215
 
        *d++ = (bgr&0x7E0)>>3;
216
 
        *d++ = (bgr&0x1F)<<3;
 
222
        register uint16_t bgr = *s++;
 
223
        *d++ = (bgr & 0xF800) >> 8;
 
224
        *d++ = (bgr & 0x7E0)  >> 3;
 
225
        *d++ = (bgr & 0x1F)   << 3;
217
226
    }
218
227
}
219
228
 
220
229
void rgb16tobgr16(const uint8_t *src, uint8_t *dst, int src_size)
221
230
{
222
 
    int i;
223
 
    int num_pixels = src_size >> 1;
 
231
    int i, num_pixels = src_size >> 1;
224
232
 
225
 
    for (i=0; i<num_pixels; i++) {
226
 
        unsigned rgb = ((const uint16_t*)src)[i];
227
 
        ((uint16_t*)dst)[i] = (rgb>>11) | (rgb&0x7E0) | (rgb<<11);
 
233
    for (i = 0; i < num_pixels; i++) {
 
234
        unsigned rgb         = ((const uint16_t *)src)[i];
 
235
        ((uint16_t *)dst)[i] = (rgb >> 11) | (rgb & 0x7E0) | (rgb << 11);
228
236
    }
229
237
}
230
238
 
231
239
void rgb16tobgr15(const uint8_t *src, uint8_t *dst, int src_size)
232
240
{
233
 
    int i;
234
 
    int num_pixels = src_size >> 1;
 
241
    int i, num_pixels = src_size >> 1;
235
242
 
236
 
    for (i=0; i<num_pixels; i++) {
237
 
        unsigned rgb = ((const uint16_t*)src)[i];
238
 
        ((uint16_t*)dst)[i] = (rgb>>11) | ((rgb&0x7C0)>>1) | ((rgb&0x1F)<<10);
 
243
    for (i = 0; i < num_pixels; i++) {
 
244
        unsigned rgb         = ((const uint16_t *)src)[i];
 
245
        ((uint16_t *)dst)[i] = (rgb >> 11) | ((rgb & 0x7C0) >> 1) | ((rgb & 0x1F) << 10);
239
246
    }
240
247
}
241
248
 
242
249
void rgb15tobgr32(const uint8_t *src, uint8_t *dst, int src_size)
243
250
{
244
 
    const uint16_t *end;
245
 
    uint8_t *d = dst;
246
 
    const uint16_t *s = (const uint16_t *)src;
247
 
    end = s + src_size/2;
 
251
    uint8_t *d          = dst;
 
252
    const uint16_t *s   = (const uint16_t *)src;
 
253
    const uint16_t *end = s + src_size / 2;
 
254
 
248
255
    while (s < end) {
249
 
        register uint16_t bgr;
250
 
        bgr = *s++;
 
256
        register uint16_t bgr = *s++;
251
257
#if HAVE_BIGENDIAN
252
258
        *d++ = 255;
253
 
        *d++ = (bgr&0x1F)<<3;
254
 
        *d++ = (bgr&0x3E0)>>2;
255
 
        *d++ = (bgr&0x7C00)>>7;
 
259
        *d++ = (bgr & 0x1F)   << 3;
 
260
        *d++ = (bgr & 0x3E0)  >> 2;
 
261
        *d++ = (bgr & 0x7C00) >> 7;
256
262
#else
257
 
        *d++ = (bgr&0x7C00)>>7;
258
 
        *d++ = (bgr&0x3E0)>>2;
259
 
        *d++ = (bgr&0x1F)<<3;
 
263
        *d++ = (bgr & 0x7C00) >> 7;
 
264
        *d++ = (bgr & 0x3E0)  >> 2;
 
265
        *d++ = (bgr & 0x1F)   << 3;
260
266
        *d++ = 255;
261
267
#endif
262
268
    }
264
270
 
265
271
void rgb15to24(const uint8_t *src, uint8_t *dst, int src_size)
266
272
{
267
 
    const uint16_t *end;
268
 
    uint8_t *d = dst;
269
 
    const uint16_t *s = (const uint16_t *)src;
270
 
    end = s + src_size/2;
 
273
    uint8_t *d          = dst;
 
274
    const uint16_t *s   = (const uint16_t *)src;
 
275
    const uint16_t *end = s + src_size / 2;
 
276
 
271
277
    while (s < end) {
272
 
        register uint16_t bgr;
273
 
        bgr = *s++;
274
 
        *d++ = (bgr&0x7C00)>>7;
275
 
        *d++ = (bgr&0x3E0)>>2;
276
 
        *d++ = (bgr&0x1F)<<3;
 
278
        register uint16_t bgr = *s++;
 
279
        *d++ = (bgr & 0x7C00) >> 7;
 
280
        *d++ = (bgr & 0x3E0)  >> 2;
 
281
        *d++ = (bgr & 0x1F)   << 3;
277
282
    }
278
283
}
279
284
 
280
285
void rgb15tobgr16(const uint8_t *src, uint8_t *dst, int src_size)
281
286
{
282
 
    int i;
283
 
    int num_pixels = src_size >> 1;
 
287
    int i, num_pixels = src_size >> 1;
284
288
 
285
 
    for (i=0; i<num_pixels; i++) {
286
 
        unsigned rgb = ((const uint16_t*)src)[i];
287
 
        ((uint16_t*)dst)[i] = ((rgb&0x7C00)>>10) | ((rgb&0x3E0)<<1) | (rgb<<11);
 
289
    for (i = 0; i < num_pixels; i++) {
 
290
        unsigned rgb         = ((const uint16_t *)src)[i];
 
291
        ((uint16_t *)dst)[i] = ((rgb & 0x7C00) >> 10) | ((rgb & 0x3E0) << 1) | (rgb << 11);
288
292
    }
289
293
}
290
294
 
291
295
void rgb15tobgr15(const uint8_t *src, uint8_t *dst, int src_size)
292
296
{
293
 
    int i;
294
 
    int num_pixels = src_size >> 1;
 
297
    int i, num_pixels = src_size >> 1;
295
298
 
296
 
    for (i=0; i<num_pixels; i++) {
297
 
        unsigned br;
298
 
        unsigned rgb = ((const uint16_t*)src)[i];
299
 
        br = rgb&0x7c1F;
300
 
        ((uint16_t*)dst)[i] = (br>>10) | (rgb&0x3E0) | (br<<10);
 
299
    for (i = 0; i < num_pixels; i++) {
 
300
        unsigned rgb         = ((const uint16_t *)src)[i];
 
301
        unsigned br          = rgb & 0x7C1F;
 
302
        ((uint16_t *)dst)[i] = (br >> 10) | (rgb & 0x3E0) | (br << 10);
301
303
    }
302
304
}
303
305
 
304
306
void rgb12tobgr12(const uint8_t *src, uint8_t *dst, int src_size)
305
307
{
306
 
    uint16_t *d = (uint16_t*)dst;
307
 
    uint16_t *s = (uint16_t*)src;
308
 
    int i;
309
 
    int num_pixels = src_size >> 1;
 
308
    uint16_t *d = (uint16_t *)dst;
 
309
    uint16_t *s = (uint16_t *)src;
 
310
    int i, num_pixels = src_size >> 1;
310
311
 
311
312
    for (i = 0; i < num_pixels; i++) {
312
313
        unsigned rgb = s[i];
313
 
        d[i] = (rgb << 8 | rgb & 0xF0 | rgb >> 8) & 0xFFF;
 
314
        d[i]         = (rgb << 8 | rgb & 0xF0 | rgb >> 8) & 0xFFF;
314
315
    }
315
316
}
316
317
 
317
318
void bgr8torgb8(const uint8_t *src, uint8_t *dst, int src_size)
318
319
{
319
 
    int i;
320
 
    int num_pixels = src_size;
321
 
    for (i=0; i<num_pixels; i++) {
322
 
        unsigned b,g,r;
323
 
        register uint8_t rgb;
324
 
        rgb = src[i];
325
 
        r = (rgb&0x07);
326
 
        g = (rgb&0x38)>>3;
327
 
        b = (rgb&0xC0)>>6;
328
 
        dst[i] = ((b<<1)&0x07) | ((g&0x07)<<3) | ((r&0x03)<<6);
 
320
    int i, num_pixels = src_size;
 
321
 
 
322
    for (i = 0; i < num_pixels; i++) {
 
323
        register uint8_t rgb = src[i];
 
324
        unsigned r           = (rgb & 0x07);
 
325
        unsigned g           = (rgb & 0x38) >> 3;
 
326
        unsigned b           = (rgb & 0xC0) >> 6;
 
327
        dst[i]               = ((b << 1) & 0x07) | ((g & 0x07) << 3) | ((r & 0x03) << 6);
329
328
    }
330
329
}
331
330
 
332
331
#define DEFINE_SHUFFLE_BYTES(a, b, c, d)                                \
333
 
void shuffle_bytes_##a##b##c##d(const uint8_t *src, uint8_t *dst, int src_size) \
 
332
void shuffle_bytes_ ## a ## b ## c ## d(const uint8_t *src,             \
 
333
                                        uint8_t *dst, int src_size)     \
334
334
{                                                                       \
335
 
    int i;                                                             \
 
335
    int i;                                                              \
336
336
                                                                        \
337
 
    for (i = 0; i < src_size; i+=4) {                                   \
 
337
    for (i = 0; i < src_size; i += 4) {                                 \
338
338
        dst[i + 0] = src[i + a];                                        \
339
339
        dst[i + 1] = src[i + b];                                        \
340
340
        dst[i + 2] = src[i + c];                                        \
346
346
DEFINE_SHUFFLE_BYTES(1, 2, 3, 0)
347
347
DEFINE_SHUFFLE_BYTES(3, 0, 1, 2)
348
348
DEFINE_SHUFFLE_BYTES(3, 2, 1, 0)
349