C++ cmsOpenProfileFromFile函数代码示例

static VALUE transform_convert(int argc, VALUE *argv, VALUE self){

  if(argc != 4){
    return Qnil;
  }

  cmsHPROFILE hInProfile, hOutProfile;
  cmsHTRANSFORM hTransform;

  VALUE in = rb_iv_get(self, "@in");
  VALUE out = rb_iv_get(self, "@out");

  hInProfile = cmsOpenProfileFromFile(RSTRING(in)->ptr, "r");
  hOutProfile = cmsOpenProfileFromFile(RSTRING(out)->ptr, "r");

  hTransform = cmsCreateTransform(hInProfile, TYPE_CMYK_8,
      hOutProfile, TYPE_RGB_8, INTENT_PERCEPTUAL, 0);

  cmsCloseProfile(hInProfile);
  cmsCloseProfile(hOutProfile);


  //TODO: Remove duplication
  cmsUInt8Number cmyk_temp[4] = { NUM2INT(argv[0]), NUM2INT(argv[1]), NUM2INT(argv[2]), NUM2INT(argv[3]) };;
  cmsUInt8Number rgb_temp[3];

//  printf("Transfrom result is cmyk(%d, %d, %d, %d)\n", cmyk_temp[0], cmyk_temp[1], cmyk_temp[2], cmyk_temp[3]);

  cmsDoTransform(hTransform, cmyk_temp, rgb_temp, 1);


//  printf("Transfrom result is rgb(%d, %d, %d)\n", rgb_temp[0], rgb_temp[1], rgb_temp[2]);

  return rb_ary_new3(3, INT2FIX(rgb_temp[0]), INT2FIX(rgb_temp[1]), INT2FIX(rgb_temp[2]));
}

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

static
cmsHPROFILE OpenProfile(const char* File)
{   
    
    if (!File) 
        return cmsCreate_sRGBProfile();    
    
	if (stricmp(File, "*sRGB") == 0)
        return cmsCreate_sRGBProfile(NULL);
    
    if (stricmp(File, "*Lab") == 0)
        return cmsCreateLabProfile(NULL);
    
    if (stricmp(File, "*LabD65") == 0) {
        
        cmsCIExyY D65xyY;
        
        cmsWhitePointFromTemp(6504, &D65xyY);           
        return cmsCreateLabProfile(&D65xyY);
    }
    
    if (stricmp(File, "*XYZ") == 0)
        return cmsCreateXYZProfile();
    
     if (stricmp(File, "*Gray22") == 0) {
           LPGAMMATABLE Gamma = cmsBuildGamma(256, 2.2);
           cmsHPROFILE hProfile = cmsCreateGrayProfile(cmsD50_xyY(), Gamma);
           cmsFreeGamma(Gamma);
           return hProfile;

    }

    return cmsOpenProfileFromFile(File, "r");
}

            void GetMonitorProfile(wxString& profileName, cmsHPROFILE& profile)
            {
                ColorsyncIteratorData data;
                data.dispuuid = CGDisplayCreateUUIDFromDisplayID(CGMainDisplayID());
                if (data.dispuuid == NULL)
                {
                    DEBUG_INFO("CGDisplayCreateUUIDFromDisplayID() failed.");
                    return;
                }
                data.url = NULL;
                ColorSyncIterateDeviceProfiles(ColorSyncIterateCallback, (void *)&data);
                CFRelease(data.dispuuid);

                CFStringRef urlstr = CFURLCopyFileSystemPath(data.url, kCFURLPOSIXPathStyle);
                CFRelease(data.url);
                if (urlstr == NULL)
                {
                    DEBUG_INFO("Failed to get URL in CFString");
                }
                else
                {
                    CFRetain(urlstr);
                    profileName = wxCFStringRef(urlstr).AsString(wxLocale::GetSystemEncoding());
                    profile = cmsOpenProfileFromFile(profileName.c_str(), "r");
                    DEBUG_INFO("Found profile: " << profileName.c_str());
                };
            };

static cmsHPROFILE
cdisplay_lcms_get_rgb_profile (CdisplayLcms *lcms)
{
  GimpColorConfig  *config;
  GimpColorManaged *managed;
  cmsHPROFILE       profile = NULL;

  managed = gimp_color_display_get_managed (GIMP_COLOR_DISPLAY (lcms));

  if (managed)
    {
      gsize         len;
      const guint8 *data = gimp_color_managed_get_icc_profile (managed, &len);

      if (data)
        profile = cmsOpenProfileFromMem ((gpointer) data, len);

      if (profile &&
          ! cdisplay_lcms_profile_is_rgb (profile))
        {
          cmsCloseProfile (profile);
          profile = NULL;
        }
    }

  if (! profile)
    {
      config = gimp_color_display_get_config (GIMP_COLOR_DISPLAY (lcms));

      if (config->rgb_profile)
        profile = cmsOpenProfileFromFile (config->rgb_profile, "r");
    }

  return profile;
}

cmsHPROFILE
dt_colorspaces_create_output_profile(const int imgid)
{
  char profile[1024];
  profile[0] = '\0';
  // db lookup colorout params, and dt_conf_() for override
  gchar *overprofile = dt_conf_get_string("plugins/lighttable/export/iccprofile");
  if(!overprofile || !strcmp(overprofile, "image"))
  {
    const dt_iop_colorout_params_t *params;
    // sqlite:
    sqlite3_stmt *stmt;
    DT_DEBUG_SQLITE3_PREPARE_V2(dt_database_get(darktable.db), "select op_params from history where imgid=?1 and operation='colorout'", -1, &stmt, NULL);
    DT_DEBUG_SQLITE3_BIND_INT(stmt, 1, imgid);
    if(sqlite3_step(stmt) == SQLITE_ROW)
    {
      params = sqlite3_column_blob(stmt, 0);
      g_strlcpy(profile, params->iccprofile, 1024);
    }
    sqlite3_finalize(stmt);
  }
  if(!overprofile && profile[0] == '\0')
  {
    g_strlcpy(profile, "sRGB", 1024);
  }
  else if(profile[0] == '\0')
  {
    g_strlcpy(profile, overprofile, 1024);
  }

  if(overprofile)
  {
    g_free(overprofile);
  }

  cmsHPROFILE output = NULL;

  if(!strcmp(profile, "sRGB"))
    output = dt_colorspaces_create_srgb_profile();
  else if(!strcmp(profile, "linear_rgb"))
    output = dt_colorspaces_create_linear_rgb_profile();
  else if(!strcmp(profile, "XYZ"))
    output = dt_colorspaces_create_xyz_profile();
  else if(!strcmp(profile, "adobergb"))
    output = dt_colorspaces_create_adobergb_profile();
  else if(!strcmp(profile, "X profile") && darktable.control->xprofile_data)
    output = cmsOpenProfileFromMem(darktable.control->xprofile_data, darktable.control->xprofile_size);
  else
  {
    // else: load file name
    char filename[1024];
    dt_colorspaces_find_profile(filename, 1024, profile, "out");
    output = cmsOpenProfileFromFile(filename, "r");
  }
  if(!output) output = dt_colorspaces_create_srgb_profile();
  return output;
}

int main(void) {
  cmsHPROFILE hInProfile, hOutProfile;
  cmsHTRANSFORM hTransform; 
  int i;
  
  hInProfile = cmsOpenProfileFromFile("USWebCoatedSWOP.icc", "r");
  hOutProfile = cmsOpenProfileFromFile("AdobeRGB1998.icc", "r");
  
  hTransform = cmsCreateTransform(hInProfile, TYPE_CMYK_8,
      hOutProfile, TYPE_RGB_8, INTENT_PERCEPTUAL, 0);
  
  cmsCloseProfile(hInProfile);
  cmsCloseProfile(hOutProfile);



  return 0;
}

static cmsHPROFILE
cdisplay_lcms_get_printer_profile (CdisplayLcms *lcms)
{
  GimpColorConfig *config;

  config = gimp_color_display_get_config (GIMP_COLOR_DISPLAY (lcms));

  if (config->printer_profile)
    return cmsOpenProfileFromFile (config->printer_profile, "r");

  return NULL;
}

struct weston_color_profile *
weston_cms_load_profile(const char *filename)
{
	struct weston_color_profile *p = NULL;
#ifdef HAVE_LCMS
	cmsHPROFILE lcms_profile;
	lcms_profile = cmsOpenProfileFromFile(filename, "r");
	if (lcms_profile)
		p = weston_cms_create_profile(filename, lcms_profile);
#endif
	return p;
}

void* convert_space (const void *source_data_ptr, int width, int height) {

    // Assign the memory for the transform
    void *YourOutputBuffer = malloc(sizeof(void)*width*height*4);
    
    // Create the required variables
    cmsHPROFILE hInProfile, hOutProfile; 
    cmsHTRANSFORM hTransform; 
    
    // Load the colour profiles
    hInProfile = cmsOpenProfileFromFile("/Library/Application Support/Nikon/Profiles/NKAdobe.icm", "r"); 
    hOutProfile = cmsCreate_sRGBProfile();
    
    // Create the transform matrix
    hTransform = cmsCreateTransform(hInProfile, 
                                    TYPE_RGBA_8, 
                                    hOutProfile, 
                                    TYPE_RGBA_8, 
                                    INTENT_PERCEPTUAL, 
                                    0);
    
    // Convert the image colours
    cmsDoTransform(hTransform, 
                   source_data_ptr, 
                   YourOutputBuffer, 
                   width*height);

    // Delete the opened stuff
    cmsDeleteTransform(hTransform); 
    cmsCloseProfile(hInProfile); 
    cmsCloseProfile(hOutProfile);
    
    // Create the return data object
  //  CFDataRef ret_val = CFDataCreate (NULL, YourOutputBuffer, height * width * 4);
    
    // release the old image
//	CFRelease (source_data_ptr);

	// Null the pointer after releasing
    source_data_ptr = NULL;
    
    // NULL the pointer
    source_data_ptr = NULL;

	// Free the temp buffer for the colour space image
 //   free(YourOutputBuffer);
    
    fprintf(stdout, "Colour space converted.");
	// return the new image
	return YourOutputBuffer;
}

static void
cdisplay_proof_combo_box_set_active (GimpColorProfileComboBox *combo,
                                     const gchar              *filename)
{
  cmsHPROFILE  profile = NULL;
  gchar       *label   = NULL;

  if (filename)
    profile = cmsOpenProfileFromFile (filename, "r");

  if (profile)
    {
      cmsUInt32Number  descSize;
      gchar           *descData;

      descSize = cmsGetProfileInfoASCII (profile, cmsInfoDescription,
                                         "en", "US", NULL, 0);
      if (descSize > 0)
        {
          descData = g_new (gchar, descSize + 1);
          descSize = cmsGetProfileInfoASCII (profile, cmsInfoDescription,
                                             "en", "US", descData, descSize);
          if (descSize > 0)
            label = gimp_any_to_utf8 (descData, -1, NULL);

          g_free (descData);
        }

      if (! label)
        {
          descSize = cmsGetProfileInfoASCII (profile, cmsInfoModel,
                                             "en", "US", NULL, 0);
          if (descSize > 0)
            {
              descData = g_new (gchar, descSize + 1);
              descSize = cmsGetProfileInfoASCII (profile, cmsInfoModel,
                                                 "en", "US", descData, descSize);
              if (descSize > 0)
                label = gimp_any_to_utf8 (descData, -1, NULL);

              g_free (descData);
            }
        }

      cmsCloseProfile (profile);
    }

  gimp_color_profile_combo_box_set_active (combo, filename, label);
  g_free (label);
}

int main(int  argc, char* argv[])
{

    int r, g, b;
    cmsUInt8Number RGB[3], RGB_OUT[3];
    cmsHTRANSFORM xform;
    cmsHPROFILE hProfile;
    double err, SumX=0, SumX2=0, Peak = 0, n = 0;


    if (argc != 2) {
        printf("roundtrip <RGB icc profile>\n");
        return 1;
    }

    hProfile = cmsOpenProfileFromFile(argv[1], "r");
    xform = cmsCreateTransform(hProfile,TYPE_RGB_8, hProfile, TYPE_RGB_8, INTENT_RELATIVE_COLORIMETRIC, cmsFLAGS_NOOPTIMIZE);

    for (r=0; r< 256; r++) {
        printf("%d  \r", r);
        for (g=0; g < 256; g++) {
            for (b=0; b < 256; b++) {

                RGB[0] = r;
                RGB[1] = g;
                RGB[2] = b;

                cmsDoTransform(xform, RGB, RGB_OUT, 1);

                err = VecDist(RGB, RGB_OUT);

                SumX  += err;
                SumX2 += err * err;
                n += 1.0;
                if (err > Peak)
                    Peak = err;

            }
        }
    }

    printf("Average %g\n", SumX / n);
    printf("Max %g\n", Peak);
    printf("Std  %g\n", sqrt((n*SumX2 - SumX * SumX) / (n*(n-1))));
    cmsCloseProfile(hProfile);
    cmsDeleteTransform(xform);

    return 0;
}

static
cmsHPROFILE OpenProfile(const char* File)
{
	cmsHPROFILE h;

       if (!File) 
            return cmsCreate_sRGBProfile();    
       
       if (stricmp(File, "*Lab") == 0)
                return cmsCreateLabProfile(NULL);
       
       if (stricmp(File, "*XYZ") == 0)
                return cmsCreateXYZProfile();
         
	   if (stricmp(File, "*srgb") == 0)
				return cmsCreate_sRGBProfile();

       
	   if (stricmp(File, "*Gray22") == 0) {
		   LPGAMMATABLE Gamma = cmsBuildGamma(256, 2.2);
		   cmsHPROFILE hProfile = cmsCreateGrayProfile(cmsD50_xyY(), Gamma);
		   cmsFreeGamma(Gamma);
		   return hProfile;

	   }
       
       if (stricmp(File, "*Lin2222") == 0) {

            LPGAMMATABLE Gamma = cmsBuildGamma(256, 2.2);
            LPGAMMATABLE Gamma4[4];
            cmsHPROFILE hProfile; 

            Gamma4[0] = Gamma4[1] = Gamma4[2] = Gamma4[3] = Gamma;
            hProfile = cmsCreateLinearizationDeviceLink(icSigCmykData, Gamma4);
		    cmsFreeGamma(Gamma);
		    return hProfile;

	   }


       h = cmsOpenProfileFromFile(File, "r");

	   
       if (cmsGetDeviceClass(h) == icSigNamedColorClass)
			FatalError("ERROR: Cannot make devicelink of named color profiles!");
       

	   return h;
}

static PyObject*
cms_profile_open(PyObject* self, PyObject* args)
{
    cmsHPROFILE hProfile;

    char* sProfile;
    if (!PyArg_ParseTuple(args, "s:profile_open", &sProfile))
        return NULL;

    hProfile = cmsOpenProfileFromFile(sProfile, "r");
    if (!hProfile) {
        PyErr_SetString(PyExc_IOError, "cannot open profile file");
        return NULL;
    }

    return cms_profile_new(hProfile);
}

static
void GenerateCSA(void)
{
	cmsHPROFILE hProfile = cmsOpenProfileFromFile(cInProf, "r");
	size_t n;
	char* Buffer;

	n = cmsGetPostScriptCSA(hProfile, Intent, NULL, 0);
	if (n == 0) return;

	Buffer = (char*) _cmsMalloc(n + 1);
	cmsGetPostScriptCSA(hProfile, Intent, Buffer, n);
	Buffer[n] = 0;

	fprintf(OutFile, "%s", Buffer);	
	
	_cmsFree(Buffer);
	cmsCloseProfile(hProfile);
}