]> git.vomp.tv Git - vompclient.git/blob - surface.cc
Fix an OO issue that only a later compiler picked up
[vompclient.git] / surface.cc
1 /*
2     Copyright 2004-2005 Chris Tallon
3     Portions copyright 2004 Jon Gettler
4
5     This file is part of VOMP.
6
7     VOMP 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     VOMP 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 VOMP; if not, write to the Free Software
19     Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
20 */
21
22 #include "surface.h"
23
24 Surface* Surface::screen = NULL;
25 Surface* Surface::buffer = NULL;
26 int Surface::disableDoubleBuffering = 0;
27
28 Surface::Surface(int fd, int id)
29 {
30   if (id == SCREEN) screen = this;
31   if (id == BUFFER) buffer = this;
32
33   fdOsd = fd;
34   memset(&surface, 0, sizeof(osd_surface_t));
35   memset(&surface.sfc, 0, sizeof(stbgfx_sfc_t));
36   memset(&surface.map, 0, sizeof(stbgfx_map_t));
37
38   font = &font_helvB18;
39 }
40
41 Surface::~Surface()
42 {
43   for (int i = 0; i < 3; i++)
44   {
45     if (surface.base[i]) munmap(surface.base[i], surface.map.map[i].size);
46   }
47
48   int a;
49
50   a = ioctl(fdOsd, GFX_FB_SFC_UNMAP, surface.sfc.handle);
51   if (a) Log::getInstance()->log("Surface", Log::ERR, "Surface unmap failed");
52
53   a = ioctl(fdOsd, GFX_FB_SFC_FREE, surface.sfc.handle);
54   if (a) Log::getInstance()->log("Surface", Log::ERR, "Surface destroy failed");
55
56 }
57
58 void Surface::disableBuffer()
59 {
60   disableDoubleBuffering = 1;
61 }
62
63 Surface* Surface::getObject(int id)
64 {
65   if (id == SCREEN) return screen;
66   if (disableDoubleBuffering) return screen;
67   if (id == BUFFER) return buffer;
68   return NULL;
69 }
70
71 int Surface::create(int height, int width)
72 {
73   int r = 0;
74   int displayNumber = 0; // mvpmc iterates 0->15 till it gets one that works?
75
76   surface.sfc.width = width;
77   surface.sfc.height = height;
78   surface.sfc.flags = 0x3f1533;
79
80   surface.sfc.unknown = -1;
81
82 //  r = ioctl(fdOsd, GFX_FB_SET_OSD, &displayNumber);
83 //  if (r) return 0;
84
85   r = ioctl(fdOsd, GFX_FB_OSD_SURFACE, &displayNumber);
86   if (r) return 0;
87
88   r = ioctl(fdOsd, GFX_FB_SFC_ALLOC, &surface.sfc);
89   if (r) return 0;
90
91   surface.map.map[0].unknown = surface.sfc.handle;
92   r = ioctl(fdOsd, GFX_FB_MAP, &surface.map);
93   if (r) return 0;
94
95   surface.base[0] = (unsigned char *)mmap(NULL, surface.map.map[0].size, PROT_READ|PROT_WRITE, MAP_SHARED, fdOsd, surface.map.map[0].addr);
96   if (surface.base[0] == MAP_FAILED) return 0;
97
98   surface.base[1] = (unsigned char *)mmap(NULL, surface.map.map[1].size, PROT_READ|PROT_WRITE, MAP_SHARED, fdOsd, surface.map.map[1].addr);
99   if (surface.base[1] == MAP_FAILED) return 0;
100
101   surface.base[2] = (unsigned char *)mmap(NULL, surface.map.map[2].size, PROT_READ|PROT_WRITE, MAP_SHARED, fdOsd, surface.map.map[2].addr);
102   if (surface.base[2] == MAP_FAILED) return 0;
103
104 //  surface.display.num = displayNumber;
105 //  r = ioctl(fdOsd, GFX_FB_MOVE_DISPLAY, &surface.display);
106 //  if (r) return 0;
107
108 //  r = ioctl(fdOsd, GFX_FB_SET_DISPLAY, &surface.display);
109 //  if (r) return 0;
110
111   return 1;
112 }
113
114 void Surface::display()
115 {
116   unsigned long fb_descriptor[2];
117
118   fb_descriptor[0] = surface.sfc.handle;
119   fb_descriptor[1] = 1;
120
121   ioctl(fdOsd, GFX_FB_ATTACH, fb_descriptor);
122 }
123
124 unsigned long Surface::getSurfaceHandle()
125 {
126   return surface.sfc.handle;
127 }
128
129 // ----------------------------------------------------------------------------
130
131 // Now for the drawing functions
132
133 /*
134  * RGB to YUV conversion tables
135  */
136 int Surface::conv_YB[256];
137 int Surface::conv_YG[256];
138 int Surface::conv_YR[256];
139 int Surface::conv_UB[256];
140 int Surface::conv_UG[256];
141 int Surface::conv_UR[256];
142 int Surface::conv_VB[256];
143 int Surface::conv_VG[256];
144 int Surface::conv_VR[256];
145
146 int Surface::conv_BY[256];
147 int Surface::conv_GY[256];
148 int Surface::conv_RY[256];
149 int Surface::conv_BU[256];
150 int Surface::conv_GU[256];
151 int Surface::conv_RU[256];
152 int Surface::conv_BV[256];
153 int Surface::conv_GV[256];
154 int Surface::conv_RV[256];
155
156 /*
157  * gfx_init() - initialize the RGB to YUV conversion tables
158  */
159 void Surface::initConversionTables(void)
160 {
161   int i;
162
163   for (i=0; i<256; i++) {
164     conv_YB[i] = (int)(0.299 * (double)i);
165     conv_BY[i] = i;
166   }
167   for (i=0; i<256; i++) {
168     conv_YG[i] = (int)(0.587 * (double)i);
169     conv_GY[i] = i;
170   }
171   for (i=0; i<256; i++) {
172     conv_YR[i] = (int)(0.114 * (double)i);
173     conv_RY[i] = i;
174   }
175
176   for (i=0; i<256; i++) {
177     conv_UB[i] = (int)(0.5 * (double)i);
178     conv_BU[i] = (int)(1.732 * (i - 128));
179   }
180   for (i=0; i<256; i++) {
181     conv_UG[i] = (int)(-0.33126 * (double)i);
182     conv_GU[i] = (int)(-0.338 * (i - 128));
183   }
184   for (i=0; i<256; i++) {
185     conv_UR[i] = (int)(-0.16874 * (double)i);
186     conv_RU[i] = 0;
187   }
188
189   for (i=0; i<256; i++) {
190     conv_VB[i] = (int)(-0.08131 * (double)i);
191     conv_BV[i] = 0;
192   }
193   for (i=0; i<256; i++) {
194     conv_VG[i] = (int)(-0.41869 * (double)i);
195     conv_GV[i] = (int)(-0.698 * (i - 128));
196   }
197   for (i=0; i<256; i++) {
198     conv_VR[i] = (int)(0.5 * (double)i);
199     conv_RV[i] = (int)(1.370 * ((double)i - 128));
200   }
201 }
202
203 /*
204  * rgb2yuv() - convert an RGB pixel to YUV
205  */
206  //inline me?
207 void Surface::rgb2yuv(unsigned char r, unsigned char g, unsigned char b, unsigned char *y, unsigned char *u, unsigned char *v)
208 {
209   int Y, U, V;
210
211   Y = conv_YB[b] + conv_YG[g] + conv_YR[r];
212   U = conv_UB[b] + conv_UG[g] + conv_UR[r] + 128;
213   V = conv_VB[b] + conv_VG[g] + conv_VR[r] + 128;
214
215   if (Y > 255)
216     Y = 255;
217   else if (Y < 0)
218     Y = 0;
219   if (U > 255)
220     U = 255;
221   else if (U < 0)
222     U = 0;
223   if (V > 255)
224     V = 255;
225   else if (V < 0)
226     V = 0;
227
228   *y = Y;
229   *u = U;
230   *v = V;
231 }
232
233 int Surface::fillblt(int x, int y, int width, int height, unsigned int c)
234 {
235   osd_fillblt_t fblt;
236
237   fblt.handle = surface.sfc.handle;
238   fblt.x = x;
239   fblt.y = y;
240   fblt.width = width;
241   fblt.height = height;
242   fblt.colour = c;
243
244   return ioctl(fdOsd, GFX_FB_OSD_FILLBLT, &fblt);
245 }
246
247 void Surface::drawPixel(int x, int y, unsigned int c)
248 {
249   int offset;
250   unsigned char r, g, b, a, Y, U, V;
251   unsigned int line, remainder;
252
253   if ((x >= (int)surface.sfc.width) || (y >= (int)surface.sfc.height))
254     return;
255
256   c2rgba(c, &r, &g, &b, &a);
257
258   rgb2yuv(r, g, b, &Y, &U, &V);
259
260   remainder = (surface.sfc.width % 4);
261   if (remainder == 0)
262     line = surface.sfc.width;
263   else
264     line = surface.sfc.width + (4 - remainder);
265
266   offset = (y * line) + x;
267
268   *(surface.base[0] + offset) = Y;
269   *(surface.base[1] + (offset & 0xfffffffe)) = U;
270   *(surface.base[1] + (offset & 0xfffffffe) + 1) = V;
271   *(surface.base[2] + offset) = a;
272
273 }
274
275 void Surface::drawHorzLine(int x1, int x2, int y, unsigned int c)
276 {
277   fillblt(x1, y, x2-x1, 1, c);
278 }
279
280 void Surface::drawVertLine(int x, int y1, int y2, unsigned int c)
281 {
282   fillblt(x, y1, 1, y2-y1, c);
283 }
284
285 void Surface::bufferToScreen() // static, this is for Box::showAll
286 {
287   if (disableDoubleBuffering) return;
288   buffer->updateToScreen(0, 0, buffer->surface.sfc.width, buffer->surface.sfc.height);
289 }
290
291 int Surface::updateToScreen(int x, int y, int width, int height) // main method for all normal windows
292 {
293   /*
294   With double buffering:
295     A view has buffer for its surface. this is buffer, copy area specified to screen
296   Without double buffering:
297     A view has screen for its surface. this is screen, all painting work has already been done. ignore
298   */
299
300   if (this == screen) return 0;
301
302   return blt(fdOsd, surface.sfc.handle, x, y, width, height, screen->getSurfaceHandle(), x, y);
303 }
304
305 int Surface::blt(int fd, unsigned long shandle, int sx, int sy, int width, int height, unsigned long dhandle, int dx, int dy)
306 {
307   osd_bitblt_t fblt;
308   memset(&fblt, 0, sizeof(fblt));
309
310   fblt.dst_handle = dhandle;
311   fblt.dst_x = dx;
312   fblt.dst_y = dy;
313
314   fblt.src_handle = shandle;
315   fblt.src_x = sx;
316   fblt.src_y = sy;
317
318   fblt.width = width;
319   fblt.height = height;
320
321   fblt.u1 = 1;
322   fblt.u2 = 0;
323   fblt.u3 = 0x0f;
324
325   return ioctl(fd, GFX_FB_OSD_BITBLT, &fblt);
326 }
327
328 int Surface::drawText(char* text, int x, int y, int r, int g, int b)
329 {
330   int h, n, i;
331   int Y, X, cx;
332   unsigned long fg;
333
334   fg = rgba(r, g, b, 255);
335
336   n = strlen(text);
337   h = font->height;
338
339   X = 0;
340   cx = 0;
341   for (i=0; i<n; i++)
342   {
343     unsigned char c = text[i];
344     unsigned long *character = &font->content[font->offset[c]];
345     int w = font->width[c];
346     int pixels = 0;
347
348     for (X=0; X<w; X++)
349     {
350       for (Y=0; Y<h; Y++)
351       {
352         if ((character[Y] >> (32 - X)) & 0x1)
353         {
354           drawPixel(x+X+cx, y+Y, fg);
355           pixels++;
356         }
357       }
358     }
359     cx += w;
360   }
361   return 1;
362 }
363
364 int Surface::drawTextRJ(char* text, int x, int y, int r, int g, int b)
365 {
366   int i, n, w;
367   w = 0;
368
369   n = strlen(text);
370
371   for (i = 0; i < n; i++)
372   {
373     w += font->width[text[i]];
374   }
375
376   x -= w;
377
378   if (x < 0) return 0;
379   else return drawText(text, x, y, r, g, b);
380 }
381
382 int Surface::getCharWidth(char c)
383 {
384   return font->width[c];
385 }
386
387 int Surface::getFontHeight()
388 {
389   return font->height;
390 }
391
392 void Surface::screenShot(char* fileName)
393 {
394   Log* logger = Log::getInstance();
395
396   FILE* outfile = fopen(fileName, "w");
397   if (outfile == NULL)
398   {
399     logger->log("Surface", Log::ERR, "Can't open JPEG");
400     return;
401   }
402   logger->log("Surface", Log::DEBUG, "File opened %u %u", surface.sfc.height, surface.sfc.width);
403
404   struct jpeg_compress_struct cinfo;
405   struct jpeg_error_mgr jerr;
406   cinfo.err = jpeg_std_error(&jerr);
407   jpeg_create_compress(&cinfo);
408   jpeg_stdio_dest(&cinfo, outfile);
409   cinfo.image_width = surface.sfc.width;
410   cinfo.image_height = surface.sfc.height;
411   cinfo.input_components = 3;
412   cinfo.in_color_space = JCS_RGB;
413   jpeg_set_defaults(&cinfo);
414   jpeg_start_compress(&cinfo, TRUE);
415
416
417   unsigned char row[surface.sfc.width * 3];
418   unsigned char* prow = (unsigned char*)&row;
419   unsigned char r, g, b;
420
421   while (cinfo.next_scanline < cinfo.image_height)
422   {
423     for(unsigned int i = 0; i < surface.sfc.width; i++)
424     {
425       readPixel(i, cinfo.next_scanline, &r, &g, &b);
426       row[i * 3] = r;
427       row[(i * 3) + 1] = g;
428       row[(i * 3) + 2] = b;
429     }
430     jpeg_write_scanlines(&cinfo, (JSAMPLE **)&prow, 1);
431   }
432
433   jpeg_finish_compress(&cinfo);
434   jpeg_destroy_compress(&cinfo);
435   fclose(outfile);
436   logger->log("Surface", Log::DEBUG, "Jpeg saved");
437 }
438
439 void Surface::readPixel(int x, int y, unsigned char* r, unsigned char* g, unsigned char* b)
440 {
441   int offset;
442   unsigned char a, Y, U, V;
443   unsigned int line, remainder;
444
445   if (((unsigned int)x >= surface.sfc.width) || ((unsigned int)y >= surface.sfc.height)) return;
446
447   remainder = (surface.sfc.width % 4);
448   if (remainder == 0)
449     line = surface.sfc.width;
450   else
451     line = surface.sfc.width + (4 - remainder);
452
453   offset = (y * line) + x;
454
455   Y = *(surface.base[0] + offset);
456   U = *(surface.base[1] + (offset & 0xfffffffe));
457   V = *(surface.base[1] + (offset & 0xfffffffe) + 1);
458   a = *(surface.base[2] + offset);
459
460   yuv2rgb(Y, U, V, r, g, b);
461 }
462
463 void Surface::yuv2rgb(int y, int u, int v, unsigned char* pr, unsigned char* pg, unsigned char* pb)
464 {
465    // from http://www.fourcc.org/index.php?http%3A//www.fourcc.org/fccyvrgb.php
466
467 //   unsigned int pixel32;
468 //   unsigned char *pixel = (unsigned char *)&pixel32;
469    int r, g, b;
470
471
472    /*
473      One formula I found:  (not the right one)
474
475      R = 1.164(Y - 16) + 1.596(Cr - 128)
476      G = 1.164(Y - 16) - 0.813(Cr - 128) - 0.391(Cb - 128)
477      B = 1.164(Y - 16)                   + 2.018(Cb - 128)
478
479
480    r = (1.164 * (y - 16))
481       + (2.018 * (v - 128));
482    g = (1.164 * (y - 16))
483       - (0.813 * (u - 128))
484       - (0.391 * (v - 128));
485    b = (1.164 * (y - 16))
486       + (1.596 * (u - 128));
487
488
489      Another formula I found:  (seems to work)
490
491      R = Y + 1.370705 (V-128)
492      G = Y - 0.698001 (V-128) - 0.337633 (U-128)
493      B = Y + 1.732446 (U-128)
494    */
495
496    r = (int)( y + (1.370705 * (v-128)) );
497    g = (int)( y - (0.698001 * (v-128)) - (0.337633 * (u-128)) );
498    b = (int)( y + (1.732446 * (u-128)) );
499
500    // Even with proper conversion, some values still need clipping.
501    if (r > 255) r = 255;
502    if (g > 255) g = 255;
503    if (b > 255) b = 255;
504    if (r < 0) r = 0;
505    if (g < 0) g = 0;
506    if (b < 0) b = 0;
507
508    // Values only go from 0-220..  Why?
509 //   pixel[0] = r * 220 / 256;
510 //   pixel[1] = g * 220 / 256;
511 //   pixel[2] = b * 220 / 256;
512 //   pixel[3] = 0;
513
514    *pr = (unsigned char) (r * 220 / 256);
515    *pg = (unsigned char) (g * 220 / 256);
516    *pb = (unsigned char) (b * 220 / 256);
517
518    /* Debug
519    //printf("yuv2rgb(%i, %i, %i) -> %i, %i, %i  (0x%x)\n",
520     y, u, v,
521     pixel[0], pixel[1], pixel[2],
522     pixel32);
523    */
524
525 //   return pixel32;
526 }