/* * NAME * ConvertMixedColors - Convert XcmsColor structures * * SYNOPSIS */ static Status ConvertMixedColors( XcmsCCC ccc, XcmsColor *pColors_in_out, XcmsColor *pWhitePt, unsigned int nColors, XcmsColorFormat targetFormat, unsigned char format_flag) /* * DESCRIPTION * This routine will only convert the following types of * batches: * DI to DI * DD to DD * DD to CIEXYZ * In other words, it will not convert the following types of * batches: * DI to DD * DD to DI(not CIEXYZ) * * format_flag: * 0x01 : convert Device-Dependent only specifications to the * target format. * 0x02 : convert Device-Independent only specifications to the * target format. * 0x03 : convert all specifications to the target format. * * RETURNS * XcmsFailure if failed, * XcmsSuccess if none of the color specifications were * compressed in the conversion process * XcmsSuccessWithCompression if at least one of the * color specifications were compressed in the * conversion process. * */ { XcmsColor *pColor, *pColors_start; XcmsColorFormat format; Status retval_tmp; Status retval = XcmsSuccess; unsigned int iColors; unsigned int nBatch; /* * Convert array of mixed color specifications in batches of * contiguous formats to the target format */ iColors = 0; while (iColors < nColors) { /* * Find contiguous array of color specifications with the * same format */ pColor = pColors_start = pColors_in_out + iColors; format = pColors_start->format; nBatch = 0; while (iColors < nColors && pColor->format == format) { pColor++; nBatch++; iColors++; } if (format != targetFormat) { /* * Need to convert this batch from current format to target format. */ if (XCMS_DI_ID(format) && (format_flag & DI_FORMAT) && XCMS_DI_ID(targetFormat)) { /* * DI->DI * * Format of interest is Device-Independent, * This batch contains Device-Independent specifications, and * the Target format is Device-Independent. */ retval_tmp = _XcmsDIConvertColors(ccc, pColors_start, pWhitePt, nBatch, targetFormat); } else if (XCMS_DD_ID(format) && (format_flag & DD_FORMAT) && (targetFormat == XcmsCIEXYZFormat)) { /* * DD->CIEXYZ * * Format of interest is Device-Dependent, * This batch contains Device-Dependent specifications, and * the Target format is CIEXYZ. * * Since DD->CIEXYZ we can use NULL instead of pCompressed. */ if ((ccc->whitePtAdjProc != NULL) && !_XcmsEqualWhitePts(ccc, pWhitePt, ScreenWhitePointOfCCC(ccc))) { /* * Need to call WhiteAdjustProc (Screen White Point to * White Point). */ retval_tmp = (*ccc->whitePtAdjProc)(ccc, ScreenWhitePointOfCCC(ccc), pWhitePt, XcmsCIEXYZFormat, pColors_start, nBatch, (Bool *)NULL); } else { retval_tmp = _XcmsDDConvertColors(ccc, pColors_start, nBatch, XcmsCIEXYZFormat, (Bool *)NULL); } } else if (XCMS_DD_ID(format) && (format_flag & DD_FORMAT) && XCMS_DD_ID(targetFormat)) { /* * DD->DD(not CIEXYZ) * * Format of interest is Device-Dependent, * This batch contains Device-Dependent specifications, and * the Target format is Device-Dependent and not CIEXYZ. */ retval_tmp = _XcmsDDConvertColors(ccc, pColors_start, nBatch, targetFormat, (Bool *)NULL); } else { /* * This routine is called for the wrong reason. */ return(XcmsFailure); } if (retval_tmp == XcmsFailure) { return(XcmsFailure); } retval = MAX(retval, retval_tmp); } } return(retval); }
/* * NAME * XcmsConvertColors - Convert XcmsColor structures * * SYNOPSIS */ Status XcmsConvertColors( XcmsCCC ccc, XcmsColor *pColors_in_out, unsigned int nColors, XcmsColorFormat targetFormat, Bool *pCompressed) /* * DESCRIPTION * Convert XcmsColor structures to another format * * RETURNS * XcmsFailure if failed, * XcmsSuccess if succeeded without gamut compression, * XcmsSuccessWithCompression if succeeded with gamut * compression. * */ { XcmsColor clientWhitePt; XcmsColor Color1; XcmsColor *pColors_tmp; int callWhiteAdjustProc = 0; XcmsColorFormat format; Status retval; unsigned char contents_flag = 0x00; unsigned int iColors; if (ccc == NULL || pColors_in_out == NULL || !(ValidDIColorSpaceID(targetFormat) || ValidDDColorSpaceID(ccc, targetFormat))) { return(XcmsFailure); } /* * Check formats in color specification array */ format = pColors_in_out->format; for (pColors_tmp = pColors_in_out, iColors = nColors; iColors; pColors_tmp++, iColors--) { if (!(ValidDIColorSpaceID(pColors_tmp->format) || ValidDDColorSpaceID(ccc, pColors_tmp->format))) { return(XcmsFailure); } if (XCMS_DI_ID(pColors_tmp->format)) { contents_flag |= DI_FORMAT; } else { contents_flag |= DD_FORMAT; } if (pColors_tmp->format != format) { contents_flag |= MIX_FORMAT; } } /* * Check if we need the Client White Point. */ if ((contents_flag & DI_FORMAT) || XCMS_DI_ID(targetFormat)) { /* To proceed, we need to get the Client White Point */ memcpy((char *)&clientWhitePt, (char *)&ccc->clientWhitePt, sizeof(XcmsColor)); if (clientWhitePt.format == XcmsUndefinedFormat) { /* * Client White Point is undefined, therefore set to the Screen * White Point. * Since Client White Point == Screen White Point, WhiteAdjustProc * is not called. */ memcpy((char *)&clientWhitePt, (char *)&ccc->pPerScrnInfo->screenWhitePt, sizeof(XcmsColor)); } else if ((ccc->whitePtAdjProc != NULL) && !_XcmsEqualWhitePts(ccc, &clientWhitePt, ScreenWhitePointOfCCC(ccc))) { /* * Client White Point != Screen White Point, and WhiteAdjustProc * is not NULL, therefore, will need to call it when * converting between DI and DD specifications. */ callWhiteAdjustProc = 1; } } /* * Make copy of array of color specifications */ if (nColors > 1) { pColors_tmp = (XcmsColor *) Xmalloc(nColors * sizeof(XcmsColor)); } else { pColors_tmp = &Color1; } memcpy((char *)pColors_tmp, (char *)pColors_in_out, nColors * sizeof(XcmsColor)); /* * zero out pCompressed */ if (pCompressed) { bzero((char *)pCompressed, nColors * sizeof(Bool)); } if (contents_flag == DD_FORMAT || contents_flag == DI_FORMAT) { /* * ENTIRE ARRAY IS IN ONE FORMAT. */ if (XCMS_DI_ID(format) && XCMS_DI_ID(targetFormat)) { /* * DI-to-DI only conversion */ retval = _XcmsDIConvertColors(ccc, pColors_tmp, &clientWhitePt, nColors, targetFormat); } else if (XCMS_DD_ID(format) && XCMS_DD_ID(targetFormat)) { /* * DD-to-DD only conversion * Since DD->DD there will be no compressed thus we can * pass NULL instead of pCompressed. */ retval = _XcmsDDConvertColors(ccc, pColors_tmp, nColors, targetFormat, (Bool *)NULL); } else { /* * Otherwise we have: * 1. Device-Independent to Device-Dependent Conversion * OR * 2. Device-Dependent to Device-Independent Conversion * * We need to go from oldFormat -> CIEXYZ -> targetFormat * adjusting for white points as necessary. */ if (XCMS_DI_ID(format)) { /* * 1. Device-Independent to Device-Dependent Conversion */ if (callWhiteAdjustProc) { /* * White Point Adjustment * Client White Point to Screen White Point */ retval = (*ccc->whitePtAdjProc)(ccc, &clientWhitePt, ScreenWhitePointOfCCC(ccc), targetFormat, pColors_tmp, nColors, pCompressed); } else { if (_XcmsDIConvertColors(ccc, pColors_tmp, &clientWhitePt, nColors, XcmsCIEXYZFormat) == XcmsFailure) { goto Failure; } retval = _XcmsDDConvertColors(ccc, pColors_tmp, nColors, targetFormat, pCompressed); } } else { /* * 2. Device-Dependent to Device-Independent Conversion */ if (callWhiteAdjustProc) { /* * White Point Adjustment * Screen White Point to Client White Point */ retval = (*ccc->whitePtAdjProc)(ccc, ScreenWhitePointOfCCC(ccc), &clientWhitePt, targetFormat, pColors_tmp, nColors, pCompressed); } else { /* * Since DD->CIEXYZ, no compression takes place therefore * we can pass NULL instead of pCompressed. */ if (_XcmsDDConvertColors(ccc, pColors_tmp, nColors, XcmsCIEXYZFormat, (Bool *)NULL) == XcmsFailure) { goto Failure; } retval = _XcmsDIConvertColors(ccc, pColors_tmp, &clientWhitePt, nColors, targetFormat); } } } } else { /* * ARRAY HAS MIXED FORMATS. */ if ((contents_flag == (DI_FORMAT | MIX_FORMAT)) && XCMS_DI_ID(targetFormat)) { /* * Convert from DI to DI in batches of contiguous formats * * Because DI->DI, WhiteAdjustProc not called. */ retval = ConvertMixedColors(ccc, pColors_tmp, &clientWhitePt, nColors, targetFormat, (unsigned char)DI_FORMAT); } else if ((contents_flag == (DD_FORMAT | MIX_FORMAT)) && XCMS_DD_ID(targetFormat)) { /* * Convert from DD to DD in batches of contiguous formats * * Because DD->DD, WhiteAdjustProc not called. */ retval = ConvertMixedColors(ccc, pColors_tmp, (XcmsColor *)NULL, nColors, targetFormat, (unsigned char)DD_FORMAT); } else if (XCMS_DI_ID(targetFormat)) { /* * We need to convert from DI-to-DI and DD-to-DI, therefore * 1. convert DD specifications to CIEXYZ, then * 2. convert all in batches to the target DI format. * * Note that ConvertMixedColors will call WhiteAdjustProc * as necessary. */ /* * Convert only DD specifications in batches of contiguous formats * to CIEXYZ * * Since DD->CIEXYZ, ConvertMixedColors will apply WhiteAdjustProc * if required. */ retval = ConvertMixedColors(ccc, pColors_tmp, &clientWhitePt, nColors, XcmsCIEXYZFormat, (unsigned char)DD_FORMAT); /* * Because at this point we may have a mix of DI formats * (e.g., CIEXYZ, CIELuv) we must convert the specs to the * target DI format in batches of contiguous source formats. */ retval = ConvertMixedColors(ccc, pColors_tmp, &clientWhitePt, nColors, targetFormat, (unsigned char)DI_FORMAT); } else { /* * We need to convert from DI-to-DD and DD-to-DD, therefore * 1. convert DI specifications to CIEXYZ, then * 2. convert all to the DD target format. * * This allows white point adjustment and gamut compression * to be applied to all the color specifications in one * swoop if those functions do in fact modify the entire * group of color specifications. */ /* * Convert in batches to CIEXYZ * * If DD->CIEXYZ, ConvertMixedColors will apply WhiteAdjustProc * if required. */ if ((retval = ConvertMixedColors(ccc, pColors_tmp, &clientWhitePt, nColors, XcmsCIEXYZFormat, (unsigned char)(DI_FORMAT | DD_FORMAT))) == XcmsFailure) { goto Failure; } /* * Convert all specifications (now in CIEXYZ format) to * the target DD format. * Since CIEXYZ->DD, compression MAY take place therefore * we must pass pCompressed. * Note that WhiteAdjustProc must be used if necessary. */ if (callWhiteAdjustProc) { /* * White Point Adjustment * Client White Point to Screen White Point */ retval = (*ccc->whitePtAdjProc)(ccc, &clientWhitePt, ScreenWhitePointOfCCC(ccc), targetFormat, pColors_tmp, nColors, pCompressed); } else { retval = _XcmsDDConvertColors(ccc, pColors_tmp, nColors, targetFormat, pCompressed); } } } if (retval != XcmsFailure) { memcpy((char *)pColors_in_out, (char *)pColors_tmp, nColors * sizeof(XcmsColor)); } if (nColors > 1) { Xfree((char *)pColors_tmp); } return(retval); Failure: if (nColors > 1) { Xfree((char *)pColors_tmp); } return(XcmsFailure); }
/* * NAME * _XcmsConvertColorsWithWhitePt - Convert XcmsColor structures * * SYNOPSIS */ Status _XcmsConvertColorsWithWhitePt( XcmsCCC ccc, XcmsColor *pColors_in_out, XcmsColor *pWhitePt, unsigned int nColors, XcmsColorFormat newFormat, Bool *pCompressed) /* * DESCRIPTION * Convert XcmsColor structures between device-independent * and/or device-dependent formats but allowing the calling * routine to specify the white point to be associated * with the color specifications (overriding * ccc->clientWhitePt). * * This routine has been provided for use in white point * adjustment routines. * * RETURNS * XcmsFailure if failed, * XcmsSuccess if succeeded without gamut compression, * XcmsSuccessWithCompression if succeeded with gamut * compression. * */ { if (ccc == NULL || pColors_in_out == NULL || pColors_in_out->format == XcmsUndefinedFormat) { return(XcmsFailure); } if (nColors == 0 || pColors_in_out->format == newFormat) { /* do nothing */ return(XcmsSuccess); } if (XCMS_DI_ID(pColors_in_out->format) && XCMS_DI_ID(newFormat)) { /* * Device-Independent to Device-Independent Conversion */ return(_XcmsDIConvertColors(ccc, pColors_in_out, pWhitePt, nColors, newFormat)); } if (XCMS_DD_ID(pColors_in_out->format) && XCMS_DD_ID(newFormat)) { /* * Device-Dependent to Device-Dependent Conversion */ return(_XcmsDDConvertColors(ccc, pColors_in_out, nColors, newFormat, pCompressed)); } /* * Otherwise we have: * 1. Device-Independent to Device-Dependent Conversion * OR * 2. Device-Dependent to Device-Independent Conversion */ if (XCMS_DI_ID(pColors_in_out->format)) { /* * 1. Device-Independent to Device-Dependent Conversion */ /* First convert to CIEXYZ */ if (_XcmsDIConvertColors(ccc, pColors_in_out, pWhitePt, nColors, XcmsCIEXYZFormat) == XcmsFailure) { return(XcmsFailure); } /* Then convert to DD Format */ return(_XcmsDDConvertColors(ccc, pColors_in_out, nColors, newFormat, pCompressed)); } else { /* * 2. Device-Dependent to Device-Independent Conversion */ /* First convert to CIEXYZ */ if (_XcmsDDConvertColors(ccc, pColors_in_out, nColors, XcmsCIEXYZFormat, pCompressed) == XcmsFailure) { return(XcmsFailure); } /* Then convert to DI Format */ return(_XcmsDIConvertColors(ccc, pColors_in_out, pWhitePt, nColors, newFormat)); } }