#头文件
/*
File: LargeImageDownsizingViewController.h
Abstract: The primary view controller for this project.
Version: 1.1
Disclaimer: IMPORTANT: This Apple software is supplied to you by Apple
Inc. ("Apple") in consideration of your agreement to the following
terms, and your use, installation, modification or redistribution of
this Apple software constitutes acceptance of these terms. If you do
not agree with these terms, please do not use, install, modify or
redistribute this Apple software.
In consideration of your agreement to abide by the following terms, and
subject to these terms, Apple grants you a personal, non-exclusive
license, under Apple's copyrights in this original Apple software (the
"Apple Software"), to use, reproduce, modify and redistribute the Apple
Software, with or without modifications, in source and/or binary forms;
provided that if you redistribute the Apple Software in its entirety and
without modifications, you must retain this notice and the following
text and disclaimers in all such redistributions of the Apple Software.
Neither the name, trademarks, service marks or logos of Apple Inc. may
be used to endorse or promote products derived from the Apple Software
without specific prior written permission from Apple. Except as
expressly stated in this notice, no other rights or licenses, express or
implied, are granted by Apple herein, including but not limited to any
patent rights that may be infringed by your derivative works or by other
works in which the Apple Software may be incorporated.
The Apple Software is provided by Apple on an "AS IS" basis. APPLE
MAKES NO WARRANTIES, EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION
THE IMPLIED WARRANTIES OF NON-INFRINGEMENT, MERCHANTABILITY AND FITNESS
FOR A PARTICULAR PURPOSE, REGARDING THE APPLE SOFTWARE OR ITS USE AND
OPERATION ALONE OR IN COMBINATION WITH YOUR PRODUCTS.
IN NO EVENT SHALL APPLE BE LIABLE FOR ANY SPECIAL, INDIRECT, INCIDENTAL
OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
INTERRUPTION) ARISING IN ANY WAY OUT OF THE USE, REPRODUCTION,
MODIFICATION AND/OR DISTRIBUTION OF THE APPLE SOFTWARE, HOWEVER CAUSED
AND WHETHER UNDER THEORY OF CONTRACT, TORT (INCLUDING NEGLIGENCE),
STRICT LIABILITY OR OTHERWISE, EVEN IF APPLE HAS BEEN ADVISED OF THE
POSSIBILITY OF SUCH DAMAGE.
Copyright (C) 2014 Apple Inc. All Rights Reserved.
*/
#import
@classImageScrollView;
@interfaceLargeImageDownsizingViewController :UIViewController{
// The input image file
UIImage* sourceImage;
// output image file
UIImage* destImage;
// sub rect of the input image bounds that represents the
// maximum amount of pixel data to load into mem at one time.
CGRectsourceTile;
// sub rect of the output image that is proportionate to the
// size of the sourceTile.
CGRectdestTile;
// the ratio of the size of the input image to the output image.
floatimageScale;
// source image width and height
CGSizesourceResolution;
// total number of pixels in the source image
floatsourceTotalPixels;
// total number of megabytes of uncompressed pixel data in the source image.
floatsourceTotalMB;
// output image width and height
CGSizedestResolution;
// the temporary container used to hold the resulting output image pixel
// data, as it is being assembled.
CGContextRefdestContext;
// the number of pixels to overlap tiles as they are assembled.
floatsourceSeemOverlap;
// an image view to visualize the image as it is being pieced together
UIImageView* progressView;
// a scroll view to display the resulting downsized image
ImageScrollView* scrollView;
}
// destImage property is specifically thread safe (i.e. no 'nonatomic' attribute)
// because it is accessed off the main thread.
@property(retain)UIImage* destImage;
-(void)downsize:(id)arg;
-(void)updateScrollView:(id)arg;
-(void)initializeScrollView:(id)arg;
-(void)createImageFromContext;
@end
源文件
/*
File: LargeImageDownsizingViewController.m
Abstract: The primary view controller for this project.
Version: 1.1
Disclaimer: IMPORTANT: This Apple software is supplied to you by Apple
Inc. ("Apple") in consideration of your agreement to the following
terms, and your use, installation, modification or redistribution of
this Apple software constitutes acceptance of these terms. If you do
not agree with these terms, please do not use, install, modify or
redistribute this Apple software.
In consideration of your agreement to abide by the following terms, and
subject to these terms, Apple grants you a personal, non-exclusive
license, under Apple's copyrights in this original Apple software (the
"Apple Software"), to use, reproduce, modify and redistribute the Apple
Software, with or without modifications, in source and/or binary forms;
provided that if you redistribute the Apple Software in its entirety and
without modifications, you must retain this notice and the following
text and disclaimers in all such redistributions of the Apple Software.
Neither the name, trademarks, service marks or logos of Apple Inc. may
be used to endorse or promote products derived from the Apple Software
without specific prior written permission from Apple. Except as
expressly stated in this notice, no other rights or licenses, express or
implied, are granted by Apple herein, including but not limited to any
patent rights that may be infringed by your derivative works or by other
works in which the Apple Software may be incorporated.
The Apple Software is provided by Apple on an "AS IS" basis. APPLE
MAKES NO WARRANTIES, EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION
THE IMPLIED WARRANTIES OF NON-INFRINGEMENT, MERCHANTABILITY AND FITNESS
FOR A PARTICULAR PURPOSE, REGARDING THE APPLE SOFTWARE OR ITS USE AND
OPERATION ALONE OR IN COMBINATION WITH YOUR PRODUCTS.
IN NO EVENT SHALL APPLE BE LIABLE FOR ANY SPECIAL, INDIRECT, INCIDENTAL
OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
INTERRUPTION) ARISING IN ANY WAY OUT OF THE USE, REPRODUCTION,
MODIFICATION AND/OR DISTRIBUTION OF THE APPLE SOFTWARE, HOWEVER CAUSED
AND WHETHER UNDER THEORY OF CONTRACT, TORT (INCLUDING NEGLIGENCE),
STRICT LIABILITY OR OTHERWISE, EVEN IF APPLE HAS BEEN ADVISED OF THE
POSSIBILITY OF SUCH DAMAGE.
Copyright (C) 2014 Apple Inc. All Rights Reserved.
*/
#import"LargeImageDownsizingViewController.h"
#import
#import"ImageScrollView.h"
/* Image Constants: for images, we define the resulting image
size and tile size in megabytes. This translates to an amount
of pixels. Keep in mind this is almost always significantly different
from the size of a file on disk for compressed formats such as png, or jpeg.
For an image to be displayed in iOS, it must first be uncompressed (decoded) from
disk. The approximate region of pixel data that is decoded from disk is defined by both,
the clipping rect set onto the current graphics context, and the content/image
offset relative to the current context.
To get the uncompressed file size of an image, use: Width x Height / pixelsPerMB, where
pixelsPerMB = 262144 pixels in a 32bit colospace (which iOS is optimized for).
Supported formats are: PNG, TIFF, JPEG. Unsupported formats: GIF, BMP, interlaced images.
*/
#define kImageFilename @"large_leaves_70mp.jpg"// 7033x10110 image, 271 MB uncompressed
/* The arguments to the downsizing routine are the resulting image size, and
"tile" size. And they are defined in terms of megabytes to simplify the correlation
between images and memory footprint available to your application.
The "tile" is the maximum amount of pixel data to load from the input image into
memory at one time. The size of the tile defines the number of iterations
required to piece together the resulting image.
Choose a resulting size for your image given both: the hardware profile of your
target devices, and the amount of memory taken by the rest of your application.
Maximizing the source image tile size will minimize the time required to complete
the downsize routine. Thus, performance must be balanced with resulting image quality.
Choosing appropriate resulting image size and tile size can be done, but is left as
an exercise to the developer. Note that the device type/version string
(e.g. "iPhone2,1" can be determined at runtime through use of the sysctlbyname function:
size_t size;
sysctlbyname("hw.machine", NULL, &size, NULL, 0);
char *machine = malloc(size);
sysctlbyname("hw.machine", machine, &size, NULL, 0);
NSString* _platform = [NSString stringWithCString:machine encoding:NSASCIIStringEncoding];
free(machine);
These constants are suggested initial values for iPad1, and iPhone 3GS */
#define IPAD1_IPHONE3GS
#ifdef IPAD1_IPHONE3GS
# define kDestImageSizeMB60.0f// The resulting image will be (x)MB of uncompressed image data.
# define kSourceImageTileSizeMB20.0f// The tile size will be (x)MB of uncompressed image data.
#endif
/* These constants are suggested initial values for iPad2, and iPhone 4 */
//#define IPAD2_IPHONE4
#ifdef IPAD2_IPHONE4
# define kDestImageSizeMB120.0f// The resulting image will be (x)MB of uncompressed image data.
# define kSourceImageTileSizeMB40.0f// The tile size will be (x)MB of uncompressed image data.
#endif
/* These constants are suggested initial values for iPhone3G, iPod2 and earlier devices */
//#define IPHONE3G_IPOD2_AND_EARLIER
#ifdef IPHONE3G_IPOD2_AND_EARLIER
# define kDestImageSizeMB30.0f// The resulting image will be (x)MB of uncompressed image data.
# define kSourceImageTileSizeMB10.0f// The tile size will be (x)MB of uncompressed image data.
#endif
/* Constants for all other iOS devices are left to be defined by the developer.
The purpose of this sample is to illustrate that device specific constants can
and should be created by you the developer, versus iterating a complete list. */
#define bytesPerMB1048576.0f
#define bytesPerPixel4.0f
#define pixelsPerMB ( bytesPerMB / bytesPerPixel )// 262144 pixels, for 4 bytes per pixel.
#define destTotalPixels kDestImageSizeMB * pixelsPerMB
#define tileTotalPixels kSourceImageTileSizeMB * pixelsPerMB
#define destSeemOverlap2.0f// the numbers of pixels to overlap the seems where tiles meet.
@implementationLargeImageDownsizingViewController
@synthesizedestImage;
// release ownership
- (void)dealloc {
[destImagerelease];
[scrollViewrelease];
//--
[superdealloc];
}
- (void)didReceiveMemoryWarning {
// Releases the view if it doesn't have a superview.
[superdidReceiveMemoryWarning];
// Release any cached data, images, etc that aren't in use.
}
#pragma mark - View lifecycle
/*
-(void)loadView {
}*/
// Implement viewDidLoad to do additional setup after loading the view, typically from a nib.
- (void)viewDidLoad {
[superviewDidLoad];
//--
progressView= [[UIImageViewalloc]initWithFrame:self.view.bounds];
[self.viewaddSubview:progressView];
[progressViewrelease];
[NSThreaddetachNewThreadSelector:@selector(downsize:)toTarget:selfwithObject:nil];
}
- (void)viewDidUnload {
[superviewDidUnload];
// Release any retained subviews of the main view.
// e.g. self.myOutlet = nil;
}
- (BOOL)shouldAutorotateToInterfaceOrientation:(UIInterfaceOrientation)interfaceOrientation {
// Return YES for supported orientations
return(interfaceOrientation ==UIInterfaceOrientationPortrait);
}
-(void)downsize:(id)arg {
// create an autorelease pool to catch calls to -autorelease.
NSAutoreleasePool* pool = [[NSAutoreleasePoolalloc]init];
// create an image from the image filename constant. Note this
// doesn't actually read any pixel information from disk, as that
// is actually done at draw time.
sourceImage= [[UIImagealloc]initWithContentsOfFile:[[NSBundlemainBundle]pathForResource:kImageFilenameofType:nil]];
if(sourceImage==nil)NSLog(@"input image not found!");
// get the width and height of the input image using
// core graphics image helper functions.
sourceResolution.width=CGImageGetWidth(sourceImage.CGImage);
sourceResolution.height=CGImageGetHeight(sourceImage.CGImage);
// use the width and height to calculate the total number of pixels
// in the input image.
sourceTotalPixels=sourceResolution.width*sourceResolution.height;
// calculate the number of MB that would be required to store
// this image uncompressed in memory.
sourceTotalMB=sourceTotalPixels/pixelsPerMB;
// determine the scale ratio to apply to the input image
// that results in an output image of the defined size.
// see kDestImageSizeMB, and how it relates to destTotalPixels.
imageScale=destTotalPixels/sourceTotalPixels;
// use the image scale to calcualte the output image width, height
destResolution.width= (int)(sourceResolution.width*imageScale);
destResolution.height= (int)(sourceResolution.height*imageScale);
// create an offscreen bitmap context that will hold the output image
// pixel data, as it becomes available by the downscaling routine.
// use the RGB colorspace as this is the colorspace iOS GPU is optimized for.
CGColorSpaceRefcolorSpace =CGColorSpaceCreateDeviceRGB();
intbytesPerRow =bytesPerPixel*destResolution.width;
// allocate enough pixel data to hold the output image.
void* destBitmapData =malloc( bytesPerRow *destResolution.height);
if( destBitmapData ==NULL)NSLog(@"failed to allocate space for the output image!");
// create the output bitmap context
destContext=CGBitmapContextCreate( destBitmapData,destResolution.width,destResolution.height, 8, bytesPerRow, colorSpace,kCGImageAlphaPremultipliedLast);
// remember CFTypes assign/check for NULL. NSObjects assign/check for nil.
if(destContext==NULL) {
free( destBitmapData );
NSLog(@"failed to create the output bitmap context!");
}
// release the color space object as its job is done
CGColorSpaceRelease( colorSpace );
// flip the output graphics context so that it aligns with the
// cocoa style orientation of the input document. this is needed
// because we used cocoa's UIImage -imageNamed to open the input file.
CGContextTranslateCTM(destContext, 0.0f,destResolution.height);
CGContextScaleCTM(destContext, 1.0f, -1.0f );
// now define the size of the rectangle to be used for the
// incremental blits from the input image to the output image.
// we use a source tile width equal to the width of the source
// image due to the way that iOS retrieves image data from disk.
// iOS must decode an image from disk in full width 'bands', even
// if current graphics context is clipped to a subrect within that
// band. Therefore we fully utilize all of the pixel data that results
// from a decoding opertion by achnoring our tile size to the full
// width of the input image.
sourceTile.size.width=sourceResolution.width;
// the source tile height is dynamic. Since we specified the size
// of the source tile in MB, see how many rows of pixels high it
// can be given the input image width.
sourceTile.size.height= (int)(tileTotalPixels/sourceTile.size.width);
NSLog(@"source tile size: %f x %f",sourceTile.size.width,sourceTile.size.height);
sourceTile.origin.x= 0.0f;
// the output tile is the same proportions as the input tile, but
// scaled to image scale.
destTile.size.width=destResolution.width;
destTile.size.height=sourceTile.size.height*imageScale;
destTile.origin.x= 0.0f;
NSLog(@"dest tile size: %f x %f",destTile.size.width,destTile.size.height);
// the source seem overlap is proportionate to the destination seem overlap.
// this is the amount of pixels to overlap each tile as we assemble the ouput image.
sourceSeemOverlap= (int)( (destSeemOverlap/destResolution.height) *sourceResolution.height);
NSLog(@"dest seem overlap: %f, source seem overlap: %f",destSeemOverlap,sourceSeemOverlap);
CGImageRefsourceTileImageRef;
// calculate the number of read/write opertions required to assemble the
// output image.
intiterations = (int)(sourceResolution.height/sourceTile.size.height);
// if tile height doesn't divide the image height evenly, add another iteration
// to account for the remaining pixels.
intremainder = (int)sourceResolution.height% (int)sourceTile.size.height;
if( remainder ) iterations++;
// add seem overlaps to the tiles, but save the original tile height for y coordinate calculations.
floatsourceTileHeightMinusOverlap =sourceTile.size.height;
sourceTile.size.height+=sourceSeemOverlap;
destTile.size.height+=destSeemOverlap;
NSLog(@"beginning downsize. iterations: %d, tile height: %f, remainder height: %d", iterations,sourceTile.size.height,remainder );
for(inty = 0; y < iterations; ++y ) {
// create an autorelease pool to catch calls to -autorelease made within the downsize loop.
NSAutoreleasePool* pool2 = [[NSAutoreleasePoolalloc]init];
NSLog(@"iteration %d of %d",y+1,iterations);
sourceTile.origin.y= y * sourceTileHeightMinusOverlap +sourceSeemOverlap;
destTile.origin.y= (destResolution.height) - ( ( y + 1 ) * sourceTileHeightMinusOverlap *imageScale+destSeemOverlap);
// create a reference to the source image with its context clipped to the argument rect.
sourceTileImageRef =CGImageCreateWithImageInRect(sourceImage.CGImage,sourceTile);
// if this is the last tile, it's size may be smaller than the source tile height.
// adjust the dest tile size to account for that difference.
if( y == iterations - 1 && remainder ) {
floatdify =destTile.size.height;
destTile.size.height=CGImageGetHeight( sourceTileImageRef ) *imageScale;
dify -=destTile.size.height;
destTile.origin.y+= dify;
}
// read and write a tile sized portion of pixels from the input image to the output image.
CGContextDrawImage(destContext,destTile, sourceTileImageRef );
/* release the source tile portion pixel data. note,
releasing the sourceTileImageRef doesn't actually release the tile portion pixel
data that we just drew, but the call afterward does. */
CGImageRelease( sourceTileImageRef );
/* while CGImageCreateWithImageInRect lazily loads just the image data defined by the argument rect,
that data is finally decoded from disk to mem when CGContextDrawImage is called. sourceTileImageRef
maintains internally a reference to the original image, and that original image both, houses and
caches that portion of decoded mem. Thus the following call to release the source image. */
[sourceImagerelease];
// free all objects that were sent -autorelease within the scope of this loop.
[pool2drain];
// we reallocate the source image after the pool is drained since UIImage -imageNamed
// returns us an autoreleased object.
if( y < iterations - 1 ) {
sourceImage= [[UIImagealloc]initWithContentsOfFile:[[NSBundlemainBundle]pathForResource:kImageFilenameofType:nil]];
[selfperformSelectorOnMainThread:@selector(updateScrollView:)withObject:nilwaitUntilDone:YES];
}
}
NSLog(@"downsize complete.");
[selfperformSelectorOnMainThread:@selector(initializeScrollView:)withObject:nilwaitUntilDone:YES];
// free the context since its job is done. destImageRef retains the pixel data now.
CGContextRelease(destContext);
[pooldrain];
}
-(void)createImageFromContext {
// create a CGImage from the offscreen image context
CGImageRefdestImageRef =CGBitmapContextCreateImage(destContext);
if( destImageRef ==NULL)NSLog(@"destImageRef is null.");
// wrap a UIImage around the CGImage
self.destImage= [UIImageimageWithCGImage:destImageRefscale:1.0forientation:UIImageOrientationDownMirrored];
// release ownership of the CGImage, since destImage retains ownership of the object now.
CGImageRelease( destImageRef );
if(destImage==nil)NSLog(@"destImage is nil.");
}
-(void)updateScrollView:(id)arg {
[selfcreateImageFromContext];
// display the output image on the screen.
progressView.image=destImage;
}
-(void)initializeScrollView:(id)arg {
[progressViewremoveFromSuperview];
[selfcreateImageFromContext];
// create a scroll view to display the resulting image.
scrollView= [[ImageScrollViewalloc]initWithFrame:self.view.boundsimage:self.destImage];
[self.viewaddSubview:scrollView];
}