FFmpeg coverage

Directory: ../../../ffmpeg/
File: src/libswscale/rgb2rgb_template.c
Date: 2026-09-28 11:37:26
Exec Total Coverage
Lines: 215 485 44.3%
Functions: 22 46 47.8%
Branches: 49 112 43.8%
Line Branch Exec Source
1 /*
2 * software RGB to RGB converter
3 * pluralize by software PAL8 to RGB converter
4 * software YUV to YUV converter
5 * software YUV to RGB converter
6 * Written by Nick Kurshev.
7 * palette & YUV & runtime CPU stuff by Michael (michaelni@gmx.at)
8 * lot of big-endian byte order fixes by Alex Beregszaszi
9 *
10 * This file is part of FFmpeg.
11 *
12 * FFmpeg is free software; you can redistribute it and/or
13 * modify it under the terms of the GNU Lesser General Public
14 * License as published by the Free Software Foundation; either
15 * version 2.1 of the License, or (at your option) any later version.
16 *
17 * FFmpeg is distributed in the hope that it will be useful,
18 * but WITHOUT ANY WARRANTY; without even the implied warranty of
19 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
20 * Lesser General Public License for more details.
21 *
22 * You should have received a copy of the GNU Lesser General Public
23 * License along with FFmpeg; if not, write to the Free Software
24 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
25 */
26
27 #include <stddef.h>
28
29 #include "libavutil/attributes.h"
30
31 133 static inline void rgb24tobgr32_c(const uint8_t *src, uint8_t *dst,
32 int src_size)
33 {
34 133 uint8_t *dest = dst;
35 133 const uint8_t *s = src;
36 133 const uint8_t *end = s + src_size;
37
38
2/2
✓ Branch 0 taken 918316 times.
✓ Branch 1 taken 133 times.
 918449 while (s < end) {
39 #if HAVE_BIGENDIAN
40 /* RGB24 (= R, G, B) -> RGB32 (= A, B, G, R) */
41 *dest++ = 255;
42 *dest++ = s[2];
43 *dest++ = s[1];
44 *dest++ = s[0];
45 s += 3;
46 #else
47 918316 *dest++ = *s++;
48 918316 *dest++ = *s++;
49 918316 *dest++ = *s++;
50 918316 *dest++ = 255;
51 #endif
52 }
53 133 }
54
55 62 static inline void rgb32tobgr24_c(const uint8_t *src, uint8_t *dst,
56 int src_size)
57 {
58 62 uint8_t *dest = dst;
59 62 const uint8_t *s = src;
60 62 const uint8_t *end = s + src_size;
61
62
2/2
✓ Branch 0 taken 57161 times.
✓ Branch 1 taken 62 times.
 57223 while (s < end) {
63 #if HAVE_BIGENDIAN
64 /* RGB32 (= A, B, G, R) -> RGB24 (= R, G, B) */
65 s++;
66 dest[2] = *s++;
67 dest[1] = *s++;
68 dest[0] = *s++;
69 dest += 3;
70 #else
71 57161 *dest++ = *s++;
72 57161 *dest++ = *s++;
73 57161 *dest++ = *s++;
74 57161 s++;
75 #endif
76 }
77 62 }
78
79 /*
80 * original by Strepto/Astral
81 * ported to gcc & bugfixed: A'rpi
82 * MMXEXT, 3DNOW optimization by Nick Kurshev
83 * 32-bit C version, and and&add trick by Michael Niedermayer
84 */
85 ✗ static inline void rgb15to16_c(const uint8_t *src, uint8_t *dst, int src_size)
86 {
87 ✗ register uint8_t *d = dst;
88 ✗ register const uint8_t *s = src;
89 ✗ register const uint8_t *end = s + src_size;
90 ✗ const uint8_t *mm_end = end - 3;
91
92 ✗ 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;
97 }
98 ✗ if (s < end) {
99 ✗ register unsigned short x = *((const uint16_t *)s);
100 ✗ *((uint16_t *)d) = (x & 0x7FFF) + (x & 0x7FE0);
101 }
102 ✗ }
103
104 ✗ static inline void rgb16to15_c(const uint8_t *src, uint8_t *dst, int src_size)
105 {
106 ✗ register uint8_t *d = dst;
107 ✗ register const uint8_t *s = src;
108 ✗ register const uint8_t *end = s + src_size;
109 ✗ const uint8_t *mm_end = end - 3;
110
111 ✗ while (s < mm_end) {
112 ✗ register uint32_t x = *((const uint32_t *)s);
113 ✗ *((uint32_t *)d) = ((x >> 1) & 0x7FE07FE0) | (x & 0x001F001F);
114 ✗ s += 4;
115 ✗ d += 4;
116 }
117 ✗ if (s < end) {
118 ✗ register uint16_t x = *((const uint16_t *)s);
119 ✗ *((uint16_t *)d) = ((x >> 1) & 0x7FE0) | (x & 0x001F);
120 }
121 ✗ }
122
123 ✗ static inline void rgb32to16_c(const uint8_t *src, uint8_t *dst, int src_size)
124 {
125 ✗ uint16_t *d = (uint16_t *)dst;
126 ✗ const uint8_t *s = src;
127 ✗ const uint8_t *end = s + src_size;
128
129 ✗ while (s < end) {
130 ✗ register int rgb = *(const uint32_t *)s;
131 ✗ s += 4;
132 ✗ *d++ = ((rgb & 0xFF) >> 3) +
133 ✗ ((rgb & 0xFC00) >> 5) +
134 ✗ ((rgb & 0xF80000) >> 8);
135 }
136 ✗ }
137
138 ✗ static inline void rgb32tobgr16_c(const uint8_t *src, uint8_t *dst,
139 int src_size)
140 {
141 ✗ uint16_t *d = (uint16_t *)dst;
142 ✗ const uint8_t *s = src;
143 ✗ const uint8_t *end = s + src_size;
144
145 ✗ while (s < end) {
146 ✗ register int rgb = *(const uint32_t *)s;
147 ✗ s += 4;
148 ✗ *d++ = ((rgb & 0xF8) << 8) +
149 ✗ ((rgb & 0xFC00) >> 5) +
150 ✗ ((rgb & 0xF80000) >> 19);
151 }
152 ✗ }
153
154 ✗ static inline void rgb32to15_c(const uint8_t *src, uint8_t *dst, int src_size)
155 {
156 ✗ uint16_t *d = (uint16_t *)dst;
157 ✗ const uint8_t *s = src;
158 ✗ const uint8_t *end = s + src_size;
159
160 ✗ while (s < end) {
161 ✗ register int rgb = *(const uint32_t *)s;
162 ✗ s += 4;
163 ✗ *d++ = ((rgb & 0xFF) >> 3) +
164 ✗ ((rgb & 0xF800) >> 6) +
165 ✗ ((rgb & 0xF80000) >> 9);
166 }
167 ✗ }
168
169 ✗ static inline void rgb32tobgr15_c(const uint8_t *src, uint8_t *dst,
170 int src_size)
171 {
172 ✗ uint16_t *d = (uint16_t *)dst;
173 ✗ const uint8_t *s = src;
174 ✗ const uint8_t *end = s + src_size;
175
176 ✗ while (s < end) {
177 ✗ register int rgb = *(const uint32_t *)s;
178 ✗ s += 4;
179 ✗ *d++ = ((rgb & 0xF8) << 7) +
180 ✗ ((rgb & 0xF800) >> 6) +
181 ✗ ((rgb & 0xF80000) >> 19);
182 }
183 ✗ }
184
185 ✗ static inline void rgb24tobgr16_c(const uint8_t *src, uint8_t *dst,
186 int src_size)
187 {
188 ✗ uint16_t *d = (uint16_t *)dst;
189 ✗ const uint8_t *s = src;
190 ✗ const uint8_t *end = s + src_size;
191
192 ✗ while (s < end) {
193 ✗ const int b = *s++;
194 ✗ const int g = *s++;
195 ✗ const int r = *s++;
196 ✗ *d++ = (b >> 3) | ((g & 0xFC) << 3) | ((r & 0xF8) << 8);
197 }
198 ✗ }
199
200 ✗ static inline void rgb24to16_c(const uint8_t *src, uint8_t *dst, int src_size)
201 {
202 ✗ uint16_t *d = (uint16_t *)dst;
203 ✗ const uint8_t *s = src;
204 ✗ const uint8_t *end = s + src_size;
205
206 ✗ while (s < end) {
207 ✗ const int r = *s++;
208 ✗ const int g = *s++;
209 ✗ const int b = *s++;
210 ✗ *d++ = (b >> 3) | ((g & 0xFC) << 3) | ((r & 0xF8) << 8);
211 }
212 ✗ }
213
214 ✗ static inline void rgb24tobgr15_c(const uint8_t *src, uint8_t *dst,
215 int src_size)
216 {
217 ✗ uint16_t *d = (uint16_t *)dst;
218 ✗ const uint8_t *s = src;
219 ✗ const uint8_t *end = s + src_size;
220
221 ✗ while (s < end) {
222 ✗ const int b = *s++;
223 ✗ const int g = *s++;
224 ✗ const int r = *s++;
225 ✗ *d++ = (b >> 3) | ((g & 0xF8) << 2) | ((r & 0xF8) << 7);
226 }
227 ✗ }
228
229 ✗ static inline void rgb24to15_c(const uint8_t *src, uint8_t *dst, int src_size)
230 {
231 ✗ uint16_t *d = (uint16_t *)dst;
232 ✗ const uint8_t *s = src;
233 ✗ const uint8_t *end = s + src_size;
234
235 ✗ while (s < end) {
236 ✗ const int r = *s++;
237 ✗ const int g = *s++;
238 ✗ const int b = *s++;
239 ✗ *d++ = (b >> 3) | ((g & 0xF8) << 2) | ((r & 0xF8) << 7);
240 }
241 ✗ }
242
243 19497 static inline void rgb15tobgr24_c(const uint8_t *src, uint8_t *dst,
244 int src_size)
245 {
246 19497 uint8_t *d = dst;
247 19497 const uint16_t *s = (const uint16_t *)src;
248 19497 const uint16_t *end = s + src_size / 2;
249
250
2/2
✓ Branch 0 taken 4808192 times.
✓ Branch 1 taken 19497 times.
 4827689 while (s < end) {
251 4808192 register uint16_t bgr = *s++;
252 4808192 *d++ = ((bgr&0x001F)<<3) | ((bgr&0x001F)>> 2);
253 4808192 *d++ = ((bgr&0x03E0)>>2) | ((bgr&0x03E0)>> 7);
254 4808192 *d++ = ((bgr&0x7C00)>>7) | ((bgr&0x7C00)>>12);
255 }
256 19497 }
257
258 ✗ static inline void rgb16tobgr24_c(const uint8_t *src, uint8_t *dst,
259 int src_size)
260 {
261 ✗ uint8_t *d = (uint8_t *)dst;
262 ✗ const uint16_t *s = (const uint16_t *)src;
263 ✗ const uint16_t *end = s + src_size / 2;
264
265 ✗ while (s < end) {
266 ✗ register uint16_t bgr = *s++;
267 ✗ *d++ = ((bgr&0x001F)<<3) | ((bgr&0x001F)>> 2);
268 ✗ *d++ = ((bgr&0x07E0)>>3) | ((bgr&0x07E0)>> 9);
269 ✗ *d++ = ((bgr&0xF800)>>8) | ((bgr&0xF800)>>13);
270 }
271 ✗ }
272
273 ✗ static inline void rgb15to32_c(const uint8_t *src, uint8_t *dst, int src_size)
274 {
275 ✗ uint8_t *d = dst;
276 ✗ const uint16_t *s = (const uint16_t *)src;
277 ✗ const uint16_t *end = s + src_size / 2;
278
279 ✗ while (s < end) {
280 ✗ register uint16_t bgr = *s++;
281 #if HAVE_BIGENDIAN
282 *d++ = 255;
283 *d++ = ((bgr&0x7C00)>>7) | ((bgr&0x7C00)>>12);
284 *d++ = ((bgr&0x03E0)>>2) | ((bgr&0x03E0)>> 7);
285 *d++ = ((bgr&0x001F)<<3) | ((bgr&0x001F)>> 2);
286 #else
287 ✗ *d++ = ((bgr&0x001F)<<3) | ((bgr&0x001F)>> 2);
288 ✗ *d++ = ((bgr&0x03E0)>>2) | ((bgr&0x03E0)>> 7);
289 ✗ *d++ = ((bgr&0x7C00)>>7) | ((bgr&0x7C00)>>12);
290 ✗ *d++ = 255;
291 #endif
292 }
293 ✗ }
294
295 ✗ static inline void rgb16to32_c(const uint8_t *src, uint8_t *dst, int src_size)
296 {
297 ✗ uint8_t *d = dst;
298 ✗ const uint16_t *s = (const uint16_t *)src;
299 ✗ const uint16_t *end = s + src_size / 2;
300
301 ✗ while (s < end) {
302 ✗ register uint16_t bgr = *s++;
303 #if HAVE_BIGENDIAN
304 *d++ = 255;
305 *d++ = ((bgr&0xF800)>>8) | ((bgr&0xF800)>>13);
306 *d++ = ((bgr&0x07E0)>>3) | ((bgr&0x07E0)>> 9);
307 *d++ = ((bgr&0x001F)<<3) | ((bgr&0x001F)>> 2);
308 #else
309 ✗ *d++ = ((bgr&0x001F)<<3) | ((bgr&0x001F)>> 2);
310 ✗ *d++ = ((bgr&0x07E0)>>3) | ((bgr&0x07E0)>> 9);
311 ✗ *d++ = ((bgr&0xF800)>>8) | ((bgr&0xF800)>>13);
312 ✗ *d++ = 255;
313 #endif
314 }
315 ✗ }
316
317 123 static inline void shuffle_bytes_2103_c(const uint8_t *src, uint8_t *dst,
318 int src_size)
319 {
320 123 int idx = 15 - src_size;
321 123 const uint8_t *s = src - idx;
322 123 uint8_t *d = dst - idx;
323
324
2/2
✓ Branch 0 taken 441999 times.
✓ Branch 1 taken 123 times.
 442122 for (; idx < 15; idx += 4) {
325 441999 register unsigned v = *(const uint32_t *)&s[idx], g = v & 0xff00ff00;
326 441999 v &= 0xff00ff;
327 441999 *(uint32_t *)&d[idx] = (v >> 16) + g + (v << 16);
328 }
329 123 }
330
331 19 static inline void shuffle_bytes_0321_c(const uint8_t *src, uint8_t *dst,
332 int src_size)
333 {
334 19 int idx = 15 - src_size;
335 19 const uint8_t *s = src - idx;
336 19 uint8_t *d = dst - idx;
337
338
2/2
✓ Branch 0 taken 215 times.
✓ Branch 1 taken 19 times.
 234 for (; idx < 15; idx += 4) {
339 215 register unsigned v = *(const uint32_t *)&s[idx], g = v & 0x00ff00ff;
340 215 v &= 0xff00ff00;
341 215 *(uint32_t *)&d[idx] = (v >> 16) + g + (v << 16);
342 }
343 19 }
344
345 #define DEFINE_SHUFFLE_BYTES(name, a, b, c, d) \
346 static void shuffle_bytes_##name (const uint8_t *src, \
347 uint8_t *dst, int src_size) \
348 { \
349 int i; \
350 \
351 for (i = 0; i < src_size; i += 4) { \
352 dst[i + 0] = src[i + a]; \
353 dst[i + 1] = src[i + b]; \
354 dst[i + 2] = src[i + c]; \
355 dst[i + 3] = src[i + d]; \
356 } \
357 }
358
359
2/2
✓ Branch 0 taken 215 times.
✓ Branch 1 taken 19 times.
 234 DEFINE_SHUFFLE_BYTES(1230_c, 1, 2, 3, 0)
360
2/2
✓ Branch 0 taken 215 times.
✓ Branch 1 taken 19 times.
 234 DEFINE_SHUFFLE_BYTES(3012_c, 3, 0, 1, 2)
361
2/2
✓ Branch 0 taken 8985815 times.
✓ Branch 1 taken 253 times.
 8986068 DEFINE_SHUFFLE_BYTES(3210_c, 3, 2, 1, 0)
362
2/2
✓ Branch 0 taken 215 times.
✓ Branch 1 taken 19 times.
 234 DEFINE_SHUFFLE_BYTES(3102_c, 3, 1, 0, 2)
363
2/2
✓ Branch 0 taken 215 times.
✓ Branch 1 taken 19 times.
 234 DEFINE_SHUFFLE_BYTES(2013_c, 2, 0, 1, 3)
364
2/2
✓ Branch 0 taken 215 times.
✓ Branch 1 taken 19 times.
 234 DEFINE_SHUFFLE_BYTES(2130_c, 2, 1, 3, 0)
365
2/2
✓ Branch 0 taken 215 times.
✓ Branch 1 taken 19 times.
 234 DEFINE_SHUFFLE_BYTES(1203_c, 1, 2, 0, 3)
366
367 889 static inline void rgb24tobgr24_c(const uint8_t *src, uint8_t *dst, int src_size)
368 {
369 unsigned i;
370
371
2/2
✓ Branch 0 taken 8004537 times.
✓ Branch 1 taken 889 times.
 8005426 for (i = 0; i < src_size; i += 3) {
372 8004537 register uint8_t x = src[i + 2];
373 8004537 dst[i + 1] = src[i + 1];
374 8004537 dst[i + 2] = src[i + 0];
375 8004537 dst[i + 0] = x;
376 }
377 889 }
378
379 ✗ static inline void yuvPlanartoyuy2_c(const uint8_t *ysrc, const uint8_t *usrc,
380 const uint8_t *vsrc, uint8_t *dst,
381 int width, int height,
382 int lumStride, int chromStride,
383 int dstStride, int vertLumPerChroma)
384 {
385 int y, i;
386 ✗ const int chromWidth = width >> 1;
387
388 ✗ for (y = 0; y < height; y++) {
389 #if HAVE_FAST_64BIT
390 ✗ uint64_t *ldst = (uint64_t *)dst;
391 ✗ const uint8_t *yc = ysrc, *uc = usrc, *vc = vsrc;
392 ✗ for (i = 0; i < chromWidth; i += 2) {
393 ✗ uint64_t k = yc[0] + (uc[0] << 8) +
394 ✗ (yc[1] << 16) + ((unsigned) vc[0] << 24);
395 ✗ uint64_t l = yc[2] + (uc[1] << 8) +
396 ✗ (yc[3] << 16) + ((unsigned) vc[1] << 24);
397 ✗ *ldst++ = k + (l << 32);
398 ✗ yc += 4;
399 ✗ uc += 2;
400 ✗ vc += 2;
401 }
402
403 #else
404 int *idst = (int32_t *)dst;
405 const uint8_t *yc = ysrc, *uc = usrc, *vc = vsrc;
406
407 for (i = 0; i < chromWidth; i++) {
408 #if HAVE_BIGENDIAN
409 *idst++ = ((unsigned)yc[0] << 24) + (uc[0] << 16) +
410 (yc[1] << 8) + (vc[0] << 0);
411 #else
412 *idst++ = yc[0] + (uc[0] << 8) +
413 (yc[1] << 16) + ((unsigned)vc[0] << 24);
414 #endif
415 yc += 2;
416 uc++;
417 vc++;
418 }
419 #endif
420 ✗ if ((y & (vertLumPerChroma - 1)) == vertLumPerChroma - 1) {
421 ✗ usrc += chromStride;
422 ✗ vsrc += chromStride;
423 }
424 ✗ ysrc += lumStride;
425 ✗ dst += dstStride;
426 }
427 ✗ }
428
429 /**
430 * Height should be a multiple of 2 and width should be a multiple of 16.
431 * (If this is a problem for anyone then tell me, and I will fix it.)
432 */
433 ✗ static inline void yv12toyuy2_c(const uint8_t *ysrc, const uint8_t *usrc,
434 const uint8_t *vsrc, uint8_t *dst,
435 int width, int height, int lumStride,
436 int chromStride, int dstStride)
437 {
438 //FIXME interpolate chroma
439 ✗ yuvPlanartoyuy2_c(ysrc, usrc, vsrc, dst, width, height, lumStride,
440 chromStride, dstStride, 2);
441 ✗ }
442
443 ✗ static inline void yuvPlanartouyvy_c(const uint8_t *ysrc, const uint8_t *usrc,
444 const uint8_t *vsrc, uint8_t *dst,
445 int width, int height,
446 int lumStride, int chromStride,
447 int dstStride, int vertLumPerChroma)
448 {
449 int y, i;
450 ✗ const int chromWidth = width >> 1;
451
452 ✗ for (y = 0; y < height; y++) {
453 #if HAVE_FAST_64BIT
454 ✗ uint64_t *ldst = (uint64_t *)dst;
455 ✗ const uint8_t *yc = ysrc, *uc = usrc, *vc = vsrc;
456 ✗ for (i = 0; i < chromWidth; i += 2) {
457 ✗ uint64_t k = uc[0] + (yc[0] << 8) +
458 ✗ (vc[0] << 16) + ((unsigned) yc[1] << 24);
459 ✗ uint64_t l = uc[1] + (yc[2] << 8) +
460 ✗ (vc[1] << 16) + ((unsigned) yc[3] << 24);
461 ✗ *ldst++ = k + (l << 32);
462 ✗ yc += 4;
463 ✗ uc += 2;
464 ✗ vc += 2;
465 }
466
467 #else
468 int *idst = (int32_t *)dst;
469 const uint8_t *yc = ysrc, *uc = usrc, *vc = vsrc;
470
471 for (i = 0; i < chromWidth; i++) {
472 #if HAVE_BIGENDIAN
473 *idst++ = ((unsigned)uc[0] << 24) + (yc[0] << 16) +
474 (vc[0] << 8) + (yc[1] << 0);
475 #else
476 *idst++ = uc[0] + (yc[0] << 8) +
477 (vc[0] << 16) + ((unsigned)yc[1] << 24);
478 #endif
479 yc += 2;
480 uc++;
481 vc++;
482 }
483 #endif
484 ✗ if ((y & (vertLumPerChroma - 1)) == vertLumPerChroma - 1) {
485 ✗ usrc += chromStride;
486 ✗ vsrc += chromStride;
487 }
488 ✗ ysrc += lumStride;
489 ✗ dst += dstStride;
490 }
491 ✗ }
492
493 /**
494 * Height should be a multiple of 2 and width should be a multiple of 16
495 * (If this is a problem for anyone then tell me, and I will fix it.)
496 */
497 ✗ static inline void yv12touyvy_c(const uint8_t *ysrc, const uint8_t *usrc,
498 const uint8_t *vsrc, uint8_t *dst,
499 int width, int height, int lumStride,
500 int chromStride, int dstStride)
501 {
502 //FIXME interpolate chroma
503 ✗ yuvPlanartouyvy_c(ysrc, usrc, vsrc, dst, width, height, lumStride,
504 chromStride, dstStride, 2);
505 ✗ }
506
507 /**
508 * Width should be a multiple of 16.
509 */
510 ✗ static inline void yuv422ptouyvy_c(const uint8_t *ysrc, const uint8_t *usrc,
511 const uint8_t *vsrc, uint8_t *dst,
512 int width, int height, int lumStride,
513 int chromStride, int dstStride)
514 {
515 ✗ yuvPlanartouyvy_c(ysrc, usrc, vsrc, dst, width, height, lumStride,
516 chromStride, dstStride, 1);
517 ✗ }
518
519 /**
520 * Width should be a multiple of 16.
521 */
522 ✗ static inline void yuv422ptoyuy2_c(const uint8_t *ysrc, const uint8_t *usrc,
523 const uint8_t *vsrc, uint8_t *dst,
524 int width, int height, int lumStride,
525 int chromStride, int dstStride)
526 {
527 ✗ yuvPlanartoyuy2_c(ysrc, usrc, vsrc, dst, width, height, lumStride,
528 chromStride, dstStride, 1);
529 ✗ }
530
531 ✗ static inline void planar2x_c(const uint8_t *src, uint8_t *dst, int srcWidth,
532 int srcHeight, int srcStride, int dstStride)
533 {
534 int x, y;
535
536 ✗ dst[0] = src[0];
537
538 // first line
539 ✗ for (x = 0; x < srcWidth - 1; x++) {
540 ✗ dst[2 * x + 1] = (3 * src[x] + src[x + 1]) >> 2;
541 ✗ dst[2 * x + 2] = (src[x] + 3 * src[x + 1]) >> 2;
542 }
543 ✗ dst[2 * srcWidth - 1] = src[srcWidth - 1];
544
545 ✗ dst += dstStride;
546
547 ✗ for (y = 1; y < srcHeight; y++) {
548 ✗ const int mmxSize = 1;
549
550 ✗ dst[0] = (src[0] * 3 + src[srcStride]) >> 2;
551 ✗ dst[dstStride] = (src[0] + 3 * src[srcStride]) >> 2;
552
553 ✗ for (x = mmxSize - 1; x < srcWidth - 1; x++) {
554 ✗ dst[2 * x + 1] = (src[x + 0] * 3 + src[x + srcStride + 1]) >> 2;
555 ✗ dst[2 * x + dstStride + 2] = (src[x + 0] + 3 * src[x + srcStride + 1]) >> 2;
556 ✗ dst[2 * x + dstStride + 1] = (src[x + 1] + 3 * src[x + srcStride]) >> 2;
557 ✗ dst[2 * x + 2] = (src[x + 1] * 3 + src[x + srcStride]) >> 2;
558 }
559 ✗ dst[srcWidth * 2 - 1] = (src[srcWidth - 1] * 3 + src[srcWidth - 1 + srcStride]) >> 2;
560 ✗ dst[srcWidth * 2 - 1 + dstStride] = (src[srcWidth - 1] + 3 * src[srcWidth - 1 + srcStride]) >> 2;
561
562 ✗ dst += dstStride * 2;
563 ✗ src += srcStride;
564 }
565
566 // last line
567 ✗ dst[0] = src[0];
568
569 ✗ for (x = 0; x < srcWidth - 1; x++) {
570 ✗ dst[2 * x + 1] = (src[x] * 3 + src[x + 1]) >> 2;
571 ✗ dst[2 * x + 2] = (src[x] + 3 * src[x + 1]) >> 2;
572 }
573 ✗ dst[2 * srcWidth - 1] = src[srcWidth - 1];
574 ✗ }
575
576 /**
577 * width should be a multiple of 2.
578 * (If this is a problem for anyone then tell me, and I will fix it.)
579 */
580 15 void ff_rgb24toyv12_c(const uint8_t *src, uint8_t *ydst, uint8_t *udst,
581 uint8_t *vdst, int width, int height, int lumStride,
582 int chromStride, int srcStride, const int32_t *rgb2yuv)
583 {
584 15 int32_t ry = rgb2yuv[RY_IDX], gy = rgb2yuv[GY_IDX], by = rgb2yuv[BY_IDX];
585 15 int32_t ru = rgb2yuv[RU_IDX], gu = rgb2yuv[GU_IDX], bu = rgb2yuv[BU_IDX];
586 15 int32_t rv = rgb2yuv[RV_IDX], gv = rgb2yuv[GV_IDX], bv = rgb2yuv[BV_IDX];
587 int y;
588 15 const int chromWidth = width >> 1;
589 15 const uint8_t *src1 = src;
590 15 const uint8_t *src2 = src1 + srcStride;
591 15 uint8_t *ydst1 = ydst;
592 15 uint8_t *ydst2 = ydst + lumStride;
593
594
2/2
✓ Branch 0 taken 426 times.
✓ Branch 1 taken 15 times.
 441 for (y = 0; y < height; y += 2) {
595 int i;
596
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 426 times.
 426 if (y + 1 == height) {
597 ✗ ydst2 = ydst1;
598 ✗ src2 = src1;
599 }
600
601
2/2
✓ Branch 0 taken 25824 times.
✓ Branch 1 taken 426 times.
 26250 for (i = 0; i < chromWidth; i++) {
602 25824 unsigned int b11 = src1[6 * i + 0];
603 25824 unsigned int g11 = src1[6 * i + 1];
604 25824 unsigned int r11 = src1[6 * i + 2];
605 25824 unsigned int b12 = src1[6 * i + 3];
606 25824 unsigned int g12 = src1[6 * i + 4];
607 25824 unsigned int r12 = src1[6 * i + 5];
608 25824 unsigned int b21 = src2[6 * i + 0];
609 25824 unsigned int g21 = src2[6 * i + 1];
610 25824 unsigned int r21 = src2[6 * i + 2];
611 25824 unsigned int b22 = src2[6 * i + 3];
612 25824 unsigned int g22 = src2[6 * i + 4];
613 25824 unsigned int r22 = src2[6 * i + 5];
614
615 25824 unsigned int Y11 = ((ry * r11 + gy * g11 + by * b11) >> RGB2YUV_SHIFT) + 16;
616 25824 unsigned int Y12 = ((ry * r12 + gy * g12 + by * b12) >> RGB2YUV_SHIFT) + 16;
617 25824 unsigned int Y21 = ((ry * r21 + gy * g21 + by * b21) >> RGB2YUV_SHIFT) + 16;
618 25824 unsigned int Y22 = ((ry * r22 + gy * g22 + by * b22) >> RGB2YUV_SHIFT) + 16;
619
620 25824 unsigned int bx = (b11 + b12 + b21 + b22) >> 2;
621 25824 unsigned int gx = (g11 + g12 + g21 + g22) >> 2;
622 25824 unsigned int rx = (r11 + r12 + r21 + r22) >> 2;
623
624 25824 unsigned int U = ((ru * rx + gu * gx + bu * bx) >> RGB2YUV_SHIFT) + 128;
625 25824 unsigned int V = ((rv * rx + gv * gx + bv * bx) >> RGB2YUV_SHIFT) + 128;
626
627 25824 ydst1[2 * i + 0] = Y11;
628 25824 ydst1[2 * i + 1] = Y12;
629 25824 ydst2[2 * i + 0] = Y21;
630 25824 ydst2[2 * i + 1] = Y22;
631 25824 udst[i] = U;
632 25824 vdst[i] = V;
633 }
634 426 src1 += srcStride * 2;
635 426 src2 += srcStride * 2;
636 426 ydst1 += lumStride * 2;
637 426 ydst2 += lumStride * 2;
638 426 udst += chromStride;
639 426 vdst += chromStride;
640 }
641 15 }
642
643 1505 static void interleaveBytes_c(const uint8_t *src1, const uint8_t *src2,
644 uint8_t *dest, int width, int height,
645 int src1Stride, int src2Stride, int dstStride)
646 {
647 int h;
648
649
2/2
✓ Branch 0 taken 44228 times.
✓ Branch 1 taken 1505 times.
 45733 for (h = 0; h < height; h++) {
650 int w;
651
2/2
✓ Branch 0 taken 11627315 times.
✓ Branch 1 taken 44228 times.
 11671543 for (w = 0; w < width; w++) {
652 11627315 dest[2 * w + 0] = src1[w];
653 11627315 dest[2 * w + 1] = src2[w];
654 }
655 44228 dest += dstStride;
656 44228 src1 += src1Stride;
657 44228 src2 += src2Stride;
658 }
659 1505 }
660
661 1422 static void deinterleaveBytes_c(const uint8_t *src, uint8_t *dst1, uint8_t *dst2,
662 int width, int height, int srcStride,
663 int dst1Stride, int dst2Stride)
664 {
665 int h;
666
667
2/2
✓ Branch 0 taken 33412 times.
✓ Branch 1 taken 1422 times.
 34834 for (h = 0; h < height; h++) {
668 int w;
669
2/2
✓ Branch 0 taken 8007987 times.
✓ Branch 1 taken 33412 times.
 8041399 for (w = 0; w < width; w++) {
670 8007987 dst1[w] = src[2 * w + 0];
671 8007987 dst2[w] = src[2 * w + 1];
672 }
673 33412 src += srcStride;
674 33412 dst1 += dst1Stride;
675 33412 dst2 += dst2Stride;
676 }
677 1422 }
678
679 2530 static void extract_even_c(const uint8_t *src, uint8_t *dst, int count)
680 {
681 2530 dst += count;
682 2530 src += count * 2;
683 2530 count = -count;
684
2/2
✓ Branch 0 taken 155132 times.
✓ Branch 1 taken 2530 times.
 157662 while (count < 0) {
685 155132 dst[count] = src[2 * count];
686 155132 count++;
687 }
688 2530 }
689
690 1265 static void extract_even2_c(const uint8_t *src, uint8_t *dst0, uint8_t *dst1,
691 int count)
692 {
693 1265 dst0 += count;
694 1265 dst1 += count;
695 1265 src += count * 4;
696 1265 count = -count;
697
2/2
✓ Branch 0 taken 38858 times.
✓ Branch 1 taken 1265 times.
 40123 while (count < 0) {
698 38858 dst0[count] = src[4 * count + 0];
699 38858 dst1[count] = src[4 * count + 2];
700 38858 count++;
701 }
702 1265 }
703
704 ✗ static void extract_even2avg_c(const uint8_t *src0, const uint8_t *src1,
705 uint8_t *dst0, uint8_t *dst1, int count)
706 {
707 ✗ dst0 += count;
708 ✗ dst1 += count;
709 ✗ src0 += count * 4;
710 ✗ src1 += count * 4;
711 ✗ count = -count;
712 ✗ while (count < 0) {
713 ✗ dst0[count] = (src0[4 * count + 0] + src1[4 * count + 0]) >> 1;
714 ✗ dst1[count] = (src0[4 * count + 2] + src1[4 * count + 2]) >> 1;
715 ✗ count++;
716 }
717 ✗ }
718
719 1265 static void extract_odd2_c(const uint8_t *src, uint8_t *dst0, uint8_t *dst1,
720 int count)
721 {
722 1265 dst0 += count;
723 1265 dst1 += count;
724 1265 src += count * 4;
725 1265 count = -count;
726 1265 src++;
727
2/2
✓ Branch 0 taken 38858 times.
✓ Branch 1 taken 1265 times.
 40123 while (count < 0) {
728 38858 dst0[count] = src[4 * count + 0];
729 38858 dst1[count] = src[4 * count + 2];
730 38858 count++;
731 }
732 1265 }
733
734 ✗ static void extract_odd2avg_c(const uint8_t *src0, const uint8_t *src1,
735 uint8_t *dst0, uint8_t *dst1, int count)
736 {
737 ✗ dst0 += count;
738 ✗ dst1 += count;
739 ✗ src0 += count * 4;
740 ✗ src1 += count * 4;
741 ✗ count = -count;
742 ✗ src0++;
743 ✗ src1++;
744 ✗ while (count < 0) {
745 ✗ dst0[count] = (src0[4 * count + 0] + src1[4 * count + 0]) >> 1;
746 ✗ dst1[count] = (src0[4 * count + 2] + src1[4 * count + 2]) >> 1;
747 ✗ count++;
748 }
749 ✗ }
750
751 ✗ static void yuyvtoyuv420_c(uint8_t *ydst, uint8_t *udst, uint8_t *vdst,
752 const uint8_t *src, int width, int height,
753 int lumStride, int chromStride, int srcStride)
754 {
755 int y;
756 ✗ const int chromWidth = AV_CEIL_RSHIFT(width, 1);
757
758 ✗ for (y = 0; y < height; y++) {
759 ✗ extract_even_c(src, ydst, width);
760 ✗ if (y & 1) {
761 ✗ extract_odd2avg_c(src - srcStride, src, udst, vdst, chromWidth);
762 ✗ udst += chromStride;
763 ✗ vdst += chromStride;
764 }
765
766 ✗ src += srcStride;
767 ✗ ydst += lumStride;
768 }
769 ✗ }
770
771 40 static void yuyvtoyuv422_c(uint8_t *ydst, uint8_t *udst, uint8_t *vdst,
772 const uint8_t *src, int width, int height,
773 int lumStride, int chromStride, int srcStride)
774 {
775 int y;
776 40 const int chromWidth = AV_CEIL_RSHIFT(width, 1);
777
778
2/2
✓ Branch 0 taken 1265 times.
✓ Branch 1 taken 40 times.
 1305 for (y = 0; y < height; y++) {
779 1265 extract_even_c(src, ydst, width);
780 1265 extract_odd2_c(src, udst, vdst, chromWidth);
781
782 1265 src += srcStride;
783 1265 ydst += lumStride;
784 1265 udst += chromStride;
785 1265 vdst += chromStride;
786 }
787 40 }
788
789 ✗ static void uyvytoyuv420_c(uint8_t *ydst, uint8_t *udst, uint8_t *vdst,
790 const uint8_t *src, int width, int height,
791 int lumStride, int chromStride, int srcStride)
792 {
793 int y;
794 ✗ const int chromWidth = AV_CEIL_RSHIFT(width, 1);
795
796 ✗ for (y = 0; y < height; y++) {
797 ✗ extract_even_c(src + 1, ydst, width);
798 ✗ if (y & 1) {
799 ✗ extract_even2avg_c(src - srcStride, src, udst, vdst, chromWidth);
800 ✗ udst += chromStride;
801 ✗ vdst += chromStride;
802 }
803
804 ✗ src += srcStride;
805 ✗ ydst += lumStride;
806 }
807 ✗ }
808
809 40 static void uyvytoyuv422_c(uint8_t *ydst, uint8_t *udst, uint8_t *vdst,
810 const uint8_t *src, int width, int height,
811 int lumStride, int chromStride, int srcStride)
812 {
813 int y;
814 40 const int chromWidth = AV_CEIL_RSHIFT(width, 1);
815
816
2/2
✓ Branch 0 taken 1265 times.
✓ Branch 1 taken 40 times.
 1305 for (y = 0; y < height; y++) {
817 1265 extract_even_c(src + 1, ydst, width);
818 1265 extract_even2_c(src, udst, vdst, chromWidth);
819
820 1265 src += srcStride;
821 1265 ydst += lumStride;
822 1265 udst += chromStride;
823 1265 vdst += chromStride;
824 }
825 40 }
826
827 5045 static av_cold void rgb2rgb_init_c(void)
828 {
829 5045 rgb15to16 = rgb15to16_c;
830 5045 rgb15tobgr24 = rgb15tobgr24_c;
831 5045 rgb15to32 = rgb15to32_c;
832 5045 rgb16tobgr24 = rgb16tobgr24_c;
833 5045 rgb16to32 = rgb16to32_c;
834 5045 rgb16to15 = rgb16to15_c;
835 5045 rgb24tobgr16 = rgb24tobgr16_c;
836 5045 rgb24tobgr15 = rgb24tobgr15_c;
837 5045 rgb24tobgr32 = rgb24tobgr32_c;
838 5045 rgb32to16 = rgb32to16_c;
839 5045 rgb32to15 = rgb32to15_c;
840 5045 rgb32tobgr24 = rgb32tobgr24_c;
841 5045 rgb24to15 = rgb24to15_c;
842 5045 rgb24to16 = rgb24to16_c;
843 5045 rgb24tobgr24 = rgb24tobgr24_c;
844 #if HAVE_BIGENDIAN
845 shuffle_bytes_0321 = shuffle_bytes_2103_c;
846 shuffle_bytes_2103 = shuffle_bytes_0321_c;
847 #else
848 5045 shuffle_bytes_0321 = shuffle_bytes_0321_c;
849 5045 shuffle_bytes_2103 = shuffle_bytes_2103_c;
850 #endif
851 5045 shuffle_bytes_1230 = shuffle_bytes_1230_c;
852 5045 shuffle_bytes_3012 = shuffle_bytes_3012_c;
853 5045 shuffle_bytes_3210 = shuffle_bytes_3210_c;
854 5045 shuffle_bytes_3102 = shuffle_bytes_3102_c;
855 5045 shuffle_bytes_2013 = shuffle_bytes_2013_c;
856 5045 shuffle_bytes_2130 = shuffle_bytes_2130_c;
857 5045 shuffle_bytes_1203 = shuffle_bytes_1203_c;
858 5045 rgb32tobgr16 = rgb32tobgr16_c;
859 5045 rgb32tobgr15 = rgb32tobgr15_c;
860 5045 yv12toyuy2 = yv12toyuy2_c;
861 5045 yv12touyvy = yv12touyvy_c;
862 5045 yuv422ptoyuy2 = yuv422ptoyuy2_c;
863 5045 yuv422ptouyvy = yuv422ptouyvy_c;
864 5045 planar2x = planar2x_c;
865 5045 ff_rgb24toyv12 = ff_rgb24toyv12_c;
866 5045 interleaveBytes = interleaveBytes_c;
867 5045 deinterleaveBytes = deinterleaveBytes_c;
868
869 5045 uyvytoyuv420 = uyvytoyuv420_c;
870 5045 uyvytoyuv422 = uyvytoyuv422_c;
871 5045 yuyvtoyuv420 = yuyvtoyuv420_c;
872 5045 yuyvtoyuv422 = yuyvtoyuv422_c;
873 5045 }
874