image_processing.c

#include <stdio.h>
#include "args.h"
#include <libgen.h>
#include "functions.h"
#include "image_processing.h"
#include <Accelerate/Accelerate.h>
#include <ApplicationServices/ApplicationServices.h>
#include <sys/stat.h>
#include <lcms2.h>

#define no 0
#define yes 1

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

CFDataRef convert32_24bit (CFDataRef source_data_ptr, img_prop im_props) {
	
	// create the variable for the 32bit image.
	UInt8 *new_24bit = NULL;
	UInt8 *colour = NULL;
	UInt8 *new_ptr = NULL;
	int i = 0;
	
	// valloc the memory necessary to store the image in.
	// we are multiplying height by width by 3 (RGB) because we want a 24 bit image
	new_24bit = valloc (im_props->image_h * im_props->image_w * 3);

	// Get the pointer to the actual data
	colour = (UInt8 *) CFDataGetBytePtr (source_data_ptr);

	// set a pointer to the first array value
	new_ptr = &new_24bit[0];

	// parse through the array, removing the alpha chanel to the new image
	while (i < im_props->image_h * im_props->image_w * 3) {

		new_ptr[i] = *colour++; //R
		new_ptr[i+1] = *colour++; //G
		new_ptr[i+2] = *colour++; //B
		i = i + 3; // Increment i
		colour = colour++; // Skip alpha
	}

	// create a CFDataRef from the modified image
	CFDataRef ret_val = CFDataCreate (NULL, (UInt8 *) new_24bit, im_props->image_h * im_props->image_w * 3);

	// update the image properties
	im_props->bits_ppixel = 24;
	im_props->bytes_row = im_props->image_w * 3;

	// release the old image
	CFRelease (source_data_ptr);
	source_data_ptr = NULL;
	
	free(new_24bit);
	new_24bit = NULL;

	// return the new image
	return ret_val;
	
}

CFDataRef convert24_32bit (CFDataRef source_data_ptr, img_prop im_props) {
	
	// create the variable for the 32bit image.
	UInt8 *new_32bit = NULL;
	UInt8 *colour;
	UInt8 *new_ptr;
	int i = 0;

	// Malloc the memory necessary to store the image in.
	// we are multiplying height by width by 4 (RGBA) because we want a 32 bit image
	new_32bit = valloc (im_props->image_h * im_props->image_w * 4);

	// Get the pointer to the actual data
	colour = (UInt8 *) CFDataGetBytePtr (source_data_ptr);

	// set a pointer to the first array value
	new_ptr = &new_32bit[0];

	// parse through the array, adding the alpha chanel to the new image
	while (i<im_props->image_h*im_props->image_w*4) {

		new_ptr[i] = *colour++; //R
		new_ptr[i+1] = *colour++; //G
		new_ptr[i+2] = *colour++; //B
		new_ptr[i+3] = 255; //A
		i = i + 4; // Increment i
	}
	
	// create a CFDataRef from the modified image
	CFDataRef ret_val = CFDataCreate (NULL, (UInt8 *)new_32bit, im_props->image_h * im_props->image_w * 4);

	// update the image properties
	im_props->bits_ppixel = 32;
	im_props->bytes_row = im_props->image_w * 4;

	// release the old image
	CFRelease (source_data_ptr);
	source_data_ptr = NULL;
	
	// return the new image
	return ret_val;
}

void process_1_image (args cli_flags, char *files) {
	
	char *out_file_name = get_out_filename (files, cli_flags);
	
	if (file_exists (out_file_name)) {
		printf ("| Output file %s already exists. skipping... ", out_file_name);
		return;
	}
	
	// Origional Image Properties struct
	img_prop o = (img_prop) malloc (sizeof (image_properties));
	
	// set all the vales in the imapg properties struct to -1
	null_ip (o);
	
	// Create a data provider
	CGDataProviderRef source_image_provider = CGDataProviderCreateWithFilename (files);
	
	// Check for a null returned value
	if (source_image_provider == NULL) {
		
		// something went wrong 
		printf ("error: Couldn't create CGDataProvider from URL.\n"); 
		exit (0);
	}
	
	// get the information from the image exif here
	o->image_rot = get_exif_rot (source_image_provider);
	

	// Create the image in memory from the JPEG data
	CGImageRef source_image = CGImageCreateWithJPEGDataProvider (source_image_provider, NULL, no, kCGRenderingIntentDefault);
	
  /********************************************/
  /* Getting the colour space **/
  
  o->colorSpace = CGImageGetColorSpace(source_image);
  
  /********************************************/
  
	// populate the image info struct
	pop_img_props (source_image, o);
	
	// create a data provider from the decoded JPEG data
	CGDataProviderRef image_data_provider = CGImageGetDataProvider (source_image);
	
	// Create a pointer to the data section of the image in memory
	CFDataRef source_data_ptr = CGDataProviderCopyData (image_data_provider);

	// The vImage_Buffers we will use
	vImage_Buffer *vImage_source = (vImage_Buffer*) malloc (sizeof (vImage_Buffer));
	
	// Check for NULL
	if (NULL == vImage_source) {
		printf ("Cannot malloc vImage_source buffer\n");
		exit (0);
	}
	
	if (o->bits_ppixel == 24) {
		
		// convert from 24bit to 32bit by adding the alpha channel.
		source_data_ptr = convert24_32bit (source_data_ptr, o);
		
	}
	
	// Setup the vImage Buffer for the image
	setupBuffer (vImage_source, o->image_h, o->image_w, o->bytes_row);

	// Assign the data to the vImage Buffer for the source
	vImage_source->data = (void *) CFDataGetBytePtr (source_data_ptr);
	
	// Check for NULL
	if (vImage_source->data == NULL) 
		printf ("Unable to get the vimage.data pointer\n");

	if (o->image_rot != 1 && o->image_rot != 4 && o->image_rot != 2) // rotate the image
		rotate_image (vImage_source, o, NULL);
	
	// flip the image
	if (o->image_rot == 2  || o->image_rot == 4 || o->image_rot == 7 || o->image_rot == 5)
		flip_image (vImage_source, o, NULL);
	
  
	// Resize the images
	resize_image (vImage_source, o, cli_flags);

    // Create a colour space to be compared against
    CGColorSpaceRef rgb = CGColorSpaceCreateWithName(kCGColorSpaceSRGB);
    if (NULL == rgb) {
        fprintf(stderr, "Unable to create the reference colourspace.\n");
        exit(0);
    }
    
    // Convert the colourspace to RGB
    if (!CFEqual(rgb, o->colorSpace) && !cli_flags->disableCC) {
        vImage_source->data = convert_space(vImage_source->data, o->image_w, o->image_h);
        if (NULL == vImage_source->data) exit(0);
    }
    
    // release the reference colour space
    CGColorSpaceRelease(rgb);
    
	// save the image
	save_image (vImage_source, o, cli_flags->quality, out_file_name);
	
	// Release the source provider
	CGDataProviderRelease (source_image_provider);
	source_image_provider = NULL;
	
	// Release the source image
	CGImageRelease (source_image);
	source_image = NULL;
	
	free(source_data_ptr);
    
	// Free the filename created by get_out_filename ()
	free (out_file_name);
	out_file_name = NULL;
	
	// free the image properties
	free (o);
	o = NULL;
	
	// if there is info in the buffer
	if (vImage_source->data != NULL) {
		free (vImage_source->data);
		vImage_source->data = NULL;
	}
	
	// free the buffer
	free (vImage_source);
	vImage_source = NULL;

} // Process 1 image

void print_ip (img_prop p) {
	
	printf ("rotation = %d \t| height = %d \t | width = %d \t | bits/pixel = %d \t | bytes/row = %d \n", 
		   p->image_rot, 
		   p->image_h, 
		   p->image_w, 
		   p->bits_ppixel,
		   p->bytes_row);
	
} // print_ip

void null_ip (img_prop p) {
	
	// set all the ints in the struct to -1
	p->image_rot = -1;
	p->image_w = -1;
	p->image_h = -1;
	p->bits_ppixel = -1;
	p->bytes_row = -1;

} // null_ip

void print_vBuff (vImage_Buffer *b) {
	
	printf ("Width = %d \t | Height = %d \t | RowBytes = %i \n",
		   (int)b->width, 
		   (int)b->height, 
		   (int)b->rowBytes);

} // Print_vBuff

void pop_img_props (CGImageRef source_image, img_prop im_props) {
	
	// Populate the remaining image property struct values
	im_props->image_w = CGImageGetWidth (source_image);
	im_props->image_h = CGImageGetHeight (source_image);
	im_props->bits_ppixel = CGImageGetBitsPerPixel (source_image);
	im_props->bytes_row = CGImageGetBytesPerRow (source_image);
} // pop_img_props 

void setupBuffer (vImage_Buffer *buffer, int h, int w, int br) {
	
	// Assign values into the buffer.
	buffer->height = h;
	buffer->width = w;
	buffer->rowBytes = br;
} // setupBuffer

// returns a malloced file name pointer
char* get_out_filename (char *file, args cf) {
	
	// the temporary filename to return
	char *out_filename = calloc (FILENAME_MAX, 1);
	char *tmp;

	// copy anything from infront of the last pat component into the outfile name
	strncpy (out_filename, file, strlen (file) - strlen (basename (file)));
	
	// because strncpy may not have termintated the string we double check
	out_filename[strlen (out_filename)] = '\0';
	
	// add the subdir if it is not null [THIS WILL NEVER BE NULL]
	if (NULL != cf->subdir) {
		
		// add the subdir to the path
		strcat (out_filename, cf->subdir);
		
		// check to see if the path already exists and create it if necessary
		if (!file_exists (out_filename))
			
			// recurrsively create sub directories
			create_dirs (out_filename);
		
		// add the trailing slash
		strcat (out_filename, "/");
	}
	
	// add the prefix if one is specified
	if (NULL != cf->prefix) {
		strcat (out_filename, cf->prefix);
	}

	// get the string
	tmp = rem_ext (basename (file));

	// copy the filename without the extention onto the end of the string
	strcat (out_filename, tmp);

	// free the string
	free(tmp);
	tmp = NULL;

	// ensure the string is terminated properly
	out_filename[strlen (out_filename)] = '\0';
	
	// append the suffix to the file name
	if (NULL != cf->suffix) {
		strcat (out_filename, cf->suffix);
	}
	
	// append the file extention to the filename
	strcat (out_filename, ".jpg");
	
	// return the a pointer to the malloced file name
	return out_filename;

} // get_out_filename ()

int get_exif_rot (CGDataProviderRef image_source) {

	int val;
	
	// Create a source to read the exif from
	CGImageSourceRef image_exif_source = CGImageSourceCreateWithDataProvider (image_source, NULL);
	
	// Check for a NULL value in the CGImageSourceRef
	if (NULL == image_exif_source) {
		
		// Could not create the CGImageSoureRef
		printf ("Could not create CGImageSourceRef for image.\n");
	}

	// NSDictionary to hold the exif from the file.
	CFDictionaryRef exif;
	
	// create an NSDictionary and populate it with the EXIF
	exif = (CFDictionaryRef) CGImageSourceCopyPropertiesAtIndex (image_exif_source, 0, NULL);
	
	// Check for a NULL value for the exif CFDict
	if (NULL == exif) {
		
		// there was no EXIF
		printf ("This file has no EXIF.\n"); 

		// Release the exif source provider
		CFRelease (image_exif_source);
		image_exif_source = NULL;

		// Release the CFDictionary
		CFRelease (exif);
		exif = NULL;

		// set the orientation to Normal.
		return 1;

	} else {

		val = CFNumberToCInt (CFDictionaryGetValue (exif, kCGImagePropertyOrientation));

		// Release the exif source provider
		CFRelease (image_exif_source);
		image_exif_source = NULL;

		// Release the CFDictionary
		CFRelease (exif);
		exif = NULL;

		// get the value at the "Orientation" tag
		return val;
	}

	// Release the exif source provider
	CFRelease (image_exif_source);
	image_exif_source = NULL;

	// Release the CFDictionary
	CFRelease (exif);
	exif = NULL;

	return 1;
	
} // get_exif ()

void reset_vImage (vImage_Buffer *s, vImage_Buffer *p, img_prop o) {
	
	// free the source data
	if (s->data != NULL) free (s->data);
	
	// Give the converted data to the source buffer
	s->data = p->data;
	
	// reset the buffer info to match the data in buffer.data
	o->image_w = s->width = p->width;
	o->image_h = s->height = p->height;
	o->bytes_row = s->rowBytes = p->rowBytes;

} // reset_vImage ()

double calcImageShortSide (int longside, int sShort, int sLong) {
	return (double)longside/ ( (double)sShort/ (double)sLong);
} // calcImageShortSide ()

double calcImageLongSide (int shortside, int sShort, int sLong) {
	return (double)shortside* ( (double)sShort/ (double)sLong);
} // calcImageLongSide ()

// flip the image either vertically or horizontally based on the rotation flag in the images EXIF
void flip_image (vImage_Buffer *vImage_source, img_prop o, args flags) {
	
	// Return error value for vImage functions
	vImage_Error error;

	// Create a buffer for processing
	vImage_Buffer *vImage_processed = (vImage_Buffer*) malloc (sizeof (vImage_Buffer));

	// Check for null
	if (vImage_processed->data == NULL) {
		printf ("Could not malloc the memory for vImage_processed->data.\n");
		exit (0);
	}	

	// setup the vimage buffers
	setupBuffer (vImage_processed, o->image_h, o->image_w, o->bytes_row);
	
	// mallocing blank data are for the processed image buffer
	vImage_processed->data = (void *) malloc (vImage_processed->rowBytes * vImage_processed->height);
	
	// Check for null
	if (vImage_processed->data == NULL) 
		printf ("Unable to get the vimage.data pointer\n");
	
	// Flipping the image.
	if (o->image_rot == 4 || o->image_rot == 7 || o->image_rot == 5) {
		printf ("Flip vertical.\n");
		error = vImageVerticalReflect_ARGB8888 (vImage_source, 
											   vImage_processed, 
											   kvImageNoFlags);	
		if (error) { 
			printf ("Flip vertical error: %d\n", (int)error);
		}
	} 
	
	// Flipping the image.
	if (o->image_rot == 2) {
		printf ("Flip Horizontal.\n");
		error = vImageHorizontalReflect_ARGB8888 (vImage_source, 
												 vImage_processed, 
												 kvImageNoFlags);	
		if (error) {
			printf ("Flip Horizontal error: %d\n", (int)error);
		}
	}

	// return the processed data to the sourcebuffer
	reset_vImage (vImage_source, vImage_processed, o);
	
	// free the processing buffer
	free (vImage_processed);
	vImage_processed = NULL;

} // flip_image ()

// rotate the image based on the rotation flag in the images EXIF
void rotate_image (vImage_Buffer *vImage_source, img_prop o, args flags) {

	// malloc space for the processed buffer
	vImage_Buffer *vImage_processed = (vImage_Buffer*) malloc (sizeof (vImage_Buffer));

	// Check for null
	if (NULL == vImage_processed) {
		printf ("Cannot malloc vImage_processed buffer\n");
		exit (0);
	}
	
	// Return error value for vImage functions
	vImage_Error error;
	
	// Make a back colour
	Pixel_8888 backColour = { (uint8_t)0, (uint8_t)0, (uint8_t)0, (uint8_t)0 };
	
	// setup vImage_processed buffer
	if (o->image_rot < 5) {

		// No change in the image dimensions
		vImage_processed->width = o->image_w;
		vImage_processed->height = o->image_h;
	} else {

		// a 90 Deg change to the image dimentions
		vImage_processed->height = o->image_w;
		vImage_processed->width = o->image_h;
	}
	
	// setup the last of the vImage_Buffer
	vImage_processed->rowBytes = vImage_processed->width*4;
	
	// malloc the memory for image processing
	vImage_processed->data = malloc (vImage_processed->rowBytes * vImage_processed->height);

	// Check for null
	if (NULL == vImage_processed->data) {
		printf ("Could not malloc the memory for vImage_processed->data.\n");
		exit (0);
	}

	// Chose the correct rotation based on the orientation flag taken from the file
	switch (o->image_rot) {
		case 3:
			printf ("\tRotating: 180 Deg .\n");

			// Rotate the image
			error = vImageRotate90_ARGB8888 (vImage_source, vImage_processed, kRotate180DegreesClockwise, backColour, kvImageNoFlags);
			if (error) { 
				printf ("Rotation Error: %d\n", (int)error);	
			}			
			break;
			
		case 5:
			printf ("\tRotating: 90 Deg Counter Clockwise - Horizontal Reflected.\n");

			// Rotate the image
			error = vImageRotate90_ARGB8888 (vImage_source, vImage_processed, kRotate90DegreesCounterClockwise, backColour, kvImageNoFlags);
			if (error) {
				printf ("Rotation Error: %d\n", (int)error);
			}
			break;
		case 6:
			printf ("\tRotating: 90 Deg Counter Clockwise.\n");

 			// Rotate the image
			error = vImageRotate90_ARGB8888 (vImage_source, vImage_processed, kRotate90DegreesClockwise, backColour, kvImageNoFlags);
			if (error) { 
				printf ("Rotation Error: %d\n", (int)error);
 			}
			break;
		case 7:
			printf ("\tRotating: 90 Deg Clockwise - Horixontal Reflected.\n");  

			// Rotate the image
			error = vImageRotate90_ARGB8888 (vImage_source, vImage_processed, kRotate90DegreesClockwise, backColour, kvImageNoFlags);
			if (error) { 
				printf ("Rotation Error: %d\n", (int)error);
			}
			break;
		case 8:
			printf ("\tRotating: 90 Deg Clockwise.\n"); 

			// Rotate the image
			error = vImageRotate90_ARGB8888 (vImage_source, vImage_processed, kRotate90DegreesCounterClockwise, backColour, kvImageNoFlags);
			if (error) { 
				printf ("Rotation Error: %d\n", (int)error);
			}
			break;
		default:
			printf ("\tNo rotation required.\n");   
			break;
	}
	
	// return the processed data to the source buffer
	reset_vImage (vImage_source, vImage_processed, o);
	
	// free the processing buffer
	free (vImage_processed);
	vImage_processed = NULL;

} // rotate_image

// resize the image to the desired output size (DEFAULT = 800px[max x or y length])
void resize_image (vImage_Buffer *vImage_source, img_prop o, args flags) {

	// create the output buffer for processing too
	vImage_Buffer *vImage_processed = (vImage_Buffer*) malloc (sizeof (vImage_Buffer));

	// Check for null
	if (NULL == vImage_processed) {
		printf ("Cannot malloc vImage_processed buffer\n");
		exit (0);
	}
	
	// Return error value for vImage functions
	vImage_Error error;
	
	// if both the width and height have been set
	if (flags->image_h != -1 && flags->image_w != -1) {
		o->image_h = flags->image_h;
		o->image_w = flags->image_w;
	}
	
	// If the output width has been set
	if (flags->image_w != -1 && flags->image_h == -1) {

		// calculate the required length or width to scale the image and apply them to the image destination attributes
		if (vImage_source->width < vImage_source->height) {
			o->image_w = flags->image_w;
			o->image_h = calcImageLongSide (flags->image_w, 
											 vImage_source->height, 
											 vImage_source->width);
		} else {
			o->image_w = flags->image_w;
			o->image_h = calcImageShortSide (flags->image_w, 
											  vImage_source->width, 
											  vImage_source->height);
		}
	}

	// If the output height has been set
	if (flags->image_h != -1 && flags->image_w == -1) {

		// calculate the required length or width to scale the image and apply them to the image destination attributes
		if (vImage_source->width < vImage_source->height) {
			o->image_h = flags->image_h;
			o->image_w = calcImageShortSide (flags->image_h, 
											  vImage_source->height, 
											  vImage_source->width);
		} else {
			o->image_h = flags->image_h;
			o->image_w = calcImageLongSide (flags->image_h, 
											 vImage_source->width, 
											 vImage_source->height);
		}
	}

	// if the max length has been set ** overides the width or height settings
	if (flags->image_l != -1) {
		
		// calculate the required length or width to scale the image and apply them to the image destination attributes
		if (vImage_source->width < vImage_source->height) {
			o->image_h = flags->image_l;
			o->image_w = calcImageShortSide (flags->image_l, 
											  vImage_source->height, 
											  vImage_source->width);
		} else {
			o->image_w = flags->image_l;
			o->image_h = calcImageShortSide (flags->image_l, 
											  vImage_source->width, 
											  vImage_source->height);
		}
	}
	
	// setup the vimage buffers
	setupBuffer (vImage_processed, o->image_h, o->image_w, o->image_w * 4);
	
	//	printf ("mallocing blank data are for the processed image buffer\n");
	vImage_processed->data = malloc (vImage_processed->rowBytes * vImage_processed->height);
	
	// Check for null
	if (NULL == vImage_processed->data) 
		printf ("Unable to get the vimage.data pointer\n");
	
	// Scale the image
	error = vImageScale_ARGB8888 (vImage_source, 
								 vImage_processed, 
								 NULL, 
								 kvImageHighQualityResampling);
	if (error) {
		printf ("Resize error: %d\n", (int) error);
	}

	// return the processed data to the sourcebuffer
	reset_vImage (vImage_source, vImage_processed, o);

	// free the processing buffer
	free (vImage_processed);
	vImage_processed = NULL;

} // resize_image

// save the image
void save_image (vImage_Buffer *src_i, img_prop o, float compression, char *o_file) {
	
	// Create a CFDataRef from the rotated data in the destination vImage_Buffer
	CFDataRef output_Data = CFDataCreate (NULL, src_i->data, src_i->height * src_i->rowBytes);
	
	if (o->bits_ppixel == 32) {
		
		// convert from 24bit to 32bit by adding the alpha channel.
		output_Data = convert32_24bit (output_Data, o);
		src_i->rowBytes = src_i->width * 3;
	}

    
	// Check for a NULL value.
	if (NULL == output_Data) {
		printf ("Could not create CFDataRef from vImage_Buffer.\n"); 
		exit (0);
	}
	
	// Create a Data provider from the rotated data
	CGDataProviderRef destination_data_provider = CGDataProviderCreateWithCFData (output_Data);
	
	// Check for null
	if (NULL == destination_data_provider) {
		printf ("Could not create CGDataProviderRef from CGDataRef.\n"); 
		exit (0);
	}
  
    CGImageRef processed_image;

  
    // Create the image with sRGB for the colour space
    processed_image = CGImageCreate (src_i->width, // 1 width
                                                src_i->height, // 2 height
                                                (size_t)o->bits_ppixel/ (o->bits_ppixel/8), // bitsPerComponent
                                                (size_t)o->bits_ppixel, //bitsPerPixel
                                                src_i->rowBytes, // bytesPerRow
                                                CGColorSpaceCreateDeviceRGB(), // Generic ColourSpace
                                                kCGBitmapByteOrder32Big, // bitmapInfo
                                                destination_data_provider, // Data provider ** DataProviderRef 
                                                NULL, // decode
                                                0, // Interpolate
                                                kCGRenderingIntentSaturation); // rendering intent
  	if (NULL == processed_image) exit (0);
/*    
  } else {

    // release the reference colour space
    CGColorSpaceRelease(rgb);

    // Create the image with sRGB for the colour space
    processed_image = CGImageCreate (src_i->width, // 1 width
                                     src_i->height, // 2 height
                                     (size_t)o->bits_ppixel/ (o->bits_ppixel/8), // bitsPerComponent
                                     (size_t)o->bits_ppixel, //bitsPerPixel
                                     src_i->rowBytes, // bytesPerRow
                                     o->colorSpace, // ColourSpace of original
                                     kCGBitmapByteOrder32Big, // bitmapInfo
                                     destination_data_provider, // Data provider ** DataProviderRef 
                                     NULL, // decode
                                     0, // Interpolate
                                     kCGRenderingIntentSaturation); // rendering intent
  	if (NULL == processed_image) exit (0);
    
  }*/
  
	// create a CFStringRef from the C string
	CFStringRef fn = CFStringCreateWithCString (NULL, o_file, kCFStringEncodingUTF8);
	if (NULL == fn) exit (0);
	
	// Convert the CFStringRef to a CFURLRef
	CFURLRef fon = CFURLCreateWithFileSystemPath (NULL, fn, kCFURLPOSIXPathStyle, false);
	if (NULL == fon) exit (0);

	// Create an image destination
	CGImageDestinationRef image_destination = CGImageDestinationCreateWithURL (fon, kUTTypeJPEG, 1, NULL);

	// Release the CFURLRef
	CFRelease (fon);
	fon = NULL;
	
	// release the CFStringRef
	CFRelease (fn);
	fn = NULL;

	// Check for a NULL value in image_destination
	if (NULL == image_destination) {
		printf ("Null Image_destination: Could not create the CGImageDestinationRef from the supplied URL.\n");
		exit (0);
	}

	// Set the compression factor for the images
	CFStringRef keys[1];
	CFTypeRef value[1];
	
	// Use compression key
	keys[0] = kCGImageDestinationLossyCompressionQuality;

	// set the compression amount. 1 = no compression 0 = max compression
	value[0] = CFNumberCreate (NULL, kCFNumberFloatType, &compression);
	
	// Pointer to the image attribs dictionary
	CFDictionaryRef options;
	
	// create the dictionary
	options = CFDictionaryCreate (kCFAllocatorDefault, (void *)keys, (void *)value, 1, NULL, NULL);
	
	// Copy data to the output information to the destination
	CGImageDestinationAddImage (image_destination, processed_image, options);
	
	// Check for a NULL value in image_destination
	if (NULL == image_destination) {
		printf ("Null Image_destination: Could not add the rotated image.\n"); 
		exit (0);
	}
	
	// Write the image to disk
	if (!CGImageDestinationFinalize (image_destination)) {
		// Could not write the file for some reason
		printf ("Could not write the file to disk.\n"); 
		exit (1);
	}

	// Release the pointer the the scaled buffer
	CFRelease (output_Data);
	output_Data = NULL;
	
	// Release the dictionary
	CFRelease (keys[0]);
	CFRelease (value[0]);
	CFRelease (options);
	options = NULL;
	
	// Release the rotated image.
	CGImageRelease (processed_image);
	processed_image = NULL;
	
	// Release a data provider
	CGDataProviderRelease (destination_data_provider);
	destination_data_provider = NULL;
	
	// Release the image destination
	CFRelease (image_destination);
	image_destination = NULL;

} // save_image