TappityServer.m (revision 62)

To get this branch, use:

bzr branch
/browse/iphone/tappity


//
//  TappityServer.m
//  Jigs
//
//  Created by döme on 25.10.2009.
//

/*
 * Copyright (c) 2009 Doemoetoer Gulyas.
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 * 3. The name of the author may not be used to endorse or promote products
 *    derived from this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */


#import "TappityServer.h"
#import "Tappity.h"
#import <QuartzCore/QuartzCore.h>
#import <OpenGLES/ES1/gl.h>
#import <OpenGLES/EAGL.h>
#import <CoreLocation/CoreLocation.h>
#import <objc/runtime.h>

#define TAPPITY_MAX_FEEDBACK_SIZE 240
CGImageRef UIGetScreenImage(void);

@interface UIImage (ScreenImage)
+ (UIImage *)imageWithScreenContents;
- (UIImage*) scaledToSize: (CGSize) size;
@end

@interface CLLocationManager (TappityServer)

- (void) setDelegate_tappity: (id) delegate;
- (void) startUpdatingLocation_tappity;
- (void) stopUpdatingLocation_tappity;
- (void) startUpdatingHeading_tappity;
- (void) stopUpdatingHeading_tappity;

@end

@interface UIAccelerometer (TappityServer)

- (void) setUpdateInterval_tappity: (NSTimeInterval) dt;

@end

@interface EAGLContext (TappityServer)

- (BOOL)presentRenderbuffer_tappity:(NSUInteger)target;


@end


@implementation CLLocationManager (TappityServer)

- (void) setDelegate_tappity: (id) obj
{
	if ([obj respondsToSelector: @selector(locationManager:didUpdateToLocation:fromLocation:)])
	{
		[[TappityServer sharedServer] setLocationDelegate: obj];
	}
	if ([obj respondsToSelector: @selector(locationManager:didUpdateHeading:)])
	{
		[[TappityServer sharedServer] setHeadingDelegate: obj];
	}
	[self setDelegate_tappity: obj];

}

- (void) startUpdatingLocation_tappity
{
	[[TappityServer sharedServer] sendData: [NSData data] withIdentifier: kTapStartUpdatingLocation];
	[self startUpdatingLocation_tappity];
}

- (void) stopUpdatingLocation_tappity
{
	[[TappityServer sharedServer] sendData: [NSData data] withIdentifier: kTapStopUpdatingLocation];
	[self stopUpdatingLocation_tappity];
}

- (void) startUpdatingHeading_tappity
{
	[[TappityServer sharedServer] sendData: [NSData data] withIdentifier: kTapStartUpdatingHeading];
	[self startUpdatingHeading_tappity];
}

- (void) stopUpdatingHeading_tappity
{
	[[TappityServer sharedServer] sendData: [NSData data] withIdentifier: kTapStopUpdatingHeading];
	[self stopUpdatingHeading_tappity];
}


@end

@implementation UIAccelerometer (TappityServer)

- (void) setUpdateInterval_tappity: (NSTimeInterval) dt
{
	[[TappityServer sharedServer] setAccelerometerUpdateInterval: dt];
	
	[self setUpdateInterval_tappity: dt];
}

@end

@implementation EAGLContext (TappityServer)

- (BOOL)presentRenderbuffer_tappity:(NSUInteger)target
{
	[TappityServer glGrabPoint];
	return [self presentRenderbuffer_tappity: target];
}


@end

static void swapMethods(Class c, SEL sela, SEL selb)
{
	Method ma = class_getInstanceMethod(c, sela);
	Method mb = class_getInstanceMethod(c, selb);
	method_exchangeImplementations(ma, mb);
	
}

static void catch_pipe(int sig_num)
{
    signal(SIGPIPE, catch_pipe);
}

__attribute__((constructor)) void initTappityServer(void)
{
//	__builtin_printf("MOOOOOOOOOOOOOOO\n");
	/* TODO:
		1. intercept UIAccelerometer
		2. intercept CLLocationManager
		class_getInstanceMethod(), method_setImplementation()
	*/

	NSAutoreleasePool* pool = [[NSAutoreleasePool alloc] init];
	
	NSString* name = [[NSBundle mainBundle] bundleIdentifier];
	
	[[TappityServer sharedServer] startBonjourServerWithName: name protocol: @"_tappity._tcp" port: 1234];
	
	Class lmc = NSClassFromString(@"CLLocationManager");
	if (lmc)
	{
		swapMethods(lmc, @selector(setDelegate:), @selector(setDelegate_tappity:));
		swapMethods(lmc, @selector(startUpdatingHeading:), @selector(startUpdatingHeading_tappity:));
		swapMethods(lmc, @selector(startUpdatingLocation:), @selector(startUpdatingLocation_tappity:));
	}

	Class accc = [UIAccelerometer class];
	swapMethods(accc, @selector(setUpdateInterval:), @selector(setUpdateInterval_tappity:));

	Class glc = NSClassFromString(@"EAGLContext");
	if (glc)
		swapMethods(glc, @selector(presentRenderbuffer:), @selector(presentRenderbuffer_tappity:));

	
	[pool drain];
	
	signal(SIGPIPE, catch_pipe);

}




@implementation TappityServer

+ (void) initialize
{
	
}

- (id) init
{
	if (!(self = [super init]))
		return nil;

	desiredFrameInterval = 0.333;
	
	messenger = [[SocketMessenger alloc] init];
	[messenger setReceiveDataOnMainThread: YES];
	[messenger setDelegate: self];
	
	return self;
}

- (void) sendData: (NSData*) data withIdentifier: (NSInteger) messageId
{
	[messenger sendData: data withIdentifier: messageId];
}

- (void) startBonjourServerWithName: (NSString*) name protocol: (NSString*) protocol port: (int) port
{
	[messenger startBonjourServerWithName: name protocol: protocol port: port];
}

- (void) connectionWasEstablished: (SocketMessenger*) theMessenger
{
	if (locationDelegate)
		[messenger sendData: [NSData data] withIdentifier: kTapStartUpdatingLocation];
	if (headingDelegate)
		[messenger sendData: [NSData data] withIdentifier: kTapStartUpdatingHeading];

	[self performSelectorOnMainThread: @selector(startScreenieTimer) withObject: nil waitUntilDone: NO];
}

- (void) startScreenieTimer
{
	[captureTimer invalidate];
	captureTimer = [NSTimer scheduledTimerWithTimeInterval: desiredFrameInterval target: self selector: @selector(captureScreen) userInfo: nil repeats: YES];
	
	
	if (!capturedImagesCondition)
		capturedImagesCondition = [[NSCondition alloc] init];

	[messenger runThreadWithTarget: self selector: @selector(imageConversionThread:)];
}

/*
static size_t _read_i8(const void* buf, uint8_t* p)
{
	uint8_t v = 0;
	memcpy(&v, buf, 1);
	*p = v;
	return 1;
}
static size_t _read_i16(const void* buf, uint16_t* p)
{
	uint16_t v = 0;
	memcpy(&v, buf, 2);
	*p = CFSwapInt16BigToHost(v);
	return 2;
}
static size_t _read_i32(const void* buf, uint32_t* p)
{
	uint32_t v = 0;
	memcpy(&v, buf, 4);
	*p = CFSwapInt32BigToHost(v);
	return 4;
}
static size_t _read_i64(const void* buf, uint64_t* p)
{
	uint64_t v = 0;
	memcpy(&v, buf, 8);
	*p = CFSwapInt64BigToHost(v);
	return 8;
}
static size_t _read_float(const void* buf, float* p)
{
	CFSwappedFloat32 v;
	memcpy(&v, buf, 4);
	*p = CFConvertFloat32SwappedToHost(v);
	return 4;
}

static size_t _read_gspoint(const void* buf, GSTouchPointRef p)
{
	size_t bc = 0;

	bc += _read_i32(buf+bc, &p->unk0);
	bc += _read_float(buf+bc, &p->unk1);
	bc += _read_float(buf+bc, &p->touchSize);
	bc += _read_float(buf+bc, &p->x);
	bc += _read_float(buf+bc, &p->y);
	bc += _read_i32(buf+bc, (uint32_t*)&p->window);
	
	return bc;
}

- (GSEvent*) gsEventWithData: (NSData*) data
{
	GSEvent* gse = [[[GSEvent alloc] init] autorelease];
	
	size_t bc = 0;
	const void* buf = [data bytes];
	
	bc += _read_i32(buf+bc, &gse->type0);
	bc += _read_i32(buf+bc, &gse->type1);
	bc += _read_i32(buf+bc, &gse->r3);
	bc += _read_float(buf+bc, &gse->avgX0);
	bc += _read_float(buf+bc, &gse->avgY0);
	bc += _read_float(buf+bc, &gse->avgX1);
	bc += _read_float(buf+bc, &gse->avgY1);
	bc += _read_i32(buf+bc, &gse->processId);
	bc += _read_i64(buf+bc, &gse->timestamp);
	bc += _read_i32(buf+bc, (uint32_t*)&gse->window);
	bc += _read_i32(buf+bc, &gse->r11);
	bc += _read_i32(buf+bc, &gse->type12);
	bc += _read_i32(buf+bc, &gse->gesture13);
	bc += _read_i32(buf+bc, &gse->gesture14);
	bc += _read_i16(buf+bc, &gse->numInitialTouches);
	bc += _read_i16(buf+bc, &gse->numCurrentTouches);
	bc += _read_i32(buf+bc, &gse->r16);
	bc += _read_i32(buf+bc, &gse->r17);
	bc += _read_i32(buf+bc, &gse->r18);
	bc += _read_i32(buf+bc, &gse->r19);
	bc += _read_i32(buf+bc, &gse->r20);
	bc += _read_i32(buf+bc, &gse->r21);
	bc += _read_i8(buf+bc, &gse->r22_0);
	bc += _read_i8(buf+bc, &gse->numPoints);
	bc += _read_i16(buf+bc, &gse->r22_2);
	for (size_t i = 0; i < gse->numPoints; ++i)
		bc += _read_gspoint(buf+bc, gse->points + i);

	return gse;
}
*/

- (void) doEventPlayback
{
	[[UIApplication sharedApplication] _playbackEvents: queuedEvents atPlaybackRate: 1.0f messageWhenDone: self withSelector: @selector(eventPlaybackDone:)];
	
	[queuedEvents autorelease];
	queuedEvents = nil;
	eventPlaybackBusy = YES;
}
- (void) eventPlaybackDone:(NSDictionary*)detail
{
	if ([queuedEvents count])
	{
		[self doEventPlayback];
	}
	else
		eventPlaybackBusy = NO;
}

- (NSDictionary*) rescaleTouches: (NSDictionary*) event
{
	
	/*
		in "Data"
		+33		num touches
		+48		x-loc 1st touch
		+52		y-loc 1st touch
		+72		x-loc 2nd touch
		+76		y-loc 2nd touch
		
		presumably touches at offsets +24 per touch
	*/

	
	long type = [[event objectForKey: @"Type"] integerValue];
		
	if (type == 3001) // touch event
	{
		NSMutableDictionary* mdict = [event mutableCopy];

		CGRect targetScreen = [[UIScreen mainScreen] bounds];
		CGRect sourceScreen = CGRectFromString([mdict objectForKey: @"UIScreen bounds"]);
		
		float xoff0 = sourceScreen.origin.x;
		float xoff1 = targetScreen.origin.x;
		float yoff0 = sourceScreen.origin.y;
		float yoff1 = targetScreen.origin.y;
		float xs0 = sourceScreen.size.width;
		float xs1 = targetScreen.size.width;
		float ys0 = sourceScreen.size.height;
		float ys1 = targetScreen.size.height;
		
		CGPoint wloc = CGPointMake([[[mdict objectForKey: @"WindowLocation"] objectForKey: @"X"] floatValue], [[[mdict objectForKey: @"WindowLocation"] objectForKey: @"Y"] floatValue]);
		CGPoint loc = CGPointMake([[[mdict objectForKey: @"Location"] objectForKey: @"X"] floatValue], [[[mdict objectForKey: @"Location"] objectForKey: @"Y"] floatValue]);
		
		wloc.x = (wloc.x - xoff0)*(xs1/xs0) + xoff1;
		wloc.y = (wloc.y - yoff0)*(ys1/ys0) + yoff1;
		loc.x = (loc.x - xoff0)*(xs1/xs0) + xoff1;
		loc.y = (loc.y - yoff0)*(ys1/ys0) + yoff1;
		
		[mdict setObject: [NSDictionary dictionaryWithObjectsAndKeys: [NSNumber numberWithFloat: wloc.x], @"X", [NSNumber numberWithFloat: wloc.y], @"Y", nil] forKey: @"WindowLocation"];
		[mdict setObject: [NSDictionary dictionaryWithObjectsAndKeys: [NSNumber numberWithFloat: loc.x], @"X", [NSNumber numberWithFloat: loc.y], @"Y", nil] forKey: @"Location"];
		
		NSMutableData* data = [[event objectForKey: @"Data"] mutableCopy];
		void* bytes = [data mutableBytes];
		
		uint8_t ntouches = ((uint8_t*)bytes)[33];
		
		for (size_t i = 0; i < ntouches; ++i)
		{
			size_t ii = 48 + i*24;
			float x = *((float*)(bytes + ii));
			float y = *((float*)(bytes + ii+4));
			
			x = (x - xoff0)*(xs1/xs0) + xoff1;
			y = (y - yoff0)*(ys1/ys0) + yoff1;
			
			*((float*)(bytes + ii)) = x;
			*((float*)(bytes + ii+4)) = y;

		}
		
		[mdict setObject: data forKey: @"Data"];
		
		[mdict removeObjectForKey: @"UIScreen bounds"];
		event = mdict;
	}
	
	return event;

}

- (void) dataReceived: (NSDictionary*) dataDict
{
	uint32_t messageId = [[dataDict objectForKey: SocketMessageIdKey] intValue];
	
//	NSLog(@"received messageid %d", messageId);

	NSData* tapData = [dataDict objectForKey: SocketMessageDataKey];
	
//	NSDictionary* tapDict = [NSPropertyListSerialization propertyListFromData: tapData mutabilityOption:NSPropertyListImmutable format: NULL errorDescription: NULL];
	switch(messageId)
	{
/*
		case kTapTouchEvent:
		{
			NSLog(@"TOUCH EVENT");
			
			GSEvent* gse = [self gsEventWithData: [tapDict objectForKey: TapGSEventKey]];
			UIWindow* window = [[UIApplication sharedApplication] keyWindow];
			gse->window = window;
			for (size_t i = 0; i < gse->numPoints; ++i)
				gse->points[i].window = window;
			
			int phase = [[tapDict objectForKey: TapTouchPhaseKey] intValue];
			NSSet* touches = [UITouch _createTouchesWithGSEvent: gse phase: phase view: [[UIApplication sharedApplication] keyWindow]];
			
			assert([[UIApplication sharedApplication] keyWindow]);
			
			NSLog(@"%@", touches);

			UIEvent* event = [UIEvent alloc];
			
			Class touchesEventClass = objc_getClass("UITouchesEvent");
			if (touchesEventClass && ![[event class] isEqual: touchesEventClass])
			{
				event = [touchesEventClass alloc];
			}
			
			[event _initWithEvent: gse touches: touches];
			
			assert(event);
			
			[[UIApplication sharedApplication] sendEvent: event];
						
			
			break;
		}
*/
		case kTapRecordedEvent:
		{			
			NSDictionary* eventDict = [NSPropertyListSerialization propertyListFromData: tapData mutabilityOption:NSPropertyListImmutable format: NULL errorDescription: NULL];
			
			if (!queuedEvents)
				queuedEvents = [[NSMutableArray alloc] init];

			eventDict = [self rescaleTouches: eventDict];

			[queuedEvents addObject: eventDict];
			
			if (!eventPlaybackBusy)
			{
				[self doEventPlayback];
			}
			break;
		}
		case kTapAcceleration:
		{			
			NSArray* accel = [NSPropertyListSerialization propertyListFromData: tapData mutabilityOption:NSPropertyListImmutable format: NULL errorDescription: NULL];
			
			UIAccelerometer* accm = [UIAccelerometer sharedAccelerometer];
			float x = [[accel objectAtIndex: 0] floatValue];
			float y = [[accel objectAtIndex: 1] floatValue];
			float z = [[accel objectAtIndex: 2] floatValue];
			[accm _acceleratedInX: x y: y z: z timestamp: [[accel objectAtIndex: 3] doubleValue]];
			
			break;
		}
		case kTapLocation:
		{
			static CLLocation* oldLoc = nil;
			CLLocation* loc = [NSKeyedUnarchiver unarchiveObjectWithData: tapData];
			if ([locationDelegate respondsToSelector: @selector(locationManager:didUpdateToLocation:fromLocation:)])
			{
				[locationDelegate locationManager: (id)self didUpdateToLocation: loc fromLocation: oldLoc];
			}
			oldLoc = loc;
			break;
		}
		case kTapCompass:
		{
			CLHeading* hdg = [NSKeyedUnarchiver unarchiveObjectWithData: tapData];
			if ([headingDelegate respondsToSelector: @selector(locationManager:didUpdateHeading:)])
			{
				[headingDelegate locationManager: (id)self didUpdateHeading: hdg];
			}
			break;
		}
		case kTapStartSendingVisualFeedback:
		{
			NSLog(@"enabling visual uplink");
			enableVisualFeedback = YES;
			break;
		}
	}
	
	[tapData release];
	
}

- (UIImage *) imageFromView: (UIView *) theView
{
	UIGraphicsBeginImageContext(theView.frame.size);
	CGContextRef context = UIGraphicsGetCurrentContext();
//	[theView.layer drawInContext:context];
	[theView.layer renderInContext:context];
	UIImage *theImage = UIGraphicsGetImageFromCurrentImageContext();
	UIGraphicsEndImageContext();
	return theImage;
}

- (void) convertAndSendImage: (UIImage*) img
{		
	[capturedImagesCondition lock];

	if (!capturedImagesQueue)
		capturedImagesQueue = [[NSMutableArray alloc] init];

	[capturedImagesQueue addObject: img];
	
	[capturedImagesCondition signal];
	[capturedImagesCondition unlock];
		
}

- (void) captureScreen
{
	NSTimeInterval now = [NSDate timeIntervalSinceReferenceDate];
	
	
	
	if ((now < lastGlUpdate + 2.0*desiredFrameInterval))
		return;
		
	// return if any gl has been updated at all
	if (lastGlUpdate || !enableVisualFeedback)
		return;
	
	[self performSelectorOnMainThread: @selector(getWindowToCapture) withObject: nil waitUntilDone: NO];

	UIWindow* window = windowToCapture;
	
	UIImage* img = [self imageFromView: window];
//	UIImage* img = [UIImage imageWithScreenContents];
	
	lastQuartzUpdate = now;
	
	if (img)
		[self convertAndSendImage: img];
}


- (void) imageConversionThread: (id) info
{
	NSAutoreleasePool* pool = [[NSAutoreleasePool alloc] init];

	@synchronized(self)
	{
		[self retain];
	}

	while ([messenger threadActive: info])
	{
		NSAutoreleasePool* pool = [[NSAutoreleasePool alloc] init];

		[capturedImagesCondition lock];
			while (![capturedImagesQueue count])
				[capturedImagesCondition wait];
				
		//NSLog(@"sending");
		
		UIImage* img = [[[capturedImagesQueue objectAtIndex: 0] retain] autorelease];
		[capturedImagesQueue removeObjectAtIndex: 0];
		
		[capturedImagesCondition unlock];
		
		CGRect imgRect = {CGPointZero, [img size]};
		
		float aspect = imgRect.size.width/imgRect.size.height;
		CGSize newSize = CGSizeMake(
			MIN(TAPPITY_MAX_FEEDBACK_SIZE, TAPPITY_MAX_FEEDBACK_SIZE*aspect),
			MIN(TAPPITY_MAX_FEEDBACK_SIZE, TAPPITY_MAX_FEEDBACK_SIZE/aspect));
		
		img = [img scaledToSize: newSize];

		NSData* imgData = UIImagePNGRepresentation(img);
	
		if (imgData)
		{
			NSString* rstr = NSStringFromCGRect(imgRect);
			NSDictionary* imgDict = [NSDictionary dictionaryWithObjectsAndKeys: imgData, TapImageDataKey, rstr, TapImageRectKey, rstr, TapReferenceRectKey, nil];
			NSData* data = [NSPropertyListSerialization dataFromPropertyList: imgDict format:NSPropertyListBinaryFormat_v1_0 errorDescription: nil];
			[messenger sendData: data withIdentifier: kTapPlacedScreenshot];
		}
		
		[pool drain];

	}
	

	[messenger threadWillExit: info];

	@synchronized(self)
	{
		[self release];
	}

	[info release];
	[pool drain];
}




- (void) getWindowToCapture
{
	@synchronized(self)
	{
		[windowToCapture release];
		windowToCapture = [[[UIApplication sharedApplication] keyWindow] retain];
	}
}
- (void) screenieThread: (id) info
{
	NSAutoreleasePool* pool = [[NSAutoreleasePool alloc] init];

	@synchronized(self)
	{
		[self retain];
	}


	while ([messenger threadActive: info])
	{
		[self captureScreen];
		usleep(200);
	}

	[messenger threadWillExit: info];

	@synchronized(self)
	{
		[self release];
	}

	[info release];
	[pool drain];
}


- (void) setAccelerometerUpdateInterval: (NSTimeInterval) dt
{
	CFSwappedFloat64 sdt = CFConvertFloat64HostToSwapped(dt);
	NSData* data = [NSData dataWithBytes: &sdt length: sizeof(CFSwappedFloat64)];
	[messenger sendData: data withIdentifier: kTapAccelerometerUpdateInterval];
}

/*
- (void)performTouches: (NSSet*) touches inView: (UIView *)view
{
    UITouch *touch = [[UITouch alloc] initInView:view];
    UIEvent *eventDown = [[UIEvent alloc] initWithTouch:touch];
    
    [touch.view touchesBegan:[eventDown allTouches] withEvent:eventDown];
    
    [touch setPhase:UITouchPhaseEnded];
    UIEvent *eventUp = [[UIEvent alloc] initWithTouch:touch];
    
    [touch.view touchesEnded:[eventUp allTouches] withEvent:eventUp];
    
    [eventDown release];
    [eventUp release];
    [touch release];
}
*/

static UIImage* imageFromGLData(NSData* data, GLint* viewport)
{
    // make data provider with data.
    CGDataProviderRef provider = CGDataProviderCreateWithData(NULL, [data bytes], [data length], NULL);
   
    // prep the ingredients
    int bitsPerComponent = 8;
    int bitsPerPixel = 32;
    int bytesPerRow = 4 * viewport[2];
    CGColorSpaceRef colorSpaceRef = CGColorSpaceCreateDeviceRGB();
    CGBitmapInfo bitmapInfo = kCGBitmapByteOrderDefault;
    CGColorRenderingIntent renderingIntent = kCGRenderingIntentDefault;
   
    // make the cgimage
    CGImageRef imageRef = CGImageCreate(viewport[2], viewport[3], bitsPerComponent, bitsPerPixel, bytesPerRow, colorSpaceRef, bitmapInfo, provider, NULL, NO, renderingIntent);
   
    // then make the uiimage from that
    UIImage *myImage = [UIImage imageWithCGImage:imageRef];
    return myImage;
}

static NSData* dataFromGL(GLint* viewport)
{
    NSInteger myDataLength = viewport[2] * viewport[3] * 4;
	
	NSMutableData* data = [NSMutableData dataWithLength: myDataLength];
   
    // allocate array and read pixels into it.
    void* buffer = [data mutableBytes];
    glReadPixels(viewport[0], viewport[1], viewport[2], viewport[3], GL_RGBA, GL_UNSIGNED_BYTE, buffer);
	
	size_t bpr = 4*viewport[2];
	void* rowbuf = calloc(1, bpr);
	
	// swap image in Y
	for (size_t i = 0; i < viewport[3]/2; ++i)
	{
		memcpy(rowbuf, buffer + i*bpr, bpr);
		memcpy(buffer + i*bpr, buffer + (viewport[3]-i-1)*bpr, bpr);
		memcpy(buffer + (viewport[3]-i-1)*bpr, rowbuf, bpr);
	}
	
	free(rowbuf);
 
	return data;
}

- (void) glGrabPoint
{
	if (!enableVisualFeedback)
		return;

	NSTimeInterval now = [NSDate timeIntervalSinceReferenceDate];
	if (lastGlUpdate + desiredFrameInterval < now)
	{
		
		GLint viewport[4];
		glGetIntegerv(GL_VIEWPORT, viewport);

		NSData* rawData = dataFromGL(viewport);
		
		float aspect = (float)viewport[2]/(float)viewport[3];
		CGSize newSize = CGSizeMake(
			MIN(TAPPITY_MAX_FEEDBACK_SIZE, TAPPITY_MAX_FEEDBACK_SIZE*aspect),
			MIN(TAPPITY_MAX_FEEDBACK_SIZE, TAPPITY_MAX_FEEDBACK_SIZE/aspect));

		UIImage* image = [imageFromGLData(rawData, viewport) scaledToSize: newSize];
		
		NSData* imgData = UIImagePNGRepresentation(image);
		if (imgData)
		{
			CGRect imgRect = CGRectMake(viewport[0], viewport[1], viewport[2], viewport[3]);
			NSString* rstr = NSStringFromCGRect(imgRect);
			NSDictionary* imgDict = [NSDictionary dictionaryWithObjectsAndKeys: imgData, TapImageDataKey, rstr, TapImageRectKey, NSStringFromCGRect(CGRectZero), TapReferenceRectKey, nil];
			NSData* data = [NSPropertyListSerialization dataFromPropertyList: imgDict format:NSPropertyListBinaryFormat_v1_0 errorDescription: nil];
			[messenger sendData: data withIdentifier: kTapPlacedScreenshot];
		}
		
		lastGlUpdate = now;
	}
}

+ (void) glGrabPoint
{
	[[self sharedServer] glGrabPoint];
}

+ (id) sharedServer
{
	static id sharedInstance = nil;
	if (!sharedInstance)
		sharedInstance = [[TappityServer alloc] init];
	
	
	return sharedInstance;
}

- (void) dealloc
{

	[captureTimer invalidate];
	
	[messenger terminateConnection];
	[messenger release];
	
	[capturedImagesCondition release];
	[capturedImagesQueue release];

	[super dealloc];
}

@synthesize locationDelegate, headingDelegate;

@end

@implementation UIImage (ScreenImage)

+ (UIImage *)imageWithScreenContents
{
    CGImageRef cgScreen = UIGetScreenImage();
    if (cgScreen) {
        UIImage *result = [UIImage imageWithCGImage:cgScreen];
        CGImageRelease(cgScreen);
        return result;
    }
    return nil;
}

CGImageRef CreateScaledCGImageFromCGImage(CGImageRef image, CGSize size)
{
	int width = size.width;
	int height = size.height;
	 
	// Declare the number of bytes per row. Each pixel in the bitmap in this
	// example is represented by 4 bytes; 8 bits each of red, green, blue, and
	// alpha.
	size_t bitmapBytesPerRow   = (width * 4);
	size_t bitmapByteCount     = (bitmapBytesPerRow * height);
	 
	// Allocate memory for image data. This is the destination in memory
	// where any drawing to the bitmap context will be rendered.
	void* bitmapData = malloc( bitmapByteCount );
	if (bitmapData == NULL)
	{
		return nil;
	}
	 
	// Create the bitmap context. We want pre-multiplied ARGB, 8-bits
	// per component. Regardless of what the source image format is
	// (CMYK, Grayscale, and so on) it will be converted over to the format
	// specified here by CGBitmapContextCreate.
	CGColorSpaceRef colorspace = CGImageGetColorSpace(image);
	CGContextRef context = CGBitmapContextCreate (bitmapData,width,height,8,bitmapBytesPerRow,
	colorspace,kCGImageAlphaPremultipliedFirst);
	CGColorSpaceRelease(colorspace);
	 
	if (context == NULL)
	// error creating context
	{
		free(bitmapData);
		return nil;
	}
	 
	// Draw the image to the bitmap context. Once we draw, the memory
	// allocated for the context for rendering will then contain the
	// raw image data in the specified color space.
	CGContextDrawImage(context, CGRectMake(0,0,width, height), image);
	 
	CGImageRef imgRef = CGBitmapContextCreateImage(context);
	CGContextRelease(context);
	free(bitmapData);
	 
	return imgRef;
}


- (UIImage*) scaledToSize: (CGSize) size
{
	CGImageRef imgref = CreateScaledCGImageFromCGImage([self CGImage], size);
	if (!imgref)
		return nil;
		
	UIImage* img = [UIImage imageWithCGImage: imgref];
	
	CGImageRelease(imgref);
		
	return img;
}

@end



Loggerhead 1.17 is a web-based interface for Bazaar branches