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 }