static void prepare (GeglOperation *operation) { const Babl *src_format = gegl_operation_get_source_format (operation, "input"); const char *format = "RGB float"; if (src_format) { const Babl *model = babl_format_get_model (src_format); if (model == babl_model ("RGB")) format = "RGB float"; else if (model == babl_model ("RGBA")) format = "RGBA float"; else if (model == babl_model ("R'G'B'")) format = "R'G'B' float"; else if (model == babl_model ("R'G'B'A")) format = "R'G'B'A float"; else if (babl_format_has_alpha (src_format)) format = "RGBA float"; } gegl_operation_set_format (operation, "input", babl_format (format)); gegl_operation_set_format (operation, "output", babl_format (format)); }
static void prepare (GeglOperation *operation) { GeglProperties *o = GEGL_PROPERTIES (operation); const Babl *src_format = gegl_operation_get_source_format (operation, "input"); const Babl *input_format = babl_format ("RGB double"); gint n_components = 3; const Babl *output_format; if (src_format) { const Babl *model = babl_format_get_model (src_format); if (model == babl_model ("RGB") || model == babl_model ("R'G'B'") || model == babl_model ("RGBA") || model == babl_model ("R'G'B'A")) { input_format = babl_format ("RGB double"); n_components = 3; } else if (model == babl_model ("Y") || model == babl_model ("Y'") || model == babl_model ("YA") || model == babl_model ("Y'A")) { input_format = babl_format ("Y double"); n_components = 1; } } if (o->squared) n_components *= 2; output_format = babl_format_n (babl_type ("double"), n_components); gegl_operation_set_format (operation, "input", input_format); gegl_operation_set_format (operation, "output", output_format); }
static void gegl_gblur_1d_prepare (GeglOperation *operation) { const Babl *src_format = gegl_operation_get_source_format (operation, "input"); const char *format = "RaGaBaA float"; /* * FIXME: when the abyss policy is _NONE, the behavior at the edge * depends on input format (with or without an alpha component) */ if (src_format) { const Babl *model = babl_format_get_model (src_format); if (model == babl_model ("RGB") || model == babl_model ("R'G'B'")) format = "RGB float"; else if (model == babl_model ("Y") || model == babl_model ("Y'")) format = "Y float"; else if (model == babl_model ("YA") || model == babl_model ("Y'A") || model == babl_model ("YaA") || model == babl_model ("Y'aA")) format = "YaA float"; } gegl_operation_set_format (operation, "output", babl_format (format)); }
gboolean gimp_babl_format_get_linear (const Babl *format) { const Babl *model; g_return_val_if_fail (format != NULL, FALSE); model = babl_format_get_model (format); if (model == babl_model ("Y") || model == babl_model ("YA") || model == babl_model ("RGB") || model == babl_model ("RGBA")) { return TRUE; } else if (model == babl_model ("Y'") || model == babl_model ("Y'A") || model == babl_model ("R'G'B'") || model == babl_model ("R'G'B'A")) { return FALSE; } else if (babl_format_is_palette (format)) { return FALSE; } g_return_val_if_reached (FALSE); }
GimpImageBaseType gimp_babl_format_get_base_type (const Babl *format) { const Babl *model; g_return_val_if_fail (format != NULL, -1); model = babl_format_get_model (format); if (model == babl_model ("Y") || model == babl_model ("Y'") || model == babl_model ("YA") || model == babl_model ("Y'A")) { return GIMP_GRAY; } else if (model == babl_model ("RGB") || model == babl_model ("R'G'B'") || model == babl_model ("RGBA") || model == babl_model ("R'G'B'A")) { return GIMP_RGB; } else if (babl_format_is_palette (format)) { return GIMP_INDEXED; } g_return_val_if_reached (-1); }
static void prepare (GeglOperation *self) { const Babl *fmt = gegl_operation_get_source_format (self, "input"); GeglProperties *o = GEGL_PROPERTIES (self); if (fmt) { const Babl *model = babl_format_get_model (fmt); if (model == babl_model ("R'aG'aB'aA") || model == babl_model ("Y'aA")) { o->user_data = NULL; fmt = babl_format ("R'aG'aB'aA float"); } else if (model == babl_model ("RaGaBaA") || model == babl_model ("YaA")) { o->user_data = NULL; fmt = babl_format ("RaGaBaA float"); } else if (model == babl_model ("R'G'B'A") || model == babl_model ("R'G'B'") || model == babl_model ("Y'") || model == babl_model ("Y'A")) { o->user_data = (void*)0xabc; fmt = babl_format ("R'G'B'A float"); } else { o->user_data = (void*)0xabc; fmt = babl_format ("RGBA float"); } } else { o->user_data = (void*)0xabc; fmt = babl_format ("RGBA float"); } gegl_operation_set_format (self, "input", fmt); gegl_operation_set_format (self, "output", fmt); gegl_operation_set_format (self, "aux", babl_format ("Y float")); return; }
static void prepare (GeglOperation *operation) { GeglProperties *o = GEGL_PROPERTIES (operation); const Babl *format; const Babl *input_format; const Babl *input_model; const Babl *lch_model; input_format = gegl_operation_get_source_format (operation, "input"); if (input_format == NULL) return; input_model = babl_format_get_model (input_format); if (babl_format_has_alpha (input_format)) { lch_model = babl_model ("CIE LCH(ab) alpha"); if (input_model == lch_model) { format = babl_format ("CIE LCH(ab) alpha float"); o->user_data = process_lch_alpha; } else { format = babl_format ("CIE Lab alpha float"); o->user_data = process_lab_alpha; } } else { lch_model = babl_model ("CIE LCH(ab)"); if (input_model == lch_model) { format = babl_format ("CIE LCH(ab) float"); o->user_data = process_lch; } else { format = babl_format ("CIE Lab float"); o->user_data = process_lab; } } gegl_operation_set_format (operation, "input", format); gegl_operation_set_format (operation, "output", format); }
GimpImageType gimp_babl_format_get_image_type (const Babl *format) { const gchar *name; g_return_val_if_fail (format != NULL, -1); name = babl_get_name (babl_format_get_model (format)); if (! strcmp (name, "Y") || ! strcmp (name, "Y'") || ! strcmp (name, "Y~")) { return GIMP_GRAY_IMAGE; } else if (! strcmp (name, "YA") || ! strcmp (name, "Y'A") || ! strcmp (name, "Y~A")) { return GIMP_GRAYA_IMAGE; } else if (! strcmp (name, "RGB") || ! strcmp (name, "R'G'B'") || ! strcmp (name, "R~G~B~")) { return GIMP_RGB_IMAGE; } else if (! strcmp (name, "RGBA") || ! strcmp (name, "R'G'B'A") || ! strcmp (name, "R~G~B~A")) { return GIMP_RGBA_IMAGE; } else if (babl_format_is_palette (format)) { if (babl_format_has_alpha (format)) return GIMP_INDEXEDA_IMAGE; else return GIMP_INDEXED_IMAGE; } g_return_val_if_reached (-1); }
GimpImageType gimp_babl_format_get_image_type (const Babl *format) { const Babl *model; g_return_val_if_fail (format != NULL, -1); model = babl_format_get_model (format); if (model == babl_model ("Y") || model == babl_model ("Y'")) { return GIMP_GRAY_IMAGE; } else if (model == babl_model ("YA") || model == babl_model ("Y'A")) { return GIMP_GRAYA_IMAGE; } else if (model == babl_model ("RGB") || model == babl_model ("R'G'B'")) { return GIMP_RGB_IMAGE; } else if (model == babl_model ("RGBA") || model == babl_model ("R'G'B'A")) { return GIMP_RGBA_IMAGE; } else if (babl_format_is_palette (format)) { if (babl_format_has_alpha (format)) return GIMP_INDEXEDA_IMAGE; else return GIMP_INDEXED_IMAGE; } g_return_val_if_reached (-1); }
static void prepare (GeglOperation *self) { const Babl *fmt = gegl_operation_get_source_format (self, "input"); GeglChantO *o = GEGL_CHANT_PROPERTIES (self); if (fmt) { const Babl *model = babl_format_get_model (fmt); if (model == babl_model ("RaGaBaA") || model == babl_model ("R'aG'aB'aA") || model == babl_model ("YaA") || model == babl_model ("Y'aA")) { o->chant_data = NULL; gegl_operation_set_format (self, "input", babl_format ("RaGaBaA float")); gegl_operation_set_format (self, "output", babl_format ("RaGaBaA float")); gegl_operation_set_format (self, "aux", babl_format ("Y float")); return; } } /* ugly way of communicating that we want the RGBA version */ /* because of that, we can't use the common opencl api for point ops */ o->chant_data = (void*)0xabc; gegl_operation_set_format (self, "input", babl_format ("RGBA float")); gegl_operation_set_format (self, "output", babl_format ("RGBA float")); gegl_operation_set_format (self, "aux", babl_format ("Y float")); return; }
static void gimp_operation_mask_components_prepare (GeglOperation *operation) { const Babl *format = gegl_operation_get_source_format (operation, "input"); if (format) { const Babl *model = babl_format_get_model (format); if (model == babl_model ("R'G'B'A")) format = babl_format ("R'G'B'A float"); else format = babl_format ("RGBA float"); } else { format = babl_format ("RGBA float"); } gegl_operation_set_format (operation, "input", format); gegl_operation_set_format (operation, "aux", format); gegl_operation_set_format (operation, "output", format); }
/** * gimp_color_profile_get_format: * @format: a #Babl format * @lcms_format: return location for an lcms format * * This function takes a #Babl format and returns the lcms format to * be used with that @format. It also returns a #Babl format to be * used instead of the passed @format, which usually is the same as * @format, unless lcms doesn't support @format. * * Note that this function currently only supports RGB, RGBA, R'G'B', * R'G'B'A, Y, YA, Y', Y'A and the cairo-RGB24 and cairo-ARGB32 formats. * * Return value: the #Babl format to be used instead of @format, or %NULL * is the passed @format is not supported at all. * * Since: 2.10 **/ const Babl * gimp_color_profile_get_format (const Babl *format, guint32 *lcms_format) { const Babl *output_format = NULL; const Babl *type; const Babl *model; gboolean has_alpha; gboolean gray; gboolean linear; g_return_val_if_fail (format != NULL, NULL); g_return_val_if_fail (lcms_format != NULL, NULL); has_alpha = babl_format_has_alpha (format); type = babl_format_get_type (format, 0); model = babl_format_get_model (format); if (format == babl_format ("cairo-RGB24")) { *lcms_format = TYPE_RGB_8; return babl_format ("R'G'B' u8"); } else if (format == babl_format ("cairo-ARGB32")) { *lcms_format = TYPE_RGBA_8; return babl_format ("R'G'B'A u8"); } else if (model == babl_model ("RGB") || model == babl_model ("RGBA")) { gray = FALSE; linear = TRUE; } else if (model == babl_model ("R'G'B'") || model == babl_model ("R'G'B'A")) { gray = FALSE; linear = FALSE; } else if (model == babl_model ("Y") || model == babl_model ("YA")) { gray = TRUE; linear = TRUE; } else if (model == babl_model ("Y'") || model == babl_model ("Y'A")) { gray = TRUE; linear = FALSE; } else if (babl_format_is_palette (format)) { if (has_alpha) { *lcms_format = TYPE_RGBA_8; return babl_format ("R'G'B'A u8"); } else { *lcms_format = TYPE_RGB_8; return babl_format ("R'G'B' u8"); } } else { g_printerr ("format: %s\n" "has_alpha = %s\n" "type = %s\n" "model = %s\n", babl_get_name (format), has_alpha ? "TRUE" : "FALSE", babl_get_name (type), babl_get_name (model)); g_return_val_if_reached (NULL); } *lcms_format = 0; if (type == babl_type ("u8")) { if (has_alpha) { if (gray) *lcms_format = TYPE_GRAYA_8; else *lcms_format = TYPE_RGBA_8; } else { if (gray) *lcms_format = TYPE_GRAY_8; else *lcms_format = TYPE_RGB_8; } output_format = format; } else if (type == babl_type ("u16")) { if (has_alpha) { if (gray) *lcms_format = TYPE_GRAYA_16; else *lcms_format = TYPE_RGBA_16; } else { if (gray) *lcms_format = TYPE_GRAY_16; else *lcms_format = TYPE_RGB_16; } output_format = format; } else if (type == babl_type ("half")) /* 16-bit floating point (half) */ { if (has_alpha) { if (gray) *lcms_format = TYPE_GRAYA_HALF_FLT; else *lcms_format = TYPE_RGBA_HALF_FLT; } else { if (gray) *lcms_format = TYPE_GRAY_HALF_FLT; else *lcms_format = TYPE_RGB_HALF_FLT; } output_format = format; } else if (type == babl_type ("float")) { if (has_alpha) { if (gray) *lcms_format = TYPE_GRAYA_FLT; else *lcms_format = TYPE_RGBA_FLT; } else { if (gray) *lcms_format = TYPE_GRAY_FLT; else *lcms_format = TYPE_RGB_FLT; } output_format = format; } else if (type == babl_type ("double")) { if (has_alpha) { if (gray) *lcms_format = TYPE_GRAYA_DBL; else *lcms_format = TYPE_RGBA_DBL; } else { if (gray) *lcms_format = TYPE_GRAY_DBL; else *lcms_format = TYPE_RGB_DBL; } output_format = format; } if (*lcms_format == 0) { g_printerr ("%s: layer format %s not supported, " "falling back to float\n", G_STRFUNC, babl_get_name (format)); if (has_alpha) { if (gray) { *lcms_format = TYPE_GRAYA_FLT; if (linear) output_format = babl_format ("YA float"); else output_format = babl_format ("Y'A float"); } else { *lcms_format = TYPE_RGBA_FLT; if (linear) output_format = babl_format ("RGBA float"); else output_format = babl_format ("R'G'B'A float"); } } else { if (gray) { *lcms_format = TYPE_GRAY_FLT; if (linear) output_format = babl_format ("Y float"); else output_format = babl_format ("Y' float"); } else { *lcms_format = TYPE_RGB_FLT; if (linear) output_format = babl_format ("RGB float"); else output_format = babl_format ("R'G'B' float"); } } } return output_format; }
static int export_tiff (GeglOperation *operation, GeglBuffer *input, const GeglRectangle *result) { GeglProperties *o = GEGL_PROPERTIES(operation); Priv *p = (Priv*) o->user_data; gshort color_space, compression = COMPRESSION_NONE; gushort bits_per_sample, samples_per_pixel; gboolean has_alpha, alpha_is_premultiplied = FALSE; gushort sample_format, predictor = 0; gushort extra_types[1]; glong rows_per_stripe = 1; gint bytes_per_row; const Babl *type, *model; gchar format_string[32]; const Babl *format; g_return_val_if_fail(p->tiff != NULL, -1); TIFFSetField(p->tiff, TIFFTAG_SUBFILETYPE, 0); TIFFSetField(p->tiff, TIFFTAG_ORIENTATION, ORIENTATION_TOPLEFT); TIFFSetField(p->tiff, TIFFTAG_IMAGEWIDTH, result->width); TIFFSetField(p->tiff, TIFFTAG_IMAGELENGTH, result->height); format = gegl_buffer_get_format(input); model = babl_format_get_model(format); type = babl_format_get_type(format, 0); if (model == babl_model("Y") || model == babl_model("Y'")) { has_alpha = FALSE; color_space = PHOTOMETRIC_MINISBLACK; model = babl_model("Y'"); samples_per_pixel = 1; } else if (model == babl_model("YA") || model == babl_model("Y'A")) { has_alpha = TRUE; alpha_is_premultiplied = FALSE; color_space = PHOTOMETRIC_MINISBLACK; model = babl_model("Y'A"); samples_per_pixel = 2; } else if (model == babl_model("YaA") || model == babl_model("Y'aA")) { has_alpha = TRUE; alpha_is_premultiplied = TRUE; color_space = PHOTOMETRIC_MINISBLACK; model = babl_model("Y'aA"); samples_per_pixel = 2; } else if (model == babl_model("RGB") || model == babl_model("R'G'B'")) { has_alpha = FALSE; color_space = PHOTOMETRIC_RGB; model = babl_model("R'G'B'"); samples_per_pixel = 3; predictor = 2; } else if (model == babl_model("RGBA") || model == babl_model("R'G'B'A")) { has_alpha = TRUE; alpha_is_premultiplied = FALSE; color_space = PHOTOMETRIC_RGB; model = babl_model("R'G'B'A"); samples_per_pixel = 4; predictor = 2; } else if (model == babl_model("RaGaBaA") || model == babl_model("R'aG'aB'aA")) { has_alpha = TRUE; alpha_is_premultiplied = TRUE; color_space = PHOTOMETRIC_RGB; model = babl_model("R'aG'aB'aA"); samples_per_pixel = 4; predictor = 2; } else { g_warning("color space not supported: %s", babl_get_name(model)); has_alpha = TRUE; alpha_is_premultiplied = TRUE; color_space = PHOTOMETRIC_RGB; model = babl_model("R'aG'aB'aA"); samples_per_pixel = 4; predictor = 2; } TIFFSetField(p->tiff, TIFFTAG_PHOTOMETRIC, color_space); TIFFSetField(p->tiff, TIFFTAG_SAMPLESPERPIXEL, samples_per_pixel); TIFFSetField(p->tiff, TIFFTAG_PLANARCONFIG, PLANARCONFIG_CONTIG); if (has_alpha) { if (alpha_is_premultiplied) extra_types[0] = EXTRASAMPLE_ASSOCALPHA; else extra_types[0] = EXTRASAMPLE_UNASSALPHA; TIFFSetField(p->tiff, TIFFTAG_EXTRASAMPLES, 1, extra_types); } if (predictor != 0) { if (compression == COMPRESSION_LZW) TIFFSetField(p->tiff, TIFFTAG_PREDICTOR, predictor); else if (compression == COMPRESSION_ADOBE_DEFLATE) TIFFSetField(p->tiff, TIFFTAG_PREDICTOR, predictor); } if (type == babl_type("u8")) { sample_format = SAMPLEFORMAT_UINT; bits_per_sample = 8; } else if (type == babl_type("half")) { sample_format = SAMPLEFORMAT_IEEEFP; bits_per_sample = 16; } else if (type == babl_type("u16")) { sample_format = SAMPLEFORMAT_UINT; bits_per_sample = 16; } else if (type == babl_type("float")) { sample_format = SAMPLEFORMAT_IEEEFP; bits_per_sample = 32; } else if (type == babl_type("u32")) { sample_format = SAMPLEFORMAT_UINT; bits_per_sample = 32; } else if (type == babl_type("double")) { sample_format = SAMPLEFORMAT_IEEEFP; bits_per_sample = 64; } else { g_warning("sample format not supported: %s", babl_get_name(type)); sample_format = SAMPLEFORMAT_UINT; type = babl_type("u8"); bits_per_sample = 8; } TIFFSetField(p->tiff, TIFFTAG_BITSPERSAMPLE, bits_per_sample); TIFFSetField(p->tiff, TIFFTAG_SAMPLEFORMAT, sample_format); TIFFSetField(p->tiff, TIFFTAG_COMPRESSION, compression); if ((compression == COMPRESSION_CCITTFAX3 || compression == COMPRESSION_CCITTFAX4) && (bits_per_sample != 1 || samples_per_pixel != 1)) { g_critical("only monochrome pictures can be compressed " "with \"CCITT Group 4\" or \"CCITT Group 3\""); return -1; } g_snprintf(format_string, 32, "%s %s", babl_get_name(model), babl_get_name(type)); format = babl_format(format_string); /* "Choose RowsPerStrip such that each strip is about 8K bytes." */ bytes_per_row = babl_format_get_bytes_per_pixel(format) * result->width; while (bytes_per_row * rows_per_stripe <= 8192) rows_per_stripe++; rows_per_stripe = MIN(rows_per_stripe, result->height); TIFFSetField(p->tiff, TIFFTAG_ROWSPERSTRIP, rows_per_stripe); return save_contiguous(operation, input, result, format); }
/** * gimp_color_profile_get_format: * @format: a #Babl format * @lcms_format: return location for an lcms format * * This function takes a #Babl format and returns the lcms format to * be used with that @format. It also returns a #Babl format to be * used instead of the passed @format, which usually is the same as * @format, unless lcms doesn't support @format. * * Note that this function currently only supports RGB, RGBA, R'G'B' and * R'G'B'A formats. * * Return value: the #Babl format to be used instead of @format, or %NULL * is the passed @format is not supported at all. * * Since: 2.10 **/ const Babl * gimp_color_profile_get_format (const Babl *format, guint32 *lcms_format) { const Babl *output_format = NULL; const Babl *type; const Babl *model; gboolean has_alpha; gboolean linear; g_return_val_if_fail (format != NULL, NULL); g_return_val_if_fail (lcms_format != NULL, NULL); has_alpha = babl_format_has_alpha (format); type = babl_format_get_type (format, 0); model = babl_format_get_model (format); if (model == babl_model ("RGB") || model == babl_model ("RGBA")) { linear = TRUE; } else if (model == babl_model ("R'G'B'") || model == babl_model ("R'G'B'A")) { linear = FALSE; } else { g_return_val_if_reached (NULL); } *lcms_format = 0; if (type == babl_type ("u8")) { if (has_alpha) *lcms_format = TYPE_RGBA_8; else *lcms_format = TYPE_RGB_8; output_format = format; } else if (type == babl_type ("u16")) { if (has_alpha) *lcms_format = TYPE_RGBA_16; else *lcms_format = TYPE_RGB_16; output_format = format; } else if (type == babl_type ("half")) /* 16-bit floating point (half) */ { if (has_alpha) *lcms_format = TYPE_RGBA_HALF_FLT; else *lcms_format = TYPE_RGB_HALF_FLT; output_format = format; } else if (type == babl_type ("float")) { if (has_alpha) *lcms_format = TYPE_RGBA_FLT; else *lcms_format = TYPE_RGB_FLT; output_format = format; } else if (type == babl_type ("double")) { if (has_alpha) { #ifdef TYPE_RGBA_DBL /* RGBA double not implemented in lcms */ *lcms_format = TYPE_RGBA_DBL; output_format = format; #endif /* TYPE_RGBA_DBL */ } else { *lcms_format = TYPE_RGB_DBL; output_format = format; } } if (*lcms_format == 0) { g_printerr ("%s: layer format %s not supported, " "falling back to float\n", G_STRFUNC, babl_get_name (format)); if (has_alpha) { *lcms_format = TYPE_RGBA_FLT; if (linear) output_format = babl_format ("RGBA float"); else output_format = babl_format ("R'G'B'A float"); } else { *lcms_format = TYPE_RGB_FLT; if (linear) output_format = babl_format ("RGB float"); else output_format = babl_format ("R'G'B' float"); } } return output_format; }