cinelerra-5.1/guicast/bccolors.C

   1
   2 /*
   3  * CINELERRA
   4  * Copyright (C) 2008 Adam Williams <broadcast at earthling dot net>
   5  *
   6  * This program is free software; you can redistribute it and/or modify
   7  * it under the terms of the GNU General Public License as published by
   8  * the Free Software Foundation; either version 2 of the License, or
   9  * (at your option) any later version.
  10  *
  11  * This program is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14  * GNU General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU General Public License
  17  * along with this program; if not, write to the Free Software
  18  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  19  *
  20  */
  21
  22 #include "bccolors.h"
  23
  24 #include <stdio.h>
  25
  26 HSV::HSV()
  27 {
  28 }
  29
  30
  31 HSV::~HSV()
  32 {
  33 }
  34
  35 YUV YUV::yuv;
  36
  37 int HSV::rgb_to_hsv(float r, float g, float b, float &h, float &s, float &v)
  38 {
  39         float min = ((r < g) ? r : g) < b ? ((r < g) ? r : g) : b;
  40         float max = ((r > g) ? r : g) > b ? ((r > g) ? r : g) : b;
  41         float delta = max - min;
  42         if( max != 0 && delta != 0 ) {
  43                 v = max;
  44                 s = delta / max;
  45                 h = r == max ? (g - b) / delta :     // between yellow & magenta
  46                     g == max ? 2 + (b - r) / delta : // between cyan & yellow
  47                                4 + (r - g) / delta;  // between magenta & cyan
  48                 if( (h*=60) < 0 ) h += 360;          // degrees
  49         }
  50         else { // r = g = b
  51                 h = 0;  s = 0;  v = max;
  52         }
  53
  54         return 0;
  55 }
  56
  57 int HSV::hsv_to_rgb(float &r, float &g, float &b, float h, float s, float v)
  58 {
  59         if( s == 0 ) { // achromatic (grey)
  60                 r = g = b = v;
  61                 return 0;
  62         }
  63
  64         h /= 60;                        // sector 0 to 5
  65         int i = (int)h;
  66         float f = h - i;                // factorial part of h
  67         float p = v * (1 - s);
  68         float q = v * (1 - s * f);
  69         float t = v * (1 - s * (1 - f));
  70
  71         switch(i) {
  72         case 0:  r = v; g = t; b = p; break;
  73         case 1:  r = q; g = v; b = p; break;
  74         case 2:  r = p; g = v; b = t; break;
  75         case 3:  r = p; g = q; b = v; break;
  76         case 4:  r = t; g = p; b = v; break;
  77         default: r = v; g = p; b = q; break;
  78         }
  79         return 0;
  80 }
  81
  82 int HSV::yuv_to_hsv(int y, int u, int v, float &h, float &s, float &va, int max)
  83 {
  84         float r, g, b;
  85         int r_i, g_i, b_i;
  86
  87 //      if(max == 0xffff)
  88 //      {
  89 //              YUV::yuv.yuv_to_rgb_16(r_i, g_i, b_i, y, u, v);
  90 //      }
  91 //      else
  92         {
  93                 YUV::yuv.yuv_to_rgb_8(r_i, g_i, b_i, y, u, v);
  94         }
  95         r = (float)r_i / max;
  96         g = (float)g_i / max;
  97         b = (float)b_i / max;
  98
  99         float h2, s2, v2;
 100         HSV::rgb_to_hsv(r, g, b, h2, s2, v2);
 101
 102         h = h2;  s = s2;  va = v2;
 103         return 0;
 104 }
 105
 106 int HSV::hsv_to_yuv(int &y, int &u, int &v, float h, float s, float va, int max)
 107 {
 108         float r, g, b;
 109         int r_i, g_i, b_i;
 110         HSV::hsv_to_rgb(r, g, b, h, s, va);
 111         r = r * max + 0.5;
 112         g = g * max + 0.5;
 113         b = b * max + 0.5;
 114         r_i = (int)CLIP(r, 0, max);
 115         g_i = (int)CLIP(g, 0, max);
 116         b_i = (int)CLIP(b, 0, max);
 117
 118         int y2, u2, v2;
 119 //      if(max == 0xffff)
 120 //              YUV::yuv.rgb_to_yuv_16(r_i, g_i, b_i, y2, u2, v2);
 121 //      else
 122                 YUV::yuv.rgb_to_yuv_8(r_i, g_i, b_i, y2, u2, v2);
 123
 124         y = y2;  u = u2;  v = v2;
 125         return 0;
 126 }
 127
 128 YUV::YUV()
 129 {
 130         for(int i = 0; i < 0x100; i++) {
 131 // compression
 132                 rtoy_tab_8[i] = (int)(R_TO_Y * 0x100 * i);
 133                 rtou_tab_8[i] = (int)(R_TO_U * 0x100 * i);
 134                 rtov_tab_8[i] = (int)(R_TO_V * 0x100 * i);
 135
 136                 gtoy_tab_8[i] = (int)(G_TO_Y * 0x100 * i);
 137                 gtou_tab_8[i] = (int)(G_TO_U * 0x100 * i);
 138                 gtov_tab_8[i] = (int)(G_TO_V * 0x100 * i);
 139
 140                 btoy_tab_8[i] = (int)(B_TO_Y * 0x100 * i);
 141                 btou_tab_8[i] = (int)(B_TO_U * 0x100 * i) + 0x8000;
 142                 btov_tab_8[i] = (int)(B_TO_V * 0x100 * i) + 0x8000;
 143         }
 144
 145         vtor_8 = &(vtor_tab_8[(0x100) / 2]);
 146         vtog_8 = &(vtog_tab_8[(0x100) / 2]);
 147         utog_8 = &(utog_tab_8[(0x100) / 2]);
 148         utob_8 = &(utob_tab_8[(0x100) / 2]);
 149
 150         for(int i = (-0x100) / 2; i < (0x100) / 2; i++) {
 151 // decompression
 152                 vtor_8[i] = (int)(V_TO_R * 0x100 * i);
 153                 vtog_8[i] = (int)(V_TO_G * 0x100 * i);
 154
 155                 utog_8[i] = (int)(U_TO_G * 0x100 * i);
 156                 utob_8[i] = (int)(U_TO_B * 0x100 * i);
 157         }
 158
 159         for(int i = 0; i < 0x10000; i++) {
 160 // compression
 161                 rtoy_tab_16[i] = (int)(R_TO_Y * 0x100 * i);
 162                 rtou_tab_16[i] = (int)(R_TO_U * 0x100 * i);
 163                 rtov_tab_16[i] = (int)(R_TO_V * 0x100 * i);
 164
 165                 gtoy_tab_16[i] = (int)(G_TO_Y * 0x100 * i);
 166                 gtou_tab_16[i] = (int)(G_TO_U * 0x100 * i);
 167                 gtov_tab_16[i] = (int)(G_TO_V * 0x100 * i);
 168
 169                 btoy_tab_16[i] = (int)(B_TO_Y * 0x100 * i);
 170                 btou_tab_16[i] = (int)(B_TO_U * 0x100 * i) + 0x800000;
 171                 btov_tab_16[i] = (int)(B_TO_V * 0x100 * i) + 0x800000;
 172         }
 173
 174         vtor_16 = &(vtor_tab_16[(0x10000) / 2]);
 175         vtog_16 = &(vtog_tab_16[(0x10000) / 2]);
 176         utog_16 = &(utog_tab_16[(0x10000) / 2]);
 177         utob_16 = &(utob_tab_16[(0x10000) / 2]);
 178
 179         for(int i = (-0x10000) / 2; i < (0x10000) / 2; i++) {
 180 // decompression
 181                 vtor_16[i] = (int)(V_TO_R * 0x100 * i);
 182                 vtog_16[i] = (int)(V_TO_G * 0x100 * i);
 183
 184                 utog_16[i] = (int)(U_TO_G * 0x100 * i);
 185                 utob_16[i] = (int)(U_TO_B * 0x100 * i);
 186         }
 187 }
 188
 189 YUV::~YUV()
 190 {
 191 }
 192