source: eviacam/trunk/fuentes/creavision/colorspaces.cpp @ 29

Last change on this file since 29 was 29, checked in by mabarracus, 4 years ago

added eviacam content

  • Property svn:executable set to *
File size: 34.4 KB
Line 
1/*******************************************************************************#
2#           guvcview              http://guvcview.berlios.de                    #
3#                                                                               #
4#           Paulo Assis <pj.assis@gmail.com>                                    #
5#           Nobuhiro Iwamatsu <iwamatsu@nigauri.org>                            #
6#                                                                               #
7# This program is free software; you can redistribute it and/or modify          #
8# it under the terms of the GNU General Public License as published by          #
9# the Free Software Foundation; either version 2 of the License, or             #
10# (at your option) any later version.                                           #
11#                                                                               #
12# This program is distributed in the hope that it will be useful,               #
13# but WITHOUT ANY WARRANTY; without even the implied warranty of                #
14# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the                 #
15# GNU General Public License for more details.                                  #
16#                                                                               #
17# You should have received a copy of the GNU General Public License             #
18# along with this program; if not, write to the Free Software                   #
19# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA     #
20#                                                                               #
21********************************************************************************/
22
23#include <stdlib.h>
24#include <string.h>
25#include <glib.h>
26#include "colorspaces.h"
27//#include "v4l2uvc.h"
28
29/*------------------------------- Color space conversions --------------------*/
30/* regular yuv (YUYV) to rgb24*/
31void 
32yuyv2rgb (BYTE *pyuv, BYTE *prgb, int width, int height)
33{
34        int l=0;
35        int SizeYUV=height * width * 2; /* 2 bytes per pixel*/
36        for(l=0;l<SizeYUV;l=l+4) 
37        {       /*iterate every 4 bytes*/
38                /* standart: r = y0 + 1.402 (v-128) */
39                /* logitech: r = y0 + 1.370705 (v-128) */
40                *prgb++=CLIP(pyuv[l] + 1.402 * (pyuv[l+3]-128));
41                /* standart: g = y0 - 0.34414 (u-128) - 0.71414 (v-128)*/
42                /* logitech: g = y0 - 0.337633 (u-128)- 0.698001 (v-128)*/
43                *prgb++=CLIP(pyuv[l] - 0.34414 * (pyuv[l+1]-128) -0.71414*(pyuv[l+3]-128));
44                /* standart: b = y0 + 1.772 (u-128) */
45                /* logitech: b = y0 + 1.732446 (u-128) */
46                *prgb++=CLIP(pyuv[l] + 1.772 *( pyuv[l+1]-128));
47                /* standart: r1 =y1 + 1.402 (v-128) */
48                /* logitech: r1 = y1 + 1.370705 (v-128) */
49                *prgb++=CLIP(pyuv[l+2] + 1.402 * (pyuv[l+3]-128));
50                /* standart: g1 = y1 - 0.34414 (u-128) - 0.71414 (v-128)*/
51                /* logitech: g1 = y1 - 0.337633 (u-128)- 0.698001 (v-128)*/
52                *prgb++=CLIP(pyuv[l+2] - 0.34414 * (pyuv[l+1]-128) -0.71414 * (pyuv[l+3]-128));
53                /* standart: b1 = y1 + 1.772 (u-128) */
54                /* logitech: b1 = y1 + 1.732446 (u-128) */
55                *prgb++=CLIP(pyuv[l+2] + 1.772*(pyuv[l+1]-128));
56        }
57}
58
59/* used for rgb video (fourcc="RGB ")           */
60/* lines are on correct order                   */
61void 
62yuyv2bgr1 (BYTE *pyuv, BYTE *pbgr, int width, int height)
63{
64
65        int l=0;
66        int SizeYUV=height * width * 2; /* 2 bytes per pixel*/
67        for(l=0;l<SizeYUV;l=l+4) 
68        {       /*iterate every 4 bytes*/
69                /* standart: b = y0 + 1.772 (u-128) */
70                /* logitech: b = y0 + 1.732446 (u-128) */
71                *pbgr++=CLIP(pyuv[l] + 1.772 *( pyuv[l+1]-128));
72                /* standart: g = y0 - 0.34414 (u-128) - 0.71414 (v-128)*/
73                /* logitech: g = y0 - 0.337633 (u-128)- 0.698001 (v-128)*/
74                *pbgr++=CLIP(pyuv[l] - 0.34414 * (pyuv[l+1]-128) -0.71414*(pyuv[l+3]-128));
75                /* standart: r = y0 + 1.402 (v-128) */
76                /* logitech: r = y0 + 1.370705 (v-128) */
77                *pbgr++=CLIP(pyuv[l] + 1.402 * (pyuv[l+3]-128));
78                /* standart: b1 = y1 + 1.772 (u-128) */
79                /* logitech: b1 = y1 + 1.732446 (u-128) */
80                *pbgr++=CLIP(pyuv[l+2] + 1.772*(pyuv[l+1]-128));
81                /* standart: g1 = y1 - 0.34414 (u-128) - 0.71414 (v-128)*/
82                /* logitech: g1 = y1 - 0.337633 (u-128)- 0.698001 (v-128)*/
83                *pbgr++=CLIP(pyuv[l+2] - 0.34414 * (pyuv[l+1]-128) -0.71414 * (pyuv[l+3]-128));
84                /* standart: r1 =y1 + 1.402 (v-128) */
85                /* logitech: r1 = y1 + 1.370705 (v-128) */
86                *pbgr++=CLIP(pyuv[l+2] + 1.402 * (pyuv[l+3]-128));
87        }
88}
89
90/* yuv (YUYV) to bgr with lines upsidedown */
91/* used for bitmap files (DIB24)           */
92void 
93yuyv2bgr (BYTE *pyuv, BYTE *pbgr, int width, int height)
94{
95
96        int l=0;
97        int k=0;
98        BYTE *preverse;
99        int bytesUsed;
100        int SizeBGR=height * width * 3; /* 3 bytes per pixel*/
101        /* BMP byte order is bgr and the lines start from last to first*/
102        preverse=pbgr+SizeBGR;/*start at the end and decrement*/
103        for(l=0;l<height;l++) 
104        {       /*iterate every 1 line*/
105                preverse-=width*3;/*put pointer at begin of unprocessed line*/
106                bytesUsed=l*width*2;
107                for (k=0;k<(width*2);k=k+4)/*iterate every 4 bytes in the line*/
108                {                             
109                        /* standart: b = y0 + 1.772 (u-128) */
110                        /* logitech: b = y0 + 1.732446 (u-128) */
111                        *preverse++=CLIP(pyuv[k+bytesUsed] + 1.772 *( pyuv[k+1+bytesUsed]-128)); 
112                        /* standart: g = y0 - 0.34414 (u-128) - 0.71414 (v-128)*/
113                        /* logitech: g = y0 - 0.337633 (u-128)- 0.698001 (v-128)*/
114                        *preverse++=CLIP(pyuv[k+bytesUsed] - 0.34414 * (pyuv[k+1+bytesUsed]-128) 
115                                -0.71414*(pyuv[k+3+bytesUsed]-128));
116                        /* standart: r = y0 + 1.402 (v-128) */
117                        /* logitech: r = y0 + 1.370705 (v-128) */
118                        *preverse++=CLIP(pyuv[k+bytesUsed] + 1.402 * (pyuv[k+3+bytesUsed]-128));
119                        /* standart: b1 = y1 + 1.772 (u-128) */
120                        /* logitech: b1 = y1 + 1.732446 (u-128) */
121                        *preverse++=CLIP(pyuv[k+2+bytesUsed] + 1.772*(pyuv[k+1+bytesUsed]-128));
122                        /* standart: g1 = y1 - 0.34414 (u-128) - 0.71414 (v-128)*/
123                        /* logitech: g1 = y1 - 0.337633 (u-128)- 0.698001 (v-128)*/
124                        *preverse++=CLIP(pyuv[k+2+bytesUsed] - 0.34414 * (pyuv[k+1+bytesUsed]-128) 
125                                -0.71414 * (pyuv[k+3+bytesUsed]-128)); 
126                        /* standart: r1 =y1 + 1.402 (v-128) */
127                        /* logitech: r1 = y1 + 1.370705 (v-128) */
128                        *preverse++=CLIP(pyuv[k+2+bytesUsed] + 1.402 * (pyuv[k+3+bytesUsed]-128));
129                }
130                preverse-=width*3;/*get it back at the begin of processed line*/
131        }
132        preverse=NULL;
133}
134
135/*convert yyuv (packed) to yuyv (packed)
136* args:
137*      framebuffer: pointer to frame buffer (yuyv)
138*      tmpbuffer: pointer to temp buffer containing yyuv packed data frame
139*      width: picture width
140*      height: picture height
141*/
142void yyuv_to_yuyv (BYTE *framebuffer, BYTE *tmpbuffer, int width, int height)
143{
144        BYTE *ptmp=NULL;
145        BYTE *pfmb=NULL;
146        ptmp = tmpbuffer;
147        pfmb = framebuffer;
148       
149        int h=0;
150        int w=0;
151       
152        for(h=0;h<height;h++) 
153        {
154                for(w=0;w<(width*2);w+=4) 
155                {
156                        /* Y0 */
157                        pfmb[0] = ptmp[0];
158                        /* U */
159                        pfmb[1] = ptmp[2];
160                        /* Y1 */
161                        pfmb[2] = ptmp[1];
162                        /* V */
163                        pfmb[3] = ptmp[3];
164                       
165                        ptmp += 4;
166                        pfmb += 4;
167                }
168        }
169}
170
171
172/*convert uyvy (packed) to yuyv (packed)
173* args:
174*      framebuffer: pointer to frame buffer (yuyv)
175*      tmpbuffer: pointer to temp buffer containing uyvy packed data frame
176*      width: picture width
177*      height: picture height
178*/
179void uyvy_to_yuyv (BYTE *framebuffer, BYTE *tmpbuffer, int width, int height)
180{
181        BYTE *ptmp = tmpbuffer;
182        BYTE *pfmb = framebuffer;
183        int h=0;
184        int w=0;
185       
186        for(h=0;h<height;h++) 
187        {
188                for(w=0;w<(width*2);w+=4) 
189                {
190                        /* Y0 */
191                        pfmb[0] = ptmp[1];
192                        /* U */
193                        pfmb[1] = ptmp[0];
194                        /* Y1 */
195                        pfmb[2] = ptmp[3];
196                        /* V */
197                        pfmb[3] = ptmp[2];
198                       
199                        ptmp += 4;
200                        pfmb += 4;
201                }
202        }
203}
204
205
206/*convert yvyu (packed) to yuyv (packed)
207* args:
208*      framebuffer: pointer to frame buffer (yuyv)
209*      tmpbuffer: pointer to temp buffer containing yvyu packed data frame
210*      width: picture width
211*      height: picture height
212*/
213void yvyu_to_yuyv (BYTE *framebuffer, BYTE *tmpbuffer, int width, int height)
214{
215        BYTE *ptmp=NULL;
216        BYTE *pfmb=NULL;
217        ptmp = tmpbuffer;
218        pfmb = framebuffer;
219       
220        int h=0;
221        int w=0;
222       
223        for(h=0;h<height;h++) 
224        {
225                for(w=0;w<(width*2);w+=4) 
226                {
227                        /* Y0 */
228                        pfmb[0] = ptmp[0];
229                        /* U */
230                        pfmb[1] = ptmp[3];
231                        /* Y1 */
232                        pfmb[2] = ptmp[2];
233                        /* V */
234                        pfmb[3] = ptmp[1];
235                       
236                        ptmp += 4;
237                        pfmb += 4;
238                }
239        }
240}
241
242/*convert yuv 420 planar (yu12) to yuv 422
243* args:
244*      framebuffer: pointer to frame buffer (yuyv)
245*      tmpbuffer: pointer to temp buffer containing yuv420 planar data frame
246*      width: picture width
247*      height: picture height
248*/
249void yuv420_to_yuyv (BYTE *framebuffer, BYTE *tmpbuffer, int width, int height) 
250{
251        BYTE *py;
252        BYTE *pu;
253        BYTE *pv;
254       
255        int linesize = width * 2;
256        int uvlinesize = width / 2;
257        int offset=0;
258        int offset1=0;
259        int offsety=0;
260        int offsety1=0;
261        int offsetuv=0;
262       
263        py=tmpbuffer;
264        pu=py+(width*height);
265        pv=pu+(width*height/4);
266       
267        int h=0;
268        int w=0;
269       
270        int wy=0;
271        int huv=0;
272        int wuv=0;
273       
274        for(h=0;h<height;h+=2) 
275        {
276                wy=0;
277                wuv=0;
278                offset = h * linesize;
279                offset1 = (h + 1) * linesize;
280                offsety = h * width;
281                offsety1 = (h + 1) * width;
282                offsetuv = huv * uvlinesize;
283               
284                for(w=0;w<linesize;w+=4) 
285                {
286                        /*y00*/
287                        framebuffer[w + offset] = py[wy + offsety];
288                        /*u0*/
289                        framebuffer[(w + 1) + offset] = pu[wuv + offsetuv];
290                        /*y01*/
291                        framebuffer[(w + 2) + offset] = py[(wy + 1) + offsety];
292                        /*v0*/
293                        framebuffer[(w + 3) + offset] = pv[wuv + offsetuv];
294                       
295                        /*y10*/
296                        framebuffer[w + offset1] = py[wy + offsety1];
297                        /*u0*/
298                        framebuffer[(w + 1) + offset1] = pu[wuv + offsetuv];
299                        /*y11*/
300                        framebuffer[(w + 2) + offset1] = py[(wy + 1) + offsety1];
301                        /*v0*/
302                        framebuffer[(w + 3) + offset1] = pv[wuv + offsetuv];
303                       
304                        wuv++;
305                        wy+=2;
306                }
307                huv++;
308        }
309}
310
311/*convert yvu 420 planar (yv12) to yuv 422
312* args:
313*      framebuffer: pointer to frame buffer (yuyv)
314*      tmpbuffer: pointer to temp buffer containing yuv420 planar data frame
315*      width: picture width
316*      height: picture height
317*/
318void yvu420_to_yuyv (BYTE *framebuffer, BYTE *tmpbuffer, int width, int height) 
319{
320        BYTE *py;
321        BYTE *pv;
322        BYTE *pu;
323       
324        int linesize = width * 2;
325        int uvlinesize = width / 2;
326        int offset=0;
327        int offset1=0;
328        int offsety=0;
329        int offsety1=0;
330        int offsetuv=0;
331       
332        py=tmpbuffer;
333        pv=py+(width*height);
334        pu=pv+((width*height)/4);
335       
336        int h=0;
337        int w=0;
338       
339        int wy=0;
340        int huv=0;
341        int wuv=0;
342       
343        for(h=0;h<height;h+=2) 
344        {
345                wy=0;
346                wuv=0;
347                offset = h * linesize;
348                offset1 = (h + 1) * linesize;
349                offsety = h * width;
350                offsety1 = (h + 1) * width;
351                offsetuv = huv * uvlinesize;
352               
353                for(w=0;w<linesize;w+=4) 
354                {
355                        /*y00*/
356                        framebuffer[w + offset] = py[wy + offsety];
357                        /*u0*/
358                        framebuffer[(w + 1) + offset] = pu[wuv + offsetuv];
359                        /*y01*/
360                        framebuffer[(w + 2) + offset] = py[(wy + 1) + offsety];
361                        /*v0*/
362                        framebuffer[(w + 3) + offset] = pv[wuv + offsetuv];
363                       
364                        /*y10*/
365                        framebuffer[w + offset1] = py[wy + offsety1];
366                        /*u0*/
367                        framebuffer[(w + 1) + offset1] = pu[wuv + offsetuv];
368                        /*y11*/
369                        framebuffer[(w + 2) + offset1] = py[(wy + 1) + offsety1];
370                        /*v0*/
371                        framebuffer[(w + 3) + offset1] = pv[wuv + offsetuv];
372                       
373                        wuv++;
374                        wy+=2;
375                }
376                huv++;
377        }
378}
379
380/*convert yuv 420 planar (uv interleaved) (nv12) to yuv 422
381* args:
382*      framebuffer: pointer to frame buffer (yuyv)
383*      tmpbuffer: pointer to temp buffer containing yuv420 (nv12) planar data frame
384*      width: picture width
385*      height: picture height
386*/
387void nv12_to_yuyv (BYTE *framebuffer, BYTE *tmpbuffer, int width, int height) 
388{
389        BYTE *py;
390        BYTE *puv;
391       
392        int linesize = width * 2;
393        int offset=0;
394        int offset1=0;
395        int offsety=0;
396        int offsety1=0;
397        int offsetuv=0;
398       
399        py=tmpbuffer;
400        puv=py+(width*height);
401       
402        int h=0;
403        int w=0;
404       
405        int wy=0;
406        int huv=0;
407        int wuv=0;
408       
409        for(h=0;h<height;h+=2) 
410        {
411                wy=0;
412                wuv=0;
413                offset = h * linesize;
414                offset1 = (h+1) * linesize;
415                offsety = h * width;
416                offsety1 = (h+1) * width;
417                offsetuv = huv * width;
418                for(w=0;w<linesize;w+=4) 
419                {
420                        /*y00*/
421                        framebuffer[w + offset] = py[wy + offsety];
422                        /*u0*/
423                        framebuffer[(w + 1) + offset] = puv[wuv + offsetuv];
424                        /*y01*/
425                        framebuffer[(w + 2) + offset] = py[(wy + 1) + offsety];
426                        /*v0*/
427                        framebuffer[(w + 3) + offset] = puv[(wuv + 1) + offsetuv];
428                       
429                        /*y10*/
430                        framebuffer[w + offset1] = py[wy + offsety1];
431                        /*u0*/
432                        framebuffer[(w + 1) + offset1] = puv[wuv + offsetuv];
433                        /*y11*/
434                        framebuffer[(w + 2) + offset1] = py[(wy + 1) + offsety1];
435                        /*v0*/
436                        framebuffer[(w + 3) + offset1] = puv[(wuv + 1) + offsetuv];
437                       
438                        wuv+=2;
439                        wy+=2;
440                }
441                huv++;
442        }
443}
444
445/*convert yuv 420 planar (vu interleaved) (nv21) to yuv 422
446* args:
447*      framebuffer: pointer to frame buffer (yuyv)
448*      tmpbuffer: pointer to temp buffer containing yuv420 (nv21) planar data frame
449*      width: picture width
450*      height: picture height
451*/
452void nv21_to_yuyv (BYTE *framebuffer, BYTE *tmpbuffer, int width, int height) 
453{
454        BYTE *py;
455        BYTE *puv;
456       
457        int linesize = width * 2;
458        int offset=0;
459        int offset1=0;
460        int offsety=0;
461        int offsety1=0;
462        int offsetuv=0;
463       
464        py=tmpbuffer;
465        puv=py+(width*height);
466       
467        int h=0;
468        int w=0;
469       
470        int wy=0;
471        int huv=0;
472        int wuv=0;
473       
474        for(h=0;h<height;h+=2) 
475        {
476                wy=0;
477                wuv=0;
478                offset = h * linesize;
479                offset1 = (h+1) * linesize;
480                offsety = h * width;
481                offsety1 = (h+1) * width;
482                offsetuv = huv * width;
483                for(w=0;w<linesize;w+=4) 
484                {
485                        /*y00*/
486                        framebuffer[w + offset] = py[wy + offsety];
487                        /*u0*/
488                        framebuffer[(w + 1) + offset] = puv[(wuv + 1) + offsetuv];
489                        /*y01*/
490                        framebuffer[(w + 2) + offset] = py[(wy + 1) + offsety];
491                        /*v0*/
492                        framebuffer[(w + 3) + offset] = puv[wuv + offsetuv];
493                       
494                        /*y10*/
495                        framebuffer[w + offset1] = py[wy + offsety1];
496                        /*u0*/
497                        framebuffer[(w + 1) + offset1] = puv[(wuv + 1) + offsetuv];
498                        /*y11*/
499                        framebuffer[(w + 2) + offset1] = py[(wy + 1) + offsety1];
500                        /*v0*/
501                        framebuffer[(w + 3) + offset1] = puv[wuv + offsetuv];
502                       
503                        wuv+=2;
504                        wy+=2;
505                }
506                huv++;
507        }
508}
509
510/*convert yuv 422 planar (uv interleaved) (nv16) to yuv 422
511* args:
512*      framebuffer: pointer to frame buffer (yuyv)
513*      tmpbuffer: pointer to temp buffer containing yuv422 (nv16) planar data frame
514*      width: picture width
515*      height: picture height
516*/
517void nv16_to_yuyv (BYTE *framebuffer, BYTE *tmpbuffer, int width, int height)
518{
519        BYTE *py;
520        BYTE *puv;
521       
522        int linesize = width * 2;
523        int offset=0;
524        int offsety=0;
525        int offsetuv=0;
526       
527        py=tmpbuffer;
528        puv=py+(width*height);
529       
530        int h=0;
531        int w=0;
532       
533        int wy=0;
534        int huv=0;
535        int wuv=0;
536       
537        for(h=0;h<height;h++) 
538        {
539                wy=0;
540                wuv=0;
541                offset = h * linesize;
542                offsety = h * width;
543                offsetuv = huv * width;
544                for(w=0;w<linesize;w+=4) 
545                {
546                        /*y00*/
547                        framebuffer[w + offset] = py[wy + offsety];
548                        /*u0*/
549                        framebuffer[(w + 1) + offset] = puv[wuv + offsetuv];
550                        /*y01*/
551                        framebuffer[(w + 2) + offset] = py[(wy + 1) + offsety];
552                        /*v0*/
553                        framebuffer[(w + 3) + offset] = puv[(wuv + 1) + offsetuv];
554                       
555                        wuv+=2;
556                        wy+=2;
557                }
558                huv++;
559        }
560}
561
562/*convert yuv 422 planar (vu interleaved) (nv61) to yuv 422
563* args:
564*      framebuffer: pointer to frame buffer (yuyv)
565*      tmpbuffer: pointer to temp buffer containing yuv422 (nv61) planar data frame
566*      width: picture width
567*      height: picture height
568*/
569void nv61_to_yuyv (BYTE *framebuffer, BYTE *tmpbuffer, int width, int height)
570{
571        BYTE *py;
572        BYTE *puv;
573       
574        int linesize = width * 2;
575        int offset=0;
576        int offsety=0;
577        int offsetuv=0;
578       
579        py=tmpbuffer;
580        puv=py+(width*height);
581       
582        int h=0;
583        int w=0;
584       
585        int wy=0;
586        int huv=0;
587        int wuv=0;
588       
589        for(h=0;h<height;h++) 
590        {
591                wy=0;
592                wuv=0;
593                offset = h * linesize;
594                offsety = h * width;
595                offsetuv = huv * width;
596                for(w=0;w<linesize;w+=4) 
597                {
598                        /*y00*/
599                        framebuffer[w + offset] = py[wy + offsety];
600                        /*u0*/
601                        framebuffer[(w + 1) + offset] = puv[(wuv + 1) + offsetuv];
602                        /*y01*/
603                        framebuffer[(w + 2) + offset] = py[(wy + 1) + offsety];
604                        /*v0*/
605                        framebuffer[(w + 3) + offset] = puv[wuv + offsetuv];
606                       
607                        wuv+=2;
608                        wy+=2;
609                }
610                huv++;
611        }
612}
613
614/*convert yuv 411 packed (y41p) to yuv 422
615* args:
616*      framebuffer: pointer to frame buffer (yuyv)
617*      tmpbuffer: pointer to temp buffer containing y41p data frame
618*      width: picture width
619*      height: picture height
620*/
621void y41p_to_yuyv (BYTE *framebuffer, BYTE *tmpbuffer, int width, int height)
622{
623        int h=0;
624        int w=0;
625        int linesize = width * 3 /2;
626        int offset = 0;
627       
628        for(h=0;h<height;h++)
629        {
630                offset = linesize * h;
631                for(w=0;w<linesize;w+=12)
632                {
633                        *framebuffer++=tmpbuffer[w+1 + offset]; //Y0
634                        *framebuffer++=tmpbuffer[w   + offset]; //U0
635                        *framebuffer++=tmpbuffer[w+3 + offset]; //Y1
636                        *framebuffer++=tmpbuffer[w+2 + offset]; //V0
637                        *framebuffer++=tmpbuffer[w+5 + offset]; //Y2
638                        *framebuffer++=tmpbuffer[w   + offset]; //U0
639                        *framebuffer++=tmpbuffer[w+7 + offset]; //Y3
640                        *framebuffer++=tmpbuffer[w+2 + offset]; //V0
641                        *framebuffer++=tmpbuffer[w+8 + offset]; //Y4
642                        *framebuffer++=tmpbuffer[w+4 + offset]; //U4
643                        *framebuffer++=tmpbuffer[w+9 + offset]; //Y5
644                        *framebuffer++=tmpbuffer[w+6 + offset]; //V4
645                        *framebuffer++=tmpbuffer[w+10+ offset]; //Y6
646                        *framebuffer++=tmpbuffer[w+4 + offset]; //U4
647                        *framebuffer++=tmpbuffer[w+11+ offset]; //Y7
648                        *framebuffer++=tmpbuffer[w+6 + offset]; //V4
649                }
650        }
651}
652
653/*convert yuv mono (grey) to yuv 422
654* args:
655*      framebuffer: pointer to frame buffer (yuyv)
656*      tmpbuffer: pointer to temp buffer containing grey (y only) data frame
657*      width: picture width
658*      height: picture height
659*/
660void grey_to_yuyv (BYTE *framebuffer, BYTE *tmpbuffer, int width, int height)
661{
662        int h=0;
663        int w=0;
664        int offset = 0;
665       
666        for(h=0;h<height;h++)
667        {
668                offset = width * h;
669                for(w=0;w<width;w++)
670                {
671                        *framebuffer++=tmpbuffer[w + offset]; //Y
672                        *framebuffer++=0x80;                  //U or V
673                }
674        }
675}
676
677/*convert SPCA501 (s501) to yuv 422
678* s501  |Y0..width..Y0|U..width/2..U|Y1..width..Y1|V..width/2..V|
679* signed values (-128;+127) must be converted to unsigned (0; 255)
680* args:
681*      framebuffer: pointer to frame buffer (yuyv)
682*      tmpbuffer: pointer to temp buffer containing s501 data frame
683*      width: picture width
684*      height: picture height
685*/
686void s501_to_yuyv(BYTE *framebuffer, BYTE *tmpbuffer, int width, int height)
687{
688        BYTE *U, *V, *Y0, *Y1;
689        BYTE *line2;
690        int h, w;
691
692        Y0 = tmpbuffer; /*fisrt line*/
693        for (h = 0; h < height/2; h++ ) 
694        {
695                line2 = framebuffer + width * 2;   /* next line          */
696                U = Y0 + width;
697                Y1 = U + width / 2;
698                V = Y1 + width;
699                for (w = width / 2; --w >= 0; ) 
700                {
701                        *framebuffer++ = (BYTE) (0x80 + *Y0++);
702                        *framebuffer++ = (BYTE) (0x80 + *U);
703                        *framebuffer++ = (BYTE) (0x80 + *Y0++);
704                        *framebuffer++ = (BYTE) (0x80 + *V);
705
706                        *line2++ = (BYTE) (0x80 + *Y1++);
707                        *line2++ = (BYTE) (0x80 + *U++);
708                        *line2++ = (BYTE) (0x80 + *Y1++);
709                        *line2++ = (BYTE) (0x80 + *V++);
710                }
711                Y0 += width * 2;                  /* next block of lines */
712                framebuffer = line2;
713        }
714}
715
716/*convert SPCA505 (s505) to yuv 422
717* s505  |Y0..width..Y0|Y1..width..Y1|U..width/2..U|V..width/2..V|
718* signed values (-128;+127) must be converted to unsigned (0; 255)
719* args:
720*      framebuffer: pointer to frame buffer (yuyv)
721*      tmpbuffer: pointer to temp buffer containing s501 data frame
722*      width: picture width
723*      height: picture height
724*/
725void s505_to_yuyv(BYTE *framebuffer, BYTE *tmpbuffer, int width, int height)
726{
727        BYTE *U, *V, *Y0, *Y1;
728        BYTE *line2;
729        int h, w;
730
731        Y0 = tmpbuffer; /*fisrt line*/
732        for (h = 0; h < height/2; h++ ) 
733        {
734                line2 = framebuffer + width * 2;   /* next line          */
735                Y1 = Y0 + width;
736                U  = Y1 + width;
737                V  = U + width/2;
738                for (w = width / 2; --w >= 0; ) 
739                {
740                        *framebuffer++ = (BYTE) (0x80 + *Y0++);
741                        *framebuffer++ = (BYTE) (0x80 + *U);
742                        *framebuffer++ = (BYTE) (0x80 + *Y0++);
743                        *framebuffer++ = (BYTE) (0x80 + *V);
744
745                        *line2++ = (BYTE) (0x80 + *Y1++);
746                        *line2++ = (BYTE) (0x80 + *U++);
747                        *line2++ = (BYTE) (0x80 + *Y1++);
748                        *line2++ = (BYTE) (0x80 + *V++);
749                }
750                Y0 += width * 2;                  /* next block of lines */
751                framebuffer = line2;
752        }
753}
754
755/*convert SPCA508 (s508) to yuv 422
756* s508  |Y0..width..Y0|U..width/2..U|V..width/2..V|Y1..width..Y1|
757* signed values (-128;+127) must be converted to unsigned (0; 255)
758* args:
759*      framebuffer: pointer to frame buffer (yuyv)
760*      tmpbuffer: pointer to temp buffer containing s501 data frame
761*      width: picture width
762*      height: picture height
763*/
764void s508_to_yuyv(BYTE *framebuffer, BYTE *tmpbuffer, int width, int height)
765{
766        BYTE *U, *V, *Y0, *Y1;
767        BYTE *line2;
768        int h, w;
769
770        Y0 = tmpbuffer; /*fisrt line*/
771        for (h = 0; h < height/2; h++ ) 
772        {
773                line2 = framebuffer + width * 2;   /* next line          */
774                U = Y0 + width;
775                V = U + width/2;
776                Y1= V + width/2;
777                for (w = width / 2; --w >= 0; ) 
778                {
779                        *framebuffer++ = (BYTE) (0x80 + *Y0++);
780                        *framebuffer++ = (BYTE) (0x80 + *U);
781                        *framebuffer++ = (BYTE) (0x80 + *Y0++);
782                        *framebuffer++ = (BYTE) (0x80 + *V);
783
784                        *line2++ = (BYTE) (0x80 + *Y1++);
785                        *line2++ = (BYTE) (0x80 + *U++);
786                        *line2++ = (BYTE) (0x80 + *Y1++);
787                        *line2++ = (BYTE) (0x80 + *V++);
788                }
789                Y0 += width * 2;                  /* next block of lines */
790                framebuffer = line2;
791        }
792}
793
794// raw bayer functions
795// from libv4l bayer.c, (C) 2008 Hans de Goede <j.w.r.degoede@hhs.nl>
796//Note: original bayer_to_bgr24 code from :
797//  1394-Based Digital Camera Control Library
798//
799//  Bayer pattern decoding functions
800//
801//  Written by Damien Douxchamps and Frederic Devernay
802static void convert_border_bayer_line_to_bgr24( BYTE* bayer, BYTE* adjacent_bayer,
803        BYTE *bgr, int width, gboolean start_with_green, gboolean blue_line)
804{
805        int t0, t1;
806
807        if (start_with_green) 
808        {
809        /* First pixel */
810                if (blue_line) 
811                {
812                        *bgr++ = bayer[1];
813                        *bgr++ = bayer[0];
814                        *bgr++ = adjacent_bayer[0];
815                } 
816                else 
817                {
818                        *bgr++ = adjacent_bayer[0];
819                        *bgr++ = bayer[0];
820                        *bgr++ = bayer[1];
821                }
822                /* Second pixel */
823                t0 = (bayer[0] + bayer[2] + adjacent_bayer[1] + 1) / 3;
824                t1 = (adjacent_bayer[0] + adjacent_bayer[2] + 1) >> 1;
825                if (blue_line) 
826                {
827                        *bgr++ = bayer[1];
828                        *bgr++ = (BYTE) t0;
829                        *bgr++ = (BYTE) t1;
830                } 
831                else 
832                {
833                        *bgr++ = (BYTE) t1;
834                        *bgr++ = (BYTE) t0;
835                        *bgr++ = bayer[1];
836                }
837                bayer++;
838                adjacent_bayer++;
839                width -= 2;
840        } 
841        else 
842        {
843                /* First pixel */
844                t0 = (bayer[1] + adjacent_bayer[0] + 1) >> 1;
845                if (blue_line) 
846                {
847                        *bgr++ = bayer[0];
848                        *bgr++ = (BYTE) t0;
849                        *bgr++ = adjacent_bayer[1];
850                } 
851                else 
852                {
853                        *bgr++ = adjacent_bayer[1];
854                        *bgr++ = (BYTE) t0;
855                        *bgr++ = bayer[0];
856                }
857                width--;
858        }
859
860        if (blue_line) 
861        {
862                for ( ; width > 2; width -= 2) 
863                {
864                        t0 = (bayer[0] + bayer[2] + 1) >> 1;
865                        *bgr++ = (BYTE) t0;
866                        *bgr++ = bayer[1];
867                        *bgr++ = adjacent_bayer[1];
868                        bayer++;
869                        adjacent_bayer++;
870
871                        t0 = (bayer[0] + bayer[2] + adjacent_bayer[1] + 1) / 3;
872                        t1 = (adjacent_bayer[0] + adjacent_bayer[2] + 1) >> 1;
873                        *bgr++ = bayer[1];
874                        *bgr++ = (BYTE) t0;
875                        *bgr++ = (BYTE) t1;
876                        bayer++;
877                        adjacent_bayer++;
878                }
879        } 
880        else 
881        {
882                for ( ; width > 2; width -= 2) 
883                {
884                        t0 = (bayer[0] + bayer[2] + 1) >> 1;
885                        *bgr++ = adjacent_bayer[1];
886                        *bgr++ = bayer[1];
887                        *bgr++ = (BYTE) t0;
888                        bayer++;
889                        adjacent_bayer++;
890
891                        t0 = (bayer[0] + bayer[2] + adjacent_bayer[1] + 1) / 3;
892                        t1 = (adjacent_bayer[0] + adjacent_bayer[2] + 1) >> 1;
893                        *bgr++ = (BYTE) t1;
894                        *bgr++ = (BYTE) t0;
895                        *bgr++ = bayer[1];
896                        bayer++;
897                        adjacent_bayer++;
898                }
899        }
900
901        if (width == 2) 
902        {
903                /* Second to last pixel */
904                t0 = (bayer[0] + bayer[2] + 1) >> 1;
905                if (blue_line) 
906                {
907                        *bgr++ = (BYTE) t0;
908                        *bgr++ = bayer[1];
909                        *bgr++ = adjacent_bayer[1];
910                } 
911                else 
912                {
913                        *bgr++ = adjacent_bayer[1];
914                        *bgr++ = bayer[1];
915                        *bgr++ = (BYTE) t0;
916                }
917                /* Last pixel */
918                t0 = (bayer[1] + adjacent_bayer[2] + 1) >> 1;
919                if (blue_line) 
920                {
921                        *bgr++ = bayer[2];
922                        *bgr++ = (BYTE) t0;
923                        *bgr++ = adjacent_bayer[1];
924                }
925                else 
926                {
927                        *bgr++ = adjacent_bayer[1];
928                        *bgr++ = (BYTE) t0;
929                        *bgr++ = bayer[2];
930                }
931        } 
932        else 
933        {
934                /* Last pixel */
935                if (blue_line) 
936                {
937                        *bgr++ = bayer[0];
938                        *bgr++ = bayer[1];
939                        *bgr++ = adjacent_bayer[1];
940                } 
941                else 
942                {
943                        *bgr++ = adjacent_bayer[1];
944                        *bgr++ = bayer[1];
945                        *bgr++ = bayer[0];
946                }
947        }
948}
949
950/* From libdc1394, which on turn was based on OpenCV's Bayer decoding */
951static void bayer_to_rgbbgr24(BYTE *bayer,
952        BYTE *bgr, int width, int height,
953        gboolean start_with_green, gboolean blue_line)
954{
955        /* render the first line */
956        convert_border_bayer_line_to_bgr24(bayer, bayer + width, bgr, width,
957                start_with_green, blue_line);
958        bgr += width * 3;
959
960        /* reduce height by 2 because of the special case top/bottom line */
961        for (height -= 2; height; height--) 
962        {
963                int t0, t1;
964                /* (width - 2) because of the border */
965                BYTE *bayerEnd = bayer + (width - 2);
966
967                if (start_with_green) 
968                {
969                        /* OpenCV has a bug in the next line, which was
970                        t0 = (bayer[0] + bayer[width * 2] + 1) >> 1; */
971                        t0 = (bayer[1] + bayer[width * 2 + 1] + 1) >> 1;
972                        /* Write first pixel */
973                        t1 = (bayer[0] + bayer[width * 2] + bayer[width + 1] + 1) / 3;
974                        if (blue_line) 
975                        {
976                                *bgr++ = (BYTE) t0;
977                                *bgr++ = (BYTE) t1;
978                                *bgr++ = bayer[width];
979                        } 
980                        else 
981                        {
982                                *bgr++ = bayer[width];
983                                *bgr++ = (BYTE) t1;
984                                *bgr++ = (BYTE) t0;
985                        }
986
987                        /* Write second pixel */
988                        t1 = (bayer[width] + bayer[width + 2] + 1) >> 1;
989                        if (blue_line) 
990                        {
991                                *bgr++ = (BYTE) t0;
992                                *bgr++ = bayer[width + 1];
993                                *bgr++ = (BYTE) t1;
994                        } 
995                        else 
996                        {
997                                *bgr++ = (BYTE) t1;
998                                *bgr++ = bayer[width + 1];
999                                *bgr++ = (BYTE) t0;
1000                        }
1001                        bayer++;
1002                } 
1003                else 
1004                {
1005                        /* Write first pixel */
1006                        t0 = (bayer[0] + bayer[width * 2] + 1) >> 1;
1007                        if (blue_line) 
1008                        {
1009                                *bgr++ = (BYTE) t0;
1010                                *bgr++ = bayer[width];
1011                                *bgr++ = bayer[width + 1];
1012                        } 
1013                        else 
1014                        {
1015                                *bgr++ = bayer[width + 1];
1016                                *bgr++ = bayer[width];
1017                                *bgr++ = (BYTE) t0;
1018                        }
1019                }
1020
1021                if (blue_line) 
1022                {
1023                        for (; bayer <= bayerEnd - 2; bayer += 2) 
1024                        {
1025                                t0 = (bayer[0] + bayer[2] + bayer[width * 2] +
1026                                        bayer[width * 2 + 2] + 2) >> 2;
1027                                t1 = (bayer[1] + bayer[width] +
1028                                        bayer[width + 2] + bayer[width * 2 + 1] +
1029                                        2) >> 2;
1030                                *bgr++ = (BYTE) t0;
1031                                *bgr++ = (BYTE) t1;
1032                                *bgr++ = bayer[width + 1];
1033
1034                                t0 = (bayer[2] + bayer[width * 2 + 2] + 1) >> 1;
1035                                t1 = (bayer[width + 1] + bayer[width + 3] +
1036                                        1) >> 1;
1037                                *bgr++ = (BYTE) t0;
1038                                *bgr++ = bayer[width + 2];
1039                                *bgr++ = (BYTE) t1;
1040                        }
1041                } 
1042                else 
1043                {
1044                        for (; bayer <= bayerEnd - 2; bayer += 2) 
1045                        {
1046                                t0 = (bayer[0] + bayer[2] + bayer[width * 2] +
1047                                        bayer[width * 2 + 2] + 2) >> 2;
1048                                t1 = (bayer[1] + bayer[width] +
1049                                        bayer[width + 2] + bayer[width * 2 + 1] +
1050                                        2) >> 2;
1051                                *bgr++ = bayer[width + 1];
1052                                *bgr++ = (BYTE) t1;
1053                                *bgr++ = (BYTE) t0;
1054
1055                                t0 = (bayer[2] + bayer[width * 2 + 2] + 1) >> 1;
1056                                t1 = (bayer[width + 1] + bayer[width + 3] +
1057                                        1) >> 1;
1058                                *bgr++ = (BYTE) t1;
1059                                *bgr++ = bayer[width + 2];
1060                                *bgr++ = (BYTE) t0;
1061                        }
1062                }
1063
1064                if (bayer < bayerEnd) 
1065                {
1066                        /* write second to last pixel */
1067                        t0 = (bayer[0] + bayer[2] + bayer[width * 2] +
1068                                bayer[width * 2 + 2] + 2) >> 2;
1069                        t1 = (bayer[1] + bayer[width] +
1070                                bayer[width + 2] + bayer[width * 2 + 1] +
1071                                2) >> 2;
1072                        if (blue_line) 
1073                        {
1074                                *bgr++ = (BYTE) t0;
1075                                *bgr++ = (BYTE) t1;
1076                                *bgr++ = bayer[width + 1];
1077                        } 
1078                        else 
1079                        {
1080                                *bgr++ = bayer[width + 1];
1081                                *bgr++ = (BYTE) t1;
1082                                *bgr++ = (BYTE) t0;
1083                        }
1084                        /* write last pixel */
1085                        t0 = (bayer[2] + bayer[width * 2 + 2] + 1) >> 1;
1086                        if (blue_line) 
1087                        {
1088                                *bgr++ = (BYTE) t0;
1089                                *bgr++ = bayer[width + 2];
1090                                *bgr++ = bayer[width + 1];
1091                        } 
1092                        else 
1093                        {
1094                                *bgr++ = bayer[width + 1];
1095                                *bgr++ = bayer[width + 2];
1096                                *bgr++ = (BYTE) t0;
1097                        }
1098                        bayer++;
1099                } 
1100                else
1101                {
1102                        /* write last pixel */
1103                        t0 = (bayer[0] + bayer[width * 2] + 1) >> 1;
1104                        t1 = (bayer[1] + bayer[width * 2 + 1] + bayer[width] + 1) / 3;
1105                        if (blue_line) 
1106                        {
1107                                *bgr++ = (BYTE) t0;
1108                                *bgr++ = (BYTE) t1;
1109                                *bgr++ = bayer[width + 1];
1110                        } 
1111                        else 
1112                        {
1113                                *bgr++ = bayer[width + 1];
1114                                *bgr++ = (BYTE) t1;
1115                                *bgr++ = (BYTE) t0;
1116                        }
1117                }
1118
1119                /* skip 2 border pixels */
1120                bayer += 2;
1121
1122                blue_line = !blue_line;
1123                start_with_green = !start_with_green;
1124        }
1125
1126        /* render the last line */
1127        convert_border_bayer_line_to_bgr24(bayer + width, bayer, bgr, width,
1128                !start_with_green, !blue_line);
1129}
1130
1131/*convert bayer raw data to rgb24
1132* args:
1133*      pBay: pointer to buffer containing Raw bayer data data
1134*      pRGB24: pointer to buffer containing rgb24 data
1135*      width: picture width
1136*      height: picture height
1137*      pix_order: bayer pixel order (0=gb/rg   1=gr/bg  2=bg/gr  3=rg/bg)
1138*/
1139void 
1140bayer_to_rgb24(BYTE *pBay, BYTE *pRGB24, int width, int height, int pix_order)
1141{
1142        switch (pix_order) 
1143        {
1144                //conversion functions are build for bgr, by switching b and r lines we get rgb
1145                case 0: /* gbgbgb... | rgrgrg... (V4L2_PIX_FMT_SGBRG8)*/
1146                        bayer_to_rgbbgr24(pBay, pRGB24, width, height, TRUE, FALSE);
1147                        break;
1148               
1149                case 1: /* grgrgr... | bgbgbg... (V4L2_PIX_FMT_SGRBG8)*/
1150                        bayer_to_rgbbgr24(pBay, pRGB24, width, height, TRUE, TRUE);
1151                        break;
1152               
1153                case 2: /* bgbgbg... | grgrgr... (V4L2_PIX_FMT_SBGGR8)*/
1154                        bayer_to_rgbbgr24(pBay, pRGB24, width, height, FALSE, FALSE);
1155                        break;
1156               
1157                case 3: /* rgrgrg... ! gbgbgb... (V4L2_PIX_FMT_SRGGB8)*/
1158                        bayer_to_rgbbgr24(pBay, pRGB24, width, height, FALSE, TRUE);
1159                        break;
1160                       
1161                default: /* default is 0*/
1162                        bayer_to_rgbbgr24(pBay, pRGB24, width, height, TRUE, FALSE);
1163                        break;
1164        }
1165}
1166
1167
1168void
1169rgb2yuyv(BYTE *prgb, BYTE *pyuv, int width, int height) 
1170{
1171
1172        int i=0;
1173        for(i=0;i<(width*height*3);i=i+6) 
1174        {
1175                /* y */ 
1176                *pyuv++ =CLIP(0.299 * (prgb[i] - 128) + 0.587 * (prgb[i+1] - 128) + 0.114 * (prgb[i+2] - 128) + 128);
1177                /* u */
1178                *pyuv++ =CLIP(((- 0.147 * (prgb[i] - 128) - 0.289 * (prgb[i+1] - 128) + 0.436 * (prgb[i+2] - 128) + 128) +
1179                        (- 0.147 * (prgb[i+3] - 128) - 0.289 * (prgb[i+4] - 128) + 0.436 * (prgb[i+5] - 128) + 128))/2);
1180                /* y1 */ 
1181                *pyuv++ =CLIP(0.299 * (prgb[i+3] - 128) + 0.587 * (prgb[i+4] - 128) + 0.114 * (prgb[i+5] - 128) + 128); 
1182                /* v*/
1183                *pyuv++ =CLIP(((0.615 * (prgb[i] - 128) - 0.515 * (prgb[i+1] - 128) - 0.100 * (prgb[i+2] - 128) + 128) +
1184                        (0.615 * (prgb[i+3] - 128) - 0.515 * (prgb[i+4] - 128) - 0.100 * (prgb[i+5] - 128) + 128))/2);
1185        }
1186}
1187
1188void
1189bgr2yuyv(BYTE *pbgr, BYTE *pyuv, int width, int height) 
1190{
1191
1192        int i=0;
1193        for(i=0;i<(width*height*3);i=i+6) 
1194        {
1195                /* y */ 
1196                *pyuv++ =CLIP(0.299 * (pbgr[i+2] - 128) + 0.587 * (pbgr[i+1] - 128) + 0.114 * (pbgr[i] - 128) + 128);
1197                /* u */
1198                *pyuv++ =CLIP(((- 0.147 * (pbgr[i+2] - 128) - 0.289 * (pbgr[i+1] - 128) + 0.436 * (pbgr[i] - 128) + 128) +
1199                        (- 0.147 * (pbgr[i+5] - 128) - 0.289 * (pbgr[i+4] - 128) + 0.436 * (pbgr[i+3] - 128) + 128))/2);
1200                /* y1 */ 
1201                *pyuv++ =CLIP(0.299 * (pbgr[i+5] - 128) + 0.587 * (pbgr[i+4] - 128) + 0.114 * (pbgr[i+3] - 128) + 128); 
1202                /* v*/
1203                *pyuv++ =CLIP(((0.615 * (pbgr[i+2] - 128) - 0.515 * (pbgr[i+1] - 128) - 0.100 * (pbgr[i] - 128) + 128) +
1204                        (0.615 * (pbgr[i+5] - 128) - 0.515 * (pbgr[i+4] - 128) - 0.100 * (pbgr[i+3] - 128) + 128))/2);
1205        }
1206}
1207
1208/*use in utils.c for jpeg decoding  420 planar to 422
1209* args:
1210*      out: pointer to data output of idct (macroblocks yyyy u v)
1211*      pic: pointer to picture buffer (yuyv)
1212*      width: picture width
1213*/
1214void yuv420pto422(int * out,unsigned char *pic,int width)
1215{
1216        int j, k;
1217        unsigned char *pic0, *pic1;
1218        int *outy, *outu, *outv;
1219        int outy1 = 0;
1220        int outy2 = 8;
1221
1222        //yyyyuv
1223        pic0 = pic;
1224        pic1 = pic + width;
1225        outy = out;
1226        outu = out + 64 * 4;
1227        outv = out + 64 * 5;   
1228        for (j = 0; j < 8; j++) 
1229        {
1230                for (k = 0; k < 8; k++)
1231                {
1232                        if( k == 4) 
1233                        { 
1234                                outy1 += 56;
1235                                outy2 += 56;
1236                        }
1237                        *pic0++ = CLIP(outy[outy1]);   //y1 line 1
1238                        *pic0++ = CLIP(128 + *outu);   //u  line 1-2
1239                        *pic0++ = CLIP(outy[outy1+1]); //y2 line 1
1240                        *pic0++ = CLIP(128 + *outv);   //v  line 1-2
1241                        *pic1++ = CLIP(outy[outy2]);   //y1 line 2
1242                        *pic1++ = CLIP(128 + *outu);   //u  line 1-2
1243                        *pic1++ = CLIP(outy[outy2+1]); //y2 line 2
1244                        *pic1++ = CLIP(128 + *outv);   //v  line 1-2
1245                        outy1 +=2; outy2 += 2; outu++; outv++;
1246                }
1247                if(j==3)
1248                {
1249                        outy = out + 128;
1250                } 
1251                else 
1252                {
1253                        outy += 16;
1254                }
1255                outy1 = 0;
1256                outy2 = 8;
1257                pic0 += 2 * (width -16);
1258                pic1 += 2 * (width -16);
1259        }
1260}
1261
1262/*use in utils.c for jpeg decoding 422 planar to 422
1263* args:
1264*      out: pointer to data output of idct (macroblocks yyyy u v)
1265*      pic: pointer to picture buffer (yuyv)
1266*      width: picture width
1267*/
1268void yuv422pto422(int * out,unsigned char *pic,int width)
1269{
1270        int j, k;
1271        unsigned char *pic0, *pic1;
1272        int *outy, *outu, *outv;
1273        int outy1 = 0;
1274        int outy2 = 8;
1275        int outu1 = 0;
1276        int outv1 = 0;
1277 
1278        //yyyyuv
1279        pic0 = pic;
1280        pic1 = pic + width;
1281        outy = out;
1282        outu = out + 64 * 4;
1283        outv = out + 64 * 5;   
1284        for (j = 0; j < 4; j++) 
1285        {
1286                for (k = 0; k < 8; k++) 
1287                {
1288                        if( k == 4)
1289                        { 
1290                                outy1 += 56;
1291                                outy2 += 56;
1292                        }
1293                        *pic0++ = CLIP(outy[outy1]);        //y1 line 1
1294                        *pic0++ = CLIP(128 + outu[outu1]);  //u  line 1
1295                        *pic0++ = CLIP(outy[outy1+1]);      //y2 line 1
1296                        *pic0++ = CLIP(128 + outv[outv1]);  //v  line 1
1297                        *pic1++ = CLIP(outy[outy2]);        //y1 line 2
1298                        *pic1++ = CLIP(128 + outu[outu1+8]);//u  line 2
1299                        *pic1++ = CLIP(outy[outy2+1]);      //y2 line 2
1300                        *pic1++ = CLIP(128 + outv[outv1+8]);//v  line 2
1301                        outv1 += 1; outu1 += 1;
1302                        outy1 +=2; outy2 +=2;
1303                }
1304                outy += 16;outu +=8; outv +=8;
1305                outv1 = 0; outu1=0;
1306                outy1 = 0;
1307                outy2 = 8;
1308                pic0 += 2 * (width -16);
1309                pic1 += 2 * (width -16);
1310        }
1311}
1312
1313/*use in utils.c for jpeg decoding 444 planar to 422
1314* args:
1315*      out: pointer to data output of idct (macroblocks yyyy u v)
1316*      pic: pointer to picture buffer (yuyv)
1317*      width: picture width
1318*/
1319void yuv444pto422(int * out,unsigned char *pic,int width)
1320{
1321        int j, k;
1322        unsigned char *pic0, *pic1;
1323        int *outy, *outu, *outv;
1324        int outy1 = 0;
1325        int outy2 = 8;
1326        int outu1 = 0;
1327        int outv1 = 0;
1328
1329        //yyyyuv
1330        pic0 = pic;
1331        pic1 = pic + width;
1332        outy = out;
1333        outu = out + 64 * 4; // Ooops where did i invert ??
1334        outv = out + 64 * 5;   
1335        for (j = 0; j < 4; j++) 
1336        {
1337                for (k = 0; k < 4; k++) 
1338                {
1339                        *pic0++ =CLIP( outy[outy1]);        //y1 line 1
1340                        *pic0++ =CLIP( 128 + outu[outu1]);  //u  line 1
1341                        *pic0++ =CLIP( outy[outy1+1]);      //y2 line 1
1342                        *pic0++ =CLIP( 128 + outv[outv1]);  //v  line 1
1343                        *pic1++ =CLIP( outy[outy2]);        //y1 line 2
1344                        *pic1++ =CLIP( 128 + outu[outu1+8]);//u  line 2
1345                        *pic1++ =CLIP( outy[outy2+1]);      //y2 line 2
1346                        *pic1++ =CLIP( 128 + outv[outv1+8]);//v  line 2
1347                        outv1 += 2; outu1 += 2;
1348                        outy1 +=2; outy2 +=2;
1349                }
1350                outy += 16;outu +=16; outv +=16;
1351                outv1 = 0; outu1=0;
1352                outy1 = 0;
1353                outy2 = 8;
1354                pic0 += 2 * (width -8);
1355                pic1 += 2 * (width -8);
1356        }
1357}
1358
1359/*use in utils.c for jpeg decoding 400 planar to 422
1360* args:
1361*      out: pointer to data output of idct (macroblocks yyyy )
1362*      pic: pointer to picture buffer (yuyv)
1363*      width: picture width
1364*/
1365void yuv400pto422(int * out,unsigned char *pic,int width)
1366{
1367        int j, k;
1368        unsigned char *pic0, *pic1;
1369        int *outy ;
1370        int outy1 = 0;
1371        int outy2 = 8;
1372        pic0 = pic;
1373        pic1 = pic + width;
1374        outy = out;
1375
1376        //yyyy
1377        for (j = 0; j < 4; j++) 
1378        {
1379                for (k = 0; k < 4; k++) 
1380                {
1381                        *pic0++ = CLIP(outy[outy1]);  //y1 line 1
1382                        *pic0++ = 128 ;               //u
1383                        *pic0++ = CLIP(outy[outy1+1]);//y2 line 1
1384                        *pic0++ = 128 ;               //v
1385                        *pic1++ = CLIP(outy[outy2]);  //y1 line 2
1386                        *pic1++ = 128 ;               //u
1387                        *pic1++ = CLIP(outy[outy2+1]);//y2 line 2
1388                        *pic1++ = 128 ;               //v
1389                        outy1 +=2; outy2 +=2; 
1390                }
1391                outy += 16;
1392                outy1 = 0;
1393                outy2 = 8;
1394                pic0 += 2 * (width -8);
1395                pic1 += 2 * (width -8);
1396        }
1397}
1398
Note: See TracBrowser for help on using the repository browser.