libs/core/GP_Gamma.c

   1 /*****************************************************************************
   2  * This file is part of gfxprim library.                                     *
   3  *                                                                           *
   4  * Gfxprim is free software; you can redistribute it and/or                  *
   5  * modify it under the terms of the GNU Lesser General Public                *
   6  * License as published by the Free Software Foundation; either              *
   7  * version 2.1 of the License, or (at your option) any later version.        *
   8  *                                                                           *
   9  * Gfxprim is distributed in the hope that it will be useful,                *
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of            *
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU         *
  12  * Lesser General Public License for more details.                           *
  13  *                                                                           *
  14  * You should have received a copy of the GNU Lesser General Public          *
  15  * License along with gfxprim; if not, write to the Free Software            *
  16  * Foundation, Inc., 51 Franklin Street, Fifth Floor,                        *
  17  * Boston, MA  02110-1301  USA                                               *
  18  *                                                                           *
  19  * Copyright (C) 2009-2013 Cyril Hrubis <metan@ucw.cz>                       *
  20  *                                                                           *
  21  *****************************************************************************/
  22
  23 #include <math.h>
  24
  25 #include "GP_Pixel.h"
  26 #include "GP_Debug.h"
  27
  28 #include "GP_Gamma.h"
  29
  30 static GP_GammaTable *tables = NULL;
  31
  32 static void fill_table8(GP_GammaTable *table, float gamma,
  33                         uint8_t in_bits, uint8_t out_bits)
  34 {
  35         unsigned int i;
  36         unsigned int in_max = (1<<in_bits) - 1;
  37         unsigned int out_max = (1<<out_bits) - 1;
  38
  39         GP_DEBUG(3, "Initalizing gamma table %f", gamma);
  40
  41         for (i = 0; i < (1U<<in_bits); i++)
  42                 table->u8[i] = pow((float)i / in_max, gamma) * out_max + 0.5;
  43 }
  44
  45 static void fill_table16(GP_GammaTable *table, float gamma,
  46                          uint8_t in_bits, uint8_t out_bits)
  47 {
  48         unsigned int i;
  49         unsigned int in_max = (1<<in_bits) - 1;
  50         unsigned int out_max = (1<<out_bits) - 1;
  51
  52         GP_DEBUG(3, "Initalizing gamma table %f", gamma);
  53
  54         for (i = 0; i < (1U<<in_bits); i++)
  55                 table->u16[i] = pow((float)i / in_max, gamma) * out_max + 0.5;
  56 }
  57
  58 static GP_GammaTable *get_table(float gamma, uint8_t in_bits, uint8_t out_bits)
  59 {
  60         GP_GammaTable *i;
  61
  62         for (i = tables; i != NULL; i = i->next)
  63                 if (gamma == i->gamma && in_bits == i->in_bits &&
  64                     out_bits == i->out_bits)
  65                         break;
  66
  67         if (i != NULL) {
  68                 GP_DEBUG(2, "Found Gamma table Gamma %f, in_bits %u, "
  69                          "out_bits %u, ref_count %u", i->gamma, i->in_bits,
  70                          i->out_bits, i->ref_count);
  71                 i->ref_count++;
  72                 return i;
  73         }
  74
  75         GP_DEBUG(2, "Creating Gamma table Gamma %f, in_bits %u, out_bits %u",
  76                  gamma, in_bits, out_bits);
  77
  78         i = malloc(sizeof(GP_GammaTable) + (1U<<in_bits) * (out_bits > 8 ? 2 : 1));
  79
  80         if (i == NULL) {
  81                 GP_WARN("Malloc failed :(");
  82                 return NULL;
  83         }
  84
  85         i->gamma = gamma;
  86         i->in_bits = in_bits;
  87         i->out_bits = out_bits;
  88         i->ref_count = 1;
  89         i->type = GP_CORRECTION_GAMMA;
  90
  91         if (out_bits > 8)
  92                 fill_table16(i, gamma, in_bits, out_bits);
  93         else
  94                 fill_table8(i, gamma, in_bits, out_bits);
  95
  96         /* Insert it into link list */
  97         i->next = tables;
  98         tables = i;
  99
 100         return i;
 101 }
 102
 103 static void put_table(GP_GammaTable *table)
 104 {
 105         if (table == NULL)
 106                 return;
 107
 108         table->ref_count--;
 109
 110         GP_DEBUG(2, "Putting gamma table Gamma %f, in_bits %u, out_bits %u, "
 111                  "ref_count %u", table->gamma, table->in_bits, table->out_bits,
 112                  table->ref_count);
 113
 114         if (table->ref_count == 0) {
 115                 GP_DEBUG(2, "Gamma table ref_count == 0, removing...");
 116
 117                 GP_GammaTable *i, *prev = NULL;
 118
 119                 /* Remove from link list and free */
 120                 for (i = tables; i != NULL; i = i->next) {
 121                         if (table == i)
 122                                 break;
 123                         prev = i;
 124                 }
 125
 126                 if (prev == NULL)
 127                         tables = table->next;
 128                 else
 129                         prev->next = table->next;
 130
 131                 free(table);
 132         }
 133 }
 134
 135 GP_Gamma *GP_GammaAcquire(GP_PixelType pixel_type, float gamma)
 136 {
 137         GP_CHECK_VALID_PIXELTYPE(pixel_type);
 138         int channels = GP_PixelTypes[pixel_type].numchannels, i;
 139
 140         GP_DEBUG(1, "Acquiring Gamma table %s gamma %f", GP_PixelTypeName(pixel_type), gamma);
 141
 142         GP_Gamma *res = malloc(sizeof(struct GP_Gamma) + 2 * channels * sizeof(void*));
 143
 144         if (res == NULL) {
 145                 GP_WARN("Malloc failed :(");
 146                 return NULL;
 147         }
 148
 149         /* NULL the pointers */
 150         for (i = 0; i < 2 * channels; i++)
 151                 res->tables[i] = NULL;
 152
 153         res->pixel_type = pixel_type;
 154         res->ref_count = 1;
 155
 156         /* Gamma to linear tables n bits -> n + 2 bits */
 157         for (i = 0; i < channels; i++) {
 158                 unsigned int chan_size = GP_PixelTypes[pixel_type].channels[i].size;
 159                 res->tables[i] = get_table(gamma, chan_size, chan_size + 2);
 160
 161                 if (res->tables[i] == NULL) {
 162                         GP_GammaRelease(res);
 163                         return NULL;
 164                 }
 165         }
 166
 167         /* And reverse tables, n + 2 bits -> n bits */
 168         for (i = 0; i < channels; i++) {
 169                 unsigned int chan_size = GP_PixelTypes[pixel_type].channels[i].size;
 170                 res->tables[i + channels] = get_table(1/gamma, chan_size + 2, chan_size);
 171
 172                 if (res->tables[i] == NULL) {
 173                         GP_GammaRelease(res);
 174                         return NULL;
 175                 }
 176         }
 177
 178         return res;
 179 }
 180
 181 GP_Gamma *GP_GammaCopy(GP_Gamma *self)
 182 {
 183         self->ref_count++;
 184         return self;
 185 }
 186
 187 void GP_GammaRelease(GP_Gamma *self)
 188 {
 189         int channels, i;
 190
 191         if (!self)
 192                 return;
 193
 194         channels = GP_PixelTypes[self->pixel_type].numchannels;
 195
 196         GP_DEBUG(1, "Releasing Gamma table %s gamma %f", GP_PixelTypeName(self->pixel_type), self->tables[0]->gamma);
 197
 198         for (i = 0; i < channels; i++)
 199                 put_table(self->tables[i]);
 200
 201         if (--self->ref_count == 0) {
 202                 GP_DEBUG(2, "Gamma ref_count == 0, releasing...");
 203                 free(self);
 204         }
 205 }
 206
 207 static const char *correction_type_names[] = {
 208         "Gamma",
 209         "sRGB",
 210 };
 211
 212 static const char *correction_type_name(enum GP_CorrectionType type)
 213 {
 214         if (type > GP_CORRECTION_sRGB)
 215                 return "Invalid";
 216
 217         return correction_type_names[type];
 218 }
 219
 220 void GP_GammaPrint(const GP_Gamma *self)
 221 {
 222         printf("Correction tables:\n");
 223
 224         const GP_PixelTypeDescription *desc = GP_PixelTypeDesc(self->pixel_type);
 225
 226         unsigned int i;
 227
 228         for (i = 0; i < desc->numchannels; i++) {
 229                 enum GP_CorrectionType type = self->tables[i]->type;
 230
 231                 printf(" %s: %s", desc->channels[i].name,
 232                        correction_type_name(type));
 233
 234                 if (type == GP_CORRECTION_GAMMA)
 235                         printf(" gamma = %.2f", self->tables[i]->gamma);
 236
 237                 printf("\n");
 238         }
 239 }