AlderconeStudio/PIKApp
AlderconeStudio
/
PIKApp
0
0
Fork 0
Code Issues 1 Pull Requests Packages Projects Releases 1 Wiki Activity
PIKApp/app/operations/pikalevelsconfig.c

988 lines
31 KiB
C
Raw Permalink Normal View History

Initial checkin of Pika from heckimp
2023-09-26 00:35:21 +02:00
/* PIKA - Photo and Image Kooker Application
* a rebranding of The GNU Image Manipulation Program (created with heckimp)
* A derived work which may be trivial. However, any changes may be (C)2023 by Aldercone Studio
*
* Original copyright, applying to most contents (license remains unchanged):
* Copyright (C) 1995 Spencer Kimball and Peter Mattis
*
* pikalevelsconfig.c
* Copyright (C) 2007 Michael Natterer <mitch@gimp.org>
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <https://www.gnu.org/licenses/>.
*/
#include "config.h"
#include <errno.h>
#include <cairo.h>
#include <gegl.h>
#include <gdk-pixbuf/gdk-pixbuf.h>
#include "libpikabase/pikabase.h"
#include "libpikacolor/pikacolor.h"
#include "libpikamath/pikamath.h"
#include "libpikaconfig/pikaconfig.h"
#include "operations-types.h"
#include "core/pika-utils.h"
#include "core/pikacurve.h"
#include "core/pikahistogram.h"
#include "pikacurvesconfig.h"
#include "pikalevelsconfig.h"
#include "pikaoperationlevels.h"
#include "pika-intl.h"
enum
{
PROP_0,
PROP_TRC,
PROP_LINEAR,
PROP_CHANNEL,
PROP_LOW_INPUT,
PROP_HIGH_INPUT,
PROP_CLAMP_INPUT,
PROP_GAMMA,
PROP_LOW_OUTPUT,
PROP_HIGH_OUTPUT,
PROP_CLAMP_OUTPUT
};
static void pika_levels_config_iface_init (PikaConfigInterface *iface);
static void pika_levels_config_get_property (GObject *object,
guint property_id,
GValue *value,
GParamSpec *pspec);
static void pika_levels_config_set_property (GObject *object,
guint property_id,
const GValue *value,
GParamSpec *pspec);
static gboolean pika_levels_config_serialize (PikaConfig *config,
PikaConfigWriter *writer,
gpointer data);
static gboolean pika_levels_config_deserialize (PikaConfig *config,
GScanner *scanner,
gint nest_level,
gpointer data);
static gboolean pika_levels_config_equal (PikaConfig *a,
PikaConfig *b);
static void pika_levels_config_reset (PikaConfig *config);
static gboolean pika_levels_config_copy (PikaConfig *src,
PikaConfig *dest,
GParamFlags flags);
G_DEFINE_TYPE_WITH_CODE (PikaLevelsConfig, pika_levels_config,
PIKA_TYPE_OPERATION_SETTINGS,
G_IMPLEMENT_INTERFACE (PIKA_TYPE_CONFIG,
pika_levels_config_iface_init))
#define parent_class pika_levels_config_parent_class
static void
pika_levels_config_class_init (PikaLevelsConfigClass *klass)
{
GObjectClass *object_class = G_OBJECT_CLASS (klass);
PikaViewableClass *viewable_class = PIKA_VIEWABLE_CLASS (klass);
object_class->set_property = pika_levels_config_set_property;
object_class->get_property = pika_levels_config_get_property;
viewable_class->default_icon_name = "pika-tool-levels";
PIKA_CONFIG_PROP_ENUM (object_class, PROP_TRC,
"trc",
_("Linear/Perceptual"),
_("Work on linear or perceptual RGB"),
PIKA_TYPE_TRC_TYPE,
PIKA_TRC_NON_LINEAR, 0);
/* compat */
PIKA_CONFIG_PROP_BOOLEAN (object_class, PROP_LINEAR,
"linear",
_("Linear"),
_("Work on linear RGB"),
FALSE, 0);
PIKA_CONFIG_PROP_ENUM (object_class, PROP_CHANNEL,
"channel",
_("Channel"),
_("The affected channel"),
PIKA_TYPE_HISTOGRAM_CHANNEL,
PIKA_HISTOGRAM_VALUE, 0);
PIKA_CONFIG_PROP_DOUBLE (object_class, PROP_LOW_INPUT,
"low-input",
_("Low Input"),
_("Low Input"),
0.0, 1.0, 0.0, 0);
PIKA_CONFIG_PROP_DOUBLE (object_class, PROP_HIGH_INPUT,
"high-input",
_("High Input"),
_("High Input"),
0.0, 1.0, 1.0, 0);
PIKA_CONFIG_PROP_BOOLEAN (object_class, PROP_CLAMP_INPUT,
"clamp-input",
_("Clamp Input"),
_("Clamp input values before applying output mapping."),
FALSE, 0);
PIKA_CONFIG_PROP_DOUBLE (object_class, PROP_GAMMA,
"gamma",
_("Gamma"),
_("Gamma"),
0.1, 10.0, 1.0, 0);
PIKA_CONFIG_PROP_DOUBLE (object_class, PROP_LOW_OUTPUT,
"low-output",
_("Low Output"),
_("Low Output"),
0.0, 1.0, 0.0, 0);
PIKA_CONFIG_PROP_DOUBLE (object_class, PROP_HIGH_OUTPUT,
"high-output",
_("High Output"),
_("High Output"),
0.0, 1.0, 1.0, 0);
PIKA_CONFIG_PROP_BOOLEAN (object_class, PROP_CLAMP_OUTPUT,
"clamp-output",
_("Clamp Output"),
_("Clamp final output values."),
FALSE, 0);
}
static void
pika_levels_config_iface_init (PikaConfigInterface *iface)
{
iface->serialize = pika_levels_config_serialize;
iface->deserialize = pika_levels_config_deserialize;
iface->equal = pika_levels_config_equal;
iface->reset = pika_levels_config_reset;
iface->copy = pika_levels_config_copy;
}
static void
pika_levels_config_init (PikaLevelsConfig *self)
{
pika_config_reset (PIKA_CONFIG (self));
}
static void
pika_levels_config_get_property (GObject *object,
guint property_id,
GValue *value,
GParamSpec *pspec)
{
PikaLevelsConfig *self = PIKA_LEVELS_CONFIG (object);
switch (property_id)
{
case PROP_TRC:
g_value_set_enum (value, self->trc);
break;
case PROP_LINEAR:
g_value_set_boolean (value, self->trc == PIKA_TRC_LINEAR ? TRUE : FALSE);
break;
case PROP_CHANNEL:
g_value_set_enum (value, self->channel);
break;
case PROP_LOW_INPUT:
g_value_set_double (value, self->low_input[self->channel]);
break;
case PROP_HIGH_INPUT:
g_value_set_double (value, self->high_input[self->channel]);
break;
case PROP_CLAMP_INPUT:
g_value_set_boolean (value, self->clamp_input);
break;
case PROP_GAMMA:
g_value_set_double (value, self->gamma[self->channel]);
break;
case PROP_LOW_OUTPUT:
g_value_set_double (value, self->low_output[self->channel]);
break;
case PROP_HIGH_OUTPUT:
g_value_set_double (value, self->high_output[self->channel]);
break;
case PROP_CLAMP_OUTPUT:
g_value_set_boolean (value, self->clamp_output);
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
break;
}
}
static void
pika_levels_config_set_property (GObject *object,
guint property_id,
const GValue *value,
GParamSpec *pspec)
{
PikaLevelsConfig *self = PIKA_LEVELS_CONFIG (object);
switch (property_id)
{
case PROP_TRC:
self->trc = g_value_get_enum (value);
break;
case PROP_LINEAR:
self->trc = g_value_get_boolean (value) ?
PIKA_TRC_LINEAR : PIKA_TRC_NON_LINEAR;
g_object_notify (object, "trc");
break;
case PROP_CHANNEL:
self->channel = g_value_get_enum (value);
g_object_notify (object, "low-input");
g_object_notify (object, "high-input");
g_object_notify (object, "gamma");
g_object_notify (object, "low-output");
g_object_notify (object, "high-output");
break;
case PROP_LOW_INPUT:
self->low_input[self->channel] = g_value_get_double (value);
break;
case PROP_HIGH_INPUT:
self->high_input[self->channel] = g_value_get_double (value);
break;
case PROP_CLAMP_INPUT:
self->clamp_input = g_value_get_boolean (value);
break;
case PROP_GAMMA:
self->gamma[self->channel] = g_value_get_double (value);
break;
case PROP_LOW_OUTPUT:
self->low_output[self->channel] = g_value_get_double (value);
break;
case PROP_HIGH_OUTPUT:
self->high_output[self->channel] = g_value_get_double (value);
break;
case PROP_CLAMP_OUTPUT:
self->clamp_output = g_value_get_boolean (value);
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
break;
}
}
static gboolean
pika_levels_config_serialize (PikaConfig *config,
PikaConfigWriter *writer,
gpointer data)
{
PikaLevelsConfig *l_config = PIKA_LEVELS_CONFIG (config);
PikaHistogramChannel channel;
PikaHistogramChannel old_channel;
gboolean success = TRUE;
if (! pika_operation_settings_config_serialize_base (config, writer, data) ||
! pika_config_serialize_property_by_name (config, "trc", writer) ||
! pika_config_serialize_property_by_name (config, "clamp-input", writer) ||
! pika_config_serialize_property_by_name (config, "clamp-output", writer))
return FALSE;
old_channel = l_config->channel;
for (channel = PIKA_HISTOGRAM_VALUE;
channel <= PIKA_HISTOGRAM_ALPHA;
channel++)
{
l_config->channel = channel;
/* serialize the channel properties manually (not using
* pika_config_serialize_properties()), so the parent class'
* properties don't end up in the config file one per channel.
* See bug #700653.
*/
success =
(pika_config_serialize_property_by_name (config, "channel", writer) &&
pika_config_serialize_property_by_name (config, "low-input", writer) &&
pika_config_serialize_property_by_name (config, "high-input", writer) &&
pika_config_serialize_property_by_name (config, "gamma", writer) &&
pika_config_serialize_property_by_name (config, "low-output", writer) &&
pika_config_serialize_property_by_name (config, "high-output", writer));
if (! success)
break;
}
l_config->channel = old_channel;
return success;
}
static gboolean
pika_levels_config_deserialize (PikaConfig *config,
GScanner *scanner,
gint nest_level,
gpointer data)
{
PikaLevelsConfig *l_config = PIKA_LEVELS_CONFIG (config);
PikaHistogramChannel old_channel;
gboolean success = TRUE;
old_channel = l_config->channel;
success = pika_config_deserialize_properties (config, scanner, nest_level);
g_object_set (config, "channel", old_channel, NULL);
return success;
}
static gboolean
pika_levels_config_equal (PikaConfig *a,
PikaConfig *b)
{
PikaLevelsConfig *config_a = PIKA_LEVELS_CONFIG (a);
PikaLevelsConfig *config_b = PIKA_LEVELS_CONFIG (b);
PikaHistogramChannel channel;
if (! pika_operation_settings_config_equal_base (a, b) ||
config_a->trc != config_b->trc ||
config_a->clamp_input != config_b->clamp_input ||
config_a->clamp_output != config_b->clamp_output)
return FALSE;
for (channel = PIKA_HISTOGRAM_VALUE;
channel <= PIKA_HISTOGRAM_ALPHA;
channel++)
{
if (config_a->gamma[channel] != config_b->gamma[channel] ||
config_a->low_input[channel] != config_b->low_input[channel] ||
config_a->high_input[channel] != config_b->high_input[channel] ||
config_a->low_output[channel] != config_b->low_output[channel] ||
config_a->high_output[channel] != config_b->high_output[channel])
return FALSE;
}
/* don't compare "channel" */
return TRUE;
}
static void
pika_levels_config_reset (PikaConfig *config)
{
PikaLevelsConfig *l_config = PIKA_LEVELS_CONFIG (config);
PikaHistogramChannel channel;
pika_operation_settings_config_reset_base (config);
for (channel = PIKA_HISTOGRAM_VALUE;
channel <= PIKA_HISTOGRAM_ALPHA;
channel++)
{
l_config->channel = channel;
pika_levels_config_reset_channel (l_config);
}
pika_config_reset_property (G_OBJECT (config), "trc");
pika_config_reset_property (G_OBJECT (config), "channel");
pika_config_reset_property (G_OBJECT (config), "clamp-input");
pika_config_reset_property (G_OBJECT (config), "clamp_output");
}
static gboolean
pika_levels_config_copy (PikaConfig *src,
PikaConfig *dest,
GParamFlags flags)
{
PikaLevelsConfig *src_config = PIKA_LEVELS_CONFIG (src);
PikaLevelsConfig *dest_config = PIKA_LEVELS_CONFIG (dest);
PikaHistogramChannel channel;
if (! pika_operation_settings_config_copy_base (src, dest, flags))
return FALSE;
for (channel = PIKA_HISTOGRAM_VALUE;
channel <= PIKA_HISTOGRAM_ALPHA;
channel++)
{
dest_config->gamma[channel] = src_config->gamma[channel];
dest_config->low_input[channel] = src_config->low_input[channel];
dest_config->high_input[channel] = src_config->high_input[channel];
dest_config->low_output[channel] = src_config->low_output[channel];
dest_config->high_output[channel] = src_config->high_output[channel];
}
g_object_notify (G_OBJECT (dest), "gamma");
g_object_notify (G_OBJECT (dest), "low-input");
g_object_notify (G_OBJECT (dest), "high-input");
g_object_notify (G_OBJECT (dest), "low-output");
g_object_notify (G_OBJECT (dest), "high-output");
dest_config->trc = src_config->trc;
dest_config->channel = src_config->channel;
dest_config->clamp_input = src_config->clamp_input;
dest_config->clamp_output = src_config->clamp_output;
g_object_notify (G_OBJECT (dest), "trc");
g_object_notify (G_OBJECT (dest), "channel");
g_object_notify (G_OBJECT (dest), "clamp-input");
g_object_notify (G_OBJECT (dest), "clamp-output");
return TRUE;
}
/* public functions */
void
pika_levels_config_reset_channel (PikaLevelsConfig *config)
{
g_return_if_fail (PIKA_IS_LEVELS_CONFIG (config));
g_object_freeze_notify (G_OBJECT (config));
pika_config_reset_property (G_OBJECT (config), "gamma");
pika_config_reset_property (G_OBJECT (config), "low-input");
pika_config_reset_property (G_OBJECT (config), "high-input");
pika_config_reset_property (G_OBJECT (config), "low-output");
pika_config_reset_property (G_OBJECT (config), "high-output");
g_object_thaw_notify (G_OBJECT (config));
}
void
pika_levels_config_stretch (PikaLevelsConfig *config,
PikaHistogram *histogram,
gboolean is_color)
{
g_return_if_fail (PIKA_IS_LEVELS_CONFIG (config));
g_return_if_fail (histogram != NULL);
g_object_freeze_notify (G_OBJECT (config));
if (is_color)
{
PikaHistogramChannel channel;
/* Set the overall value to defaults */
channel = config->channel;
config->channel = PIKA_HISTOGRAM_VALUE;
pika_levels_config_reset_channel (config);
config->channel = channel;
for (channel = PIKA_HISTOGRAM_RED;
channel <= PIKA_HISTOGRAM_BLUE;
channel++)
{
pika_levels_config_stretch_channel (config, histogram, channel);
}
}
else
{
pika_levels_config_stretch_channel (config, histogram,
PIKA_HISTOGRAM_VALUE);
}
g_object_thaw_notify (G_OBJECT (config));
}
void
pika_levels_config_stretch_channel (PikaLevelsConfig *config,
PikaHistogram *histogram,
PikaHistogramChannel channel)
{
gdouble count;
gdouble bias = 0.006;
gint n_bins;
gint i;
g_return_if_fail (PIKA_IS_LEVELS_CONFIG (config));
g_return_if_fail (histogram != NULL);
g_object_freeze_notify (G_OBJECT (config));
config->gamma[channel] = 1.0;
config->low_output[channel] = 0.0;
config->high_output[channel] = 1.0;
n_bins = pika_histogram_n_bins (histogram);
count = pika_histogram_get_count (histogram, channel, 0, n_bins - 1);
if (count == 0.0)
{
config->low_input[channel] = 0.0;
config->high_input[channel] = 0.0;
}
else
{
gdouble new_count;
gdouble percentage;
gdouble next_percentage;
/* Set the low input */
new_count = 0.0;
for (i = 0; i < (n_bins - 1); i++)
{
new_count += pika_histogram_get_value (histogram, channel, i);
percentage = new_count / count;
next_percentage = (new_count +
pika_histogram_get_value (histogram,
channel,
i + 1)) / count;
if (fabs (percentage - bias) < fabs (next_percentage - bias))
{
config->low_input[channel] = (gdouble) (i + 1) / (n_bins - 1);
break;
}
}
/* Set the high input */
new_count = 0.0;
for (i = (n_bins - 1); i > 0; i--)
{
new_count += pika_histogram_get_value (histogram, channel, i);
percentage = new_count / count;
next_percentage = (new_count +
pika_histogram_get_value (histogram,
channel,
i - 1)) / count;
if (fabs (percentage - bias) < fabs (next_percentage - bias))
{
config->high_input[channel] = (gdouble) (i - 1) / (n_bins - 1);
break;
}
}
}
g_object_notify (G_OBJECT (config), "gamma");
g_object_notify (G_OBJECT (config), "low-input");
g_object_notify (G_OBJECT (config), "high-input");
g_object_notify (G_OBJECT (config), "low-output");
g_object_notify (G_OBJECT (config), "high-output");
g_object_thaw_notify (G_OBJECT (config));
}
static gdouble
pika_levels_config_input_from_color (PikaHistogramChannel channel,
const PikaRGB *color)
{
switch (channel)
{
case PIKA_HISTOGRAM_VALUE:
return MAX (MAX (color->r, color->g), color->b);
case PIKA_HISTOGRAM_RED:
return color->r;
case PIKA_HISTOGRAM_GREEN:
return color->g;
case PIKA_HISTOGRAM_BLUE:
return color->b;
case PIKA_HISTOGRAM_ALPHA:
return color->a;
case PIKA_HISTOGRAM_RGB:
return MIN (MIN (color->r, color->g), color->b);
case PIKA_HISTOGRAM_LUMINANCE:
return PIKA_RGB_LUMINANCE (color->r, color->g, color->b);
}
return 0.0;
}
void
pika_levels_config_adjust_by_colors (PikaLevelsConfig *config,
PikaHistogramChannel channel,
const PikaRGB *black,
const PikaRGB *gray,
const PikaRGB *white)
{
g_return_if_fail (PIKA_IS_LEVELS_CONFIG (config));
g_object_freeze_notify (G_OBJECT (config));
if (black)
{
config->low_input[channel] = pika_levels_config_input_from_color (channel,
black);
g_object_notify (G_OBJECT (config), "low-input");
}
if (white)
{
config->high_input[channel] = pika_levels_config_input_from_color (channel,
white);
g_object_notify (G_OBJECT (config), "high-input");
}
if (gray)
{
gdouble input;
gdouble range;
gdouble inten;
gdouble out_light;
gdouble lightness;
/* Calculate lightness value */
lightness = PIKA_RGB_LUMINANCE (gray->r, gray->g, gray->b);
input = pika_levels_config_input_from_color (channel, gray);
range = config->high_input[channel] - config->low_input[channel];
if (range <= 0)
goto out;
input -= config->low_input[channel];
if (input < 0)
goto out;
/* Normalize input and lightness */
inten = input / range;
out_light = lightness / range;
/* See bug 622054: picking pure black or white as gamma doesn't
* work. But we cannot compare to 0.0 or 1.0 because cpus and
* compilers are shit. If you try to check out_light using
* printf() it will give exact 0.0 or 1.0 anyway, probably
* because the generated code is different and out_light doesn't
* live in a register. That must be why the cpu/compiler mafia
* invented epsilon and defined this shit to be the programmer's
* responsibility.
*/
if (out_light <= 0.0001 || out_light >= 0.9999)
goto out;
/* Map selected color to corresponding lightness */
config->gamma[channel] = log (inten) / log (out_light);
config->gamma[channel] = CLAMP (config->gamma[channel], 0.1, 10.0);
g_object_notify (G_OBJECT (config), "gamma");
}
out:
g_object_thaw_notify (G_OBJECT (config));
}
PikaCurvesConfig *
pika_levels_config_to_curves_config (PikaLevelsConfig *config)
{
PikaCurvesConfig *curves;
PikaHistogramChannel channel;
g_return_val_if_fail (PIKA_IS_LEVELS_CONFIG (config), NULL);
curves = g_object_new (PIKA_TYPE_CURVES_CONFIG, NULL);
pika_operation_settings_config_copy_base (PIKA_CONFIG (config),
PIKA_CONFIG (curves),
0);
curves->trc = config->trc;
for (channel = PIKA_HISTOGRAM_VALUE;
channel <= PIKA_HISTOGRAM_ALPHA;
channel++)
{
PikaCurve *curve = curves->curve[channel];
static const gint n = 8;
gdouble gamma = config->gamma[channel];
gdouble delta_in;
gdouble delta_out;
gdouble x, y;
/* clear the points set by default */
pika_curve_clear_points (curve);
delta_in = config->high_input[channel] - config->low_input[channel];
delta_out = config->high_output[channel] - config->low_output[channel];
x = config->low_input[channel];
y = config->low_output[channel];
pika_curve_add_point (curve, x, y);
if (delta_out != 0 && gamma != 1.0)
{
/* The Levels tool performs gamma adjustment, which is a
* power law, while the Curves tool uses cubic Bézier
* curves. Here we try to approximate this gamma adjustment
* with a Bézier curve with 5 control points. Two of them
* must be (low_input, low_output) and (high_input,
* high_output), so we need to add 3 more control points in
* the middle.
*/
gint i;
if (gamma > 1)
{
/* Case no. 1: γ > 1
*
* The curve should look like a horizontal
* parabola. Since its curvature is greatest when x is
* small, we add more control points there, so the
* approximation is more accurate. I decided to set the
* length of the consecutive segments to x₀, γ⋅x₀, γ²⋅x₀
* and γ³⋅x₀ and I saw that the curves looked
* good. Still, this is completely arbitrary.
*/
gdouble dx = 0;
gdouble x0;
for (i = 0; i < n; ++i)
dx = dx * gamma + 1;
x0 = delta_in / dx;
dx = 0;
for (i = 1; i < n; ++i)
{
dx = dx * gamma + x0;
x = config->low_input[channel] + dx;
y = config->low_output[channel] + delta_out *
pika_operation_levels_map_input (config, channel, x);
pika_curve_add_point (curve, x, y);
}
}
else
{
/* Case no. 2: γ < 1
*
* The curve is the same as the one in case no. 1,
* observed through a reflexion along the y = x axis. So
* if we invert γ and swap the x and y axes we can use
* the same method as in case no. 1.
*/
PikaLevelsConfig *config_inv;
gdouble dy = 0;
gdouble y0;
const gdouble gamma_inv = 1 / gamma;
config_inv = pika_config_duplicate (PIKA_CONFIG (config));
config_inv->gamma[channel] = gamma_inv;
config_inv->low_input[channel] = config->low_output[channel];
config_inv->low_output[channel] = config->low_input[channel];
config_inv->high_input[channel] = config->high_output[channel];
config_inv->high_output[channel] = config->high_input[channel];
for (i = 0; i < n; ++i)
dy = dy * gamma_inv + 1;
y0 = delta_out / dy;
dy = 0;
for (i = 1; i < n; ++i)
{
dy = dy * gamma_inv + y0;
y = config->low_output[channel] + dy;
x = config->low_input[channel] + delta_in *
pika_operation_levels_map_input (config_inv, channel, y);
pika_curve_add_point (curve, x, y);
}
g_object_unref (config_inv);
}
}
x = config->high_input[channel];
y = config->high_output[channel];
pika_curve_add_point (curve, x, y);
}
return curves;
}
gboolean
pika_levels_config_load_cruft (PikaLevelsConfig *config,
GInputStream *input,
GError **error)
{
GDataInputStream *data_input;
gint low_input[5];
gint high_input[5];
gint low_output[5];
gint high_output[5];
gdouble gamma[5];
gchar *line;
gsize line_len;
gint i;
g_return_val_if_fail (PIKA_IS_LEVELS_CONFIG (config), FALSE);
g_return_val_if_fail (G_IS_INPUT_STREAM (input), FALSE);
g_return_val_if_fail (error == NULL || *error == NULL, FALSE);
data_input = g_data_input_stream_new (input);
line_len = 64;
line = pika_data_input_stream_read_line_always (data_input, &line_len,
NULL, error);
if (! line)
return FALSE;
if (strcmp (line, "# PIKA Levels File") != 0)
{
g_set_error_literal (error, PIKA_CONFIG_ERROR, PIKA_CONFIG_ERROR_PARSE,
_("not a PIKA Levels file"));
g_object_unref (data_input);
g_free (line);
return FALSE;
}
g_free (line);
for (i = 0; i < 5; i++)
{
gchar float_buf[32];
gchar *endp;
gint fields;
line_len = 64;
line = pika_data_input_stream_read_line_always (data_input, &line_len,
NULL, error);
if (! line)
{
g_object_unref (data_input);
return FALSE;
}
fields = sscanf (line, "%d %d %d %d %31s",
&low_input[i],
&high_input[i],
&low_output[i],
&high_output[i],
float_buf);
g_free (line);
if (fields != 5)
goto error;
gamma[i] = g_ascii_strtod (float_buf, &endp);
if (endp == float_buf || errno == ERANGE)
goto error;
}
g_object_unref (data_input);
g_object_freeze_notify (G_OBJECT (config));
for (i = 0; i < 5; i++)
{
config->low_input[i] = low_input[i] / 255.0;
config->high_input[i] = high_input[i] / 255.0;
config->gamma[i] = gamma[i];
config->low_output[i] = low_output[i] / 255.0;
config->high_output[i] = high_output[i] / 255.0;
}
config->trc = PIKA_TRC_NON_LINEAR;
config->clamp_input = TRUE;
config->clamp_output = TRUE;
g_object_notify (G_OBJECT (config), "trc");
g_object_notify (G_OBJECT (config), "low-input");
g_object_notify (G_OBJECT (config), "high-input");
g_object_notify (G_OBJECT (config), "clamp-input");
g_object_notify (G_OBJECT (config), "gamma");
g_object_notify (G_OBJECT (config), "low-output");
g_object_notify (G_OBJECT (config), "high-output");
g_object_notify (G_OBJECT (config), "clamp-output");
g_object_thaw_notify (G_OBJECT (config));
return TRUE;
error:
g_object_unref (data_input);
g_set_error_literal (error, PIKA_CONFIG_ERROR, PIKA_CONFIG_ERROR_PARSE,
_("parse error"));
return FALSE;
}
gboolean
pika_levels_config_save_cruft (PikaLevelsConfig *config,
GOutputStream *output,
GError **error)
{
GString *string;
gint i;
g_return_val_if_fail (PIKA_IS_LEVELS_CONFIG (config), FALSE);
g_return_val_if_fail (G_IS_OUTPUT_STREAM (output), FALSE);
g_return_val_if_fail (error == NULL || *error == NULL, FALSE);
string = g_string_new ("# PIKA Levels File\n");
for (i = 0; i < 5; i++)
{
gchar buf[G_ASCII_DTOSTR_BUF_SIZE];
g_string_append_printf (string,
"%d %d %d %d %s\n",
(gint) (config->low_input[i] * 255.999),
(gint) (config->high_input[i] * 255.999),
(gint) (config->low_output[i] * 255.999),
(gint) (config->high_output[i] * 255.999),
g_ascii_dtostr (buf, G_ASCII_DTOSTR_BUF_SIZE,
config->gamma[i]));
}
if (! g_output_stream_write_all (output, string->str, string->len,
NULL, NULL, error))
{
g_prefix_error (error, _("Writing levels file failed: "));
g_string_free (string, TRUE);
return FALSE;
}
g_string_free (string, TRUE);
return TRUE;
}