wined3d: Consistently store format bitcounts in BYTEs.
[wine] / dlls / qcap / yuv.c
1 /* DirectShow capture services (QCAP.DLL)
2  *
3  * Copyright 2005 Maarten Lankhorst
4  *
5  * This file contains the part of the vfw capture interface that
6  * does the actual Video4Linux(1/2) stuff required for capturing
7  * and setting/getting media format..
8  *
9  * This library is free software; you can redistribute it and/or
10  * modify it under the terms of the GNU Lesser General Public
11  * License as published by the Free Software Foundation; either
12  * version 2.1 of the License, or (at your option) any later version.
13  *
14  * This library is distributed in the hope that it will be useful,
15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
17  * Lesser General Public License for more details.
18  *
19  * You should have received a copy of the GNU Lesser General Public
20  * License along with this library; if not, write to the Free Software
21  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
22  */
23
24 #include "config.h"
25 #include <stdarg.h>
26
27 #include "windef.h"
28 #include "wingdi.h"
29 #include "objbase.h"
30 #include "strmif.h"
31 #include "qcap_main.h"
32 #include "wine/debug.h"
33
34 /* This is not used if V4L support is missing */
35 #ifdef HAVE_LINUX_VIDEODEV_H
36
37 WINE_DEFAULT_DEBUG_CHANNEL(qcap);
38
39 static int yuv_xy[256]; /* Gray value */
40 static int yuv_gu[256]; /* Green U */
41 static int yuv_bu[256]; /* Blue  U */
42 static int yuv_rv[256]; /* Red   V */
43 static int yuv_gv[256]; /* Green V */
44 static int initialised = 0;
45
46 static inline int ValidRange(int in) {
47    if (in > 255) in = 255;
48    if (in < 0) in = 0;
49    return in;
50 }
51
52 typedef struct RGB {
53 #if 0 /* For some reason I have to revert R and B, not sure why */
54   unsigned char r, g, b;
55 #else
56   unsigned char b, g, r;
57 #endif
58 } RGB;
59
60 static inline void YUV2RGB(const unsigned char y_, const unsigned char cb, const unsigned char cr, RGB* retval) {
61    retval->r = ValidRange(yuv_xy[y_] + yuv_rv[cr]);
62    retval->g = ValidRange(yuv_xy[y_] + yuv_gu[cb] + yuv_gv[cr]);
63    retval->b = ValidRange(yuv_xy[y_] + yuv_bu[cb]);
64 }
65
66 void YUV_Init(void) {
67    float y, u, v;
68    int y_, cb, cr;
69
70    if (initialised++) return;
71
72    for (y_ = 0; y_ <= 255; y_++)
73    {
74       y = ((float) 255 / 219) * (y_ - 16);
75       yuv_xy[y_] = y;
76    }
77
78    for (cb = 0; cb <= 255; cb++)
79    {
80       u = ((float) 255 / 224) * (cb - 128);
81       yuv_gu[cb] = -0.344 * u;
82       yuv_bu[cb] =  1.772 * u;
83    }
84
85    for (cr = 0; cr <= 255; cr++)
86    {
87       v = ((float) 255 / 224) * (cr - 128);
88       yuv_rv[cr] =  1.402 * v;
89       yuv_gv[cr] = -0.714 * v;
90    }
91    TRACE("Filled hash table\n");
92 }
93
94 static void Parse_YUYV(unsigned char *destbuffer, const unsigned char *input, int width, int height)
95 {
96    const unsigned char *pY, *pCb, *pCr;
97    int togo = width * height / 2;
98    pY = input;
99    pCb = input+1;
100    pCr = input+3;
101    while (--togo) {
102       YUV2RGB(*pY, *pCb, *pCr, (RGB *)destbuffer);
103       pY += 2; destbuffer += 3;
104       YUV2RGB(*pY, *pCb, *pCr, (RGB *)destbuffer);
105       pY += 2; pCb += 4; pCr += 4; destbuffer += 3;
106    }
107 }
108
109 static void Parse_UYVY(unsigned char *destbuffer, const unsigned char *input, int width, int height)
110 {
111    const unsigned char *pY, *pCb, *pCr;
112    int togo = width * height / 2;
113    pY = input+1;
114    pCb = input;
115    pCr = input+2;
116    while (--togo) {
117       YUV2RGB(*pY, *pCb, *pCr, (RGB *)destbuffer);
118       pY += 2; destbuffer += 3;
119       YUV2RGB(*pY, *pCb, *pCr, (RGB *)destbuffer);
120       pY += 2; pCb += 4; pCr += 4; destbuffer += 3;
121    }
122 }
123
124 static void Parse_UYYVYY(unsigned char *destbuffer, const unsigned char *input, int width, int height)
125 {
126    const unsigned char *pY, *pCb, *pCr;
127    int togo = width * height / 4;
128    pY = input+1;
129    pCb = input;
130    pCr = input+4;
131    while (--togo) {
132       YUV2RGB(*pY, *pCb, *pCr, (RGB *)destbuffer);
133       destbuffer += 3; pY++;
134       YUV2RGB(*pY, *pCb, *pCr, (RGB *)destbuffer);
135       pY += 2; destbuffer += 3;
136       YUV2RGB(*pY, *pCb, *pCr, (RGB *)destbuffer);
137       destbuffer += 3; pY++;
138       YUV2RGB(*pY, *pCb, *pCr, (RGB *)destbuffer);
139       pY += 2; pCb += 6; pCr += 6; destbuffer += 3;
140    }
141 }
142
143 static void Parse_PYUV(unsigned char *destbuffer, const unsigned char *input, int width, int height, int wstep, int hstep)
144 {
145    /* We have 3 pointers, One to Y, one to Cb and 1 to Cr */
146
147 /* C19 *89* declaration block (Grr julliard for not allowing C99) */
148    int ysize, uvsize;
149    const unsigned char *pY, *pCb, *pCr;
150    int swstep = 0, shstep = 0;
151    int ypos = 0, xpos = 0;
152    int indexUV = 0, cUv;
153 /* End of Grr */
154
155    ysize = width * height;
156    uvsize = (width / wstep) * (height / hstep);
157    pY = input;
158    pCb = pY + ysize;
159    pCr = pCb + uvsize;
160    /* Bottom down DIB */
161    do {
162       swstep = 0;
163       cUv = indexUV;
164       for (xpos = 0; xpos < width; xpos++) {
165          YUV2RGB(*(pY++), pCb[cUv], pCr[cUv], (RGB *)destbuffer);
166          destbuffer += 3;
167          if (++swstep == wstep) {
168             cUv++;
169             swstep = 0;
170          }
171       }
172       if (++shstep == hstep) {
173          shstep = 0;
174          indexUV = cUv;
175       }
176    } while (++ypos < height);
177 }
178
179 void YUV_To_RGB24(enum YUV_Format format, unsigned char *target, const unsigned char *source, int width, int height) {
180    int wstep, hstep;
181    if (format < ENDPLANAR) {
182       switch (format) {
183          case YUVP_421: wstep = 2; hstep = 1; break;
184          case YUVP_422: wstep = 2; hstep = 2; break;
185          case YUVP_441: wstep = 4; hstep = 1; break;
186          case YUVP_444: wstep = 4; hstep = 4; break;
187          default: ERR("Unhandled format \"%d\"\n", format); return;
188       }
189       Parse_PYUV(target, source, width, height, wstep, hstep);
190    } else {
191       switch (format) {
192          case YUYV: Parse_YUYV(target, source, width, height); return;
193          case UYVY: Parse_UYVY(target, source, width, height); return;
194          case UYYVYY: Parse_UYYVYY(target, source, width, height); return;
195          default: ERR("Unhandled format \"%d\"\n", format); return;
196       }
197    }
198 }
199 #endif