Visual Servoing Platform  version 3.6.1 under development (2024-05-02)
vpImageConvert_yuv.cpp
1 /****************************************************************************
2  *
3  * ViSP, open source Visual Servoing Platform software.
4  * Copyright (C) 2005 - 2023 by Inria. All rights reserved.
5  *
6  * This software is free software; you can redistribute it and/or modify
7  * it under the terms of the GNU General Public License as published by
8  * the Free Software Foundation; either version 2 of the License, or
9  * (at your option) any later version.
10  * See the file LICENSE.txt at the root directory of this source
11  * distribution for additional information about the GNU GPL.
12  *
13  * For using ViSP with software that can not be combined with the GNU
14  * GPL, please contact Inria about acquiring a ViSP Professional
15  * Edition License.
16  *
17  * See https://visp.inria.fr for more information.
18  *
19  * This software was developed at:
20  * Inria Rennes - Bretagne Atlantique
21  * Campus Universitaire de Beaulieu
22  * 35042 Rennes Cedex
23  * France
24  *
25  * If you have questions regarding the use of this file, please contact
26  * Inria at visp@inria.fr
27  *
28  * This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
29  * WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
30  *
31  * Description:
32  * Convert image types.
33  */
34 
41 #include <visp3/core/vpConfig.h>
42 #include <visp3/core/vpImageConvert.h>
43 
44 namespace
45 {
46 void vpSAT(int &c)
47 {
48  if (c < 0) {
49  c = 0;
50  }
51  else {
52  c = 255;
53  }
54 }
55 };
56 
69 void vpImageConvert::YUYVToRGBa(unsigned char *yuyv, unsigned char *rgba, unsigned int width, unsigned int height)
70 {
71  unsigned char *s;
72  unsigned char *d;
73  int w, h;
74  int r, g, b, cr, cg, cb, y1, y2;
75 
76  h = static_cast<int>(height);
77  w = static_cast<int>(width);
78  s = yuyv;
79  d = rgba;
80  while (h--) {
81  int c = w / 2;
82  while (c--) {
83  y1 = *s;
84  ++s;
85  cb = ((*s - 128) * 454) / 256;
86  cg = (*s - 128) * 88;
87  ++s;
88  y2 = *s;
89  ++s;
90  cr = ((*s - 128) * 359) / 256;
91  cg = (cg + ((*s - 128) * 183)) / 256;
92  ++s;
93 
94  r = y1 + cr;
95  b = y1 + cb;
96  g = y1 - cg;
97  vpSAT(r);
98  vpSAT(g);
99  vpSAT(b);
100 
101  *d++ = static_cast<unsigned char>(r);
102  *d++ = static_cast<unsigned char>(g);
103  *d++ = static_cast<unsigned char>(b);
104  *d++ = vpRGBa::alpha_default;
105 
106  r = y2 + cr;
107  b = y2 + cb;
108  g = y2 - cg;
109  vpSAT(r);
110  vpSAT(g);
111  vpSAT(b);
112 
113  *d++ = static_cast<unsigned char>(r);
114  *d++ = static_cast<unsigned char>(g);
115  *d++ = static_cast<unsigned char>(b);
116  *d++ = vpRGBa::alpha_default;
117  }
118  }
119 }
120 
131 void vpImageConvert::YUYVToRGB(unsigned char *yuyv, unsigned char *rgb, unsigned int width, unsigned int height)
132 {
133  unsigned char *s;
134  unsigned char *d;
135  int h, w;
136  int r, g, b, cr, cg, cb, y1, y2;
137 
138  h = static_cast<int>(height);
139  w = static_cast<int>(width);
140  s = yuyv;
141  d = rgb;
142  while (h--) {
143  int c = w / 2;
144  while (c--) {
145  y1 = *s;
146  ++s;
147  cb = ((*s - 128) * 454) / 256;
148  cg = (*s - 128) * 88;
149  ++s;
150  y2 = *s;
151  ++s;
152  cr = ((*s - 128) * 359) / 256;
153  cg = (cg + ((*s - 128) * 183)) / 256;
154  ++s;
155 
156  r = y1 + cr;
157  b = y1 + cb;
158  g = y1 - cg;
159  vpSAT(r);
160  vpSAT(g);
161  vpSAT(b);
162 
163  *d++ = static_cast<unsigned char>(r);
164  *d++ = static_cast<unsigned char>(g);
165  *d++ = static_cast<unsigned char>(b);
166 
167  r = y2 + cr;
168  b = y2 + cb;
169  g = y2 - cg;
170  vpSAT(r);
171  vpSAT(g);
172  vpSAT(b);
173 
174  *d++ = static_cast<unsigned char>(r);
175  *d++ = static_cast<unsigned char>(g);
176  *d++ = static_cast<unsigned char>(b);
177  }
178  }
179 }
180 
191 void vpImageConvert::YUYVToGrey(unsigned char *yuyv, unsigned char *grey, unsigned int size)
192 {
193  unsigned int i = 0, j = 0;
194  const unsigned int doubleSize = size * 2;
195  while (j < doubleSize) {
196  grey[i++] = yuyv[j];
197  grey[i++] = yuyv[j + 2];
198  j += 4;
199  }
200 }
201 
211 void vpImageConvert::YUV411ToRGBa(unsigned char *yuv, unsigned char *rgba, unsigned int size)
212 {
213  for (unsigned int i = size / 4; i; --i) {
214  int U = static_cast<int>((*yuv - 128) * 0.354);
215  ++yuv;
216  int U5 = 5 * U;
217  int Y0 = *yuv;
218  ++yuv;
219  int Y1 = *yuv;
220  ++yuv;
221  int V = static_cast<int>((*yuv - 128) * 0.707);
222  ++yuv;
223  int V2 = 2 * V;
224  int Y2 = *yuv;
225  ++yuv;
226  int Y3 = *yuv;
227  ++yuv;
228  int UV = -U - V;
229 
230  // Original equations
231  // R = Y + 1.402 V
232  // G = Y - 0.344 U - 0.714 V
233  // B = Y + 1.772 U
234  int R = Y0 + V2;
235  vpSAT(R);
236 
237  int G = Y0 + UV;
238  vpSAT(G);
239 
240  int B = Y0 + U5;
241  vpSAT(B);
242 
243  *rgba++ = static_cast<unsigned char>(R);
244  *rgba++ = static_cast<unsigned char>(G);
245  *rgba++ = static_cast<unsigned char>(B);
246  *rgba++ = vpRGBa::alpha_default;
247 
248  //---
249  R = Y1 + V2;
250  vpSAT(R);
251 
252  G = Y1 + UV;
253  vpSAT(G);
254 
255  B = Y1 + U5;
256  vpSAT(B);
257 
258  *rgba++ = static_cast<unsigned char>(R);
259  *rgba++ = static_cast<unsigned char>(G);
260  *rgba++ = static_cast<unsigned char>(B);
261  *rgba++ = vpRGBa::alpha_default;
262 
263  //---
264  R = Y2 + V2;
265  vpSAT(R);
266 
267  G = Y2 + UV;
268  vpSAT(G);
269 
270  B = Y2 + U5;
271  vpSAT(B);
272 
273  *rgba++ = static_cast<unsigned char>(R);
274  *rgba++ = static_cast<unsigned char>(G);
275  *rgba++ = static_cast<unsigned char>(B);
276  *rgba++ = vpRGBa::alpha_default;
277 
278  //---
279  R = Y3 + V2;
280  vpSAT(R);
281 
282  G = Y3 + UV;
283  vpSAT(G);
284 
285  B = Y3 + U5;
286  vpSAT(B);
287 
288  *rgba++ = static_cast<unsigned char>(R);
289  *rgba++ = static_cast<unsigned char>(G);
290  *rgba++ = static_cast<unsigned char>(B);
291  *rgba++ = vpRGBa::alpha_default;
292  }
293 }
294 
307 void vpImageConvert::YUV422ToRGBa(unsigned char *yuv, unsigned char *rgba, unsigned int size)
308 {
309  for (unsigned int i = size / 2; i; --i) {
310  int U = static_cast<int>((*yuv - 128) * 0.354);
311  ++yuv;
312  int U5 = 5 * U;
313  int Y0 = *yuv;
314  ++yuv;
315  int V = static_cast<int>((*yuv - 128) * 0.707);
316  ++yuv;
317  int V2 = 2 * V;
318  int Y1 = *yuv;
319  ++yuv;
320  int UV = -U - V;
321 
322  //---
323  int R = Y0 + V2;
324  vpSAT(R);
325 
326  int G = Y0 + UV;
327  vpSAT(G);
328 
329  int B = Y0 + U5;
330  vpSAT(B);
331 
332  *rgba++ = static_cast<unsigned char>(R);
333  *rgba++ = static_cast<unsigned char>(G);
334  *rgba++ = static_cast<unsigned char>(B);
335  *rgba++ = vpRGBa::alpha_default;
336 
337  //---
338  R = Y1 + V2;
339  vpSAT(R);
340 
341  G = Y1 + UV;
342  vpSAT(G);
343 
344  B = Y1 + U5;
345  vpSAT(B);
346 
347  *rgba++ = static_cast<unsigned char>(R);
348  *rgba++ = static_cast<unsigned char>(G);
349  *rgba++ = static_cast<unsigned char>(B);
350  *rgba++ = vpRGBa::alpha_default;
351  }
352 }
353 
362 void vpImageConvert::YUV411ToGrey(unsigned char *yuv, unsigned char *grey, unsigned int size)
363 {
364  unsigned int i = 0, j = 0;
365  const unsigned int iterLimit = (size * 3) / 2;
366  while (j < iterLimit) {
367  grey[i] = yuv[j + 1];
368  grey[i + 1] = yuv[j + 2];
369  grey[i + 2] = yuv[j + 4];
370  grey[i + 3] = yuv[j + 5];
371 
372  i += 4;
373 
374  j += 6;
375  }
376 }
377 
388 void vpImageConvert::YUV422ToRGB(unsigned char *yuv, unsigned char *rgb, unsigned int size)
389 {
390  for (unsigned int i = size / 2; i; --i) {
391  int U = static_cast<int>((*yuv - 128) * 0.354);
392  ++yuv;
393  int U5 = 5 * U;
394  int Y0 = *yuv;
395  ++yuv;
396  int V = static_cast<int>((*yuv - 128) * 0.707);
397  ++yuv;
398  int V2 = 2 * V;
399  int Y1 = *yuv;
400  ++yuv;
401  int UV = -U - V;
402 
403  //---
404  int R = Y0 + V2;
405  vpSAT(R);
406 
407  int G = Y0 + UV;
408  vpSAT(G);
409 
410  int B = Y0 + U5;
411  vpSAT(B);
412 
413  *rgb++ = static_cast<unsigned char>(R);
414  *rgb++ = static_cast<unsigned char>(G);
415  *rgb++ = static_cast<unsigned char>(B);
416 
417  //---
418  R = Y1 + V2;
419  vpSAT(R);
420 
421  G = Y1 + UV;
422  vpSAT(G);
423 
424  B = Y1 + U5;
425  vpSAT(B);
426 
427  *rgb++ = static_cast<unsigned char>(R);
428  *rgb++ = static_cast<unsigned char>(G);
429  *rgb++ = static_cast<unsigned char>(B);
430  }
431 }
432 
443 void vpImageConvert::YUV422ToGrey(unsigned char *yuv, unsigned char *grey, unsigned int size)
444 {
445  unsigned int i = 0, j = 0;
446  const unsigned int doubleSize = size * 2;
447 
448  while (j < doubleSize) {
449  grey[i++] = yuv[j + 1];
450  grey[i++] = yuv[j + 3];
451  j += 4;
452  }
453 }
454 
463 void vpImageConvert::YUV411ToRGB(unsigned char *yuv, unsigned char *rgb, unsigned int size)
464 {
465  for (unsigned int i = size / 4; i; --i) {
466  int U = static_cast<int>((*yuv - 128) * 0.354);
467  ++yuv;
468  int U5 = 5 * U;
469  int Y0 = *yuv;
470  ++yuv;
471  int Y1 = *yuv;
472  ++yuv;
473  int V = static_cast<int>((*yuv - 128) * 0.707);
474  ++yuv;
475  int V2 = 2 * V;
476  int Y2 = *yuv;
477  ++yuv;
478  int Y3 = *yuv;
479  ++yuv;
480  int UV = -U - V;
481 
482  // Original equations
483  // R = Y + 1.402 V
484  // G = Y - 0.344 U - 0.714 V
485  // B = Y + 1.772 U
486  int R = Y0 + V2;
487  vpSAT(R);
488 
489  int G = Y0 + UV;
490  vpSAT(G);
491 
492  int B = Y0 + U5;
493  vpSAT(B);
494 
495  *rgb++ = static_cast<unsigned char>(R);
496  *rgb++ = static_cast<unsigned char>(G);
497  *rgb++ = static_cast<unsigned char>(B);
498 
499  //---
500  R = Y1 + V2;
501  vpSAT(R);
502 
503  G = Y1 + UV;
504  vpSAT(G);
505 
506  B = Y1 + U5;
507  vpSAT(B);
508 
509  *rgb++ = static_cast<unsigned char>(R);
510  *rgb++ = static_cast<unsigned char>(G);
511  *rgb++ = static_cast<unsigned char>(B);
512 
513  //---
514  R = Y2 + V2;
515  vpSAT(R);
516 
517  G = Y2 + UV;
518  vpSAT(G);
519 
520  B = Y2 + U5;
521  vpSAT(B);
522 
523  *rgb++ = static_cast<unsigned char>(R);
524  *rgb++ = static_cast<unsigned char>(G);
525  *rgb++ = static_cast<unsigned char>(B);
526 
527  //---
528  R = Y3 + V2;
529  vpSAT(R);
530 
531  G = Y3 + UV;
532  vpSAT(G);
533 
534  B = Y3 + U5;
535  vpSAT(B);
536 
537  *rgb++ = static_cast<unsigned char>(R);
538  *rgb++ = static_cast<unsigned char>(G);
539  *rgb++ = static_cast<unsigned char>(B);
540  }
541 }
542 
553 void vpImageConvert::YUV420ToRGBa(unsigned char *yuv, unsigned char *rgba, unsigned int width, unsigned int height)
554 {
555  int U, V, R, G, B, V2, U5, UV;
556  int Y0, Y1, Y2, Y3;
557  unsigned int size = width * height;
558  unsigned char *iU = yuv + size;
559  unsigned char *iV = yuv + ((5 * size) / 4);
560  const unsigned int halfHeight = height / 2, halfWidth = width / 2;
561  for (unsigned int i = 0; i < halfHeight; ++i) {
562  for (unsigned int j = 0; j < halfWidth; ++j) {
563  U = static_cast<int>(((*iU) - 128) * 0.354);
564  ++iU;
565  U5 = 5 * U;
566  V = static_cast<int>(((*iV) - 128) * 0.707);
567  ++iV;
568  V2 = 2 * V;
569  UV = -U - V;
570  Y0 = *yuv;
571  ++yuv;
572  Y1 = *yuv;
573  yuv = yuv + (width - 1);
574  Y2 = *yuv;
575  ++yuv;
576  Y3 = *yuv;
577  yuv = (yuv - width) + 1;
578 
579  // Original equations
580  // R = Y + 1.402 V
581  // G = Y - 0.344 U - 0.714 V
582  // B = Y + 1.772 U
583  R = Y0 + V2;
584  vpSAT(R);
585 
586  G = Y0 + UV;
587  vpSAT(G);
588 
589  B = Y0 + U5;
590  vpSAT(B);
591 
592  *rgba++ = static_cast<unsigned char>(R);
593  *rgba++ = static_cast<unsigned char>(G);
594  *rgba++ = static_cast<unsigned char>(B);
595  *rgba++ = vpRGBa::alpha_default;
596 
597  //---
598  R = Y1 + V2;
599  vpSAT(R);
600 
601  G = Y1 + UV;
602  vpSAT(G);
603 
604  B = Y1 + U5;
605  vpSAT(B);
606 
607  *rgba++ = static_cast<unsigned char>(R);
608  *rgba++ = static_cast<unsigned char>(G);
609  *rgba++ = static_cast<unsigned char>(B);
610  *rgba = vpRGBa::alpha_default;
611  rgba = (rgba + (4 * width)) - 7;
612 
613  //---
614  R = Y2 + V2;
615  vpSAT(R);
616 
617  G = Y2 + UV;
618  vpSAT(G);
619 
620  B = Y2 + U5;
621  vpSAT(B);
622 
623  *rgba++ = static_cast<unsigned char>(R);
624  *rgba++ = static_cast<unsigned char>(G);
625  *rgba++ = static_cast<unsigned char>(B);
626  *rgba++ = vpRGBa::alpha_default;
627 
628  //---
629  R = Y3 + V2;
630  vpSAT(R);
631 
632  G = Y3 + UV;
633  vpSAT(G);
634 
635  B = Y3 + U5;
636  vpSAT(B);
637 
638  *rgba++ = static_cast<unsigned char>(R);
639  *rgba++ = static_cast<unsigned char>(G);
640  *rgba++ = static_cast<unsigned char>(B);
641  *rgba = vpRGBa::alpha_default;
642  rgba = (rgba - (4 * width)) + 1;
643  }
644  yuv += width;
645  rgba += 4 * width;
646  }
647 }
648 
657 void vpImageConvert::YUV420ToRGB(unsigned char *yuv, unsigned char *rgb, unsigned int width, unsigned int height)
658 {
659  int U, V, R, G, B, V2, U5, UV;
660  int Y0, Y1, Y2, Y3;
661  unsigned int size = width * height;
662  unsigned char *iU = yuv + size;
663  unsigned char *iV = yuv + ((5 * size) / 4);
664  const unsigned int halfHeight = height / 2, halfWidth = width / 2;
665  for (unsigned int i = 0; i < halfHeight; ++i) {
666  for (unsigned int j = 0; j < halfWidth; ++j) {
667  U = static_cast<int>(((*iU) - 128) * 0.354);
668  ++iU;
669  U5 = 5 * U;
670  V = static_cast<int>(((*iV) - 128) * 0.707);
671  ++iV;
672  V2 = 2 * V;
673  UV = -U - V;
674  Y0 = *yuv;
675  ++yuv;
676  Y1 = *yuv;
677  yuv = yuv + (width - 1);
678  Y2 = *yuv;
679  ++yuv;
680  Y3 = *yuv;
681  yuv = (yuv - width) + 1;
682 
683  // Original equations
684  // R = Y + 1.402 V
685  // G = Y - 0.344 U - 0.714 V
686  // B = Y + 1.772 U
687  R = Y0 + V2;
688  vpSAT(R);
689 
690  G = Y0 + UV;
691  vpSAT(G);
692 
693  B = Y0 + U5;
694  vpSAT(B);
695 
696  *rgb++ = static_cast<unsigned char>(R);
697  *rgb++ = static_cast<unsigned char>(G);
698  *rgb++ = static_cast<unsigned char>(B);
699 
700  //---
701  R = Y1 + V2;
702  vpSAT(R);
703 
704  G = Y1 + UV;
705  vpSAT(G);
706 
707  B = Y1 + U5;
708  vpSAT(B);
709 
710  *rgb++ = static_cast<unsigned char>(R);
711  *rgb++ = static_cast<unsigned char>(G);
712  *rgb = static_cast<unsigned char>(B);
713  rgb = rgb + ((3 * width) - 5);
714 
715  //---
716  R = Y2 + V2;
717  vpSAT(R);
718 
719  G = Y2 + UV;
720  vpSAT(G);
721 
722  B = Y2 + U5;
723  vpSAT(B);
724 
725  *rgb++ = static_cast<unsigned char>(R);
726  *rgb++ = static_cast<unsigned char>(G);
727  *rgb++ = static_cast<unsigned char>(B);
728 
729  //---
730  R = Y3 + V2;
731  vpSAT(R);
732 
733  G = Y3 + UV;
734  vpSAT(G);
735 
736  B = Y3 + U5;
737  vpSAT(B);
738 
739  *rgb++ = static_cast<unsigned char>(R);
740  *rgb++ = static_cast<unsigned char>(G);
741  *rgb = static_cast<unsigned char>(B);
742  rgb = (rgb - (3 * width)) + 1;
743  }
744  yuv += width;
745  rgb += 3 * width;
746  }
747 }
748 
756 void vpImageConvert::YUV420ToGrey(unsigned char *yuv, unsigned char *grey, unsigned int size)
757 {
758  for (unsigned int i = 0; i < size; ++i) {
759  *grey++ = *yuv;
760  ++yuv;
761  }
762 }
763 
773 void vpImageConvert::YUV444ToRGBa(unsigned char *yuv, unsigned char *rgba, unsigned int size)
774 {
775  for (unsigned int i = 0; i < size; ++i) {
776  int U = static_cast<int>((*yuv - 128) * 0.354);
777  ++yuv;
778  int U5 = 5 * U;
779  int Y = *yuv;
780  ++yuv;
781  int V = static_cast<int>((*yuv - 128) * 0.707);
782  ++yuv;
783  int V2 = 2 * V;
784  int UV = -U - V;
785 
786  // Original equations
787  // R = Y + 1.402 V
788  // G = Y - 0.344 U - 0.714 V
789  // B = Y + 1.772 U
790  int R = Y + V2;
791  vpSAT(R);
792 
793  int G = Y + UV;
794  vpSAT(G);
795 
796  int B = Y + U5;
797  vpSAT(B);
798 
799  *rgba++ = static_cast<unsigned char>(R);
800  *rgba++ = static_cast<unsigned char>(G);
801  *rgba++ = static_cast<unsigned char>(B);
802  *rgba++ = vpRGBa::alpha_default;
803  }
804 }
805 
813 void vpImageConvert::YUV444ToRGB(unsigned char *yuv, unsigned char *rgb, unsigned int size)
814 {
815  for (unsigned int i = 0; i < size; ++i) {
816  int U = static_cast<int>((*yuv - 128) * 0.354);
817  ++yuv;
818  int U5 = 5 * U;
819  int Y = *yuv;
820  ++yuv;
821  int V = static_cast<int>((*yuv - 128) * 0.707);
822  ++yuv;
823  int V2 = 2 * V;
824  int UV = -U - V;
825 
826  // Original equations
827  // R = Y + 1.402 V
828  // G = Y - 0.344 U - 0.714 V
829  // B = Y + 1.772 U
830  int R = Y + V2;
831  vpSAT(R);
832 
833  int G = Y + UV;
834  vpSAT(G);
835 
836  int B = Y + U5;
837  vpSAT(B);
838 
839  *rgb++ = static_cast<unsigned char>(R);
840  *rgb++ = static_cast<unsigned char>(G);
841  *rgb++ = static_cast<unsigned char>(B);
842  }
843 }
844 
852 void vpImageConvert::YUV444ToGrey(unsigned char *yuv, unsigned char *grey, unsigned int size)
853 {
854  ++yuv;
855  for (unsigned int i = 0; i < size; ++i) {
856  *grey++ = *yuv;
857  yuv = yuv + 3;
858  }
859 }
860 
871 void vpImageConvert::YV12ToRGBa(unsigned char *yuv, unsigned char *rgba, unsigned int width, unsigned int height)
872 {
873  int U, V, R, G, B, V2, U5, UV;
874  int Y0, Y1, Y2, Y3;
875  unsigned int size = width * height;
876  unsigned char *iV = yuv + size;
877  unsigned char *iU = yuv + ((5 * size) / 4);
878  const unsigned int halfHeight = height / 2, halfWidth = width / 2;
879  for (unsigned int i = 0; i < halfHeight; ++i) {
880  for (unsigned int j = 0; j < halfWidth; ++j) {
881  U = static_cast<int>(((*iU) - 128) * 0.354);
882  ++iU;
883  U5 = 5 * U;
884  V = static_cast<int>(((*iV) - 128) * 0.707);
885  ++iV;
886  V2 = 2 * V;
887  UV = -U - V;
888  Y0 = *yuv;
889  ++yuv;
890  Y1 = *yuv;
891  yuv = yuv + (width - 1);
892  Y2 = *yuv;
893  ++yuv;
894  Y3 = *yuv;
895  yuv = (yuv - width) + 1;
896 
897  // Original equations
898  // R = Y + 1.402 V
899  // G = Y - 0.344 U - 0.714 V
900  // B = Y + 1.772 U
901  R = Y0 + V2;
902  vpSAT(R);
903 
904  G = Y0 + UV;
905  vpSAT(G);
906 
907  B = Y0 + U5;
908  vpSAT(B);
909 
910  *rgba++ = static_cast<unsigned char>(R);
911  *rgba++ = static_cast<unsigned char>(G);
912  *rgba++ = static_cast<unsigned char>(B);
913  *rgba++ = vpRGBa::alpha_default;
914 
915  //---
916  R = Y1 + V2;
917  vpSAT(R);
918 
919  G = Y1 + UV;
920  vpSAT(G);
921 
922  B = Y1 + U5;
923  vpSAT(B);
924 
925  *rgba++ = static_cast<unsigned char>(R);
926  *rgba++ = static_cast<unsigned char>(G);
927  *rgba++ = static_cast<unsigned char>(B);
928  *rgba = 0;
929  rgba = rgba + ((4 * width) - 7);
930 
931  //---
932  R = Y2 + V2;
933  vpSAT(R);
934 
935  G = Y2 + UV;
936  vpSAT(G);
937 
938  B = Y2 + U5;
939  vpSAT(B);
940 
941  *rgba++ = static_cast<unsigned char>(R);
942  *rgba++ = static_cast<unsigned char>(G);
943  *rgba++ = static_cast<unsigned char>(B);
944  *rgba++ = vpRGBa::alpha_default;
945 
946  //---
947  R = Y3 + V2;
948  vpSAT(R);
949 
950  G = Y3 + UV;
951  vpSAT(G);
952 
953  B = Y3 + U5;
954  vpSAT(B);
955 
956  *rgba++ = static_cast<unsigned char>(R);
957  *rgba++ = static_cast<unsigned char>(G);
958  *rgba++ = static_cast<unsigned char>(B);
959  *rgba = vpRGBa::alpha_default;
960  rgba = (rgba - (4 * width)) + 1;
961  }
962  yuv += width;
963  rgba += 4 * width;
964  }
965 }
966 
975 void vpImageConvert::YV12ToRGB(unsigned char *yuv, unsigned char *rgb, unsigned int height, unsigned int width)
976 {
977  int U, V, R, G, B, V2, U5, UV;
978  int Y0, Y1, Y2, Y3;
979  unsigned int size = width * height;
980  unsigned char *iV = yuv + size;
981  unsigned char *iU = yuv + ((5 * size) / 4);
982  const unsigned int halfHeight = height / 2, halfWidth = width / 2;
983  for (unsigned int i = 0; i < halfHeight; ++i) {
984  for (unsigned int j = 0; j < halfWidth; ++j) {
985  U = static_cast<int>(((*iU) - 128) * 0.354);
986  ++iU;
987  U5 = 5 * U;
988  V = static_cast<int>(((*iV) - 128) * 0.707);
989  ++iV;
990  V2 = 2 * V;
991  UV = -U - V;
992  Y0 = *yuv;
993  ++yuv;
994  Y1 = *yuv;
995  yuv = yuv + (width - 1);
996  Y2 = *yuv;
997  ++yuv;
998  Y3 = *yuv;
999  yuv = (yuv - width) + 1;
1000 
1001  // Original equations
1002  // R = Y + 1.402 V
1003  // G = Y - 0.344 U - 0.714 V
1004  // B = Y + 1.772 U
1005  R = Y0 + V2;
1006  vpSAT(R);
1007 
1008  G = Y0 + UV;
1009  vpSAT(G);
1010 
1011  B = Y0 + U5;
1012  vpSAT(B);
1013 
1014  *rgb++ = static_cast<unsigned char>(R);
1015  *rgb++ = static_cast<unsigned char>(G);
1016  *rgb++ = static_cast<unsigned char>(B);
1017 
1018  //---
1019  R = Y1 + V2;
1020  vpSAT(R);
1021 
1022  G = Y1 + UV;
1023  vpSAT(G);
1024 
1025  B = Y1 + U5;
1026  vpSAT(B);
1027 
1028  *rgb++ = static_cast<unsigned char>(R);
1029  *rgb++ = static_cast<unsigned char>(G);
1030  *rgb = static_cast<unsigned char>(B);
1031  rgb = rgb + ((3 * width) - 5);
1032 
1033  //---
1034  R = Y2 + V2;
1035  vpSAT(R);
1036 
1037  G = Y2 + UV;
1038  vpSAT(G);
1039 
1040  B = Y2 + U5;
1041  vpSAT(B);
1042 
1043  *rgb++ = static_cast<unsigned char>(R);
1044  *rgb++ = static_cast<unsigned char>(G);
1045  *rgb++ = static_cast<unsigned char>(B);
1046 
1047  //---
1048  R = Y3 + V2;
1049  vpSAT(R);
1050 
1051  G = Y3 + UV;
1052  vpSAT(G);
1053 
1054  B = Y3 + U5;
1055  vpSAT(B);
1056 
1057  *rgb++ = static_cast<unsigned char>(R);
1058  *rgb++ = static_cast<unsigned char>(G);
1059  *rgb = static_cast<unsigned char>(B);
1060  rgb = (rgb - (3 * width)) + 1;
1061  }
1062  yuv += width;
1063  rgb += 3 * width;
1064  }
1065 }
1066 
1077 void vpImageConvert::YVU9ToRGBa(unsigned char *yuv, unsigned char *rgba, unsigned int width, unsigned int height)
1078 {
1079  int U, V, R, G, B, V2, U5, UV;
1080  int Y0, Y1, Y2, Y3, Y4, Y5, Y6, Y7, Y8, Y9, Y10, Y11, Y12, Y13, Y14, Y15;
1081  unsigned int size = width * height;
1082  unsigned char *iV = yuv + size;
1083  unsigned char *iU = yuv + ((17 * size) / 16);
1084  const unsigned int quarterHeight = height / 4, quarterWidth = width / 4;
1085  for (unsigned int i = 0; i < quarterHeight; ++i) {
1086  for (unsigned int j = 0; j < quarterWidth; ++j) {
1087  U = static_cast<int>(((*iU) - 128) * 0.354);
1088  ++iU;
1089  U5 = 5 * U;
1090  V = static_cast<int>(((*iV) - 128) * 0.707);
1091  ++iV;
1092  V2 = 2 * V;
1093  UV = -U - V;
1094  Y0 = *yuv;
1095  ++yuv;
1096  Y1 = *yuv;
1097  ++yuv;
1098  Y2 = *yuv;
1099  ++yuv;
1100  Y3 = *yuv;
1101  yuv = yuv + (width - 3);
1102  Y4 = *yuv;
1103  ++yuv;
1104  Y5 = *yuv;
1105  ++yuv;
1106  Y6 = *yuv;
1107  ++yuv;
1108  Y7 = *yuv;
1109  yuv = yuv + (width - 3);
1110  Y8 = *yuv;
1111  ++yuv;
1112  Y9 = *yuv;
1113  ++yuv;
1114  Y10 = *yuv;
1115  ++yuv;
1116  Y11 = *yuv;
1117  yuv = yuv + (width - 3);
1118  Y12 = *yuv;
1119  ++yuv;
1120  Y13 = *yuv;
1121  ++yuv;
1122  Y14 = *yuv;
1123  ++yuv;
1124  Y15 = *yuv;
1125  yuv = (yuv - (3 * width)) + 1;
1126 
1127  // Original equations
1128  // R = Y + 1.402 V
1129  // G = Y - 0.344 U - 0.714 V
1130  // B = Y + 1.772 U
1131  R = Y0 + V2;
1132  vpSAT(R);
1133 
1134  G = Y0 + UV;
1135  vpSAT(G);
1136 
1137  B = Y0 + U5;
1138  vpSAT(B);
1139 
1140  *rgba++ = static_cast<unsigned char>(R);
1141  *rgba++ = static_cast<unsigned char>(G);
1142  *rgba++ = static_cast<unsigned char>(B);
1143  *rgba++ = vpRGBa::alpha_default;
1144 
1145  //---
1146  R = Y1 + V2;
1147  vpSAT(R);
1148 
1149  G = Y1 + UV;
1150  vpSAT(G);
1151 
1152  B = Y1 + U5;
1153  vpSAT(B);
1154 
1155  *rgba++ = static_cast<unsigned char>(R);
1156  *rgba++ = static_cast<unsigned char>(G);
1157  *rgba++ = static_cast<unsigned char>(B);
1158  *rgba++ = vpRGBa::alpha_default;
1159 
1160  //---
1161  R = Y2 + V2;
1162  vpSAT(R);
1163 
1164  G = Y2 + UV;
1165  vpSAT(G);
1166 
1167  B = Y2 + U5;
1168  vpSAT(B);
1169 
1170  *rgba++ = static_cast<unsigned char>(R);
1171  *rgba++ = static_cast<unsigned char>(G);
1172  *rgba++ = static_cast<unsigned char>(B);
1173  *rgba++ = vpRGBa::alpha_default;
1174 
1175  //---
1176  R = Y3 + V2;
1177  vpSAT(R);
1178 
1179  G = Y3 + UV;
1180  vpSAT(G);
1181 
1182  B = Y3 + U5;
1183  vpSAT(B);
1184 
1185  *rgba++ = static_cast<unsigned char>(R);
1186  *rgba++ = static_cast<unsigned char>(G);
1187  *rgba++ = static_cast<unsigned char>(B);
1188  *rgba = vpRGBa::alpha_default;
1189  rgba = rgba + ((4 * width) - 15);
1190 
1191  R = Y4 + V2;
1192  vpSAT(R);
1193 
1194  G = Y4 + UV;
1195  vpSAT(G);
1196 
1197  B = Y4 + U5;
1198  vpSAT(B);
1199 
1200  *rgba++ = static_cast<unsigned char>(R);
1201  *rgba++ = static_cast<unsigned char>(G);
1202  *rgba++ = static_cast<unsigned char>(B);
1203  *rgba++ = vpRGBa::alpha_default;
1204 
1205  //---
1206  R = Y5 + V2;
1207  vpSAT(R);
1208 
1209  G = Y5 + UV;
1210  vpSAT(G);
1211 
1212  B = Y5 + U5;
1213  vpSAT(B);
1214 
1215  *rgba++ = static_cast<unsigned char>(R);
1216  *rgba++ = static_cast<unsigned char>(G);
1217  *rgba++ = static_cast<unsigned char>(B);
1218  *rgba++ = vpRGBa::alpha_default;
1219 
1220  //---
1221  R = Y6 + V2;
1222  vpSAT(R);
1223 
1224  G = Y6 + UV;
1225  vpSAT(G);
1226 
1227  B = Y6 + U5;
1228  vpSAT(B);
1229 
1230  *rgba++ = static_cast<unsigned char>(R);
1231  *rgba++ = static_cast<unsigned char>(G);
1232  *rgba++ = static_cast<unsigned char>(B);
1233  *rgba++ = vpRGBa::alpha_default;
1234 
1235  //---
1236  R = Y7 + V2;
1237  vpSAT(R);
1238 
1239  G = Y7 + UV;
1240  vpSAT(G);
1241 
1242  B = Y7 + U5;
1243  vpSAT(B);
1244 
1245  *rgba++ = static_cast<unsigned char>(R);
1246  *rgba++ = static_cast<unsigned char>(G);
1247  *rgba++ = static_cast<unsigned char>(B);
1248  *rgba = vpRGBa::alpha_default;
1249  rgba = rgba + ((4 * width) - 15);
1250 
1251  R = Y8 + V2;
1252  vpSAT(R);
1253 
1254  G = Y8 + UV;
1255  vpSAT(G);
1256 
1257  B = Y8 + U5;
1258  vpSAT(B);
1259 
1260  *rgba++ = static_cast<unsigned char>(R);
1261  *rgba++ = static_cast<unsigned char>(G);
1262  *rgba++ = static_cast<unsigned char>(B);
1263  *rgba++ = vpRGBa::alpha_default;
1264 
1265  //---
1266  R = Y9 + V2;
1267  vpSAT(R);
1268 
1269  G = Y9 + UV;
1270  vpSAT(G);
1271 
1272  B = Y9 + U5;
1273  vpSAT(B);
1274 
1275  *rgba++ = static_cast<unsigned char>(R);
1276  *rgba++ = static_cast<unsigned char>(G);
1277  *rgba++ = static_cast<unsigned char>(B);
1278  *rgba++ = vpRGBa::alpha_default;
1279 
1280  //---
1281  R = Y10 + V2;
1282  vpSAT(R);
1283 
1284  G = Y10 + UV;
1285  vpSAT(G);
1286 
1287  B = Y10 + U5;
1288  vpSAT(B);
1289 
1290  *rgba++ = static_cast<unsigned char>(R);
1291  *rgba++ = static_cast<unsigned char>(G);
1292  *rgba++ = static_cast<unsigned char>(B);
1293  *rgba++ = vpRGBa::alpha_default;
1294 
1295  //---
1296  R = Y11 + V2;
1297  vpSAT(R);
1298 
1299  G = Y11 + UV;
1300  vpSAT(G);
1301 
1302  B = Y11 + U5;
1303  vpSAT(B);
1304 
1305  *rgba++ = static_cast<unsigned char>(R);
1306  *rgba++ = static_cast<unsigned char>(G);
1307  *rgba++ = static_cast<unsigned char>(B);
1308  *rgba = vpRGBa::alpha_default;
1309  rgba = rgba + ((4 * width) - 15);
1310 
1311  R = Y12 + V2;
1312  vpSAT(R);
1313 
1314  G = Y12 + UV;
1315  vpSAT(G);
1316 
1317  B = Y12 + U5;
1318  vpSAT(B);
1319 
1320  *rgba++ = static_cast<unsigned char>(R);
1321  *rgba++ = static_cast<unsigned char>(G);
1322  *rgba++ = static_cast<unsigned char>(B);
1323  *rgba++ = vpRGBa::alpha_default;
1324 
1325  //---
1326  R = Y13 + V2;
1327  vpSAT(R);
1328 
1329  G = Y13 + UV;
1330  vpSAT(G);
1331 
1332  B = Y13 + U5;
1333  vpSAT(B);
1334 
1335  *rgba++ = static_cast<unsigned char>(R);
1336  *rgba++ = static_cast<unsigned char>(G);
1337  *rgba++ = static_cast<unsigned char>(B);
1338  *rgba++ = vpRGBa::alpha_default;
1339 
1340  //---
1341  R = Y14 + V2;
1342  vpSAT(R);
1343 
1344  G = Y14 + UV;
1345  vpSAT(G);
1346 
1347  B = Y14 + U5;
1348  vpSAT(B);
1349 
1350  *rgba++ = static_cast<unsigned char>(R);
1351  *rgba++ = static_cast<unsigned char>(G);
1352  *rgba++ = static_cast<unsigned char>(B);
1353  *rgba++ = vpRGBa::alpha_default;
1354 
1355  //---
1356  R = Y15 + V2;
1357  vpSAT(R);
1358 
1359  G = Y15 + UV;
1360  vpSAT(G);
1361 
1362  B = Y15 + U5;
1363  vpSAT(B);
1364 
1365  *rgba++ = static_cast<unsigned char>(R);
1366  *rgba++ = static_cast<unsigned char>(G);
1367  *rgba++ = static_cast<unsigned char>(B);
1368  *rgba = vpRGBa::alpha_default;
1369  rgba = (rgba - (12 * width)) + 1;
1370  }
1371  yuv += 3 * width;
1372  rgba += 12 * width;
1373  }
1374 }
1375 
1383 void vpImageConvert::YVU9ToRGB(unsigned char *yuv, unsigned char *rgb, unsigned int height, unsigned int width)
1384 {
1385  int U, V, R, G, B, V2, U5, UV;
1386  int Y0, Y1, Y2, Y3, Y4, Y5, Y6, Y7, Y8, Y9, Y10, Y11, Y12, Y13, Y14, Y15;
1387  unsigned int size = width * height;
1388  unsigned char *iV = yuv + size;
1389  unsigned char *iU = yuv + ((17 * size) / 16);
1390  const unsigned int quarterHeight = height / 4, quarterWidth = width / 4;
1391  for (unsigned int i = 0; i < quarterHeight; ++i) {
1392  for (unsigned int j = 0; j < quarterWidth; ++j) {
1393  U = static_cast<int>((*iU - 128) * 0.354);
1394  ++iU;
1395  U5 = 5 * U;
1396  V = static_cast<int>((*iV - 128) * 0.707);
1397  ++iV;
1398  V2 = 2 * V;
1399  UV = -U - V;
1400  Y0 = *yuv;
1401  ++yuv;
1402  Y1 = *yuv;
1403  ++yuv;
1404  Y2 = *yuv;
1405  ++yuv;
1406  Y3 = *yuv;
1407  yuv = yuv + (width - 3);
1408  Y4 = *yuv;
1409  ++yuv;
1410  Y5 = *yuv;
1411  ++yuv;
1412  Y6 = *yuv;
1413  ++yuv;
1414  Y7 = *yuv;
1415  yuv = yuv + (width - 3);
1416  Y8 = *yuv;
1417  ++yuv;
1418  Y9 = *yuv;
1419  ++yuv;
1420  Y10 = *yuv;
1421  ++yuv;
1422  Y11 = *yuv;
1423  yuv = yuv + (width - 3);
1424  Y12 = *yuv;
1425  ++yuv;
1426  Y13 = *yuv;
1427  ++yuv;
1428  Y14 = *yuv;
1429  ++yuv;
1430  Y15 = *yuv;
1431  yuv = (yuv - (3 * width)) + 1;
1432 
1433  // Original equations
1434  // R = Y + 1.402 V
1435  // G = Y - 0.344 U - 0.714 V
1436  // B = Y + 1.772 U
1437  R = Y0 + V2;
1438  vpSAT(R);
1439 
1440  G = Y0 + UV;
1441  vpSAT(G);
1442 
1443  B = Y0 + U5;
1444  vpSAT(B);
1445 
1446  *rgb++ = static_cast<unsigned char>(R);
1447  *rgb++ = static_cast<unsigned char>(G);
1448  *rgb++ = static_cast<unsigned char>(B);
1449 
1450  //---
1451  R = Y1 + V2;
1452  vpSAT(R);
1453 
1454  G = Y1 + UV;
1455  vpSAT(G);
1456 
1457  B = Y1 + U5;
1458  vpSAT(B);
1459 
1460  *rgb++ = static_cast<unsigned char>(R);
1461  *rgb++ = static_cast<unsigned char>(G);
1462  *rgb++ = static_cast<unsigned char>(B);
1463 
1464  //---
1465  R = Y2 + V2;
1466  vpSAT(R);
1467 
1468  G = Y2 + UV;
1469  vpSAT(G);
1470 
1471  B = Y2 + U5;
1472  vpSAT(B);
1473 
1474  *rgb++ = static_cast<unsigned char>(R);
1475  *rgb++ = static_cast<unsigned char>(G);
1476  *rgb++ = static_cast<unsigned char>(B);
1477 
1478  //---
1479  R = Y3 + V2;
1480  vpSAT(R);
1481 
1482  G = Y3 + UV;
1483  vpSAT(G);
1484 
1485  B = Y3 + U5;
1486  vpSAT(B);
1487 
1488  *rgb++ = static_cast<unsigned char>(R);
1489  *rgb++ = static_cast<unsigned char>(G);
1490  *rgb = static_cast<unsigned char>(B);
1491  rgb = rgb + ((3 * width) - 11);
1492 
1493  R = Y4 + V2;
1494  vpSAT(R);
1495 
1496  G = Y4 + UV;
1497  vpSAT(G);
1498 
1499  B = Y4 + U5;
1500  vpSAT(B);
1501 
1502  *rgb++ = static_cast<unsigned char>(R);
1503  *rgb++ = static_cast<unsigned char>(G);
1504  *rgb++ = static_cast<unsigned char>(B);
1505 
1506  //---
1507  R = Y5 + V2;
1508  vpSAT(R);
1509 
1510  G = Y5 + UV;
1511  vpSAT(G);
1512 
1513  B = Y5 + U5;
1514  vpSAT(B);
1515 
1516  *rgb++ = static_cast<unsigned char>(R);
1517  *rgb++ = static_cast<unsigned char>(G);
1518  *rgb++ = static_cast<unsigned char>(B);
1519 
1520  //---
1521  R = Y6 + V2;
1522  vpSAT(R);
1523 
1524  G = Y6 + UV;
1525  vpSAT(G);
1526 
1527  B = Y6 + U5;
1528  vpSAT(B);
1529 
1530  *rgb++ = static_cast<unsigned char>(R);
1531  *rgb++ = static_cast<unsigned char>(G);
1532  *rgb++ = static_cast<unsigned char>(B);
1533 
1534  //---
1535  R = Y7 + V2;
1536  vpSAT(R);
1537 
1538  G = Y7 + UV;
1539  vpSAT(G);
1540 
1541  B = Y7 + U5;
1542  vpSAT(B);
1543 
1544  *rgb++ = static_cast<unsigned char>(R);
1545  *rgb++ = static_cast<unsigned char>(G);
1546  *rgb = static_cast<unsigned char>(B);
1547  rgb = rgb + ((3 * width) - 11);
1548 
1549  R = Y8 + V2;
1550  vpSAT(R);
1551 
1552  G = Y8 + UV;
1553  vpSAT(G);
1554 
1555  B = Y8 + U5;
1556  vpSAT(B);
1557 
1558  *rgb++ = static_cast<unsigned char>(R);
1559  *rgb++ = static_cast<unsigned char>(G);
1560  *rgb++ = static_cast<unsigned char>(B);
1561 
1562  //---
1563  R = Y9 + V2;
1564  vpSAT(R);
1565 
1566  G = Y9 + UV;
1567  vpSAT(G);
1568 
1569  B = Y9 + U5;
1570  vpSAT(B);
1571 
1572  *rgb++ = static_cast<unsigned char>(R);
1573  *rgb++ = static_cast<unsigned char>(G);
1574  *rgb++ = static_cast<unsigned char>(B);
1575 
1576  //---
1577  R = Y10 + V2;
1578  vpSAT(R);
1579 
1580  G = Y10 + UV;
1581  vpSAT(G);
1582 
1583  B = Y10 + U5;
1584  vpSAT(B);
1585 
1586  *rgb++ = static_cast<unsigned char>(R);
1587  *rgb++ = static_cast<unsigned char>(G);
1588  *rgb++ = static_cast<unsigned char>(B);
1589 
1590  //---
1591  R = Y11 + V2;
1592  vpSAT(R);
1593 
1594  G = Y11 + UV;
1595  vpSAT(G);
1596 
1597  B = Y11 + U5;
1598  vpSAT(B);
1599 
1600  *rgb++ = static_cast<unsigned char>(R);
1601  *rgb++ = static_cast<unsigned char>(G);
1602  *rgb = static_cast<unsigned char>(B);
1603  rgb = (rgb + (3 * width)) - 11;
1604 
1605  R = Y12 + V2;
1606  vpSAT(R);
1607 
1608  G = Y12 + UV;
1609  vpSAT(G);
1610 
1611  B = Y12 + U5;
1612  vpSAT(B);
1613 
1614  *rgb++ = static_cast<unsigned char>(R);
1615  *rgb++ = static_cast<unsigned char>(G);
1616  *rgb++ = static_cast<unsigned char>(B);
1617 
1618  //---
1619  R = Y13 + V2;
1620  vpSAT(R);
1621 
1622  G = Y13 + UV;
1623  vpSAT(G);
1624 
1625  B = Y13 + U5;
1626  vpSAT(B);
1627 
1628  *rgb++ = static_cast<unsigned char>(R);
1629  *rgb++ = static_cast<unsigned char>(G);
1630  *rgb++ = static_cast<unsigned char>(B);
1631 
1632  //---
1633  R = Y14 + V2;
1634  vpSAT(R);
1635 
1636  G = Y14 + UV;
1637  vpSAT(G);
1638 
1639  B = Y14 + U5;
1640  vpSAT(B);
1641 
1642  *rgb++ = static_cast<unsigned char>(R);
1643  *rgb++ = static_cast<unsigned char>(G);
1644  *rgb++ = static_cast<unsigned char>(B);
1645 
1646  //---
1647  R = Y15 + V2;
1648  vpSAT(R);
1649 
1650  G = Y15 + UV;
1651  vpSAT(G);
1652 
1653  B = Y15 + U5;
1654  vpSAT(B);
1655 
1656  *rgb++ = static_cast<unsigned char>(R);
1657  *rgb++ = static_cast<unsigned char>(G);
1658  *rgb++ = static_cast<unsigned char>(B);
1659  rgb = (rgb - (9 * width)) + 1;
1660  }
1661  yuv += 3 * width;
1662  rgb += 9 * width;
1663  }
1664 }
vpImageConvert::YUV411ToGrey
static void YUV411ToGrey(unsigned char *yuv, unsigned char *grey, unsigned int size)
Definition: vpImageConvert_yuv.cpp:362
vpImageConvert::YVU9ToRGBa
static void YVU9ToRGBa(unsigned char *yuv, unsigned char *rgba, unsigned int width, unsigned int height)
Definition: vpImageConvert_yuv.cpp:1077
vpImageConvert::YUYVToRGBa
static void YUYVToRGBa(unsigned char *yuyv, unsigned char *rgba, unsigned int width, unsigned int height)
Definition: vpImageConvert_yuv.cpp:69
vpImageConvert::YUV422ToGrey
static void YUV422ToGrey(unsigned char *yuv, unsigned char *grey, unsigned int size)
Definition: vpImageConvert_yuv.cpp:443
vpImageConvert::YUV420ToRGBa
static void YUV420ToRGBa(unsigned char *yuv, unsigned char *rgba, unsigned int width, unsigned int height)
Definition: vpImageConvert_yuv.cpp:553
vpImageConvert::YUYVToGrey
static void YUYVToGrey(unsigned char *yuyv, unsigned char *grey, unsigned int size)
Definition: vpImageConvert_yuv.cpp:191
vpImageConvert::YUV411ToRGBa
static void YUV411ToRGBa(unsigned char *yuv, unsigned char *rgba, unsigned int size)
Definition: vpImageConvert_yuv.cpp:211
vpImageConvert::YUV420ToGrey
static void YUV420ToGrey(unsigned char *yuv, unsigned char *grey, unsigned int size)
Definition: vpImageConvert_yuv.cpp:756
vpImageConvert::YVU9ToRGB
static void YVU9ToRGB(unsigned char *yuv, unsigned char *rgb, unsigned int width, unsigned int height)
Definition: vpImageConvert_yuv.cpp:1383
vpImageConvert::YV12ToRGBa
static void YV12ToRGBa(unsigned char *yuv, unsigned char *rgba, unsigned int width, unsigned int height)
Definition: vpImageConvert_yuv.cpp:871
vpImageConvert::YUV444ToRGB
static void YUV444ToRGB(unsigned char *yuv, unsigned char *rgb, unsigned int size)
Definition: vpImageConvert_yuv.cpp:813
vpImageConvert::YUV411ToRGB
static void YUV411ToRGB(unsigned char *yuv, unsigned char *rgb, unsigned int size)
Definition: vpImageConvert_yuv.cpp:463
vpImageConvert::YUV422ToRGB
static void YUV422ToRGB(unsigned char *yuv, unsigned char *rgb, unsigned int size)
Definition: vpImageConvert_yuv.cpp:388
vpImageConvert::YUV422ToRGBa
static void YUV422ToRGBa(unsigned char *yuv, unsigned char *rgba, unsigned int size)
Definition: vpImageConvert_yuv.cpp:307
vpImageConvert::YV12ToRGB
static void YV12ToRGB(unsigned char *yuv, unsigned char *rgb, unsigned int width, unsigned int height)
Definition: vpImageConvert_yuv.cpp:975
vpImageConvert::YUV444ToRGBa
static void YUV444ToRGBa(unsigned char *yuv, unsigned char *rgba, unsigned int size)
Definition: vpImageConvert_yuv.cpp:773
vpImageConvert::YUV444ToGrey
static void YUV444ToGrey(unsigned char *yuv, unsigned char *grey, unsigned int size)
Definition: vpImageConvert_yuv.cpp:852
vpImageConvert::YUV420ToRGB
static void YUV420ToRGB(unsigned char *yuv, unsigned char *rgb, unsigned int width, unsigned int height)
Definition: vpImageConvert_yuv.cpp:657
vpImageConvert::YUYVToRGB
static void YUYVToRGB(unsigned char *yuyv, unsigned char *rgb, unsigned int width, unsigned int height)
Definition: vpImageConvert_yuv.cpp:131
vpRGBa::alpha_default
@ alpha_default
Definition: vpRGBa.h:63