CGImageRef MyCreateJPEGImageRef(){
CGImageRef image;
CGDataProviderRef provider;
CFStringRef name;
CFURLRef url;
// Get the URL to the bundle resource.
url = CFURLCreateWithFileSystemPath( kCFAllocatorDefault,
CFSTR("/Users/reza/.irssi/irss.jpg"), // file path name
kCFURLPOSIXPathStyle, // interpret as POSIX path
false ); // is it a directory?
// Create the data provider object
provider = CGDataProviderCreateWithURL (url);
CFRelease (url);
printtext(NULL, NULL, MSGLEVEL_CLIENTNOTICE,"debug1\n");
// Create the image object from that provider.
image = CGImageCreateWithJPEGDataProvider (provider, NULL, true,
kCGRenderingIntentDefault);
if (image == NULL)
printtext(NULL, NULL, MSGLEVEL_CLIENTNOTICE,"debug2\n");
CGDataProviderRelease (provider);
return (image);
}
// add an HIImageViewRef to the parentView
HIViewRef
AddImage( HIViewRef parentView )
{
OSStatus status = paramErr;
HIViewRef cgImageView = NULL;
CGImageRef cgImage = NULL;
CGDataProviderRef cgImageProvider = NULL;
HILayoutInfo layoutInfo;
CFBundleRef theAppBundle = NULL;
CFStringRef imageFileName = NULL;
CFURLRef imageURL = NULL;
HIRect parentFrame;
theAppBundle = CFBundleGetMainBundle();
imageFileName = CFStringCreateWithCString( NULL /*allocator*/, "rainbowpark.jpg", kCFStringEncodingASCII );
imageURL = CFBundleCopyResourceURL( theAppBundle, imageFileName, NULL, NULL );
cgImageProvider = CGDataProviderCreateWithURL(imageURL);
require( cgImageProvider != NULL, FAIL );
cgImage = CGImageCreateWithJPEGDataProvider( cgImageProvider, NULL, false, kCGRenderingIntentDefault );
require( cgImage != NULL, FAIL );
CGDataProviderRelease( cgImageProvider );
CFRelease( imageFileName );
HIImageViewCreate( cgImage, &cgImageView );
CGImageRelease( cgImage);
require( cgImageView != NULL, FAIL );
layoutInfo.binding.left.kind = kHILayoutBindLeft;
layoutInfo.binding.left.toView = NULL;
layoutInfo.binding.left.offset = 0.0;
layoutInfo.binding.top.kind = kHILayoutBindTop;
layoutInfo.binding.top.toView = NULL;
layoutInfo.binding.top.offset = 0.0;
layoutInfo.binding.right.kind = kHILayoutBindRight;
layoutInfo.binding.right.toView = NULL;
layoutInfo.binding.right.offset = 0.0;
layoutInfo.binding.bottom.kind = kHILayoutBindBottom;
layoutInfo.binding.bottom.toView = NULL;
layoutInfo.binding.bottom.offset = 0.0;
verify_noerr( HIViewSetLayoutInfo(cgImageView, &layoutInfo) );
verify_noerr( HIImageViewSetScaleToFit(cgImageView, true) );
status = HIViewAddSubview(parentView, cgImageView);
if( status != noErr )
{
CFRelease( cgImageView );
cgImageView = NULL;
}
FAIL:
return cgImageView;
}
unsigned char* os_image_load_from_file(const char* filename, int* outWidth, int* outHeight, int* outChannels, int unused) {
const int fileHandle = open(filename, O_RDONLY);
struct stat statBuffer;
fstat(fileHandle, &statBuffer);
const size_t bytesInFile = (size_t)(statBuffer.st_size);
uint8_t* fileData = (uint8_t*)(mmap(NULL, bytesInFile, PROT_READ, MAP_SHARED, fileHandle, 0));
if (fileData == MAP_FAILED) {
fprintf(stderr, "Couldn't open file '%s' with mmap\n", filename);
return NULL;
}
CFDataRef fileDataRef = CFDataCreateWithBytesNoCopy(NULL, fileData, bytesInFile, kCFAllocatorNull);
CGDataProviderRef imageProvider = CGDataProviderCreateWithCFData(fileDataRef);
const char* suffix = strrchr(filename, '.');
if (!suffix || suffix == filename) {
suffix = "";
}
CGImageRef image;
if (strcasecmp(suffix, ".png") == 0) {
image = CGImageCreateWithPNGDataProvider(imageProvider, NULL, true, kCGRenderingIntentDefault);
} else if ((strcasecmp(suffix, ".jpg") == 0) ||
(strcasecmp(suffix, ".jpeg") == 0)) {
image = CGImageCreateWithJPEGDataProvider(imageProvider, NULL, true, kCGRenderingIntentDefault);
} else {
munmap(fileData, bytesInFile);
close(fileHandle);
CFRelease(imageProvider);
CFRelease(fileDataRef);
fprintf(stderr, "Unknown suffix for file '%s'\n", filename);
return NULL;
}
const int width = (int)CGImageGetWidth(image);
const int height = (int)CGImageGetHeight(image);
const int channels = 4;
CGColorSpaceRef colorSpace = CGColorSpaceCreateDeviceRGB();
const int bytesPerRow = (width * channels);
const int bytesInImage = (bytesPerRow * height);
uint8_t* result = (uint8_t*)(malloc(bytesInImage));
const int bitsPerComponent = 8;
CGContextRef context = CGBitmapContextCreate(result, width, height,
bitsPerComponent, bytesPerRow, colorSpace,
kCGImageAlphaPremultipliedLast | kCGBitmapByteOrder32Big);
CGColorSpaceRelease(colorSpace);
CGContextDrawImage(context, CGRectMake(0, 0, width, height), image);
CGContextRelease(context);
CFRelease(image);
munmap(fileData, bytesInFile);
close(fileHandle);
CFRelease(imageProvider);
CFRelease(fileDataRef);
*outWidth = width;
*outHeight = height;
*outChannels = channels;
return result;
}
void loadJPEG_color( const char *path, cv::Mat &image )
{
CGDataProviderRef jpegDataProvider = CGDataProviderCreateWithFilename( path );
CGImageRef imageRef = CGImageCreateWithJPEGDataProvider( jpegDataProvider, NULL, false, kCGRenderingIntentDefault );
copyImageData_color( imageRef, image );
CGImageRelease( imageRef );
CGDataProviderRelease( jpegDataProvider );
}
CGImageRef CGImageCreateWithJPEGDataProvider_wrap(
CGDataProviderRef source,
objVectorOop decodeArrayOop,
bool shouldInterpolate,
uint32 colorRenderingIntent,
void* FH) {
float* decodeArray; uint32 decodeLen;
return
convertFloatObjVector( decodeArrayOop, "CGImageCreateWithJPEGDataProvider", FH,
decodeArray, decodeLen)
? CGImageCreateWithJPEGDataProvider( source, decodeArray, shouldInterpolate, CGColorRenderingIntent(colorRenderingIntent))
: NULL;
}
UncompressedImage
LoadJPEGFile(Path path)
{
CGDataProviderRef data_provider = CGDataProviderCreateWithFilename(path.c_str());
if (nullptr == data_provider)
return UncompressedImage();
CGImageRef image = CGImageCreateWithJPEGDataProvider(
data_provider, nullptr, false, kCGRenderingIntentDefault);
UncompressedImage result = CGImageToUncompressedImage(image);
if (nullptr != image)
CFRelease(image);
CFRelease(data_provider);
return result;
}
CGImageRef nglImageCGCodec::ReadInfo(nglIStream* pIStream)
{
mpIStream = pIStream;
CGImageRef pCGImage = NULL;
const bool shouldInterpolate = true;
if (ProbePNG(pIStream))
{
pCGImage = CGImageCreateWithPNGDataProvider(mpCGProvider, NULL, shouldInterpolate, kCGRenderingIntentDefault);
}
else if (ProbeJPEG(pIStream))
{
pCGImage = CGImageCreateWithJPEGDataProvider(mpCGProvider, NULL, false, kCGRenderingIntentDefault);
}
if (pCGImage)
{
nglImageInfo info;
info.mWidth = CGImageGetWidth(pCGImage);
info.mHeight = CGImageGetHeight(pCGImage);
if (info.mWidth > 0 && info.mHeight > 0)
{
info.mBufferFormat = eImageFormatRaw;
info.mPixelFormat = eImagePixelRGBA;
info.mBytesPerPixel = 4;
info.mBitDepth = 8 * info.mBytesPerPixel;
info.mBytesPerLine = info.mWidth * info.mBytesPerPixel;
info.mPreMultAlpha = true;
info.mpBuffer = NULL;
if (!SendInfo(info))
{
CGImageRelease(pCGImage);
return NULL;
}
return pCGImage;
}
CGImageRelease(pCGImage);
}
return NULL;
}
static CGImageRef quartz_loadimage(GVJ_t * job, usershape_t *us)
{
assert(job);
assert(us);
assert(us->name);
if (us->data && us->datafree != quartz_freeimage) {
us->datafree(us); /* free incompatible cache data */
us->data = NULL;
us->datafree = NULL;
}
if (!us->data) { /* read file into cache */
if (!gvusershape_file_access(us))
return NULL;
#if __MAC_OS_X_VERSION_MIN_REQUIRED >= 1050 || __IPHONE_OS_VERSION_MIN_REQUIRED >= 20000
CGDataProviderRef data_provider = CGDataProviderCreateSequential(us->f, &file_data_provider_callbacks);
#else
CGDataProviderRef data_provider = CGDataProviderCreate(us->f, &file_data_provider_callbacks);
#endif
#if __MAC_OS_X_VERSION_MIN_REQUIRED >= 1040
/* match usershape format to a UTI for type hinting, if possible */
format_type hint_format_type;
switch (us->type) {
case FT_BMP:
hint_format_type = FORMAT_BMP;
break;
case FT_GIF:
hint_format_type = FORMAT_GIF;
break;
case FT_PNG:
hint_format_type = FORMAT_PNG;
break;
case FT_JPEG:
hint_format_type = FORMAT_JPEG;
break;
case FT_PDF:
hint_format_type = FORMAT_PDF;
break;
default:
hint_format_type = FORMAT_NONE;
break;
}
CFDictionaryRef options = hint_format_type == FORMAT_NONE ? NULL : CFDictionaryCreate(
kCFAllocatorDefault,
(const void **)&kCGImageSourceTypeIdentifierHint,
(const void **)(format_uti + hint_format_type),
1,
&kCFTypeDictionaryKeyCallBacks,
&kCFTypeDictionaryValueCallBacks);
/* get first image from usershape file */
CGImageSourceRef image_source = CGImageSourceCreateWithDataProvider(data_provider, options);
us->data = CGImageSourceCreateImageAtIndex(image_source, 0, NULL);
if (image_source)
CFRelease(image_source);
if (options)
CFRelease(options);
#else
switch (us->type) {
case FT_PNG:
us->data = CGImageCreateWithPNGDataProvider(data_provider, NULL, false, kCGRenderingIntentDefault);
break;
case FT_JPEG:
us->data = CGImageCreateWithJPEGDataProvider(data_provider, NULL, false, kCGRenderingIntentDefault);
break;
default:
us->data = NULL;
break;
}
#endif
/* clean up */
if (us->data)
us->datafree = quartz_freeimage;
CGDataProviderRelease(data_provider);
gvusershape_file_release(us);
}
return (CGImageRef)(us->data);
}
static mblk_t *jpeg2yuv(uint8_t *jpgbuf, int bufsize, MSVideoSize *reqsize){
#ifndef NO_FFMPEG
AVCodecContext av_context;
int got_picture=0;
AVFrame orig;
mblk_t *ret;
struct SwsContext *sws_ctx;
AVPacket pkt;
MSPicture dest;
AVCodec *codec=avcodec_find_decoder(CODEC_ID_MJPEG);
if (codec==NULL){
ms_error("Could not find MJPEG decoder in ffmpeg.");
return NULL;
}
avcodec_get_context_defaults(&av_context);
if (avcodec_open(&av_context,codec)<0){
ms_error("jpeg2yuv: avcodec_open failed");
return NULL;
}
av_init_packet(&pkt);
pkt.data=jpgbuf;
pkt.size=bufsize;
if (avcodec_decode_video2(&av_context,&orig,&got_picture,&pkt) < 0) {
ms_error("jpeg2yuv: avcodec_decode_video failed");
avcodec_close(&av_context);
return NULL;
}
ret=ms_yuv_buf_alloc(&dest, reqsize->width,reqsize->height);
/* not using SWS_FAST_BILINEAR because it doesn't play well with
* av_context.pix_fmt set to PIX_FMT_YUVJ420P by jpeg decoder */
sws_ctx=sws_getContext(av_context.width,av_context.height,av_context.pix_fmt,
reqsize->width,reqsize->height,PIX_FMT_YUV420P,SWS_BILINEAR,
NULL, NULL, NULL);
if (sws_ctx==NULL) {
ms_error("jpeg2yuv: ms_sws_getContext() failed.");
avcodec_close(&av_context);
freemsg(ret);
return NULL;
}
#if LIBSWSCALE_VERSION_INT >= AV_VERSION_INT(0,9,0)
if (sws_scale(sws_ctx,(const uint8_t* const *)orig.data,orig.linesize,0,av_context.height,dest.planes,dest.strides)<0){
#else
if (sws_scale(sws_ctx,(uint8_t**)orig.data,orig.linesize,0,av_context.height,dest.planes,dest.strides)<0){
#endif
ms_error("jpeg2yuv: ms_sws_scale() failed.");
sws_freeContext(sws_ctx);
avcodec_close(&av_context);
freemsg(ret);
return NULL;
}
sws_freeContext(sws_ctx);
avcodec_close(&av_context);
return ret;
#elif TARGET_OS_IPHONE
MSPicture dest;
CGDataProviderRef dataProvider = CGDataProviderCreateWithData(NULL, jpgbuf, bufsize, NULL);
// use the data provider to get a CGImage; release the data provider
CGImageRef image = CGImageCreateWithJPEGDataProvider(dataProvider, NULL, FALSE,
kCGRenderingIntentDefault);
CGDataProviderRelease(dataProvider);
reqsize->width = CGImageGetWidth(image);
reqsize->height = CGImageGetHeight(image);
uint8_t* tmp = (uint8_t*) malloc(reqsize->width * reqsize->height * 4);
mblk_t* ret=ms_yuv_buf_alloc(&dest, reqsize->width, reqsize->height);
CGColorSpaceRef colourSpace = CGColorSpaceCreateDeviceRGB();
CGContextRef imageContext =
CGBitmapContextCreate(tmp, reqsize->width, reqsize->height, 8, reqsize->width*4, colourSpace, kCGImageAlphaNoneSkipLast);
CGColorSpaceRelease(colourSpace);
// draw the image to the context, release it
CGContextDrawImage(imageContext, CGRectMake(0, 0, reqsize->width, reqsize->height), image);
CGImageRelease(image);
/* convert tmp/RGB -> ret/YUV */
for(int y=0; y<reqsize->height; y++) {
for(int x=0; x<reqsize->width; x++) {
uint8_t r = tmp[y * reqsize->width * 4 + x * 4 + 0];
uint8_t g = tmp[y * reqsize->width * 4 + x * 4 + 1];
uint8_t b = tmp[y * reqsize->width * 4 + x * 4 + 2];
// Y
*dest.planes[0]++ = (uint8_t)((0.257 * r) + (0.504 * g) + (0.098 * b) + 16);
// U/V subsampling
if ((y % 2==0) && (x%2==0)) {
uint32_t r32=0, g32=0, b32=0;
for(int i=0; i<2; i++) {
for(int j=0; j<2; j++) {
r32 += tmp[(y+i) * reqsize->width * 4 + (x+j) * 4 + 0];
g32 += tmp[(y+i) * reqsize->width * 4 + (x+j) * 4 + 1];
b32 += tmp[(y+i) * reqsize->width * 4 + (x+j) * 4 + 2];
}
}
r32 = (uint32_t)(r32 * 0.25f); g32 = (uint32_t)(g32 * 0.25f); b32 = (uint32_t) (b32 * 0.25f);
// U
*dest.planes[1]++ = (uint8_t)(-(0.148 * r32) - (0.291 * g32) + (0.439 * b32) + 128);
// V
*dest.planes[2]++ = (uint8_t)((0.439 * r32) - (0.368 * g32) - (0.071 * b32) + 128);
}
}
}
free(tmp);
return ret;
#else
return NULL;
#endif
}
mblk_t *ms_load_jpeg_as_yuv(const char *jpgpath, MSVideoSize *reqsize){
#if defined(WIN32)
mblk_t *m=NULL;
DWORD st_sizel;
DWORD st_sizeh;
uint8_t *jpgbuf;
DWORD err;
HANDLE fd;
#ifdef UNICODE
WCHAR wUnicode[1024];
MultiByteToWideChar(CP_UTF8, 0, jpgpath, -1, wUnicode, 1024);
fd = CreateFile(wUnicode, GENERIC_READ, FILE_SHARE_READ, NULL,
OPEN_EXISTING, 0, NULL);
#else
fd = CreateFile(jpgpath, GENERIC_READ, FILE_SHARE_READ, NULL,
OPEN_EXISTING, 0, NULL);
#endif
if (fd==INVALID_HANDLE_VALUE){
ms_error("Failed to open %s",jpgpath);
return NULL;
}
st_sizel=0;
st_sizeh=0;
st_sizel = GetFileSize(fd, &st_sizeh);
if (st_sizeh>0 || st_sizel<=0)
{
CloseHandle(fd);
ms_error("Can't load file %s",jpgpath);
return NULL;
}
jpgbuf=(uint8_t*)ms_malloc0(st_sizel);
if (jpgbuf==NULL)
{
CloseHandle(fd);
ms_error("Cannot allocate buffer for %s",jpgpath);
return NULL;
}
err=0;
ReadFile(fd, jpgbuf, st_sizel, &err, NULL) ;
if (err!=st_sizel){
ms_error("Could not read as much as wanted !");
}
m=jpeg2yuv(jpgbuf,st_sizel,reqsize);
ms_free(jpgbuf);
if (m==NULL)
{
CloseHandle(fd);
ms_error("Cannot load image from buffer for %s",jpgpath);
return NULL;
}
CloseHandle(fd);
return m;
#else
mblk_t *m=NULL;
struct stat statbuf;
uint8_t *jpgbuf;
int err;
int fd=open(jpgpath,O_RDONLY);
if (fd!=-1){
fstat(fd,&statbuf);
if (statbuf.st_size<=0)
{
close(fd);
ms_error("Cannot load %s",jpgpath);
return NULL;
}
jpgbuf=(uint8_t*)ms_malloc0(statbuf.st_size + FF_INPUT_BUFFER_PADDING_SIZE);
if (jpgbuf==NULL)
{
close(fd);
ms_error("Cannot allocate buffer for %s",jpgpath);
return NULL;
}
err=read(fd,jpgbuf,statbuf.st_size);
if (err!=statbuf.st_size){
ms_error("Could not read as much as wanted: %i<>%li !",err,(long)statbuf.st_size);
}
m=jpeg2yuv(jpgbuf,statbuf.st_size,reqsize);
ms_free(jpgbuf);
if (m==NULL)
{
close(fd);
ms_error("Cannot load image from buffer for %s",jpgpath);
return NULL;
}
}else{
ms_error("Cannot load %s",jpgpath);
return NULL;
}
close(fd);
return m;
#endif
}
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
CGImageRef CGImageCreateWithJPEGDataProvider_wrap(
CGDataProviderRef source,
bool shouldInterpolate,
uint32 colorRenderingIntent) {
return CGImageCreateWithJPEGDataProvider( source, NULL, shouldInterpolate, CGColorRenderingIntent(colorRenderingIntent));
}