void InitUtils(const char* PName)
{
strncpy(ProgramName, PName, sizeof(ProgramName));
ProgramName[sizeof(ProgramName)-1] = 0;
cmsSetLogErrorHandler(MyErrorLogHandler);
}
/**
* cd_icc_effect_generate_cogl_color_data:
**/
static CoglHandle
cd_icc_effect_generate_cogl_color_data (const gchar *filename, GError **error)
{
CoglHandle tex = NULL;
cmsHPROFILE device_profile;
cmsHPROFILE srgb_profile;
cmsUInt8Number *data;
cmsHTRANSFORM transform;
guint array_size;
guint r, g, b;
guint8 *p;
cmsSetLogErrorHandler (cd_icc_effect_error_cb);
srgb_profile = cmsCreate_sRGBProfile ();
device_profile = cmsOpenProfileFromFile (filename, "r");
/* create a cube and cut itup into parts */
array_size = GCM_GLSL_LOOKUP_SIZE * GCM_GLSL_LOOKUP_SIZE * GCM_GLSL_LOOKUP_SIZE;
data = g_new0 (cmsUInt8Number, 3 * array_size);
transform = cmsCreateTransform (srgb_profile, TYPE_RGB_8, device_profile, TYPE_RGB_8, INTENT_PERCEPTUAL, 0);
/* we failed */
if (transform == NULL)
{
g_set_error (error, 1, 0, "could not create transform");
goto out;
}
/* create mapping (blue->r, green->t, red->s) */
for (p = data, b = 0; b < GCM_GLSL_LOOKUP_SIZE; b++) {
for (g = 0; g < GCM_GLSL_LOOKUP_SIZE; g++) {
for (r = 0; r < GCM_GLSL_LOOKUP_SIZE; r++) {
*(p++) = (r * 255) / (GCM_GLSL_LOOKUP_SIZE - 1);
*(p++) = (g * 255) / (GCM_GLSL_LOOKUP_SIZE - 1);
*(p++) = (b * 255) / (GCM_GLSL_LOOKUP_SIZE - 1);
}
}
}
cmsDoTransform (transform, data, data, array_size);
/* creates a cogl texture from the data */
tex = cogl_texture_3d_new_from_data (GCM_GLSL_LOOKUP_SIZE, /* width */
GCM_GLSL_LOOKUP_SIZE, /* height */
GCM_GLSL_LOOKUP_SIZE, /* depth */
COGL_TEXTURE_NO_AUTO_MIPMAP,
COGL_PIXEL_FORMAT_RGB_888,
COGL_PIXEL_FORMAT_ANY,
/* data is tightly packed so we can pass zero */
0, 0,
data, error);
out:
cmsCloseProfile (device_profile);
cmsCloseProfile (srgb_profile);
if (transform != NULL)
cmsDeleteTransform (transform);
g_free (data);
return tex;
}
/* Get ICC Profile handle from buffer */
gcmmhprofile_t
gscms_get_profile_handle_mem(gs_memory_t *mem, unsigned char *buffer,
unsigned int input_size)
{
cmsSetLogErrorHandler(gscms_error);
return(cmsOpenProfileFromMemTHR((cmsContext)mem,buffer,input_size));
}
int
main (int argc, char *argv[])
{
GcmPickerPrivate *priv;
GOptionContext *context;
GtkApplication *application;
guint xid = 0;
int status = 0;
const GOptionEntry options[] = {
{ "parent-window", 'p', 0, G_OPTION_ARG_INT, &xid,
/* TRANSLATORS: we can make this modal (stay on top of) another window */
_("Set the parent window to make this modal"), NULL },
{ NULL}
};
/* setup translations */
setlocale (LC_ALL, "");
bindtextdomain (GETTEXT_PACKAGE, LOCALEDIR);
bind_textdomain_codeset (GETTEXT_PACKAGE, "UTF-8");
textdomain (GETTEXT_PACKAGE);
/* setup LCMS */
cmsSetLogErrorHandler (gcm_picker_error_cb);
context = g_option_context_new (NULL);
/* TRANSLATORS: tool that is used to pick colors */
g_option_context_set_summary (context, _("GNOME Color Manager Color Picker"));
g_option_context_add_group (context, gcm_debug_get_option_group ());
g_option_context_add_group (context, gtk_get_option_group (TRUE));
g_option_context_add_main_entries (context, options, NULL);
g_option_context_parse (context, &argc, &argv, NULL);
g_option_context_free (context);
/* create private */
priv = g_new0 (GcmPickerPrivate, 1);
priv->last_ambient = -1.0f;
priv->xid = xid;
/* ensure single instance */
application = gtk_application_new ("org.gnome.ColorManager.Picker", 0);
g_signal_connect (application, "startup",
G_CALLBACK (gcm_picker_startup_cb), priv);
g_signal_connect (application, "activate",
G_CALLBACK (gcm_picker_activate_cb), priv);
status = g_application_run (G_APPLICATION (application), argc, argv);
g_object_unref (application);
if (priv->client != NULL)
g_object_unref (priv->client);
if (priv->builder != NULL)
g_object_unref (priv->builder);
g_free (priv);
return status;
}
ScLcms2ColorMgmtEngineImpl::ScLcms2ColorMgmtEngineImpl()
: ScColorMgmtEngineData("Littlecms v2", 1)
{
if (!m_profileCache)
m_profileCache = QSharedPointer<ScColorProfileCache>(new ScColorProfileCache());
if (!m_transformPool)
m_transformPool = QSharedPointer<ScColorTransformPool>(new ScColorTransformPool(0));
cmsUInt16Number alarmCodes[cmsMAXCHANNELS] = { 0 };
alarmCodes[1] = 0xFFFF;
cmsSetAlarmCodes(alarmCodes);
cmsSetLogErrorHandler(&cmsErrorHandler);
}
/* Do any initialization if needed to the CMS */
int
gscms_create(gs_memory_t *memory)
{
/* Set our own error handling function */
cmsSetLogErrorHandler(gscms_error);
cmsPluginTHR(memory, (void *)&gs_cms_memhandler);
/* If we had created any persitent state that we needed access to in the
* other functions, we should store that by calling:
* gs_lib_ctx_set_cms_context(memory, state);
* We can then retrieve it anywhere else by calling:
* gs_lib_ctx_get_cms_context(memory);
* LCMS currently uses no such state. */
return 0;
}
static void init(void)
{
cmsCIEXYZ D65_XYZ = {0.95047, 1.0, 1.08883 };
cmsCIExyY D65;
cmsXYZ2xyY(&D65, &D65_XYZ);
cmsToneCurve *linear = cmsBuildGamma(NULL, 1.0);
cmsToneCurve *linrgb[3] = {linear,linear,linear};
cmsCIExyYTRIPLE primaries = {
{0.64, 0.33, 1.0},
{0.30, 0.60, 1.0},
{0.15, 0.06, 1.0}
};
cmsFloat64Number P[5] = { 2.4, 1. / 1.055, 0.055 / 1.055, 1. / 12.92, 0.04045 };
cmsToneCurve *srgb = cmsBuildParametricToneCurve(NULL, 4, P);
cmsToneCurve *srgbcurve[3] = {srgb,srgb,srgb};
cmsHPROFILE hsRGB = cmsCreateRGBProfile(&D65, &primaries, srgbcurve);
cmsHPROFILE hLab = cmsCreateLab4Profile(NULL);
cmsHPROFILE hlRGB = cmsCreateRGBProfile(&D65, &primaries, linrgb);
cmsHPROFILE hlGray = cmsCreateGrayProfile(cmsD50_xyY(), linear);
cmsSetHeaderFlags(hlGray, cmsEmbeddedProfileTrue);
cmsSaveProfileToFile(hlGray,"lgray.icc");
cmsSetHeaderFlags(hlRGB, cmsEmbeddedProfileTrue);
cmsSaveProfileToFile(hlRGB,"lrgb.icc");
xform_srgb_to_lrgb = cmsCreateTransform(hsRGB, TYPE_RGB_DBL,
hlRGB, TYPE_RGB_DBL,
INTENT_RELATIVE_COLORIMETRIC,
cmsFLAGS_NOOPTIMIZE /* preserve precision */
);
xform_srgb_to_lab = cmsCreateTransform(hsRGB, TYPE_RGB_DBL, hLab,
TYPE_Lab_DBL, INTENT_RELATIVE_COLORIMETRIC,
cmsFLAGS_NOOPTIMIZE);
xform_srgb_to_lgray = cmsCreateTransform(hsRGB, TYPE_RGB_DBL, hlGray,
TYPE_GRAY_DBL, INTENT_RELATIVE_COLORIMETRIC,
cmsFLAGS_NOOPTIMIZE);
cmsCloseProfile(hsRGB);
cmsCloseProfile(hlRGB);
cmsCloseProfile(hLab);
cmsCloseProfile(hlGray);
cmsFreeToneCurve(linear);
cmsFreeToneCurve(srgb);
cmsSetLogErrorHandler(errlog);
/* sRGB, RGB, Lab, Gray */
printf("R',G',B',R,G,B,L,a,b,Gray\n");
}
static void
gimp_color_transform_class_init (GimpColorTransformClass *klass)
{
GObjectClass *object_class = G_OBJECT_CLASS (klass);
object_class->finalize = gimp_color_transform_finalize;
gimp_color_transform_signals[PROGRESS] =
g_signal_new ("progress",
G_OBJECT_CLASS_TYPE (object_class),
G_SIGNAL_RUN_FIRST,
G_STRUCT_OFFSET (GimpColorTransformClass,
progress),
NULL, NULL,
g_cclosure_marshal_VOID__DOUBLE,
G_TYPE_NONE, 1,
G_TYPE_DOUBLE);
g_type_class_add_private (klass, sizeof (GimpColorTransformPrivate));
cmsSetLogErrorHandler (lcms_error_handler);
}
BOOL WINAPI DllMain( HINSTANCE hinst, DWORD reason, LPVOID reserved )
{
TRACE( "(%p, %d, %p)\n", hinst, reason, reserved );
switch (reason)
{
case DLL_PROCESS_ATTACH:
DisableThreadLibraryCalls( hinst );
#ifdef HAVE_LCMS2
cmsSetLogErrorHandler( lcms_error_handler );
#else
ERR( "Wine was built without support for liblcms2, expect problems\n" );
#endif
break;
case DLL_PROCESS_DETACH:
if (reserved) break;
#ifdef HAVE_LCMS2
free_handle_tables();
#endif
break;
}
return TRUE;
}
/**
* main:
**/
int
main (int argc, char *argv[])
{
GOptionContext *context;
guint retval = 0;
GError *error = NULL;
GMainLoop *loop;
GtkWidget *main_window;
GtkWidget *widget;
UniqueApp *unique_app;
guint xid = 0;
McmColorimeter *colorimeter = NULL;
const GOptionEntry options[] = {
{ "parent-window", 'p', 0, G_OPTION_ARG_INT, &xid,
/* TRANSLATORS: we can make this modal (stay on top of) another window */
_("Set the parent window to make this modal"), NULL },
{ NULL}
};
/* setup translations */
setlocale (LC_ALL, "");
bindtextdomain (GETTEXT_PACKAGE, LOCALEDIR);
bind_textdomain_codeset (GETTEXT_PACKAGE, "UTF-8");
textdomain (GETTEXT_PACKAGE);
/* setup LCMS */
cmsSetLogErrorHandler (mcm_picker_error_cb);
context = g_option_context_new (NULL);
/* TRANSLATORS: tool that is used to pick colors */
g_option_context_set_summary (context, _("MATE Color Manager Color Picker"));
g_option_context_add_group (context, egg_debug_get_option_group ());
g_option_context_add_group (context, gtk_get_option_group (TRUE));
g_option_context_add_main_entries (context, options, NULL);
g_option_context_parse (context, &argc, &argv, NULL);
g_option_context_free (context);
/* block in a loop */
loop = g_main_loop_new (NULL, FALSE);
/* are we already activated? */
unique_app = unique_app_new ("org.mate.ColorManager.Picker", NULL);
if (unique_app_is_running (unique_app)) {
egg_debug ("You have another instance running. This program will now close");
unique_app_send_message (unique_app, UNIQUE_ACTIVATE, NULL);
goto out;
}
g_signal_connect (unique_app, "message-received",
G_CALLBACK (mcm_picker_message_received_cb), NULL);
/* get UI */
builder = gtk_builder_new ();
retval = gtk_builder_add_from_file (builder, MCM_DATA "/mcm-picker.ui", &error);
if (retval == 0) {
egg_warning ("failed to load ui: %s", error->message);
g_error_free (error);
goto out;
}
main_window = GTK_WIDGET (gtk_builder_get_object (builder, "dialog_picker"));
gtk_window_set_icon_name (GTK_WINDOW (main_window), MCM_STOCK_ICON);
g_signal_connect (main_window, "delete_event",
G_CALLBACK (mcm_picker_delete_event_cb), loop);
widget = GTK_WIDGET (gtk_builder_get_object (builder, "button_close"));
g_signal_connect (widget, "clicked",
G_CALLBACK (mcm_picker_close_cb), loop);
widget = GTK_WIDGET (gtk_builder_get_object (builder, "button_help"));
g_signal_connect (widget, "clicked",
G_CALLBACK (mcm_picker_help_cb), NULL);
widget = GTK_WIDGET (gtk_builder_get_object (builder, "button_measure"));
g_signal_connect (widget, "clicked",
G_CALLBACK (mcm_picker_measure_cb), NULL);
widget = GTK_WIDGET (gtk_builder_get_object (builder, "image_preview"));
gtk_widget_set_size_request (widget, 200, 200);
/* add application specific icons to search path */
gtk_icon_theme_append_search_path (gtk_icon_theme_get_default (),
MCM_DATA G_DIR_SEPARATOR_S "icons");
/* use the color device */
colorimeter = mcm_colorimeter_new ();
g_signal_connect (colorimeter, "changed", G_CALLBACK (mcm_picker_colorimeter_changed_cb), NULL);
/* set the parent window if it is specified */
if (xid != 0) {
egg_debug ("Setting xid %i", xid);
mcm_window_set_parent_xid (GTK_WINDOW (main_window), xid);
}
/* use argyll */
calibrate = MCM_CALIBRATE (mcm_calibrate_argyll_new ());
g_signal_connect (calibrate, "notify::xyz",
G_CALLBACK (mcm_picker_xyz_notify_cb), NULL);
/* use an info bar if there is no device, or the wrong device */
info_bar_hardware = gtk_info_bar_new ();
info_bar_hardware_label = gtk_label_new (NULL);
gtk_info_bar_set_message_type (GTK_INFO_BAR(info_bar_hardware), GTK_MESSAGE_INFO);
widget = gtk_info_bar_get_content_area (GTK_INFO_BAR(info_bar_hardware));
gtk_container_add (GTK_CONTAINER(widget), info_bar_hardware_label);
gtk_widget_show (info_bar_hardware_label);
/* add infobar to devices pane */
widget = GTK_WIDGET (gtk_builder_get_object (builder, "vbox1"));
gtk_box_pack_start (GTK_BOX(widget), info_bar_hardware, FALSE, FALSE, 0);
/* disable some ui if no hardware */
mcm_picker_colorimeter_setup_ui (colorimeter);
/* maintain a list of profiles */
profile_store = mcm_profile_store_new ();
/* default to AdobeRGB */
profile_filename = "/usr/share/color/icc/Argyll/ClayRGB1998.icm";
/* setup RGB combobox */
widget = GTK_WIDGET (gtk_builder_get_object (builder, "combobox_colorspace"));
mcm_prefs_set_combo_simple_text (widget);
mcm_prefs_setup_space_combobox (widget);
g_signal_connect (G_OBJECT (widget), "changed",
G_CALLBACK (mcm_prefs_space_combo_changed_cb), NULL);
/* setup results expander */
mcm_picker_refresh_results ();
/* setup initial preview window */
widget = GTK_WIDGET (gtk_builder_get_object (builder, "image_preview"));
gtk_image_set_from_file (GTK_IMAGE (widget), DATADIR "/icons/hicolor/64x64/apps/mate-color-manager.png");
/* wait */
gtk_widget_show (main_window);
g_main_loop_run (loop);
out:
g_object_unref (unique_app);
if (profile_store != NULL)
g_object_unref (profile_store);
if (colorimeter != NULL)
g_object_unref (colorimeter);
if (calibrate != NULL)
g_object_unref (calibrate);
if (builder != NULL)
g_object_unref (builder);
g_main_loop_unref (loop);
return retval;
}
PyObject *
load_png_fast_progressive (char *filename,
PyObject *get_buffer_callback)
{
// Note: we are not using the method that libpng calls "Reading PNG
// files progressively". That method would involve feeding the data
// into libpng piece by piece, which is not necessary if we can give
// libpng a simple FILE pointer.
png_structp png_ptr = NULL;
png_infop info_ptr = NULL;
PyObject * result = NULL;
FILE *fp = NULL;
uint32_t width, height;
uint32_t rows_left;
png_byte color_type;
png_byte bit_depth;
bool have_alpha;
char *cm_processing = NULL;
// ICC profile-based colour conversion data.
png_charp icc_profile_name = NULL;
int icc_compression_type = 0;
#if PNG_LIBPNG_VER < 10500 // 1.5.0beta36, according to libpng CHANGES
png_charp icc_profile = NULL;
#else
png_bytep icc_profile = NULL;
#endif
png_uint_32 icc_proflen = 0;
// The sRGB flag has an intent field, which we ignore -
// the target gamut is sRGB already.
int srgb_intent = 0;
// Generic RGB space conversion params.
// The assumptions we're making are those of sRGB,
// but they'll be overridden by gammas or primaries in the file if used.
bool generic_rgb_have_gAMA = false;
bool generic_rgb_have_cHRM = false;
double generic_rgb_file_gamma = 45455 / PNG_gAMA_scale;
double generic_rgb_white_x = 31270 / PNG_cHRM_scale;
double generic_rgb_white_y = 32900 / PNG_cHRM_scale;
double generic_rgb_red_x = 64000 / PNG_cHRM_scale;
double generic_rgb_red_y = 33000 / PNG_cHRM_scale;
double generic_rgb_green_x = 30000 / PNG_cHRM_scale;
double generic_rgb_green_y = 60000 / PNG_cHRM_scale;
double generic_rgb_blue_x = 15000 / PNG_cHRM_scale;
double generic_rgb_blue_y = 6000 / PNG_cHRM_scale;
// Indicates the case where no CM information was present in the file and we
// treated it as sRGB.
bool possible_legacy_png = false;
// LCMS stuff
cmsHPROFILE input_buffer_profile = NULL;
cmsHPROFILE nparray_data_profile = cmsCreate_sRGBProfile();
cmsHTRANSFORM input_buffer_to_nparray = NULL;
cmsToneCurve *gamma_transfer_func = NULL;
cmsUInt32Number input_buffer_format = 0;
cmsSetLogErrorHandler(log_lcms2_error);
fp = fopen(filename, "rb");
if (!fp) {
PyErr_SetFromErrno(PyExc_IOError);
//PyErr_Format(PyExc_IOError, "Could not open PNG file for writing: %s",
// filename);
goto cleanup;
}
png_ptr = png_create_read_struct (PNG_LIBPNG_VER_STRING, (png_voidp)NULL,
png_read_error_callback, NULL);
if (!png_ptr) {
PyErr_SetString(PyExc_MemoryError, "png_create_write_struct() failed");
goto cleanup;
}
info_ptr = png_create_info_struct(png_ptr);
if (!info_ptr) {
PyErr_SetString(PyExc_MemoryError, "png_create_info_struct() failed");
goto cleanup;
}
if (setjmp(png_jmpbuf(png_ptr))) {
goto cleanup;
}
png_init_io(png_ptr, fp);
png_read_info(png_ptr, info_ptr);
// If there's an embedded ICC profile, use it in preference to any other
// colour management information present.
if (png_get_iCCP (png_ptr, info_ptr, &icc_profile_name,
&icc_compression_type, &icc_profile,
&icc_proflen))
{
input_buffer_profile = cmsOpenProfileFromMem(icc_profile, icc_proflen);
if (! input_buffer_profile) {
PyErr_SetString(PyExc_MemoryError, "cmsOpenProfileFromMem() failed");
goto cleanup;
}
cm_processing = "iCCP (use embedded colour profile)";
}
// Shorthand for sRGB.
else if (png_get_sRGB (png_ptr, info_ptr, &srgb_intent)) {
input_buffer_profile = cmsCreate_sRGBProfile();
cm_processing = "sRGB (explicit sRGB chunk)";
}
else {
// We might have generic RGB transformation information in the form of
// the chromaticities for R, G and B and a generic gamma curve.
if (png_get_cHRM (png_ptr, info_ptr,
&generic_rgb_white_x, &generic_rgb_white_y,
&generic_rgb_red_x, &generic_rgb_red_y,
&generic_rgb_green_x, &generic_rgb_green_y,
&generic_rgb_blue_x, &generic_rgb_blue_y))
{
generic_rgb_have_cHRM = true;
}
if (png_get_gAMA(png_ptr, info_ptr, &generic_rgb_file_gamma)) {
generic_rgb_have_gAMA = true;
}
if (generic_rgb_have_gAMA || generic_rgb_have_cHRM) {
cmsCIExyYTRIPLE primaries = {{generic_rgb_red_x, generic_rgb_red_y},
{generic_rgb_green_x, generic_rgb_green_y},
{generic_rgb_blue_x, generic_rgb_blue_y}};
cmsCIExyY white_point = {generic_rgb_white_x, generic_rgb_white_y};
gamma_transfer_func = cmsBuildGamma(NULL, 1.0/generic_rgb_file_gamma);
cmsToneCurve *transfer_funcs[3] = {gamma_transfer_func,
gamma_transfer_func,
gamma_transfer_func };
input_buffer_profile = cmsCreateRGBProfile(&white_point, &primaries,
transfer_funcs);
cm_processing = "cHRM and/or gAMA (generic RGB space)";
}
// Possible legacy PNG, or rather one which might have been written with an
// old version of MyPaint. Treat as sRGB, but flag the strangeness because
// it might be important for PNGs in old OpenRaster files.
else {
possible_legacy_png = true;
input_buffer_profile = cmsCreate_sRGBProfile();
cm_processing = "sRGB (no CM chunks present)";
}
}
if (png_get_interlace_type (png_ptr, info_ptr) != PNG_INTERLACE_NONE) {
PyErr_SetString(PyExc_RuntimeError,
"Interlaced PNG files are not supported!");
goto cleanup;
}
color_type = png_get_color_type(png_ptr, info_ptr);
bit_depth = png_get_bit_depth(png_ptr, info_ptr);
have_alpha = color_type & PNG_COLOR_MASK_ALPHA;
if (color_type == PNG_COLOR_TYPE_PALETTE) {
png_set_palette_to_rgb(png_ptr);
}
if (color_type == PNG_COLOR_TYPE_GRAY && bit_depth < 8) {
png_set_expand_gray_1_2_4_to_8(png_ptr);
}
if (png_get_valid(png_ptr, info_ptr, PNG_INFO_tRNS)) {
png_set_tRNS_to_alpha(png_ptr);
have_alpha = true;
}
if (bit_depth < 8) {
png_set_packing(png_ptr);
}
if (!have_alpha) {
png_set_add_alpha(png_ptr, 0xFF, PNG_FILLER_AFTER);
}
if (color_type == PNG_COLOR_TYPE_GRAY ||
color_type == PNG_COLOR_TYPE_GRAY_ALPHA) {
png_set_gray_to_rgb(png_ptr);
}
png_read_update_info(png_ptr, info_ptr);
// Verify what we have done
bit_depth = png_get_bit_depth(png_ptr, info_ptr);
if (! (bit_depth == 8 || bit_depth == 16)) {
PyErr_SetString(PyExc_RuntimeError, "Failed to convince libpng to convert "
"to 8 or 16 bits per channel");
goto cleanup;
}
if (png_get_color_type(png_ptr, info_ptr) != PNG_COLOR_TYPE_RGB_ALPHA) {
PyErr_SetString(PyExc_RuntimeError, "Failed to convince libpng to convert "
"to RGBA (wrong color_type)");
goto cleanup;
}
if (png_get_channels(png_ptr, info_ptr) != 4) {
PyErr_SetString(PyExc_RuntimeError, "Failed to convince libpng to convert "
"to RGBA (wrong number of channels)");
goto cleanup;
}
// PNGs use network byte order, i.e. big-endian in descending order
// of bit significance. LittleCMS uses whatever's detected for the compiler.
// ref: http://www.w3.org/TR/2003/REC-PNG-20031110/#7Integers-and-byte-order
if (bit_depth == 16) {
#ifdef CMS_USE_BIG_ENDIAN
input_buffer_format = TYPE_RGBA_16;
#else
input_buffer_format = TYPE_RGBA_16_SE;
#endif
}
else {
input_buffer_format = TYPE_RGBA_8;
}
input_buffer_to_nparray = cmsCreateTransform
(input_buffer_profile, input_buffer_format,
nparray_data_profile, TYPE_RGBA_8,
INTENT_PERCEPTUAL, 0);
width = png_get_image_width(png_ptr, info_ptr);
height = png_get_image_height(png_ptr, info_ptr);
rows_left = height;
while (rows_left) {
PyObject *pyarr = NULL;
uint32_t rows = 0;
uint32_t row = 0;
const uint8_t input_buf_bytes_per_pixel = (bit_depth==8) ? 4 : 8;
const uint32_t input_buf_row_stride = sizeof(png_byte) * width
* input_buf_bytes_per_pixel;
png_byte *input_buffer = NULL;
png_bytep *input_buf_row_pointers = NULL;
pyarr = PyObject_CallFunction(get_buffer_callback, "ii", width, height);
if (! pyarr) {
PyErr_Format(PyExc_RuntimeError, "Get-buffer callback failed");
goto cleanup;
}
#ifdef HEAVY_DEBUG
//assert(PyArray_ISCARRAY(arr));
assert(PyArray_NDIM(pyarr) == 3);
assert(PyArray_DIM(pyarr, 1) == width);
assert(PyArray_DIM(pyarr, 2) == 4);
assert(PyArray_TYPE(pyarr) == NPY_UINT8);
assert(PyArray_ISBEHAVED(pyarr));
assert(PyArray_STRIDE(pyarr, 1) == 4*sizeof(uint8_t));
assert(PyArray_STRIDE(pyarr, 2) == sizeof(uint8_t));
#endif
rows = PyArray_DIM(pyarr, 0);
if (rows > rows_left) {
PyErr_Format(PyExc_RuntimeError,
"Attempt to read %d rows from the PNG, "
"but only %d are left",
rows, rows_left);
goto cleanup;
}
input_buffer = (png_byte *) malloc(rows * input_buf_row_stride);
input_buf_row_pointers = (png_bytep *)malloc(rows * sizeof(png_bytep));
for (row=0; row<rows; row++) {
input_buf_row_pointers[row] = input_buffer + (row * input_buf_row_stride);
}
png_read_rows(png_ptr, input_buf_row_pointers, NULL, rows);
rows_left -= rows;
for (row=0; row<rows; row++) {
uint8_t *pyarr_row = (uint8_t *)PyArray_DATA(pyarr)
+ row*PyArray_STRIDE(pyarr, 0);
uint8_t *input_row = input_buf_row_pointers[row];
// Really minimal fake colour management. Just remaps to sRGB.
cmsDoTransform(input_buffer_to_nparray, input_row, pyarr_row, width);
// lcms2 ignores alpha, so copy that verbatim
// If it's 8bpc RGBA, use A.
// If it's 16bpc RrGgBbAa, use A.
for (uint32_t i=0; i<width; ++i) {
const uint32_t pyarr_alpha_byte = (i*4) + 3;
const uint32_t buf_alpha_byte = (i*input_buf_bytes_per_pixel)
+ ((bit_depth==8) ? 3 : 6);
pyarr_row[pyarr_alpha_byte] = input_row[buf_alpha_byte];
}
}
free(input_buf_row_pointers);
free(input_buffer);
Py_DECREF(pyarr);
}
png_read_end(png_ptr, NULL);
result = Py_BuildValue("{s:b,s:i,s:i,s:s}",
"possible_legacy_png", possible_legacy_png,
"width", width,
"height", height,
"cm_conversions_applied", cm_processing);
cleanup:
if (info_ptr) png_destroy_read_struct (&png_ptr, &info_ptr, NULL);
// libpng's style is to free internally allocated stuff like the icc
// tables in png_destroy_*(). I think.
if (fp) fclose(fp);
if (input_buffer_profile) cmsCloseProfile(input_buffer_profile);
if (nparray_data_profile) cmsCloseProfile(nparray_data_profile);
if (input_buffer_to_nparray) cmsDeleteTransform(input_buffer_to_nparray);
if (gamma_transfer_func) cmsFreeToneCurve(gamma_transfer_func);
return result;
}
/**
* main:
**/
int
main (int argc, char *argv[])
{
CdUtilPrivate *priv;
gboolean ret = TRUE;
gboolean verbose = FALSE;
guint retval = 1;
g_autoptr(GError) error = NULL;
g_autofree gchar *cmd_descriptions = NULL;
g_autofree gchar *locale = NULL;
g_autoptr(GFile) file = NULL;
const GOptionEntry options[] = {
{ "verbose", 'v', 0, G_OPTION_ARG_NONE, &verbose,
/* TRANSLATORS: command line option */
_("Show extra debugging information"), NULL },
{ "locale", '\0', 0, G_OPTION_ARG_STRING, &locale,
/* TRANSLATORS: command line option */
_("The locale to use when setting localized text"), NULL },
{ NULL}
};
setlocale (LC_ALL, "");
bindtextdomain (GETTEXT_PACKAGE, LOCALEDIR);
bind_textdomain_codeset (GETTEXT_PACKAGE, "UTF-8");
textdomain (GETTEXT_PACKAGE);
cmsSetLogErrorHandler (cd_util_lcms_error_cb);
/* create helper object */
priv = g_new0 (CdUtilPrivate, 1);
priv->rewrite_file = TRUE;
priv->client = cd_client_new ();
/* add commands */
priv->cmd_array = g_ptr_array_new_with_free_func ((GDestroyNotify) cd_util_item_free);
cd_util_add (priv->cmd_array,
"extract-vcgt",
/* TRANSLATORS: command description */
_("Generate the VCGT calibration of a given size"),
cd_util_extract_vcgt);
cd_util_add (priv->cmd_array,
"md-clear",
/* TRANSLATORS: command description */
_("Clear any metadata in the profile"),
cd_util_clear_metadata);
cd_util_add (priv->cmd_array,
"md-init",
/* TRANSLATORS: command description */
_("Initialize any metadata for the profile"),
cd_util_init_metadata);
cd_util_add (priv->cmd_array,
"md-add",
/* TRANSLATORS: command description */
_("Add a metadata item to the profile"),
cd_util_add_metadata);
cd_util_add (priv->cmd_array,
"md-remove",
/* TRANSLATORS: command description */
_("Remove a metadata item from the profile"),
cd_util_remove_metadata);
cd_util_add (priv->cmd_array,
"set-copyright",
/* TRANSLATORS: command description */
_("Sets the copyright string"),
cd_util_set_copyright);
cd_util_add (priv->cmd_array,
"set-description",
/* TRANSLATORS: command description */
_("Sets the description string"),
cd_util_set_description);
cd_util_add (priv->cmd_array,
"set-manufacturer",
/* TRANSLATORS: command description */
_("Sets the manufacturer string"),
cd_util_set_manufacturer);
cd_util_add (priv->cmd_array,
"set-model",
/* TRANSLATORS: command description */
_("Sets the model string"),
cd_util_set_model);
cd_util_add (priv->cmd_array,
"md-fix",
/* TRANSLATORS: command description */
_("Automatically fix metadata in the profile"),
cd_util_set_fix_metadata);
cd_util_add (priv->cmd_array,
"set-version",
/* TRANSLATORS: command description */
_("Set the ICC profile version"),
cd_util_set_version);
cd_util_add (priv->cmd_array,
"export-tag-data",
/* TRANSLATORS: command description */
_("Export the tag data"),
cd_util_export_tag_data);
/* sort by command name */
g_ptr_array_sort (priv->cmd_array,
(GCompareFunc) cd_sort_command_name_cb);
/* get a list of the commands */
priv->context = g_option_context_new (NULL);
cmd_descriptions = cd_util_get_descriptions (priv->cmd_array);
g_option_context_set_summary (priv->context, cmd_descriptions);
/* TRANSLATORS: program name */
g_set_application_name (_("Color Management"));
g_option_context_add_main_entries (priv->context, options, NULL);
ret = g_option_context_parse (priv->context, &argc, &argv, &error);
if (!ret) {
/* TRANSLATORS: the user didn't read the man page */
g_print ("%s: %s\n", _("Failed to parse arguments"),
error->message);
goto out;
}
/* use explicit locale */
priv->locale = g_strdup (locale);
/* set verbose? */
if (verbose) {
g_setenv ("COLORD_VERBOSE", "1", FALSE);
} else {
g_log_set_handler (G_LOG_DOMAIN, G_LOG_LEVEL_DEBUG,
cd_util_ignore_cb, NULL);
}
/* the first option is always the filename */
if (argc < 2) {
g_print ("%s\n", "Filename must be the first argument");
goto out;
}
/* open file */
file = g_file_new_for_path (argv[1]);
priv->icc = cd_icc_new ();
ret = cd_icc_load_file (priv->icc,
file,
CD_ICC_LOAD_FLAGS_ALL,
NULL,
&error);
if (!ret) {
g_print ("%s\n", error->message);
goto out;
}
/* run the specified command */
ret = cd_util_run (priv, argv[2], (gchar**) &argv[2], &error);
if (!ret) {
g_print ("%s\n", error->message);
goto out;
}
/* save file */
if (priv->rewrite_file) {
ret = cd_icc_save_file (priv->icc,
file,
CD_ICC_SAVE_FLAGS_NONE,
NULL,
&error);
if (!ret) {
g_print ("%s\n", error->message);
goto out;
}
}
/* success */
retval = 0;
out:
if (priv != NULL) {
if (priv->cmd_array != NULL)
g_ptr_array_unref (priv->cmd_array);
g_option_context_free (priv->context);
if (priv->icc != NULL)
g_object_unref (priv->icc);
g_object_unref (priv->client);
g_free (priv->locale);
g_free (priv);
}
return retval;
}
JNIEXPORT jint JNICALL JNI_OnLoad(JavaVM *jvm, void *reserved) {
javaVM = jvm;
cmsSetLogErrorHandler(errorHandler);
return JNI_VERSION_1_6;
}