/* |
File: SquareCamViewController.m |
Abstract: Dmonstrates iOS 5 features of the AVCaptureStillImageOutput class |
Version: 1.0 |
|
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) 2013 Apple Inc. All Rights Reserved. |
|
*/ |
|
#import "SquareCamViewController.h" |
#import <CoreImage/CoreImage.h> |
#import <ImageIO/ImageIO.h> |
#import <AssertMacros.h> |
#import <AssetsLibrary/AssetsLibrary.h> |
|
#pragma mark- |
|
// used for KVO observation of the @"capturingStillImage" property to perform flash bulb animation |
static const NSString *AVCaptureStillImageIsCapturingStillImageContext = @"AVCaptureStillImageIsCapturingStillImageContext"; |
|
static CGFloat DegreesToRadians(CGFloat degrees) {return degrees * M_PI / 180;}; |
|
static void ReleaseCVPixelBuffer(void *pixel, const void *data, size_t size); |
static void ReleaseCVPixelBuffer(void *pixel, const void *data, size_t size) |
{ |
CVPixelBufferRef pixelBuffer = (CVPixelBufferRef)pixel; |
CVPixelBufferUnlockBaseAddress( pixelBuffer, 0 ); |
CVPixelBufferRelease( pixelBuffer ); |
} |
|
// create a CGImage with provided pixel buffer, pixel buffer must be uncompressed kCVPixelFormatType_32ARGB or kCVPixelFormatType_32BGRA |
static OSStatus CreateCGImageFromCVPixelBuffer(CVPixelBufferRef pixelBuffer, CGImageRef *imageOut); |
static OSStatus CreateCGImageFromCVPixelBuffer(CVPixelBufferRef pixelBuffer, CGImageRef *imageOut) |
{ |
OSStatus err = noErr; |
OSType sourcePixelFormat; |
size_t width, height, sourceRowBytes; |
void *sourceBaseAddr = NULL; |
CGBitmapInfo bitmapInfo; |
CGColorSpaceRef colorspace = NULL; |
CGDataProviderRef provider = NULL; |
CGImageRef image = NULL; |
|
sourcePixelFormat = CVPixelBufferGetPixelFormatType( pixelBuffer ); |
if ( kCVPixelFormatType_32ARGB == sourcePixelFormat ) |
bitmapInfo = kCGBitmapByteOrder32Big | kCGImageAlphaNoneSkipFirst; |
else if ( kCVPixelFormatType_32BGRA == sourcePixelFormat ) |
bitmapInfo = kCGBitmapByteOrder32Little | kCGImageAlphaNoneSkipFirst; |
else |
return -95014; // only uncompressed pixel formats |
|
sourceRowBytes = CVPixelBufferGetBytesPerRow( pixelBuffer ); |
width = CVPixelBufferGetWidth( pixelBuffer ); |
height = CVPixelBufferGetHeight( pixelBuffer ); |
|
CVPixelBufferLockBaseAddress( pixelBuffer, 0 ); |
sourceBaseAddr = CVPixelBufferGetBaseAddress( pixelBuffer ); |
|
colorspace = CGColorSpaceCreateDeviceRGB(); |
|
CVPixelBufferRetain( pixelBuffer ); |
provider = CGDataProviderCreateWithData( (void *)pixelBuffer, sourceBaseAddr, sourceRowBytes * height, ReleaseCVPixelBuffer); |
image = CGImageCreate(width, height, 8, 32, sourceRowBytes, colorspace, bitmapInfo, provider, NULL, true, kCGRenderingIntentDefault); |
|
bail: |
if ( err && image ) { |
CGImageRelease( image ); |
image = NULL; |
} |
if ( provider ) CGDataProviderRelease( provider ); |
if ( colorspace ) CGColorSpaceRelease( colorspace ); |
*imageOut = image; |
return err; |
} |
|
// utility used by newSquareOverlayedImageForFeatures for |
static CGContextRef CreateCGBitmapContextForSize(CGSize size); |
static CGContextRef CreateCGBitmapContextForSize(CGSize size) |
{ |
CGContextRef context = NULL; |
CGColorSpaceRef colorSpace; |
int bitmapBytesPerRow; |
|
bitmapBytesPerRow = (size.width * 4); |
|
colorSpace = CGColorSpaceCreateDeviceRGB(); |
context = CGBitmapContextCreate (NULL, |
size.width, |
size.height, |
8, // bits per component |
bitmapBytesPerRow, |
colorSpace, |
kCGImageAlphaPremultipliedLast); |
CGContextSetAllowsAntialiasing(context, NO); |
CGColorSpaceRelease( colorSpace ); |
return context; |
} |
|
#pragma mark- |
|
@interface UIImage (RotationMethods) |
- (UIImage *)imageRotatedByDegrees:(CGFloat)degrees; |
@end |
|
@implementation UIImage (RotationMethods) |
|
- (UIImage *)imageRotatedByDegrees:(CGFloat)degrees |
{ |
// calculate the size of the rotated view's containing box for our drawing space |
UIView *rotatedViewBox = [[UIView alloc] initWithFrame:CGRectMake(0,0,self.size.width, self.size.height)]; |
CGAffineTransform t = CGAffineTransformMakeRotation(DegreesToRadians(degrees)); |
rotatedViewBox.transform = t; |
CGSize rotatedSize = rotatedViewBox.frame.size; |
[rotatedViewBox release]; |
|
// Create the bitmap context |
UIGraphicsBeginImageContext(rotatedSize); |
CGContextRef bitmap = UIGraphicsGetCurrentContext(); |
|
// Move the origin to the middle of the image so we will rotate and scale around the center. |
CGContextTranslateCTM(bitmap, rotatedSize.width/2, rotatedSize.height/2); |
|
// // Rotate the image context |
CGContextRotateCTM(bitmap, DegreesToRadians(degrees)); |
|
// Now, draw the rotated/scaled image into the context |
CGContextScaleCTM(bitmap, 1.0, -1.0); |
CGContextDrawImage(bitmap, CGRectMake(-self.size.width / 2, -self.size.height / 2, self.size.width, self.size.height), [self CGImage]); |
|
UIImage *newImage = UIGraphicsGetImageFromCurrentImageContext(); |
UIGraphicsEndImageContext(); |
return newImage; |
|
} |
|
@end |
|
#pragma mark- |
|
@interface SquareCamViewController (InternalMethods) |
- (void)setupAVCapture; |
- (void)teardownAVCapture; |
- (void)drawFaceBoxesForFeatures:(NSArray *)features forVideoBox:(CGRect)clap orientation:(UIDeviceOrientation)orientation; |
@end |
|
@implementation SquareCamViewController |
|
- (void)setupAVCapture |
{ |
NSError *error = nil; |
|
AVCaptureSession *session = [AVCaptureSession new]; |
if ([[UIDevice currentDevice] userInterfaceIdiom] == UIUserInterfaceIdiomPhone) |
[session setSessionPreset:AVCaptureSessionPreset640x480]; |
else |
[session setSessionPreset:AVCaptureSessionPresetPhoto]; |
|
// Select a video device, make an input |
AVCaptureDevice *device = [AVCaptureDevice defaultDeviceWithMediaType:AVMediaTypeVideo]; |
AVCaptureDeviceInput *deviceInput = [AVCaptureDeviceInput deviceInputWithDevice:device error:&error]; |
require( error == nil, bail ); |
|
isUsingFrontFacingCamera = NO; |
if ( [session canAddInput:deviceInput] ) |
[session addInput:deviceInput]; |
|
// Make a still image output |
stillImageOutput = [AVCaptureStillImageOutput new]; |
[stillImageOutput addObserver:self forKeyPath:@"capturingStillImage" options:NSKeyValueObservingOptionNew context:AVCaptureStillImageIsCapturingStillImageContext]; |
if ( [session canAddOutput:stillImageOutput] ) |
[session addOutput:stillImageOutput]; |
|
// Make a video data output |
videoDataOutput = [AVCaptureVideoDataOutput new]; |
|
// we want BGRA, both CoreGraphics and OpenGL work well with 'BGRA' |
NSDictionary *rgbOutputSettings = [NSDictionary dictionaryWithObject: |
[NSNumber numberWithInt:kCMPixelFormat_32BGRA] forKey:(id)kCVPixelBufferPixelFormatTypeKey]; |
[videoDataOutput setVideoSettings:rgbOutputSettings]; |
[videoDataOutput setAlwaysDiscardsLateVideoFrames:YES]; // discard if the data output queue is blocked (as we process the still image) |
|
// create a serial dispatch queue used for the sample buffer delegate as well as when a still image is captured |
// a serial dispatch queue must be used to guarantee that video frames will be delivered in order |
// see the header doc for setSampleBufferDelegate:queue: for more information |
videoDataOutputQueue = dispatch_queue_create("VideoDataOutputQueue", DISPATCH_QUEUE_SERIAL); |
[videoDataOutput setSampleBufferDelegate:self queue:videoDataOutputQueue]; |
|
if ( [session canAddOutput:videoDataOutput] ) |
[session addOutput:videoDataOutput]; |
[[videoDataOutput connectionWithMediaType:AVMediaTypeVideo] setEnabled:NO]; |
|
effectiveScale = 1.0; |
previewLayer = [[AVCaptureVideoPreviewLayer alloc] initWithSession:session]; |
[previewLayer setBackgroundColor:[[UIColor blackColor] CGColor]]; |
[previewLayer setVideoGravity:AVLayerVideoGravityResizeAspect]; |
CALayer *rootLayer = [previewView layer]; |
[rootLayer setMasksToBounds:YES]; |
[previewLayer setFrame:[rootLayer bounds]]; |
[rootLayer addSublayer:previewLayer]; |
[session startRunning]; |
|
bail: |
[session release]; |
if (error) { |
UIAlertView *alertView = [[UIAlertView alloc] initWithTitle:[NSString stringWithFormat:@"Failed with error %d", (int)[error code]] |
message:[error localizedDescription] |
delegate:nil |
cancelButtonTitle:@"Dismiss" |
otherButtonTitles:nil]; |
[alertView show]; |
[alertView release]; |
[self teardownAVCapture]; |
} |
} |
|
// clean up capture setup |
- (void)teardownAVCapture |
{ |
[videoDataOutput release]; |
if (videoDataOutputQueue) |
dispatch_release(videoDataOutputQueue); |
[stillImageOutput removeObserver:self forKeyPath:@"isCapturingStillImage"]; |
[stillImageOutput release]; |
[previewLayer removeFromSuperlayer]; |
[previewLayer release]; |
} |
|
// perform a flash bulb animation using KVO to monitor the value of the capturingStillImage property of the AVCaptureStillImageOutput class |
- (void)observeValueForKeyPath:(NSString *)keyPath ofObject:(id)object change:(NSDictionary *)change context:(void *)context |
{ |
if ( context == AVCaptureStillImageIsCapturingStillImageContext ) { |
BOOL isCapturingStillImage = [[change objectForKey:NSKeyValueChangeNewKey] boolValue]; |
|
if ( isCapturingStillImage ) { |
// do flash bulb like animation |
flashView = [[UIView alloc] initWithFrame:[previewView frame]]; |
[flashView setBackgroundColor:[UIColor whiteColor]]; |
[flashView setAlpha:0.f]; |
[[[self view] window] addSubview:flashView]; |
|
[UIView animateWithDuration:.4f |
animations:^{ |
[flashView setAlpha:1.f]; |
} |
]; |
} |
else { |
[UIView animateWithDuration:.4f |
animations:^{ |
[flashView setAlpha:0.f]; |
} |
completion:^(BOOL finished){ |
[flashView removeFromSuperview]; |
[flashView release]; |
flashView = nil; |
} |
]; |
} |
} |
} |
|
// utility routing used during image capture to set up capture orientation |
- (AVCaptureVideoOrientation)avOrientationForDeviceOrientation:(UIDeviceOrientation)deviceOrientation |
{ |
AVCaptureVideoOrientation result = deviceOrientation; |
if ( deviceOrientation == UIDeviceOrientationLandscapeLeft ) |
result = AVCaptureVideoOrientationLandscapeRight; |
else if ( deviceOrientation == UIDeviceOrientationLandscapeRight ) |
result = AVCaptureVideoOrientationLandscapeLeft; |
return result; |
} |
|
// utility routine to create a new image with the red square overlay with appropriate orientation |
// and return the new composited image which can be saved to the camera roll |
- (CGImageRef)newSquareOverlayedImageForFeatures:(NSArray *)features |
inCGImage:(CGImageRef)backgroundImage |
withOrientation:(UIDeviceOrientation)orientation |
frontFacing:(BOOL)isFrontFacing |
{ |
CGImageRef returnImage = NULL; |
CGRect backgroundImageRect = CGRectMake(0., 0., CGImageGetWidth(backgroundImage), CGImageGetHeight(backgroundImage)); |
CGContextRef bitmapContext = CreateCGBitmapContextForSize(backgroundImageRect.size); |
CGContextClearRect(bitmapContext, backgroundImageRect); |
CGContextDrawImage(bitmapContext, backgroundImageRect, backgroundImage); |
CGFloat rotationDegrees = 0.; |
|
switch (orientation) { |
case UIDeviceOrientationPortrait: |
rotationDegrees = -90.; |
break; |
case UIDeviceOrientationPortraitUpsideDown: |
rotationDegrees = 90.; |
break; |
case UIDeviceOrientationLandscapeLeft: |
if (isFrontFacing) rotationDegrees = 180.; |
else rotationDegrees = 0.; |
break; |
case UIDeviceOrientationLandscapeRight: |
if (isFrontFacing) rotationDegrees = 0.; |
else rotationDegrees = 180.; |
break; |
case UIDeviceOrientationFaceUp: |
case UIDeviceOrientationFaceDown: |
default: |
break; // leave the layer in its last known orientation |
} |
UIImage *rotatedSquareImage = [square imageRotatedByDegrees:rotationDegrees]; |
|
// features found by the face detector |
for ( CIFaceFeature *ff in features ) { |
CGRect faceRect = [ff bounds]; |
CGContextDrawImage(bitmapContext, faceRect, [rotatedSquareImage CGImage]); |
} |
returnImage = CGBitmapContextCreateImage(bitmapContext); |
CGContextRelease (bitmapContext); |
|
return returnImage; |
} |
|
// utility routine used after taking a still image to write the resulting image to the camera roll |
- (BOOL)writeCGImageToCameraRoll:(CGImageRef)cgImage withMetadata:(NSDictionary *)metadata |
{ |
CFMutableDataRef destinationData = CFDataCreateMutable(kCFAllocatorDefault, 0); |
CGImageDestinationRef destination = CGImageDestinationCreateWithData(destinationData, |
CFSTR("public.jpeg"), |
1, |
NULL); |
BOOL success = (destination != NULL); |
require(success, bail); |
|
const float JPEGCompQuality = 0.85f; // JPEGHigherQuality |
CFMutableDictionaryRef optionsDict = NULL; |
CFNumberRef qualityNum = NULL; |
|
qualityNum = CFNumberCreate(0, kCFNumberFloatType, &JPEGCompQuality); |
if ( qualityNum ) { |
optionsDict = CFDictionaryCreateMutable(0, 0, &kCFTypeDictionaryKeyCallBacks, &kCFTypeDictionaryValueCallBacks); |
if ( optionsDict ) |
CFDictionarySetValue(optionsDict, kCGImageDestinationLossyCompressionQuality, qualityNum); |
CFRelease( qualityNum ); |
} |
|
CGImageDestinationAddImage( destination, cgImage, optionsDict ); |
success = CGImageDestinationFinalize( destination ); |
|
if ( optionsDict ) |
CFRelease(optionsDict); |
|
require(success, bail); |
|
CFRetain(destinationData); |
ALAssetsLibrary *library = [ALAssetsLibrary new]; |
[library writeImageDataToSavedPhotosAlbum:(id)destinationData metadata:metadata completionBlock:^(NSURL *assetURL, NSError *error) { |
if (destinationData) |
CFRelease(destinationData); |
}]; |
[library release]; |
|
|
bail: |
if (destinationData) |
CFRelease(destinationData); |
if (destination) |
CFRelease(destination); |
return success; |
} |
|
// utility routine to display error aleart if takePicture fails |
- (void)displayErrorOnMainQueue:(NSError *)error withMessage:(NSString *)message |
{ |
dispatch_async(dispatch_get_main_queue(), ^(void) { |
UIAlertView *alertView = [[UIAlertView alloc] initWithTitle:[NSString stringWithFormat:@"%@ (%d)", message, (int)[error code]] |
message:[error localizedDescription] |
delegate:nil |
cancelButtonTitle:@"Dismiss" |
otherButtonTitles:nil]; |
[alertView show]; |
[alertView release]; |
}); |
} |
|
// main action method to take a still image -- if face detection has been turned on and a face has been detected |
// the square overlay will be composited on top of the captured image and saved to the camera roll |
- (IBAction)takePicture:(id)sender |
{ |
// Find out the current orientation and tell the still image output. |
AVCaptureConnection *stillImageConnection = [stillImageOutput connectionWithMediaType:AVMediaTypeVideo]; |
UIDeviceOrientation curDeviceOrientation = [[UIDevice currentDevice] orientation]; |
AVCaptureVideoOrientation avcaptureOrientation = [self avOrientationForDeviceOrientation:curDeviceOrientation]; |
[stillImageConnection setVideoOrientation:avcaptureOrientation]; |
[stillImageConnection setVideoScaleAndCropFactor:effectiveScale]; |
|
BOOL doingFaceDetection = detectFaces && (effectiveScale == 1.0); |
|
// set the appropriate pixel format / image type output setting depending on if we'll need an uncompressed image for |
// the possiblity of drawing the red square over top or if we're just writing a jpeg to the camera roll which is the trival case |
if (doingFaceDetection) |
[stillImageOutput setOutputSettings:[NSDictionary dictionaryWithObject:[NSNumber numberWithInt:kCMPixelFormat_32BGRA] |
forKey:(id)kCVPixelBufferPixelFormatTypeKey]]; |
else |
[stillImageOutput setOutputSettings:[NSDictionary dictionaryWithObject:AVVideoCodecJPEG |
forKey:AVVideoCodecKey]]; |
|
[stillImageOutput captureStillImageAsynchronouslyFromConnection:stillImageConnection |
completionHandler:^(CMSampleBufferRef imageDataSampleBuffer, NSError *error) { |
if (error) { |
[self displayErrorOnMainQueue:error withMessage:@"Take picture failed"]; |
} |
else { |
if (doingFaceDetection) { |
// Got an image. |
CVPixelBufferRef pixelBuffer = CMSampleBufferGetImageBuffer(imageDataSampleBuffer); |
CFDictionaryRef attachments = CMCopyDictionaryOfAttachments(kCFAllocatorDefault, imageDataSampleBuffer, kCMAttachmentMode_ShouldPropagate); |
CIImage *ciImage = [[CIImage alloc] initWithCVPixelBuffer:pixelBuffer options:(NSDictionary *)attachments]; |
if (attachments) |
CFRelease(attachments); |
|
NSDictionary *imageOptions = nil; |
NSNumber *orientation = CMGetAttachment(imageDataSampleBuffer, kCGImagePropertyOrientation, NULL); |
if (orientation) { |
imageOptions = [NSDictionary dictionaryWithObject:orientation forKey:CIDetectorImageOrientation]; |
} |
|
// when processing an existing frame we want any new frames to be automatically dropped |
// queueing this block to execute on the videoDataOutputQueue serial queue ensures this |
// see the header doc for setSampleBufferDelegate:queue: for more information |
dispatch_sync(videoDataOutputQueue, ^(void) { |
|
// get the array of CIFeature instances in the given image with a orientation passed in |
// the detection will be done based on the orientation but the coordinates in the returned features will |
// still be based on those of the image. |
NSArray *features = [faceDetector featuresInImage:ciImage options:imageOptions]; |
CGImageRef srcImage = NULL; |
OSStatus err = CreateCGImageFromCVPixelBuffer(CMSampleBufferGetImageBuffer(imageDataSampleBuffer), &srcImage); |
check(!err); |
|
CGImageRef cgImageResult = [self newSquareOverlayedImageForFeatures:features |
inCGImage:srcImage |
withOrientation:curDeviceOrientation |
frontFacing:isUsingFrontFacingCamera]; |
if (srcImage) |
CFRelease(srcImage); |
|
CFDictionaryRef attachments = CMCopyDictionaryOfAttachments(kCFAllocatorDefault, |
imageDataSampleBuffer, |
kCMAttachmentMode_ShouldPropagate); |
[self writeCGImageToCameraRoll:cgImageResult withMetadata:(id)attachments]; |
if (attachments) |
CFRelease(attachments); |
if (cgImageResult) |
CFRelease(cgImageResult); |
|
}); |
|
[ciImage release]; |
} |
else { |
// trivial simple JPEG case |
NSData *jpegData = [AVCaptureStillImageOutput jpegStillImageNSDataRepresentation:imageDataSampleBuffer]; |
CFDictionaryRef attachments = CMCopyDictionaryOfAttachments(kCFAllocatorDefault, |
imageDataSampleBuffer, |
kCMAttachmentMode_ShouldPropagate); |
ALAssetsLibrary *library = [[ALAssetsLibrary alloc] init]; |
[library writeImageDataToSavedPhotosAlbum:jpegData metadata:(id)attachments completionBlock:^(NSURL *assetURL, NSError *error) { |
if (error) { |
[self displayErrorOnMainQueue:error withMessage:@"Save to camera roll failed"]; |
} |
}]; |
|
if (attachments) |
CFRelease(attachments); |
[library release]; |
} |
} |
} |
]; |
} |
|
// turn on/off face detection |
- (IBAction)toggleFaceDetection:(id)sender |
{ |
detectFaces = [(UISwitch *)sender isOn]; |
[[videoDataOutput connectionWithMediaType:AVMediaTypeVideo] setEnabled:detectFaces]; |
if (!detectFaces) { |
dispatch_async(dispatch_get_main_queue(), ^(void) { |
// clear out any squares currently displaying. |
[self drawFaceBoxesForFeatures:[NSArray array] forVideoBox:CGRectZero orientation:UIDeviceOrientationPortrait]; |
}); |
} |
} |
|
// find where the video box is positioned within the preview layer based on the video size and gravity |
+ (CGRect)videoPreviewBoxForGravity:(NSString *)gravity frameSize:(CGSize)frameSize apertureSize:(CGSize)apertureSize |
{ |
CGFloat apertureRatio = apertureSize.height / apertureSize.width; |
CGFloat viewRatio = frameSize.width / frameSize.height; |
|
CGSize size = CGSizeZero; |
if ([gravity isEqualToString:AVLayerVideoGravityResizeAspectFill]) { |
if (viewRatio > apertureRatio) { |
size.width = frameSize.width; |
size.height = apertureSize.width * (frameSize.width / apertureSize.height); |
} else { |
size.width = apertureSize.height * (frameSize.height / apertureSize.width); |
size.height = frameSize.height; |
} |
} else if ([gravity isEqualToString:AVLayerVideoGravityResizeAspect]) { |
if (viewRatio > apertureRatio) { |
size.width = apertureSize.height * (frameSize.height / apertureSize.width); |
size.height = frameSize.height; |
} else { |
size.width = frameSize.width; |
size.height = apertureSize.width * (frameSize.width / apertureSize.height); |
} |
} else if ([gravity isEqualToString:AVLayerVideoGravityResize]) { |
size.width = frameSize.width; |
size.height = frameSize.height; |
} |
|
CGRect videoBox; |
videoBox.size = size; |
if (size.width < frameSize.width) |
videoBox.origin.x = (frameSize.width - size.width) / 2; |
else |
videoBox.origin.x = (size.width - frameSize.width) / 2; |
|
if ( size.height < frameSize.height ) |
videoBox.origin.y = (frameSize.height - size.height) / 2; |
else |
videoBox.origin.y = (size.height - frameSize.height) / 2; |
|
return videoBox; |
} |
|
// called asynchronously as the capture output is capturing sample buffers, this method asks the face detector (if on) |
// to detect features and for each draw the red square in a layer and set appropriate orientation |
- (void)drawFaceBoxesForFeatures:(NSArray *)features forVideoBox:(CGRect)clap orientation:(UIDeviceOrientation)orientation |
{ |
NSArray *sublayers = [NSArray arrayWithArray:[previewLayer sublayers]]; |
NSInteger sublayersCount = [sublayers count], currentSublayer = 0; |
NSInteger featuresCount = [features count], currentFeature = 0; |
|
[CATransaction begin]; |
[CATransaction setValue:(id)kCFBooleanTrue forKey:kCATransactionDisableActions]; |
|
// hide all the face layers |
for ( CALayer *layer in sublayers ) { |
if ( [[layer name] isEqualToString:@"FaceLayer"] ) |
[layer setHidden:YES]; |
} |
|
if ( featuresCount == 0 || !detectFaces ) { |
[CATransaction commit]; |
return; // early bail. |
} |
|
CGSize parentFrameSize = [previewView frame].size; |
NSString *gravity = [previewLayer videoGravity]; |
BOOL isMirrored = [previewLayer isMirrored]; |
CGRect previewBox = [SquareCamViewController videoPreviewBoxForGravity:gravity |
frameSize:parentFrameSize |
apertureSize:clap.size]; |
|
for ( CIFaceFeature *ff in features ) { |
// find the correct position for the square layer within the previewLayer |
// the feature box originates in the bottom left of the video frame. |
// (Bottom right if mirroring is turned on) |
CGRect faceRect = [ff bounds]; |
|
// flip preview width and height |
CGFloat temp = faceRect.size.width; |
faceRect.size.width = faceRect.size.height; |
faceRect.size.height = temp; |
temp = faceRect.origin.x; |
faceRect.origin.x = faceRect.origin.y; |
faceRect.origin.y = temp; |
// scale coordinates so they fit in the preview box, which may be scaled |
CGFloat widthScaleBy = previewBox.size.width / clap.size.height; |
CGFloat heightScaleBy = previewBox.size.height / clap.size.width; |
faceRect.size.width *= widthScaleBy; |
faceRect.size.height *= heightScaleBy; |
faceRect.origin.x *= widthScaleBy; |
faceRect.origin.y *= heightScaleBy; |
|
if ( isMirrored ) |
faceRect = CGRectOffset(faceRect, previewBox.origin.x + previewBox.size.width - faceRect.size.width - (faceRect.origin.x * 2), previewBox.origin.y); |
else |
faceRect = CGRectOffset(faceRect, previewBox.origin.x, previewBox.origin.y); |
|
CALayer *featureLayer = nil; |
|
// re-use an existing layer if possible |
while ( !featureLayer && (currentSublayer < sublayersCount) ) { |
CALayer *currentLayer = [sublayers objectAtIndex:currentSublayer++]; |
if ( [[currentLayer name] isEqualToString:@"FaceLayer"] ) { |
featureLayer = currentLayer; |
[currentLayer setHidden:NO]; |
} |
} |
|
// create a new one if necessary |
if ( !featureLayer ) { |
featureLayer = [CALayer new]; |
[featureLayer setContents:(id)[square CGImage]]; |
[featureLayer setName:@"FaceLayer"]; |
[previewLayer addSublayer:featureLayer]; |
[featureLayer release]; |
} |
[featureLayer setFrame:faceRect]; |
|
switch (orientation) { |
case UIDeviceOrientationPortrait: |
[featureLayer setAffineTransform:CGAffineTransformMakeRotation(DegreesToRadians(0.))]; |
break; |
case UIDeviceOrientationPortraitUpsideDown: |
[featureLayer setAffineTransform:CGAffineTransformMakeRotation(DegreesToRadians(180.))]; |
break; |
case UIDeviceOrientationLandscapeLeft: |
[featureLayer setAffineTransform:CGAffineTransformMakeRotation(DegreesToRadians(90.))]; |
break; |
case UIDeviceOrientationLandscapeRight: |
[featureLayer setAffineTransform:CGAffineTransformMakeRotation(DegreesToRadians(-90.))]; |
break; |
case UIDeviceOrientationFaceUp: |
case UIDeviceOrientationFaceDown: |
default: |
break; // leave the layer in its last known orientation |
} |
currentFeature++; |
} |
|
[CATransaction commit]; |
} |
|
- (void)captureOutput:(AVCaptureOutput *)captureOutput didOutputSampleBuffer:(CMSampleBufferRef)sampleBuffer fromConnection:(AVCaptureConnection *)connection |
{ |
// got an image |
CVPixelBufferRef pixelBuffer = CMSampleBufferGetImageBuffer(sampleBuffer); |
CFDictionaryRef attachments = CMCopyDictionaryOfAttachments(kCFAllocatorDefault, sampleBuffer, kCMAttachmentMode_ShouldPropagate); |
CIImage *ciImage = [[CIImage alloc] initWithCVPixelBuffer:pixelBuffer options:(NSDictionary *)attachments]; |
if (attachments) |
CFRelease(attachments); |
NSDictionary *imageOptions = nil; |
UIDeviceOrientation curDeviceOrientation = [[UIDevice currentDevice] orientation]; |
int exifOrientation; |
|
/* kCGImagePropertyOrientation values |
The intended display orientation of the image. If present, this key is a CFNumber value with the same value as defined |
by the TIFF and EXIF specifications -- see enumeration of integer constants. |
The value specified where the origin (0,0) of the image is located. If not present, a value of 1 is assumed. |
|
used when calling featuresInImage: options: The value for this key is an integer NSNumber from 1..8 as found in kCGImagePropertyOrientation. |
If present, the detection will be done based on that orientation but the coordinates in the returned features will still be based on those of the image. */ |
|
enum { |
PHOTOS_EXIF_0ROW_TOP_0COL_LEFT = 1, // 1 = 0th row is at the top, and 0th column is on the left (THE DEFAULT). |
PHOTOS_EXIF_0ROW_TOP_0COL_RIGHT = 2, // 2 = 0th row is at the top, and 0th column is on the right. |
PHOTOS_EXIF_0ROW_BOTTOM_0COL_RIGHT = 3, // 3 = 0th row is at the bottom, and 0th column is on the right. |
PHOTOS_EXIF_0ROW_BOTTOM_0COL_LEFT = 4, // 4 = 0th row is at the bottom, and 0th column is on the left. |
PHOTOS_EXIF_0ROW_LEFT_0COL_TOP = 5, // 5 = 0th row is on the left, and 0th column is the top. |
PHOTOS_EXIF_0ROW_RIGHT_0COL_TOP = 6, // 6 = 0th row is on the right, and 0th column is the top. |
PHOTOS_EXIF_0ROW_RIGHT_0COL_BOTTOM = 7, // 7 = 0th row is on the right, and 0th column is the bottom. |
PHOTOS_EXIF_0ROW_LEFT_0COL_BOTTOM = 8 // 8 = 0th row is on the left, and 0th column is the bottom. |
}; |
|
switch (curDeviceOrientation) { |
case UIDeviceOrientationPortraitUpsideDown: // Device oriented vertically, home button on the top |
exifOrientation = PHOTOS_EXIF_0ROW_LEFT_0COL_BOTTOM; |
break; |
case UIDeviceOrientationLandscapeLeft: // Device oriented horizontally, home button on the right |
if (isUsingFrontFacingCamera) |
exifOrientation = PHOTOS_EXIF_0ROW_BOTTOM_0COL_RIGHT; |
else |
exifOrientation = PHOTOS_EXIF_0ROW_TOP_0COL_LEFT; |
break; |
case UIDeviceOrientationLandscapeRight: // Device oriented horizontally, home button on the left |
if (isUsingFrontFacingCamera) |
exifOrientation = PHOTOS_EXIF_0ROW_TOP_0COL_LEFT; |
else |
exifOrientation = PHOTOS_EXIF_0ROW_BOTTOM_0COL_RIGHT; |
break; |
case UIDeviceOrientationPortrait: // Device oriented vertically, home button on the bottom |
default: |
exifOrientation = PHOTOS_EXIF_0ROW_RIGHT_0COL_TOP; |
break; |
} |
|
imageOptions = [NSDictionary dictionaryWithObject:[NSNumber numberWithInt:exifOrientation] forKey:CIDetectorImageOrientation]; |
NSArray *features = [faceDetector featuresInImage:ciImage options:imageOptions]; |
[ciImage release]; |
|
// get the clean aperture |
// the clean aperture is a rectangle that defines the portion of the encoded pixel dimensions |
// that represents image data valid for display. |
CMFormatDescriptionRef fdesc = CMSampleBufferGetFormatDescription(sampleBuffer); |
CGRect clap = CMVideoFormatDescriptionGetCleanAperture(fdesc, false /*originIsTopLeft == false*/); |
|
dispatch_async(dispatch_get_main_queue(), ^(void) { |
[self drawFaceBoxesForFeatures:features forVideoBox:clap orientation:curDeviceOrientation]; |
}); |
} |
|
- (void)dealloc |
{ |
[self teardownAVCapture]; |
[faceDetector release]; |
[square release]; |
[super dealloc]; |
} |
|
// use front/back camera |
- (IBAction)switchCameras:(id)sender |
{ |
AVCaptureDevicePosition desiredPosition; |
if (isUsingFrontFacingCamera) |
desiredPosition = AVCaptureDevicePositionBack; |
else |
desiredPosition = AVCaptureDevicePositionFront; |
|
for (AVCaptureDevice *d in [AVCaptureDevice devicesWithMediaType:AVMediaTypeVideo]) { |
if ([d position] == desiredPosition) { |
[[previewLayer session] beginConfiguration]; |
AVCaptureDeviceInput *input = [AVCaptureDeviceInput deviceInputWithDevice:d error:nil]; |
for (AVCaptureInput *oldInput in [[previewLayer session] inputs]) { |
[[previewLayer session] removeInput:oldInput]; |
} |
[[previewLayer session] addInput:input]; |
[[previewLayer session] commitConfiguration]; |
break; |
} |
} |
isUsingFrontFacingCamera = !isUsingFrontFacingCamera; |
} |
|
- (void)didReceiveMemoryWarning |
{ |
[super didReceiveMemoryWarning]; |
// Release any cached data, images, etc that aren't in use. |
} |
|
#pragma mark - View lifecycle |
|
- (void)viewDidLoad |
{ |
[super viewDidLoad]; |
// Do any additional setup after loading the view, typically from a nib. |
[self setupAVCapture]; |
square = [[UIImage imageNamed:@"squarePNG"] retain]; |
NSDictionary *detectorOptions = [[NSDictionary alloc] initWithObjectsAndKeys:CIDetectorAccuracyLow, CIDetectorAccuracy, nil]; |
faceDetector = [[CIDetector detectorOfType:CIDetectorTypeFace context:nil options:detectorOptions] retain]; |
[detectorOptions release]; |
} |
|
- (void)viewDidUnload |
{ |
[super viewDidUnload]; |
// Release any retained subviews of the main view. |
// e.g. self.myOutlet = nil; |
} |
|
- (void)viewWillAppear:(BOOL)animated |
{ |
[super viewWillAppear:animated]; |
} |
|
- (void)viewDidAppear:(BOOL)animated |
{ |
[super viewDidAppear:animated]; |
} |
|
- (void)viewWillDisappear:(BOOL)animated |
{ |
[super viewWillDisappear:animated]; |
} |
|
- (void)viewDidDisappear:(BOOL)animated |
{ |
[super viewDidDisappear:animated]; |
} |
|
- (BOOL)shouldAutorotateToInterfaceOrientation:(UIInterfaceOrientation)interfaceOrientation |
{ |
// Return YES for supported orientations |
return (interfaceOrientation == UIInterfaceOrientationPortrait); |
} |
|
- (BOOL)gestureRecognizerShouldBegin:(UIGestureRecognizer *)gestureRecognizer |
{ |
if ( [gestureRecognizer isKindOfClass:[UIPinchGestureRecognizer class]] ) { |
beginGestureScale = effectiveScale; |
} |
return YES; |
} |
|
// scale image depending on users pinch gesture |
- (IBAction)handlePinchGesture:(UIPinchGestureRecognizer *)recognizer |
{ |
BOOL allTouchesAreOnThePreviewLayer = YES; |
NSUInteger numTouches = [recognizer numberOfTouches], i; |
for ( i = 0; i < numTouches; ++i ) { |
CGPoint location = [recognizer locationOfTouch:i inView:previewView]; |
CGPoint convertedLocation = [previewLayer convertPoint:location fromLayer:previewLayer.superlayer]; |
if ( ! [previewLayer containsPoint:convertedLocation] ) { |
allTouchesAreOnThePreviewLayer = NO; |
break; |
} |
} |
|
if ( allTouchesAreOnThePreviewLayer ) { |
effectiveScale = beginGestureScale * recognizer.scale; |
if (effectiveScale < 1.0) |
effectiveScale = 1.0; |
CGFloat maxScaleAndCropFactor = [[stillImageOutput connectionWithMediaType:AVMediaTypeVideo] videoMaxScaleAndCropFactor]; |
if (effectiveScale > maxScaleAndCropFactor) |
effectiveScale = maxScaleAndCropFactor; |
[CATransaction begin]; |
[CATransaction setAnimationDuration:.025]; |
[previewLayer setAffineTransform:CGAffineTransformMakeScale(effectiveScale, effectiveScale)]; |
[CATransaction commit]; |
} |
} |
|
@end |
