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; }