source: libpipi/trunk/pipi/pixels.c @ 2846

Last change on this file since 2846 was 2846, checked in by Sam Hocevar, 11 years ago

Add a --gamma command to modify the global gamma value. This is a nasty
hack that will hopefully disappear in the future. The default gamma is
now 2.2 again (sRGB approximation).

File size: 8.2 KB
Line 
1/*
2 *  libpipi       Pathetic image processing interface library
3 *  Copyright (c) 2004-2008 Sam Hocevar <sam@zoy.org>
4 *                All Rights Reserved
5 *
6 *  $Id$
7 *
8 *  This library is free software. It comes without any warranty, to
9 *  the extent permitted by applicable law. You can redistribute it
10 *  and/or modify it under the terms of the Do What The Fuck You Want
11 *  To Public License, Version 2, as published by Sam Hocevar. See
12 *  http://sam.zoy.org/wtfpl/COPYING for more details.
13 */
14
15/*
16 * pixels.c: pixel-level image manipulation
17 */
18
19#include "config.h"
20#include "common.h"
21
22#include <stdio.h>
23#include <stdlib.h>
24#include <string.h>
25
26#include <math.h>
27
28#include "pipi.h"
29#include "pipi_internals.h"
30
31static void init_tables(void);
32
33static double global_gamma = 2.2;
34static int done = 0;
35
36static float u8tof32_table[256];
37static inline float u8tof32(uint8_t p) { return u8tof32_table[(int)p]; }
38
39/* Return a direct pointer to an image's pixels. */
40pipi_pixels_t *pipi_getpixels(pipi_image_t *img, pipi_format_t type)
41{
42    size_t bytes = 0;
43    int x, y, i, bpp = 0;
44
45    if(type < 0 || type >= PIPI_PIXELS_MAX)
46        return NULL;
47
48    if(img->last_modified == type)
49        return &img->p[type];
50
51    /* Handle special cases */
52    if(type == PIPI_PIXELS_MASK_C)
53        return &img->p[type];
54
55    /* Preliminary conversions */
56    if(img->last_modified == PIPI_PIXELS_RGBA_C
57                  && type == PIPI_PIXELS_Y_F)
58        pipi_getpixels(img, PIPI_PIXELS_RGBA_F);
59    else if(img->last_modified == PIPI_PIXELS_BGR_C
60                       && type == PIPI_PIXELS_Y_F)
61        pipi_getpixels(img, PIPI_PIXELS_RGBA_F);
62    else if(img->last_modified == PIPI_PIXELS_Y_F
63                       && type == PIPI_PIXELS_RGBA_C)
64        pipi_getpixels(img, PIPI_PIXELS_RGBA_F);
65    else if(img->last_modified == PIPI_PIXELS_Y_F
66                       && type == PIPI_PIXELS_BGR_C)
67        pipi_getpixels(img, PIPI_PIXELS_RGBA_F);
68
69    /* Allocate pixels if necessary */
70    if(!img->p[type].pixels)
71    {
72        switch(type)
73        {
74        case PIPI_PIXELS_RGBA_C:
75            bytes = img->w * img->h * 4 * sizeof(uint8_t);
76            bpp = 4 * sizeof(uint8_t);
77            break;
78        case PIPI_PIXELS_BGR_C:
79            bytes = img->w * img->h * 3 * sizeof(uint8_t);
80            bpp = 3 * sizeof(uint8_t);
81            break;
82        case PIPI_PIXELS_RGBA_F:
83            bytes = img->w * img->h * 4 * sizeof(float);
84            bpp = 4 * sizeof(float);
85            break;
86        case PIPI_PIXELS_Y_F:
87            bytes = img->w * img->h * sizeof(float);
88            bpp = sizeof(float);
89            break;
90        default:
91            return NULL;
92        }
93
94        img->p[type].pixels = malloc(bytes);
95        img->p[type].bytes = bytes;
96        img->p[type].bpp = bpp;
97        img->p[type].w = img->w;
98        img->p[type].h = img->h;
99    }
100
101    /* Convert pixels */
102    if(img->last_modified == PIPI_PIXELS_RGBA_C
103                  && type == PIPI_PIXELS_RGBA_F)
104    {
105        uint8_t *src = (uint8_t *)img->p[PIPI_PIXELS_RGBA_C].pixels;
106        float *dest = (float *)img->p[type].pixels;
107
108        init_tables();
109
110        for(y = 0; y < img->h; y++)
111            for(x = 0; x < img->w; x++)
112                for(i = 0; i < 4; i++)
113                    dest[4 * (y * img->w + x) + i]
114                        = u8tof32(src[4 * (y * img->w + x) + i]);
115    }
116    else if(img->last_modified == PIPI_PIXELS_BGR_C
117                       && type == PIPI_PIXELS_RGBA_F)
118    {
119        uint8_t *src = (uint8_t *)img->p[PIPI_PIXELS_BGR_C].pixels;
120        float *dest = (float *)img->p[type].pixels;
121
122        init_tables();
123
124        for(y = 0; y < img->h; y++)
125            for(x = 0; x < img->w; x++)
126            {
127                dest[4 * (y * img->w + x)]
128                    = u8tof32(src[3 * (y * img->w + x) + 2]);
129                dest[4 * (y * img->w + x) + 1]
130                    = u8tof32(src[3 * (y * img->w + x) + 1]);
131                dest[4 * (y * img->w + x) + 2]
132                    = u8tof32(src[3 * (y * img->w + x)]);
133                dest[4 * (y * img->w + x) + 3] = 1.0;
134            }
135    }
136    else if(img->last_modified == PIPI_PIXELS_RGBA_F
137                       && type == PIPI_PIXELS_RGBA_C)
138    {
139        float *src = (float *)img->p[PIPI_PIXELS_RGBA_F].pixels;
140        uint8_t *dest = (uint8_t *)img->p[type].pixels;
141
142        init_tables();
143
144        for(y = 0; y < img->h; y++)
145            for(x = 0; x < img->w; x++)
146                for(i = 0; i < 4; i++)
147                {
148                    double p, e;
149                    uint8_t d;
150
151                    p = src[4 * (y * img->w + x) + i];
152
153                    if(p < 0.) d = 0.;
154                    else if(p > 1.) d = 255;
155                    else d = (int)(255.999 * pow(p, 1. / global_gamma));
156
157                    dest[4 * (y * img->w + x) + i] = d;
158
159                    e = (p - u8tof32(d)) / 16;
160                    if(x < img->w - 1)
161                        src[4 * (y * img->w + x + 1) + i] += e * 7;
162                    if(y < img->h - 1)
163                    {
164                        if(x > 0)
165                            src[4 * ((y + 1) * img->w + x - 1) + i] += e * 3;
166                        src[4 * ((y + 1) * img->w + x) + i] += e * 5;
167                        if(x < img->w - 1)
168                            src[4 * ((y + 1) * img->w + x + 1) + i] += e;
169                    }
170                }
171    }
172    else if(img->last_modified == PIPI_PIXELS_RGBA_F
173                       && type == PIPI_PIXELS_BGR_C)
174    {
175        float *src = (float *)img->p[PIPI_PIXELS_RGBA_F].pixels;
176        uint8_t *dest = (uint8_t *)img->p[type].pixels;
177
178        init_tables();
179
180        for(y = 0; y < img->h; y++)
181            for(x = 0; x < img->w; x++)
182                for(i = 0; i < 3; i++)
183                {
184                    double p, e;
185                    uint8_t d;
186
187                    p = src[4 * (y * img->w + x) + i];
188
189                    if(p < 0.) d = 0.;
190                    else if(p > 1.) d = 255;
191                    else d = (int)(255.999 * pow(p, 1. / global_gamma));
192
193                    dest[3 * (y * img->w + x) + i] = d;
194
195                    e = (p - u8tof32(d)) / 16;
196                    if(x < img->w - 1)
197                        src[4 * (y * img->w + x + 1) + i] += e * 7;
198                    if(y < img->h - 1)
199                    {
200                        if(x > 0)
201                            src[4 * ((y + 1) * img->w + x - 1) + i] += e * 3;
202                        src[4 * ((y + 1) * img->w + x) + i] += e * 5;
203                        if(x < img->w - 1)
204                            src[4 * ((y + 1) * img->w + x + 1) + i] += e;
205                    }
206                }
207    }
208    else if(img->last_modified == PIPI_PIXELS_Y_F
209                       && type == PIPI_PIXELS_RGBA_F)
210    {
211        float *src = (float *)img->p[PIPI_PIXELS_Y_F].pixels;
212        float *dest = (float *)img->p[PIPI_PIXELS_RGBA_F].pixels;
213
214        init_tables();
215
216        for(y = 0; y < img->h; y++)
217            for(x = 0; x < img->w; x++)
218            {
219                float p = src[y * img->w + x];
220                dest[4 * (y * img->w + x)] = p;
221                dest[4 * (y * img->w + x) + 1] = p;
222                dest[4 * (y * img->w + x) + 2] = p;
223                dest[4 * (y * img->w + x) + 3] = 1.0;
224            }
225    }
226    else if(img->last_modified == PIPI_PIXELS_RGBA_F
227                       && type == PIPI_PIXELS_Y_F)
228    {
229        float *src = (float *)img->p[PIPI_PIXELS_RGBA_F].pixels;
230        float *dest = (float *)img->p[PIPI_PIXELS_Y_F].pixels;
231
232        init_tables();
233
234        for(y = 0; y < img->h; y++)
235            for(x = 0; x < img->w; x++)
236            {
237                float p = 0.;
238                p += 0.299 * src[4 * (y * img->w + x)];
239                p += 0.587 * src[4 * (y * img->w + x) + 1];
240                p += 0.114 * src[4 * (y * img->w + x) + 2];
241                dest[y * img->w + x] = p;
242            }
243    }
244    else
245    {
246        memset(img->p[type].pixels, 0, bytes);
247    }
248
249    img->last_modified = type;
250
251    return &img->p[type];
252}
253
254void pipi_set_gamma(double g)
255{
256    if(g > 0.)
257    {
258        global_gamma = g;
259        done = 0;
260    }
261}
262
263static void init_tables(void)
264{
265    int i;
266
267    if(done)
268        return;
269
270    for(i = 0; i < 256; i++)
271        u8tof32_table[i] = pow((double)i / 255., global_gamma);
272
273    done = 1;
274}
275
Note: See TracBrowser for help on using the repository browser.