Remove HTTPD object type
[vlc.git] / 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 }