root/oggzcap/src/MyController.mm

//////// InOut Theora encoder example + oggfwd
#include "encoder_example.h"

extern "C" {
  int myOggfwd_init( const char* outIceIp, int outIcePort, 
         const char *outUsername, const char *outPassword, const char *outIceMount,
         const char *description, const char *genre, const char *name, const char *url );
        void myOggfwd_close() ;
        void encoder_example_init(int inW, int inH, int inFramerate, int in_video_r, int in_video_q) ;
        int encoder_example_loop( CVPixelBufferRef imBuffRef ) ;
        int encoder_example_end() ;
};

#import "MyController.h"

// Number of reader objects used by the program at once.
// Each reader object is designed to read and hold a 
// single screen frame buffer.
#define kNumReaderObjects               20

// This is the CoreVideo display link callback. The display link invokes
// this callback whenever it wants you to output a frame. In our case, 
// we call our displayLinkCallback to perform readback of the screen using
// OpenGL
static CVReturn MyRenderCallback(CVDisplayLinkRef displayLink, 
                                         const CVTimeStamp *inNow, 
                                         const CVTimeStamp *inOutputTime, 
                                         CVOptionFlags flagsIn, 
                                         CVOptionFlags *flagsOut, 
                                         void *displayLinkContext)
{
        return [(MyController *)displayLinkContext displayLinkCallback:inOutputTime flagsOut:flagsOut];
}


@implementation MyController

#pragma mark ---------- Initialization/Termination ----------

// Setup notifications to let us know when application is finished
// launching so we can use this time to create the OpenGL context
// used to render, and to let us know when the app. is terminating
// so  we can perform cleanup
-(id)init
{
        if (self = [super init])
        {
                mGLContext = nil;
                
                [[NSNotificationCenter defaultCenter] addObserver:self
                        selector:@selector(applicationDidFinishLaunching:)
                        name:@"NSApplicationDidFinishLaunchingNotification" object:NSApp];

                [[NSNotificationCenter defaultCenter] addObserver:self
                        selector:@selector(applicationWillTerminate:)
                        name:@"NSApplicationWillTerminateNotification" object:NSApp];
        }
        
        return self;
}

// Perform cleanup when the application terminates
- (void) applicationWillTerminate:(NSNotification*)notification
{       
        [myController release] ;
}

// Create OpenGL context used to render
- (void) applicationDidFinishLaunching:(NSNotification*)notification
{
        NSOpenGLPixelFormatAttribute attributes[] = {
                        NSOpenGLPFAFullScreen,
                        NSOpenGLPFAScreenMask,
                        (NSOpenGLPixelFormatAttribute)CGDisplayIDToOpenGLDisplayMask(kCGDirectMainDisplay),
                        (NSOpenGLPixelFormatAttribute) 0
        };

        mGLPixelFormat = [[NSOpenGLPixelFormat alloc] initWithAttributes:attributes];
        NSAssert( mGLPixelFormat != nil, @"No Full-Screen Renderer");
        if (!mGLPixelFormat) return;

        //Create OpenGL context used to render
        mGLContext = [[NSOpenGLContext alloc] initWithFormat:mGLPixelFormat shareContext:nil];
        NSAssert( mGLContext != nil, @"NSOpenGLContext initialization failure");        
        [mGLContext makeCurrentContext];
        [mGLContext setFullScreen];

        CGDirectDisplayID displayID = CGMainDisplayID();
        //NSAssert( displayID != nil, @"CGMainDisplayID failure");
        if (displayID)
        {
                mDisplayRect = CGDisplayBounds(displayID);
        }
        
        
        // INOUT INIT ALL
        [self initINOUT] ;
        
}



#pragma mark -------- Reader --------

// Called from our display link callback.
// This routine will attempt to get an available reader object
// to initiate a screen grab operation (to fill the object's buffer).
// It then checks to see if any reader objects have indeed been 
// filled (a screen grab operation has completed and the object's 
// buffer is filled) and if so it passes the reader object to the 
// exporter/compressor object so it can be compressed and the frame
// added to the movie.

// INOUT - OLD ONE
- (void) readAndCompressFrames
{
        //InOut //NSLog(@"Read and Compress Frames\n");
        
        //Compute the local time
        if(mStartTime == 0.0)
        {
                NSTimeInterval  time = [NSDate timeIntervalSinceReferenceDate];
                mStartTime = time;
        }

        // Get an available reader object from the reader "free" queue
        FrameReader *freeReaderObj = [mFrameQueueController removeOldestItemFromFreeQ];
        if (freeReaderObj)
        {
                [freeReaderObj setBufferReadTime:mStartTime];
                // pass object to FrameReader and do a read operation
                // this call spawns a new thread to do the read
                [freeReaderObj readScreenAsyncOnSeparateThread];
        }
        
        // see if there are available frames in the "filled" queue
        FrameReader *filledReaderObj = [mFrameQueueController removeOldestItemFromFilledQ];
        if (filledReaderObj)
        {
                // get the frame and process it (processImage)          
                [self processImage:[filledReaderObj readScreenAsyncFinish]] ;
                
                // Ok... next
                QueueController *frameQController = [filledReaderObj queueController];
                [frameQController addItemToFreeQ:filledReaderObj];
                
        }
}

#pragma mark -------- Display Link --------

// This is called from the Display Link callback.
// We'll use this callback to read/compress our frames.
- (CVReturn)displayLinkCallback:(const CVTimeStamp*)timeStamp flagsOut:(CVOptionFlags*)flagsOut
{
        // there is no autorelease pool when this method is called because it will be called from another thread
        // it's important to create one or you will leak objects
        NSAutoreleasePool *pool = [NSAutoreleasePool new];

        // Each iteration we will attemp to read the screen into a buffer (if
        // one is available), compress the buffer contents, then add the 
        // compressed frame to a movie
        [self readAndCompressFrames];

        [pool release];

        return kCVReturnSuccess;
}

#pragma mark ---------- Action Methods ----------

-(void)pLog:(NSString*)inLog
{
        //[logTextField setStringValue:[NSString stringWithFormat:@"%@\n%@",inLog,[logTextField stringValue]]] ;
        
        NSRange endRange;
    endRange.location = [[logTextView textStorage] length];
    endRange.length = 0;
    [logTextView replaceCharactersInRange:endRange withString:inLog];
        endRange.length = [inLog length];
    [logTextView scrollRangeToVisible:endRange];

        //[logTextView insertText:inLog] ;
}
- (IBAction)clearLog:(id)sender
{
        [logTextView setString:@""] ;
}
-(void)initINOUT
{
        [self pLog:@"[OggZCap] Initialization..\n"] ;
        
//      NSRect srcRect = NSMakeRect(0, 0, 320, 240);
//      inPreviewView = [[SampleCIView alloc] initWithFrame:srcRect];
        
        totalFrames = 0 ;
        capturing = FALSE ;
        captureRectChanged = FALSE ;
        captureRectChangedCompt = 0 ;
        
        lockF = [NSRecursiveLock new] ;
        
        videOpened = FALSE ;
        
        // Global variables
        inListening = FALSE ;
        showInPreview = FALSE ;
        showOutPreview = FALSE ;
        
        captureRect = NSMakeRect(0,0,320,240) ;
        
        // OUT Video Settings
        outBitrate = 20000 ;
        outQuality = 16 ;
        outFramerate = 12 ;
        [outFramerateDisplayed setStringValue:[NSString stringWithFormat:@"%d",outFramerate]];
        
        // IN Video Settings
        inFramerate = 2 ;
        [inFramerateDisplayed setStringValue:[NSString stringWithFormat:@"%d",inFramerate]];
        
        [self clearInDisplay] ;
        [self clearOutDisplay] ;
        
                
        [logTextView setSelectable:TRUE] ;
        [logTextView setEditable:FALSE] ;

}
- (void)clearInDisplay
{
        CIImage *newI = [CIImage imageWithContentsOfURL: [NSURL fileURLWithPath:[[NSBundle mainBundle] pathForResource: @"in" ofType: @"png"]]];
        [inPreviewView setImage:newI] ;
        
        CGRect mmR = CGRectMake(0,0,320,240) ;
        [inPreviewView setCleanRect:(CGRect)mmR];
        NSRect tmpR = NSMakeRect(0,0,320,240) ;
        [inPreviewView setDisplaySize:*(CGSize *)&tmpR.size];
        [inPreviewView setNeedsDisplay:YES];
}
- (void)clearOutDisplay
{
        CIImage *newI = [CIImage imageWithContentsOfURL: [NSURL fileURLWithPath:[[NSBundle mainBundle] pathForResource: @"out" ofType: @"png"]]];
        [outPreviewView setImage:newI] ;
        
        CGRect mmR = CGRectMake(0,0,320,240) ;
        [outPreviewView setCleanRect:(CGRect)mmR];
        NSRect tmpR = NSMakeRect(0,0,320,240) ;
        [outPreviewView setDisplaySize:*(CGSize *)&tmpR.size];
        [outPreviewView setNeedsDisplay:YES];
}

-(void)startOut
{       
        ////////////////////////////////////////////////////////////
        // INIT myOggfwd
        NSString *tmpIcecastIp = [outIcecastIPTF stringValue] ;
        int tmpIcecastPort = [outIcecastPortTF intValue] ;
//      NSString *tmpIcecastMount = [outIcecastMountTF stringValue] ;
        NSString *tmpStrPassword = [outIcecastPassword stringValue] ;
        NSString *tmpStrUsername = [outIcecastUsername stringValue] ;

        NSString *tmpStrName   = [projectName stringValue] ;
        NSString *tmpStrAuthor = [projectAuthor stringValue] ; 
        NSString *tmpStrDescr  = [projectDescr stringValue] ;
        NSString *tmpStrTags   = [projectLocation stringValue] ;
        NSString *tmpStrAuthorURL = [NSString stringWithFormat:@"http://wiki.citu.info/users/%@",tmpStrAuthor];
        NSString *tmpIcecastMount = [NSString stringWithFormat:@"%@.ogg",tmpStrName];
#if 0
//      tmpIcecastMount = [tmpIcecastMount stringByReplacingOccurancesOfString:@" " withString:@"_"]; // WTF 10.5 only
        const char* cmount = [tmpIcecastMount UTF8String];
#else
        char* cmount = strdup([tmpIcecastMount UTF8String]);
        char* tmp;
        while (tmp=strchr(cmount, ' ')) {
            *tmp='_';
        }
#endif
        
        [self pLog:[NSString stringWithFormat:@"Starting Video Out to Icecast2 server:\n  http://%@:%d/%@\n",tmpIcecastIp,tmpIcecastPort,tmpIcecastMount]] ;
/*
        char *cip = (char*)malloc(sizeof(char)*99);
        char *cmount = (char*)malloc(sizeof(char)*strlen(...));
        strcpy(cip, [tmpIcecastIp UTF8String]) ;
        strcpy(cmount, [tmpIcecastMount UTF8String]) ;
*/
        const char* cip    = [tmpIcecastIp UTF8String];
        const char* cname  = [tmpStrName UTF8String];
        const char* cdesc  = [tmpStrDescr UTF8String];
        const char* ctags  = [tmpStrTags UTF8String];
        const char* curl   = [tmpStrAuthorURL UTF8String];
        const char* cpass  = [tmpStrPassword UTF8String];
        const char* user   = [tmpStrUsername UTF8String];

        int iceConnect = myOggfwd_init(cip, tmpIcecastPort, strlen(user)?user:NULL, cpass, (const char*) cmount, cdesc, ctags, cname, curl) ;
        
        if(iceConnect==1) {
                ////////////////////////////////////////////////////////////
                // INIT encoder_example
                // sample values = 7,20000,16 ... 
                outBitrate = [outBitrateTF intValue] ;
                outQuality = [outQualityTF intValue] ;
                int vidW = (int)captureRect.size.width ;
                int vidH = (int)captureRect.size.height ;
                
                encoder_example_init(vidW, vidH, outFramerate, outBitrate, outQuality) ;
                
                ////////////////////////////////////////////////////////////
                // Start Screen Capture
                
                NSNumber *widthNum,*heightNum;
                
                widthNum = [NSNumber numberWithFloat:captureRect.size.width];
                heightNum = [NSNumber numberWithFloat:captureRect.size.height];
                //NSLog(@"(myController) LAUNCHING new capture with size : %d x %d \n",widthNum,heightNum);
                
                // make a frame queue controller, which will create and manage the
                // underlying set of (multiple) frame reader objects
                mFrameQueueController = [[QueueController alloc] initWithReaderObjects:
                        kNumReaderObjects       // create this many frame reader objects
                                                                                                                                          aContext:mGLContext 
                                                                                                                                        pixelsWide:[widthNum unsignedIntValue] 
                                                                                                                                        pixelsHigh:[heightNum unsignedIntValue] ];
                
                captureRectChanged = TRUE ;
                captureRectChangedCompt = 0 ;
                
                //      // create display link for the main display
                //      CVDisplayLinkCreateWithCGDisplay(kCGDirectMainDisplay, &mDisplayLink);
                //      if (NULL != mDisplayLink) 
                //      {
                //              // set the current display of a display link.
                //              CVDisplayLinkSetCurrentCGDisplay(mDisplayLink, kCGDirectMainDisplay);
                //                      
                //              // set the renderer output callback function
                //              CVDisplayLinkSetOutputCallback(mDisplayLink, &MyRenderCallback, self);
                //                      
                //              // activates a display link.
                //              CVDisplayLinkStart(mDisplayLink);
                //      }
                
                mStartTime = 0.0 ;
                
                [self startOutTimer:outFramerate] ;
                
                capturing = TRUE ;
                                
                [startOutButton setEnabled:NO];
                [stopOutButton setEnabled:YES];
                [resizeRadio setEnabled:NO];
                //[showZoneButton setEnabled:NO];
                
                [outBitrateTF setEnabled:NO];
                [outQualityTF setEnabled:NO];
                [outIcecastIPTF setEnabled:NO];
                [outIcecastPortTF setEnabled:NO];
//              [outIcecastMountTF setEnabled:NO];
                [outIcecastPassword setEnabled:NO];
                [outIcecastUsername setEnabled:NO];
                [projectName setEnabled:NO];
                [projectAuthor setEnabled:NO];
                [projectLocation setEnabled:NO];
                [projectDescr setEnabled:NO];

                [self setCaptureWindowMode:TRUE] ;
                [mCaptureTarget makeKeyAndOrderFront:self];
                [self setCaptureWindowMode:FALSE] ;
        }
        else {
                [self pLog:@"Icecast Server Problem : Video Out stopped...\n"] ;
        }
}

-(void)stopOut
{
        [self pLog:@"Stopping Video Out...\n"] ;
        
        capturing = FALSE ;
        
        ////////////////// Stop Out Timer
        [self stopOutTimer] ;
        
        ////////////////// Clear Display
        [self clearOutDisplay] ;
                
        ////////////////// Stop and clean encoder & oggfwd
        myOggfwd_close() ;
        encoder_example_end() ;
        totalFrames = 0 ;
        
        // Stop CVDisplayLink to prevent
        // more frames from being read
//      if (mDisplayLink)
//      {
//              CVDisplayLinkStop(mDisplayLink);
//              CVDisplayLinkRelease(mDisplayLink);
//              mDisplayLink = NULL;
//      }

        // Free our queue controller
        if (mFrameQueueController)
        {
                [mFrameQueueController release];
                mFrameQueueController = nil;
        }
        
        [startOutButton setEnabled:YES];
        [stopOutButton setEnabled:NO];
        [showZoneButton setEnabled:YES];
        [resizeRadio setEnabled:YES];

        [outBitrateTF setEnabled:YES];
        [outQualityTF setEnabled:YES];
        [outIcecastIPTF setEnabled:YES];
        [outIcecastPortTF setEnabled:YES];
        [outIcecastPassword setEnabled:YES];
        [outIcecastUsername setEnabled:YES];
//      [outIcecastMountTF setEnabled:YES];
        [projectName setEnabled:YES];
        [projectAuthor setEnabled:YES];
        [projectLocation setEnabled:YES];
        [projectDescr setEnabled:YES];

        [mCaptureTarget close];
}

#pragma mark ---------- Action Loop Methods ----------

////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////
// IN OUT LOOPS

- (void)newInFrameProcess
{
        ////////////////////////////////

        ////////////////////////////////
        // Update Image Preview
        //if(!showInPreview)
        //CIImage *inImage = [CIImage imageWithCVImageBuffer:theNewImageBuffer];
        //[inPreviewView setImage:inImage]; 
}

- (void)newOutFrameProcess
{       
        CVPixelBufferRef theNewImageBuffer ;
        
        totalFrames++ ;
        
        //NSLog(@"//////////////////////////////////////(myController) %d FRAME PROCESS BEGIN\n", totalFrames);
                
        ////////////////////////////////////////////////////////////////////
        // GET IMAGE FROM SCREEN
        ////////////////////////////////////////////////////////////////////
        NSAutoreleasePool *pool = [NSAutoreleasePool new];
        
        // Get an available reader object from the reader "free" queue
        FrameReader *freeReaderObj = [mFrameQueueController removeOldestItemFromFreeQ];
        if (freeReaderObj)
        {
                // set capture position and size
                if(captureRectChanged) {
                        captureRectChangedCompt++ ;
                        [freeReaderObj setCaptureRect:captureRect] ;
                        if(captureRectChangedCompt > kNumReaderObjects*2 ) captureRectChanged = FALSE ;
                }
                
                [freeReaderObj setBufferReadTime:mStartTime];
                [freeReaderObj readScreenAsyncOnSeparateThread];
        }
        
        // see if there are available frames in the "filled" queue
        FrameReader *filledReaderObj = [mFrameQueueController removeOldestItemFromFilledQ];
        if (filledReaderObj)
        {
                //[self pLog:[NSString stringWithFormat:@"Processing: %d\n",totalFrames]] ;

                // get the frame and process it (processImage)
                theNewImageBuffer = [filledReaderObj readScreenAsyncFinish] ;
#if 0   
                if (theNewImageBuffer != NULL) {
                        [self pLog:[NSString stringWithFormat:@"frame %d\n", CVPixelBufferGetWidth(theNewImageBuffer) ]] ;
                }
#endif
                ////////////////////////////////////////////////////////////////////
                // Update Image Preview
                ////////////////////////////////////////////////////////////////////
                if(showOutPreview) {
                        CIImage *youpImage = [CIImage imageWithCVImageBuffer:theNewImageBuffer];
                        [outPreviewView setImage:youpImage];
                        CGRect mmR = CGRectMake(0,0,captureRect.size.width,captureRect.size.height) ;
                        [outPreviewView setCleanRect:(CGRect)mmR];
                        NSRect tmpR = NSMakeRect(0,0,captureRect.size.width,captureRect.size.height) ;
                        [outPreviewView setDisplaySize:*(CGSize *)&tmpR.size];
                        [outPreviewView setNeedsDisplay:YES];
                }
        
                ////////////////////////////////////////////////////////////////////
                // Encode Frame (result is forwarded to myOggfwd)
                ////////////////////////////////////////////////////////////////////
                int res = encoder_example_loop( theNewImageBuffer ) ;
                //[NSThread detachNewThreadSelector:@selector(encodeFrame:) toTarget:self withObject:localBuff]; // OLD [to file] part
        
                // Ok... next
                QueueController *frameQController = [filledReaderObj queueController];
                [frameQController addItemToFreeQ:filledReaderObj];
        }
        [pool release];
        
        //NSLog(@"//////////////////////////////////////(myController) %d FRAME PROCESS DONE\n", totalFrames);
}

- (void)encodeFrame:(CVPixelBufferRef)myBuff
{
        CVPixelBufferRef givenBuff = (CVPixelBufferRef)myBuff ;
        int res = encoder_example_loop( givenBuff ) ;   
}

//////// TEMP - CALLED EVERY NEW FRAME (display link callback)
- (void)processImage:(CVPixelBufferRef)imageBuffer
{
        //NSLog(@"(myController) I'VE GOT NEW FRAME, that's great !!\n");
        [lockF lock] ;
        if(imageBuffer) localBuff = imageBuffer ;
        else NSLog(@"(myController) BIG PROBLEM : processImage AREGARDER !!!!!!!!!!!!!!!!!\n");
        [lockF unlock] ;
}

////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////
#pragma mark ---------- Timers Methods ----------

- (void)startOutTimer:(int)_inFramerate
{
        /// InOut - FIXED framerate
        NSTimeInterval previewFramesInterval = 1.0/_inFramerate ;
        //printf("FRAMETT = %s\n", previewFramesInterval) ;
        
    if (outPreviewTimer == nil) {
        // Schedule an ordinary NSTimer that will invoke -advanceSlideshow: at regular intervals, each time we need to advance to the next slide.
        outPreviewTimer = [[NSTimer scheduledTimerWithTimeInterval:previewFramesInterval target:self selector:@selector(nextOut:) userInfo:nil repeats:YES] retain];
    }
}
- (void)nextOut:(NSTimer *)timer 
{
        [self newOutFrameProcess] ;
}
- (void)stopOutTimer 
{
        //NSLog(@"(myController) STOPPING OUT TIMER\n");
    if (outPreviewTimer != nil) {
        // Cancel and release the slideshow advance timer.
        [outPreviewTimer invalidate];
        [outPreviewTimer release];
        outPreviewTimer = nil;
    }
}

////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////
#pragma mark ---------- GUI Buttons Methods (InOutController) ----------

- (void)updateServerIP:(NSString*)inStr
{
        [serverTF setStringValue:inStr] ;
}

////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////

#pragma mark ---------- GUI Buttons Methods (InOutController) ----------
- (IBAction)startOutAction:(id)sender
{
        [self startOut];
}

- (IBAction)stopOutAction:(id)sender
{
        [self stopOut];
}


#pragma mark ---------- Buttons Methods ----------

- (IBAction)outFramerateStepper:(id)sender
{
        outFramerate = [sender intValue]; // Get the new value FR
        [outFramerateDisplayed setStringValue:[NSString stringWithFormat:@"%d",outFramerate]];
}

- (void)toggleOutPreview:(id)sender
{
        showOutPreview = ([sender intValue]==1) ;
        //NSLog(@"(myController) Changing Out Preview State : %d\n",showOutPreview);
        if(!showOutPreview) [self clearOutDisplay] ;
}

- (IBAction)setSizeAndPosition:(id)sender
{
        //NSLog(@"(myController) YOU PUSHED The Set size and position.....\n");

        //[captureRect release] ;
        //captureRect = [[mCaptureTarget frame] retain] ;
        captureRect = [mCaptureTarget frame] ;
        captureRectChanged = TRUE ;
        captureRectChangedCompt = 0 ;
                
        /// Display size and location
        //printf("(myController) TARGET : pos = %f,%f size = %f,%f\n",captureRect.origin.x,captureRect.origin.y,captureRect.size.width,captureRect.size.height);
        
        [self setCaptureWindowMode:FALSE] ;
        
        //[mCaptureTarget close];
}

- (void)setCaptureWindowMode:(BOOL)mode
{
        if(mode) { // visible, movable
                
                [mCaptureTarget setAlphaValue:0.5];
                [mCaptureTarget setBackgroundColor: [NSColor redColor]];
                //[mCaptureTarget setOpaque:YES];
                [mCaptureTarget setMovableByWindowBackground: YES] ;
                
                [setSizeChoicesBox setHidden:FALSE] ;
        }
        else { // always on top, only frame
                
                [mCaptureTarget setAlphaValue:1];
                [mCaptureTarget setBackgroundColor:[NSColor clearColor]];
                [mCaptureTarget setOpaque:NO];
                [mCaptureTarget setMovableByWindowBackground: NO] ;
                
                [setSizeChoicesBox setHidden:TRUE] ;
        }
        [mCaptureTarget display] ;
}

- (IBAction)setCaptureSize:(id)sender
{
        int rowS =[sender selectedRow] ;
        int colS =[sender selectedColumn] ;
        int newW,newH ;
        NSRect oldFrame, newFrame ;
        int newX, newY ;
        
        switch(rowS) {
        case 0:
                if(colS==0)     {newW=160; newH=128;}
                else            {newW=400; newH=304;}
        break;
        case 1:
                if(colS==0)     {newW=208; newH=160;}
                else            {newW=640; newH=480;}
        break;
        case 2:
                if(colS==0)     {newW=320; newH=240;}
                else            {newW=800; newH=608;}
        break;
        }
        
        oldFrame = [mCaptureTarget frame] ;
        newX = oldFrame.origin.x + oldFrame.size.width/2 - newW/2 ;
        newY = oldFrame.origin.y + (oldFrame.size.height)/2 - newH/2 ;

        newFrame = NSMakeRect(newX,newY,newW,newH) ;
        [mCaptureTarget setFrame:newFrame display:YES] ;
        
        /// Display size and location
        //printf("INOUT - : pos = %d\n", rowS );
        [self pLog:[NSString stringWithFormat:@"Capture Size: %d:%d\n", newW, newH]] ;
}

#pragma mark ---------- Windows ----------

- (IBAction)showInOutCaptureTarget:(id)sender
{
        // show movie capture window
        [self setCaptureWindowMode:TRUE] ;
        [mCaptureTarget makeKeyAndOrderFront:self];
}

// Displays the capture movie window for the user
- (IBAction)showInOutWindow:(id)sender
{
        // show movie capture window
        [mMovieCaptureWindow center];
        [mMovieCaptureWindow makeKeyAndOrderFront:self];
}

// Called if the user presses the "Cancel" button in
// the capture movie window
- (IBAction)closeInOutWindow:(id)sender
{
        // pressing cancel button in movie capture window
        // simply closes the window
        [mMovieCaptureWindow close];
        [mCaptureTarget close];
}








@end