git.sesse.net Git - vlc/blob - modules/gui/beos/DrawingTidbits.cpp

   1 /*****************************************************************************
   2  * DrawingTidbits.cpp
   3  *****************************************************************************
   4  * Copyright (C) 2001 the VideoLAN team
   5  * $Id$
   6  *
   7  * Authors: Tony Castley <tcastley@mail.powerup.com.au>
   8  *          Stephan Aßmus <stippi@yellowbites.com>
   9  *
  10  * This program is free software; you can redistribute it and/or modify
  11  * it under the terms of the GNU General Public License as published by
  12  * the Free Software Foundation; either version 2 of the License, or
  13  * (at your option) any later version.
  14  *
  15  * This program is distributed in the hope that it will be useful,
  16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18  * GNU General Public License for more details.
  19  *
  20  * You should have received a copy of the GNU General Public License
  21  * along with this program; if not, write to the Free Software
  22  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
  23  *****************************************************************************/
  24
  25 #include <math.h>
  26
  27 #include <Bitmap.h>
  28 #include <Debug.h>
  29 #include <Screen.h>
  30
  31 #include "DrawingTidbits.h"
  32
  33 // ShiftComponent
  34 inline uchar
  35 ShiftComponent(uchar component, float percent)
  36 {
  37     // change the color by <percent>, make sure we aren't rounding
  38     // off significant bits
  39     if (percent >= 1)
  40         return (uchar)(component * (2 - percent));
  41     else
  42         return (uchar)(255 - percent * (255 - component));
  43 }
  44
  45 // ShiftColor
  46 rgb_color
  47 ShiftColor(rgb_color color, float percent)
  48 {
  49         rgb_color result = {
  50                 ShiftComponent(color.red, percent),
  51                 ShiftComponent(color.green, percent),
  52                 ShiftComponent(color.blue, percent),
  53                 0
  54         };
  55
  56         return result;
  57 }
  58
  59 // CompareColors
  60 static bool
  61 CompareColors(const rgb_color a, const rgb_color b)
  62 {
  63         return a.red == b.red
  64                 && a.green == b.green
  65                 && a.blue == b.blue
  66                 && a.alpha == b.alpha;
  67 }
  68
  69 // ==
  70 bool
  71 operator==(const rgb_color &a, const rgb_color &b)
  72 {
  73         return CompareColors(a, b);
  74 }
  75
  76 // !=
  77 bool
  78 operator!=(const rgb_color &a, const rgb_color &b)
  79 {
  80         return !CompareColors(a, b);
  81 }
  82
  83 // ReplaceColor
  84 void
  85 ReplaceColor(BBitmap *bitmap, rgb_color from, rgb_color to)
  86 {
  87         ASSERT(bitmap->ColorSpace() == B_COLOR_8_BIT); // other color spaces not implemented yet
  88
  89         BScreen screen(B_MAIN_SCREEN_ID);
  90         uint32 fromIndex = screen.IndexForColor(from);
  91         uint32 toIndex = screen.IndexForColor(to);
  92
  93         uchar *bits = (uchar *)bitmap->Bits();
  94         int32 bitsLength = bitmap->BitsLength();
  95         for (int32 index = 0; index < bitsLength; index++)
  96                 if (bits[index] == fromIndex)
  97                         bits[index] = toIndex;
  98 }
  99
 100 // ReplaceTransparentColor
 101 void
 102 ReplaceTransparentColor(BBitmap *bitmap, rgb_color with)
 103 {
 104         ASSERT(bitmap->ColorSpace() == B_COLOR_8_BIT); // other color spaces not implemented yet
 105
 106         BScreen screen(B_MAIN_SCREEN_ID);
 107         uint32 withIndex = screen.IndexForColor(with);
 108
 109         uchar *bits = (uchar *)bitmap->Bits();
 110         int32 bitsLength = bitmap->BitsLength();
 111         for (int32 index = 0; index < bitsLength; index++)
 112                 if (bits[index] == B_TRANSPARENT_8_BIT)
 113                         bits[index] = withIndex;
 114 }
 115
 116 // ycrcb_to_rgb
 117 inline void
 118 ycbcr_to_rgb( uint8 y, uint8 cb, uint8 cr,
 119                           uint8& r, uint8& g, uint8& b)
 120 {
 121         r = (uint8)max_c( 0, min_c( 255, 1.164 * ( y - 16 ) + 1.596 * ( cr - 128 ) ) );
 122         g = (uint8)max_c( 0, min_c( 255, 1.164 * ( y - 16 ) - 0.813 * ( cr - 128 )
 123                                                                 - 0.391 * ( cb - 128 ) ) );
 124         b = (uint8)max_c( 0, min_c( 255, 1.164 * ( y - 16 ) + 2.018 * ( cb - 128 ) ) );
 125 }
 126
 127 // this function will not produce visually pleasing results!
 128 // we'd have to convert to Lab colorspace, do the mixing
 129 // and convert back to RGB - in an ideal world...
 130 //
 131 // mix_colors
 132 inline void
 133 mix_colors( uint8 ra, uint8 ga, uint8 ba,
 134                         uint8 rb, uint8 gb, uint8 bb,
 135                         uint8& r, uint8& g, uint8& b, float mixLevel )
 136 {
 137         float mixA = ( 1.0 - mixLevel );
 138         float mixB = mixLevel;
 139         r = (uint8)(mixA * ra + mixB * rb);
 140         g = (uint8)(mixA * ga + mixB * gb);
 141         b = (uint8)(mixA * ba + mixB * bb);
 142 }
 143
 144 // the algorithm used is probably pretty slow, but it should be easy
 145 // to understand what's going on...
 146 //
 147 // scale_bitmap
 148 status_t
 149 scale_bitmap( BBitmap* bitmap, uint32 fromWidth, uint32 fromHeight )
 150 {
 151         status_t status = B_BAD_VALUE;
 152
 153         if ( bitmap && bitmap->IsValid()
 154                  && ( bitmap->ColorSpace() == B_RGB32 || bitmap->ColorSpace() == B_RGBA32 ) )
 155         {
 156                 status = B_MISMATCHED_VALUES;
 157                 // we only support upscaling as of now
 158                 uint32 destWidth = bitmap->Bounds().IntegerWidth() + 1;
 159                 uint32 destHeight = bitmap->Bounds().IntegerHeight() + 1;
 160                 if ( fromWidth <= destWidth && fromHeight <= destHeight )
 161                 {
 162                         status = B_OK;
 163                         uint32 bpr = bitmap->BytesPerRow();
 164                         if ( fromWidth < destWidth )
 165                         {
 166                                 // scale horizontally
 167                                 uint8* src = (uint8*)bitmap->Bits();
 168                                 uint8* p = new uint8[fromWidth * 4];    // temp buffer
 169                                 for ( uint32 y = 0; y < fromHeight; y++ )
 170                                 {
 171                                         // copy valid pixels into temp buffer
 172                                         memcpy( p, src, fromWidth * 4 );
 173                                         for ( uint32 x = 0; x < destWidth; x++ )
 174                                         {
 175                                                 // mix colors of left and right pixels and write it back
 176                                                 // into the bitmap
 177                                                 float xPos = ( (float)x / (float)destWidth ) * (float)fromWidth;
 178                                                 uint32 leftIndex = (uint32)floorf( xPos ) * 4;
 179                                                 uint32 rightIndex = (uint32)ceilf( xPos ) * 4;
 180                                                 rgb_color left;
 181                                                 left.red = p[leftIndex + 2];
 182                                                 left.green = p[leftIndex + 1];
 183                                                 left.blue = p[leftIndex + 0];
 184                                                 rgb_color right;
 185                                                 right.red = p[rightIndex + 2];
 186                                                 right.green = p[rightIndex + 1];
 187                                                 right.blue = p[rightIndex + 0];
 188                                                 rgb_color mix;
 189                                                 mix_colors( left.red, left.green, left.blue,
 190                                                                         right.red, right.green, right.blue,
 191                                                                         mix.red, mix.green, mix.blue, xPos - floorf( xPos ) );
 192                                                 uint32 destIndex = x * 4;
 193                                                 src[destIndex + 2] = mix.red;
 194                                                 src[destIndex + 1] = mix.green;
 195                                                 src[destIndex + 0] = mix.blue;
 196                                         }
 197                                         src += bpr;
 198                                 }
 199                                 delete[] p;
 200                         }
 201                         if ( fromHeight < destHeight )
 202                         {
 203                                 // scale vertically
 204                                 uint8* src = (uint8*)bitmap->Bits();
 205                                 uint8* p = new uint8[fromHeight * 3];   // temp buffer
 206                                 for ( uint32 x = 0; x < destWidth; x++ )
 207                                 {
 208                                         // copy valid pixels into temp buffer
 209                                         for ( uint32 y = 0; y < fromHeight; y++ )
 210                                         {
 211                                                 uint32 destIndex = y * 3;
 212                                                 uint32 srcIndex = x * 4 + y * bpr;
 213                                                 p[destIndex + 0] = src[srcIndex + 0];
 214                                                 p[destIndex + 1] = src[srcIndex + 1];
 215                                                 p[destIndex + 2] = src[srcIndex + 2];
 216                                         }
 217                                         // do the scaling
 218                                         for ( uint32 y = 0; y < destHeight; y++ )
 219                                         {
 220                                                 // mix colors of upper and lower pixels and write it back
 221                                                 // into the bitmap
 222                                                 float yPos = ( (float)y / (float)destHeight ) * (float)fromHeight;
 223                                                 uint32 upperIndex = (uint32)floorf( yPos ) * 3;
 224                                                 uint32 lowerIndex = (uint32)ceilf( yPos ) * 3;
 225                                                 rgb_color upper;
 226                                                 upper.red = p[upperIndex + 2];
 227                                                 upper.green = p[upperIndex + 1];
 228                                                 upper.blue = p[upperIndex + 0];
 229                                                 rgb_color lower;
 230                                                 lower.red = p[lowerIndex + 2];
 231                                                 lower.green = p[lowerIndex + 1];
 232                                                 lower.blue = p[lowerIndex + 0];
 233                                                 rgb_color mix;
 234                                                 mix_colors( upper.red, upper.green, upper.blue,
 235                                                                         lower.red, lower.green, lower.blue,
 236                                                                         mix.red, mix.green, mix.blue, yPos - floorf( yPos ) );
 237                                                 uint32 destIndex = x * 4 + y * bpr;
 238                                                 src[destIndex + 2] = mix.red;
 239                                                 src[destIndex + 1] = mix.green;
 240                                                 src[destIndex + 0] = mix.blue;
 241                                         }
 242                                 }
 243                                 delete[] p;
 244                         }
 245                 }
 246         }
 247         return status;
 248 }
 249
 250 // convert_bitmap
 251 status_t
 252 convert_bitmap( BBitmap* inBitmap, BBitmap* outBitmap )
 253 {
 254         status_t status = B_BAD_VALUE;
 255         // see that we got valid bitmaps
 256         if ( inBitmap && inBitmap->IsValid()
 257                  && outBitmap && outBitmap->IsValid() )
 258         {
 259                 status = B_MISMATCHED_VALUES;
 260                 // see that bitmaps are compatible and that we support the conversion
 261                 if ( inBitmap->Bounds().Width() <= outBitmap->Bounds().Width()
 262                          && inBitmap->Bounds().Height() <= outBitmap->Bounds().Height()
 263                          && ( outBitmap->ColorSpace() == B_RGB32
 264                                   || outBitmap->ColorSpace() == B_RGBA32) )
 265                 {
 266                         int32 width = inBitmap->Bounds().IntegerWidth() + 1;
 267                         int32 height = inBitmap->Bounds().IntegerHeight() + 1;
 268                         int32 srcBpr = inBitmap->BytesPerRow();
 269                         int32 dstBpr = outBitmap->BytesPerRow();
 270                         uint8* srcBits = (uint8*)inBitmap->Bits();
 271                         uint8* dstBits = (uint8*)outBitmap->Bits();
 272                         switch (inBitmap->ColorSpace())
 273                         {
 274                                 case B_YCbCr422:
 275                                         // Y0[7:0]  Cb0[7:0]  Y1[7:0]  Cr0[7:0]
 276                                         // Y2[7:0]  Cb2[7:0]  Y3[7:0]  Cr2[7:0]
 277                                         for ( int32 y = 0; y < height; y++ )
 278                                         {
 279                                                 for ( int32 x = 0; x < width; x += 2 )
 280                                                 {
 281                                                         int32 srcOffset = x * 2;
 282                                                         int32 dstOffset = x * 4;
 283                                                         ycbcr_to_rgb( srcBits[srcOffset + 0],
 284                                                                                   srcBits[srcOffset + 1],
 285                                                                                   srcBits[srcOffset + 3],
 286                                                                                   dstBits[dstOffset + 2],
 287                                                                                   dstBits[dstOffset + 1],
 288                                                                                   dstBits[dstOffset + 0] );
 289                                                         ycbcr_to_rgb( srcBits[srcOffset + 2],
 290                                                                                   srcBits[srcOffset + 1],
 291                                                                                   srcBits[srcOffset + 3],
 292                                                                                   dstBits[dstOffset + 6],
 293                                                                                   dstBits[dstOffset + 5],
 294                                                                                   dstBits[dstOffset + 4] );
 295                                                         // take care of alpha
 296                                                         dstBits[x * 4 + 3] = 255;
 297                                                         dstBits[x * 4 + 7] = 255;
 298                                                 }
 299                                                 srcBits += srcBpr;
 300                                                 dstBits += dstBpr;
 301                                         }
 302                                         status = B_OK;
 303                                         break;
 304                                 case B_YCbCr420:
 305                                         // Non-interlaced only!
 306                                         // Cb0  Y0  Y1  Cb2 Y2  Y3  on even scan lines ...
 307                                         // Cr0  Y0  Y1  Cr2 Y2  Y3  on odd scan lines
 308                                         status = B_ERROR;
 309                                         break;
 310                                 case B_YUV422:
 311                                         // U0[7:0]  Y0[7:0]   V0[7:0]  Y1[7:0]
 312                                         // U2[7:0]  Y2[7:0]   V2[7:0]  Y3[7:0]
 313                                         status = B_ERROR;
 314                                         break;
 315                                 case B_RGB32:
 316                                 case B_RGBA32:
 317                                         memcpy( dstBits, srcBits, inBitmap->BitsLength() );
 318                                         status = B_OK;
 319                                         break;
 320                                 case B_RGB16:
 321                                         // G[2:0],B[4:0]  R[4:0],G[5:3]
 322                                         for ( int32 y = 0; y < height; y ++ )
 323                                         {
 324                                                 for ( int32 x = 0; x < width; x++ )
 325                                                 {
 326                                                         int32 srcOffset = x * 2;
 327                                                         int32 dstOffset = x * 4;
 328                                                         uint8 blue = srcBits[srcOffset + 0] & 0x1f;
 329                                                         uint8 green = ( srcBits[srcOffset + 0] >> 5 )
 330                                                                                   | ( ( srcBits[srcOffset + 1] & 0x07 ) << 3 );
 331                                                         uint8 red = srcBits[srcOffset + 1] & 0xf8;
 332                                                         // homogeneously scale each component to 8 bit
 333                                                         dstBits[dstOffset + 0] = (blue << 3) | (blue >> 2);
 334                                                         dstBits[dstOffset + 1] = (green << 2) | (green >> 4);
 335                                                         dstBits[dstOffset + 2] = red | (red >> 5);
 336                                                 }
 337                                                 srcBits += srcBpr;
 338                                                 dstBits += dstBpr;
 339                                         }
 340                                         status = B_OK;
 341                                         break;
 342                                 default:
 343                                         status = B_MISMATCHED_VALUES;
 344                                         break;
 345                         }
 346                         if ( status == B_OK )
 347                         {
 348                                 if ( width < outBitmap->Bounds().IntegerWidth() + 1
 349                                          || height < outBitmap->Bounds().IntegerHeight() + 1 )
 350                                 {
 351                                         scale_bitmap( outBitmap, width, height );
 352                                 }
 353                         }
 354                 }
 355         }
 356         return status;
 357 }
 358
 359 // clip_float
 360 inline uint8
 361 clip_float(float value)
 362 {
 363         if (value < 0)
 364                 value = 0;
 365         if (value > 255)
 366                 value = 255;
 367         return (uint8)value;
 368 }
 369
 370 // dim_bitmap
 371 status_t
 372 dim_bitmap(BBitmap* bitmap, rgb_color center, float dimLevel)
 373 {
 374         status_t status = B_BAD_VALUE;
 375         if (bitmap && bitmap->IsValid())
 376         {
 377                 switch (bitmap->ColorSpace())
 378                 {
 379                         case B_CMAP8:
 380                         {
 381                                 BScreen screen(B_MAIN_SCREEN_ID);
 382                                 if (screen.IsValid())
 383                                 {
 384                                         // iterate over each pixel, get the respective
 385                                         // color from the screen object, find the distance
 386                                         // to the "center" color and shorten the distance
 387                                         // by "dimLevel"
 388                                         int32 length = bitmap->BitsLength();
 389                                         uint8* bits = (uint8*)bitmap->Bits();
 390                                         for (int32 i = 0; i < length; i++)
 391                                         {
 392                                                 // preserve transparent pixels
 393                                                 if (bits[i] != B_TRANSPARENT_MAGIC_CMAP8)
 394                                                 {
 395                                                         // get color for this index
 396                                                         rgb_color c = screen.ColorForIndex(bits[i]);
 397                                                         // red
 398                                                         float dist = (c.red - center.red) * dimLevel;
 399                                                         c.red = clip_float(center.red + dist);
 400                                                         // green
 401                                                         dist = (c.green - center.green) * dimLevel;
 402                                                         c.green = clip_float(center.green + dist);
 403                                                         // blue
 404                                                         dist = (c.blue - center.blue) * dimLevel;
 405                                                         c.blue = clip_float(center.blue + dist);
 406                                                         // write correct index of the dimmed color
 407                                                         // back into bitmap (and hope the match is close...)
 408                                                         bits[i] = screen.IndexForColor(c);
 409                                                 }
 410                                         }
 411                                         status = B_OK;
 412                                 }
 413                                 break;
 414                         }
 415                         case B_RGB32:
 416                         case B_RGBA32:
 417                         {
 418                                 // iterate over each color component, find the distance
 419                                 // to the "center" color and shorten the distance
 420                                 // by "dimLevel"
 421                                 uint8* bits = (uint8*)bitmap->Bits();
 422                                 int32 bpr = bitmap->BytesPerRow();
 423                                 int32 pixels = bitmap->Bounds().IntegerWidth() + 1;
 424                                 int32 lines = bitmap->Bounds().IntegerHeight() + 1;
 425                                 // iterate over color components
 426                                 for (int32 y = 0; y < lines; y++) {
 427                                         for (int32 x = 0; x < pixels; x++) {
 428                                                 int32 offset = 4 * x; // four bytes per pixel
 429                                                 // blue
 430                                                 float dist = (bits[offset + 0] - center.blue) * dimLevel;
 431                                                 bits[offset + 0] = clip_float(center.blue + dist);
 432                                                 // green
 433                                                 dist = (bits[offset + 1] - center.green) * dimLevel;
 434                                                 bits[offset + 1] = clip_float(center.green + dist);
 435                                                 // red
 436                                                 dist = (bits[offset + 2] - center.red) * dimLevel;
 437                                                 bits[offset + 2] = clip_float(center.red + dist);
 438                                                 // ignore alpha channel
 439                                         }
 440                                         // next line
 441                                         bits += bpr;
 442                                 }
 443                                 status = B_OK;
 444                                 break;
 445                         }
 446                         default:
 447                                 status = B_ERROR;
 448                                 break;
 449                 }
 450         }
 451         return status;
 452 }
 453
 454 // dimmed_color_cmap8
 455 rgb_color
 456 dimmed_color_cmap8(rgb_color color, rgb_color center, float dimLevel)
 457 {
 458         BScreen screen(B_MAIN_SCREEN_ID);
 459         if (screen.IsValid())
 460         {
 461                 // red
 462                 float dist = (color.red - center.red) * dimLevel;
 463                 color.red = clip_float(center.red + dist);
 464                 // green
 465                 dist = (color.green - center.green) * dimLevel;
 466                 color.green = clip_float(center.green + dist);
 467                 // blue
 468                 dist = (color.blue - center.blue) * dimLevel;
 469                 color.blue = clip_float(center.blue + dist);
 470                 // get color index for dimmed color
 471                 int32 index = screen.IndexForColor(color);
 472                 // put color at index (closest match in palette
 473                 // to dimmed result) into returned color
 474                 color = screen.ColorForIndex(index);
 475         }
 476         return color;
 477 }