X-Git-Url: http://git.osdn.jp/view?a=blobdiff_plain;f=macosx%2FPictureController.mm;h=5dae523b9cb85aef3de8ddf134f20086b53d0f97;hb=ce32291e230fa2ab820ce17c8a5c0cbff3d98e2c;hp=30d7fae3ca618def1c4a26ec12c7365f22e7fe85;hpb=6058bcf4b5dd82a16282f324eb10af750dc38cc0;p=handbrake-jp%2Fhandbrake-jp-git.git

diff --git a/macosx/PictureController.mm b/macosx/PictureController.mm
index 30d7fae3..5dae523b 100644
--- a/macosx/PictureController.mm
+++ b/macosx/PictureController.mm
@@ -1,42 +1,150 @@
 /* $Id: PictureController.mm,v 1.11 2005/08/01 15:10:44 titer Exp $
 
    This file is part of the HandBrake source code.
-   Homepage: <http://handbrake.m0k.org/>.
+   Homepage: <http://handbrake.fr/>.
    It may be used under the terms of the GNU General Public License. */
 
-#include "PictureController.h"
+#import "PictureController.h"
+#import "Controller.h"
+#import "HBPreviewController.h"
 
-static int GetAlignedSize( int size )
+
+
+@implementation PictureController
+
+- (id)init
+{
+	if (self = [super initWithWindowNibName:@"PictureSettings"])
+	{
+        // NSWindowController likes to lazily load its window. However since
+        // this controller tries to set all sorts of outlets before the window
+        // is displayed, we need it to load immediately. The correct way to do
+        // this, according to the documentation, is simply to invoke the window
+        // getter once.
+        //
+        // If/when we switch a lot of this stuff to bindings, this can probably
+        // go away.
+        [self window];
+        
+	fPreviewController = [[PreviewController alloc] init];
+    }
+	return self;
+}
+
+//------------------------------------------------------------------------------------
+// Displays and brings the picture window to the front
+//------------------------------------------------------------------------------------
+- (IBAction) showPictureWindow: (id)sender
 {
-    int result = 1;
-    while( result < size )
+    if ([fPreviewController fullScreen] == YES)
+    {
+        [self showWindow:sender];
+        [[NSUserDefaults standardUserDefaults] setBool:YES forKey:@"PictureSizeWindowIsOpen"];
+        [self setToFullScreenMode];
+    }
+    else
     {
-        result *= 2;
+        if ([[self window] isVisible])
+        {
+            [[self window] close];
+        }
+        else
+        {
+            [self showWindow:sender];
+            [[NSUserDefaults standardUserDefaults] setBool:YES forKey:@"PictureSizeWindowIsOpen"];
+            [self setToWindowedMode];
+        }
     }
-    return result;
 }
 
-@implementation PictureController
+- (BOOL) previewFullScreenMode
+{
+    return [fPreviewController fullScreen];
+}
 
-- (void) SetHandle: (hb_handle_t *) handle
+- (IBAction) previewGoWindowed: (id)sender
 {
-    fHandle = handle;
+    [fPreviewController goWindowedScreen:self];
+}
+
+- (IBAction) showPreviewWindow: (id)sender
+{
+    [[NSUserDefaults standardUserDefaults] setBool:YES forKey:@"PreviewWindowIsOpen"];
+    [fPreviewController showWindow:sender];
+}
+
+
+
+
+- (void) setToFullScreenMode
+{
+    int32_t shieldLevel = CGShieldingWindowLevel(); 
+    
+    [fPictureWindow setLevel:shieldLevel + 1]; 
+    // Show the window. 
+    [fPictureWindow makeKeyAndOrderFront:self];
+}
 
-    fHasQE = CGDisplayUsesOpenGLAcceleration( kCGDirectMainDisplay );
+- (void) setToWindowedMode
+{
+    /* Set the window back to Floating Window mode 
+     * This will put the window always on top, but
+     * since we have Hide on Deactivate set in our
+     * xib, if other apps are put in focus we will
+     * hide properly to stay out of the way
+     */
+    [[self window] setLevel:NSFloatingWindowLevel];
+}
 
-    fBuffer     = NULL;
-    fBufferSize = 0;
-    fTexBuf[0]  = NULL;
-    fTexBuf[1]  = NULL;
-    fTexBufSize = 0;
+- (void)setHBController: (HBController *)controller
+{
+    fHBController = controller;
+    [fPreviewController   setHBController: controller];
+    
+}
 
+- (void)awakeFromNib
+{
+    [fPictureWindow setDelegate:self];
+    if( ![[self window] setFrameUsingName:@"PictureSizing"] )
+        [[self window] center];
+    [self setWindowFrameAutosaveName:@"PictureSizing"];
+    [[self window] setExcludedFromWindowsMenu:YES];
+    
+    [self setInitialPictureFilters];
+    
+    /* Setup our layers for core animation */
+    [fSizeFilterView setWantsLayer:YES];
+}
+
+
+- (void)windowWillClose:(NSNotification *)aNotification
+{
+[[NSUserDefaults standardUserDefaults] setBool:NO forKey:@"PictureSizeWindowIsOpen"];
+}
+
+- (BOOL)windowShouldClose:(id)fPictureWindow
+{
+    return YES;
+}
+
+- (void) dealloc
+{
+    [fPreviewController release];
+    [super dealloc];
+}
+
+- (void) SetHandle: (hb_handle_t *) handle
+{
+    fHandle = handle;
+    
     [fWidthStepper  setValueWraps: NO];
     [fWidthStepper  setIncrement: 16];
-    [fWidthStepper  setMinValue: 16];
+    [fWidthStepper  setMinValue: 64];
     [fHeightStepper setValueWraps: NO];
     [fHeightStepper setIncrement: 16];
-    [fHeightStepper setMinValue: 16];
-
+    [fHeightStepper setMinValue: 64];
+    
     [fCropTopStepper    setIncrement: 2];
     [fCropTopStepper    setMinValue:  0];
     [fCropBottomStepper setIncrement: 2];
@@ -45,6 +153,8 @@ static int GetAlignedSize( int size )
     [fCropLeftStepper   setMinValue:  0];
     [fCropRightStepper  setIncrement: 2];
     [fCropRightStepper  setMinValue:  0];
+    
+    [fPreviewController SetHandle: fHandle];
 }
 
 - (void) SetTitle: (hb_title_t *) title
@@ -52,28 +162,9 @@ static int GetAlignedSize( int size )
     hb_job_t * job = title->job;
 
     fTitle = title;
-
-    /* Make sure we have big enough buffers */
-    int newSize;
-    newSize = ( title->width + 2 ) * (title->height + 2 ) * 4;
-    if( fBufferSize < newSize )
-    {
-        fBufferSize = newSize;
-        fBuffer     = (uint8_t *) realloc( fBuffer, fBufferSize );
-    }
-    if( !fHasQE )
-    {
-        newSize = ( GetAlignedSize( title->width + 2 ) *
-            GetAlignedSize( title->height + 2 ) * 4 );
-    }
-    if( fTexBufSize < newSize )
-    {
-        fTexBufSize = newSize;
-        fTexBuf[0]  = (uint8_t *) realloc( fTexBuf[0], fTexBufSize );
-        fTexBuf[1]  = (uint8_t *) realloc( fTexBuf[1], fTexBufSize );
-    }
-
-
+    
+    
+    
     [fWidthStepper      setMaxValue: title->width];
     [fWidthStepper      setIntValue: job->width];
     [fWidthField        setIntValue: job->width];
@@ -85,144 +176,67 @@ static int GetAlignedSize( int size )
     [fCropBottomStepper setMaxValue: title->height/2-2];
     [fCropLeftStepper   setMaxValue: title->width/2-2];
     [fCropRightStepper  setMaxValue: title->width/2-2];
-    [fDeinterlaceCheck  setState:    job->deinterlace ? NSOnState : NSOffState];
-	[fPARCheck  setState:    job->pixel_ratio ? NSOnState : NSOffState];
-	if ([fAutoCropMainWindow  intValue] == 0)
-	{
-	[fCropMatrix  selectCellAtRow: 1 column:0];
-	}
-	else
-	{
-	[fCropMatrix  selectCellAtRow: 0 column:0];
-	}
-    MaxOutputWidth = job->width;
-	MaxOutputHeight = job->height;
-    fPicture = 0;
-    [self SettingsChanged: nil];
-}
-
-- (void) Display: (int) anim
-{
-    hb_get_preview( fHandle, fTitle, fPicture, fBuffer );
-
-    /* Backup previous picture (for effects) */
-    memcpy( fTexBuf[1], fTexBuf[0], fTexBufSize );
-
-    if( fHasQE )
-    {
-        /* Simply copy */
-        memcpy( fTexBuf[0], fBuffer, fTexBufSize );
-    }
-    else
-    {
-        /* Copy line by line */
-        uint8_t * in  = fBuffer;
-        uint8_t * out = fTexBuf[0];
-		
-        for( int i = fTitle->height + 2; i--; )
-        {
-            memcpy( out, in, 4 * ( fTitle->width + 2 ) );
-            in  += 4 * ( fTitle->width + 2 );
-            out += 4 * GetAlignedSize( fTitle->width + 2 );
-        }
-	
-    }
 
-    if( [fEffectsCheck state] == NSOffState )
-    {
-        anim = HB_ANIMATE_NONE;
-    }
-    else if( [[NSApp currentEvent] modifierFlags] & NSShiftKeyMask )
+    /* Populate the Anamorphic NSPopUp button here */
+    [fAnamorphicPopUp removeAllItems];
+    [fAnamorphicPopUp addItemWithTitle: @"None"];
+    [fAnamorphicPopUp addItemWithTitle: @"Strict"];
+    if (allowLooseAnamorphic)
     {
-        anim |= HB_ANIMATE_SLOW;
+    [fAnamorphicPopUp addItemWithTitle: @"Loose"];
     }
-
-    [fPictureGLView Display: anim buffer1: fTexBuf[0]
-        buffer2: fTexBuf[1] width: ( fTitle->width + 2 )
-        height: ( fTitle->height + 2 )];
-	
-	/* Set the Output Display below the Preview Picture*/
-	int titlewidth = fTitle->width-fTitle->job->crop[2]-fTitle->job->crop[3];
-	int arpwidth = fTitle->job->pixel_aspect_width;
-	int arpheight = fTitle->job->pixel_aspect_height;
-	int displayparwidth = titlewidth * arpwidth / arpheight;
-	int displayparheight = fTitle->height-fTitle->job->crop[0]-fTitle->job->crop[1];
-	if (fTitle->job->pixel_ratio == 1)
+    [fAnamorphicPopUp selectItemAtIndex: job->anamorphic.mode];
+    
+    /* We initially set the previous state of keep ar to on */
+    keepAspectRatioPreviousState = 1;
+	if (!autoCrop)
 	{
-	
-	[fInfoField setStringValue: [NSString stringWithFormat:
-	@"Source: %dx%d, Output: %dx%d, Anamorphic: %dx%d", fTitle->width, fTitle->height,
-	titlewidth, displayparheight, displayparwidth,
-	displayparheight]];
-	
-	
+        [fCropMatrix  selectCellAtRow: 1 column:0];
+        /* If auto, lets set the crop steppers according to current job->crop values */
+        [fCropTopStepper    setIntValue: job->crop[0]];
+        [fCropTopField      setIntValue: job->crop[0]];
+        [fCropBottomStepper setIntValue: job->crop[1]];
+        [fCropBottomField   setIntValue: job->crop[1]];
+        [fCropLeftStepper   setIntValue: job->crop[2]];
+        [fCropLeftField     setIntValue: job->crop[2]];
+        [fCropRightStepper  setIntValue: job->crop[3]];
+        [fCropRightField    setIntValue: job->crop[3]];
 	}
 	else
 	{
-	[fInfoField setStringValue: [NSString stringWithFormat:
-        @"Source: %dx%d, Output: %dx%d", fTitle->width, fTitle->height,
-        fTitle->job->width, fTitle->job->height]];	
+        [fCropMatrix  selectCellAtRow: 0 column:0];
 	}
-
-
-    [fPrevButton setEnabled: ( fPicture > 0 )];
-    [fNextButton setEnabled: ( fPicture < 9 )];
+	
+    /* Set filters widgets according to the filters struct */
+    [fDetelecinePopUp selectItemAtIndex:fPictureFilterSettings.detelecine];
+    [fDecombPopUp selectItemAtIndex:fPictureFilterSettings.decomb];
+    [fDeinterlacePopUp selectItemAtIndex: fPictureFilterSettings.deinterlace];
+    [fDenoisePopUp selectItemAtIndex: fPictureFilterSettings.denoise];
+    [fDeblockSlider setFloatValue:fPictureFilterSettings.deblock];
+    [fGrayscaleCheck setState:fPictureFilterSettings.grayscale];
+    
+    [self deblockSliderChanged: nil];
+    
+    fPicture = 0;
+    MaxOutputWidth = title->width - job->crop[2] - job->crop[3];
+    MaxOutputHeight = title->height - job->crop[0] - job->crop[1];
+    
+    [self SettingsChanged: nil];
 }
 
+    
+
 - (IBAction) SettingsChanged: (id) sender
 {
     hb_job_t * job = fTitle->job;
     
-	if ([fPARCheck state] == 1 )
-	{
-	[fWidthStepper      setIntValue: MaxOutputWidth];
-	[fWidthField        setIntValue: MaxOutputWidth];
-	
-	/* This will show correct anamorphic height values, but
-	show distorted preview picture ratio */
-	[fHeightStepper      setIntValue: fTitle->height-fTitle->job->crop[0]-fTitle->job->crop[1]];
-	[fHeightField        setIntValue: fTitle->height-fTitle->job->crop[0]-fTitle->job->crop[1]];
-	
-	/* This will show wrong anamorphic height values, but
-	show proper preview picture ratio */
-	//[fHeightStepper      setIntValue: MaxOutputHeight];
-	//[fHeightField        setIntValue: MaxOutputHeight];
-	[fRatioCheck        setState: 0];
-
-	[fWidthStepper setEnabled: NO];
-	[fWidthField setEnabled: NO];
-	[fHeightStepper setEnabled: NO];
-	[fHeightField setEnabled: NO];
-	[fRatioCheck setEnabled: NO];
-	
-	
-	}
-	else
-	{
-	[fWidthStepper setEnabled: YES];
-	[fWidthField setEnabled: YES];
-	[fHeightStepper setEnabled: YES];
-	[fHeightField setEnabled: YES];
-	[fRatioCheck setEnabled: YES];
-	}
-	
-	
-	
-    job->width       = [fWidthStepper  intValue];
-    job->height      = [fHeightStepper intValue];
-    job->keep_ratio  = ( [fRatioCheck state] == NSOnState );
-    job->deinterlace = ( [fDeinterlaceCheck state] == NSOnState );
-	job->pixel_ratio = ( [fPARCheck state] == NSOnState );
-
+    autoCrop = ( [fCropMatrix selectedRow] == 0 );
+    [fCropTopStepper    setEnabled: !autoCrop];
+    [fCropBottomStepper setEnabled: !autoCrop];
+    [fCropLeftStepper   setEnabled: !autoCrop];
+    [fCropRightStepper  setEnabled: !autoCrop];
 
-
-    bool autocrop = ( [fCropMatrix selectedRow] == 0 );
-    [fCropTopStepper    setEnabled: !autocrop];
-    [fCropBottomStepper setEnabled: !autocrop];
-    [fCropLeftStepper   setEnabled: !autocrop];
-    [fCropRightStepper  setEnabled: !autocrop];
-	[fAutoCropMainWindow  setStringValue: [NSString stringWithFormat:@"%d",autocrop]];
-    if( autocrop )
+    if( autoCrop )
     {
         memcpy( job->crop, fTitle->crop, 4 * sizeof( int ) );
     }
@@ -233,11 +247,88 @@ static int GetAlignedSize( int size )
         job->crop[2] = [fCropLeftStepper   intValue];
         job->crop[3] = [fCropRightStepper  intValue];
     }
+    
+	if( [fAnamorphicPopUp indexOfSelectedItem] > 0 )
+	{
+        if ([fAnamorphicPopUp indexOfSelectedItem] == 2) // Loose anamorphic
+        {
+            job->anamorphic.mode = 2;
+            [fWidthStepper setEnabled: YES];
+            [fWidthField setEnabled: YES];
+            /* We set job->width and call hb_set_anamorphic_size in libhb to do a "dry run" to get
+             * the values to be used by libhb for loose anamorphic
+             */
+            /* if the sender is the anamorphic popup, then we know that loose anamorphic has just
+             * been turned on, so snap the width to full width for the source.
+             */
+            if (sender == fAnamorphicPopUp)
+            {
+                [fWidthStepper      setIntValue: fTitle->width-fTitle->job->crop[2]-fTitle->job->crop[3]];
+                [fWidthField        setIntValue: fTitle->width-fTitle->job->crop[2]-fTitle->job->crop[3]];
+            }
+            job->width       = [fWidthStepper  intValue];
+            hb_set_anamorphic_size(job, &output_width, &output_height, &output_par_width, &output_par_height);
+            [fHeightStepper      setIntValue: output_height];
+            [fHeightField        setIntValue: output_height];
+            job->height      = [fHeightStepper intValue];
+            
+        }
+        else // must be "1" or strict anamorphic
+        {
+            [fWidthStepper      setIntValue: fTitle->width-fTitle->job->crop[2]-fTitle->job->crop[3]];
+            [fWidthField        setIntValue: fTitle->width-fTitle->job->crop[2]-fTitle->job->crop[3]];
+            
+            /* This will show correct anamorphic height values, but
+             show distorted preview picture ratio */
+            [fHeightStepper      setIntValue: fTitle->height-fTitle->job->crop[0]-fTitle->job->crop[1]];
+            [fHeightField        setIntValue: fTitle->height-fTitle->job->crop[0]-fTitle->job->crop[1]];
+            job->width       = [fWidthStepper  intValue];
+            job->height      = [fHeightStepper intValue];
+            
+            job->anamorphic.mode = 1;
+            [fWidthStepper setEnabled: NO];
+            [fWidthField setEnabled: NO];
+        }
+        
+        /* if the sender is the Anamorphic checkbox, record the state
+         of KeepAspect Ratio so it can be reset if Anamorphic is unchecked again */
+        if (sender == fAnamorphicPopUp)
+        {
+            keepAspectRatioPreviousState = [fRatioCheck state];
+        }
+        [fRatioCheck setState:NSOffState];
+        [fRatioCheck setEnabled: NO];
+        
+        
+        [fHeightStepper setEnabled: NO];
+        [fHeightField setEnabled: NO];
+        
+    }
+    else
+	{
+        job->width       = [fWidthStepper  intValue];
+        job->height      = [fHeightStepper intValue];
+        job->anamorphic.mode = 0;
+        [fWidthStepper setEnabled: YES];
+        [fWidthField setEnabled: YES];
+        [fHeightStepper setEnabled: YES];
+        [fHeightField setEnabled: YES];
+        [fRatioCheck setEnabled: YES];
+        /* if the sender is the Anamorphic checkbox, we return the
+         keep AR checkbox to its previous state */
+        if (sender == fAnamorphicPopUp)
+        {
+            [fRatioCheck setState:keepAspectRatioPreviousState];
+        }
+        
+	}
+	
+    job->keep_ratio  = ( [fRatioCheck state] == NSOnState );
 
     if( job->keep_ratio )
     {
         if( sender == fWidthStepper || sender == fRatioCheck ||
-            sender == fCropTopStepper || sender == fCropBottomStepper )
+           sender == fCropTopStepper || sender == fCropBottomStepper )
         {
             hb_fix_aspect( job, HB_KEEP_WIDTH );
             if( job->height > fTitle->height )
@@ -255,12 +346,22 @@ static int GetAlignedSize( int size )
                 hb_fix_aspect( job, HB_KEEP_WIDTH );
             }
         }
+        // hb_get_preview can't handle sizes that are larger than the original title
+        // dimensions
+        if( job->width > fTitle->width )
+            job->width = fTitle->width;
+
+        if( job->height > fTitle->height )
+            job->height = fTitle->height;
     }
-    
+
     [fWidthStepper      setIntValue: job->width];
     [fWidthField        setIntValue: job->width];
-    [fHeightStepper     setIntValue: job->height];
-    [fHeightField       setIntValue: job->height];
+    if( [fAnamorphicPopUp indexOfSelectedItem] < 2 )
+	{
+        [fHeightStepper     setIntValue: job->height];
+        [fHeightField       setIntValue: job->height];
+    }
     [fCropTopStepper    setIntValue: job->crop[0]];
     [fCropTopField      setIntValue: job->crop[0]];
     [fCropBottomStepper setIntValue: job->crop[1]];
@@ -269,33 +370,392 @@ static int GetAlignedSize( int size )
     [fCropLeftField     setIntValue: job->crop[2]];
     [fCropRightStepper  setIntValue: job->crop[3]];
     [fCropRightField    setIntValue: job->crop[3]];
-    [self Display: HB_ANIMATE_NONE];
+    
+    [fPreviewController SetTitle:fTitle];
+    /* Sanity Check Here for < 16 px preview to avoid
+     crashing hb_get_preview. In fact, just for kicks
+     lets getting previews at a min limit of 32, since
+     no human can see any meaningful detail below that */
+    if (job->width >= 64 && job->height >= 64)
+    {
+       
+         // Purge the existing picture previews so they get recreated the next time
+        // they are needed.
+        [fPreviewController purgeImageCache];
+        /* We actually call displayPreview now from pictureSliderChanged which keeps
+         * our picture preview slider in sync with the previews being shown
+         */
+
+    //[fPreviewController pictureSliderChanged:nil];
+    [self reloadStillPreview];
+    }
+
+    /* we get the sizing info to display from fPreviewController */
+    [fSizeInfoField setStringValue: [fPreviewController pictureSizeInfoString]];
+
+    if (sender != nil)
+    {
+        [fHBController pictureSettingsDidChange];
+    }   
+    
 }
 
-- (IBAction) PreviousPicture: (id) sender
-{   
-    if( fPicture <= 0 )
+- (NSString*) getPictureSizeInfoString
+{
+    return [fSizeInfoField stringValue];
+}
+
+- (void)reloadStillPreview
+{ 
+   hb_job_t * job = fTitle->job; 
+   
+   [fPreviewController SetTitle:fTitle];
+    /* Sanity Check Here for < 16 px preview to avoid
+     crashing hb_get_preview. In fact, just for kicks
+     lets getting previews at a min limit of 32, since
+     no human can see any meaningful detail below that */
+    if (job->width >= 64 && job->height >= 64)
     {
-        return;
+       
+         // Purge the existing picture previews so they get recreated the next time
+        // they are needed.
+        [fPreviewController purgeImageCache];
+        /* We actually call displayPreview now from pictureSliderChanged which keeps
+         * our picture preview slider in sync with the previews being shown
+         */
+
+    [fPreviewController pictureSliderChanged:nil];
     }
-    fPicture--;
-    [self Display: HB_ANIMATE_BACKWARD];
+    
+}
+
+
+#pragma mark -
+
+- (BOOL) autoCrop
+{
+    return autoCrop;
+}
+- (void) setAutoCrop: (BOOL) setting
+{
+    autoCrop = setting;
+}
+
+- (BOOL) allowLooseAnamorphic
+{
+    return allowLooseAnamorphic;
+}
+
+- (void) setAllowLooseAnamorphic: (BOOL) setting
+{
+    allowLooseAnamorphic = setting;
+}
+
+- (IBAction)showPreviewPanel: (id)sender forTitle: (hb_title_t *)title
+{
+    [self SetTitle:title];
+    [self showWindow:sender];
+
 }
 
-- (IBAction) NextPicture: (id) sender
+
+#pragma mark -
+/* we use this to setup the initial picture filters upon first launch, after that their states
+are maintained across different sources */
+- (void) setInitialPictureFilters
+{
+	/* we use a popup to show the detelecine settings */
+	[fDetelecinePopUp removeAllItems];
+    [fDetelecinePopUp addItemWithTitle: @"Off"];
+    [fDetelecinePopUp addItemWithTitle: @"Default"];
+    [fDetelecinePopUp addItemWithTitle: @"Custom"];
+    [fDetelecinePopUp selectItemAtIndex: fPictureFilterSettings.detelecine];
+    
+    [self modeDecombDeinterlaceSliderChanged:nil];
+    /* we use a popup to show the decomb settings */
+	[fDecombPopUp removeAllItems];
+    [fDecombPopUp addItemWithTitle: @"Off"];
+    [fDecombPopUp addItemWithTitle: @"Default"];
+    [fDecombPopUp addItemWithTitle: @"Custom"];
+    [fDecombPopUp selectItemAtIndex: fPictureFilterSettings.decomb];
+    
+    /* we use a popup to show the deinterlace settings */
+	[fDeinterlacePopUp removeAllItems];
+    [fDeinterlacePopUp addItemWithTitle: @"None"];
+    [fDeinterlacePopUp addItemWithTitle: @"Fast"];
+    [fDeinterlacePopUp addItemWithTitle: @"Slow"];
+	[fDeinterlacePopUp addItemWithTitle: @"Slower"];
+    [fDeinterlacePopUp addItemWithTitle: @"Custom"];
+    
+	/* Set deinterlaces level according to the integer in the main window */
+	[fDeinterlacePopUp selectItemAtIndex: fPictureFilterSettings.deinterlace];
+
+	/* we use a popup to show the denoise settings */
+	[fDenoisePopUp removeAllItems];
+    [fDenoisePopUp addItemWithTitle: @"None"];
+    [fDenoisePopUp addItemWithTitle: @"Weak"];
+	[fDenoisePopUp addItemWithTitle: @"Medium"];
+    [fDenoisePopUp addItemWithTitle: @"Strong"];
+    [fDenoisePopUp addItemWithTitle: @"Custom"];
+	/* Set denoises level according to the integer in the main window */
+	[fDenoisePopUp selectItemAtIndex: fPictureFilterSettings.denoise];
+    
+
+}
+
+
+
+
+- (IBAction) modeDecombDeinterlaceSliderChanged: (id) sender
 {
-    if( fPicture >= 9 )
+    /* Decomb selected*/
+    if ([fDecombDeinterlaceSlider floatValue] == 0.0)
+    {
+    [fDecombBox setHidden:NO];
+    [fDeinterlaceBox setHidden:YES];
+    fPictureFilterSettings.decomb = [fDecombPopUp indexOfSelectedItem];
+    fPictureFilterSettings.usedecomb = 1;
+    fPictureFilterSettings.deinterlace = 0;
+    [self adjustFilterDisplay:fDecombPopUp];
+    [fDecombPopUp selectItemAtIndex:fPictureFilterSettings.decomb];
+    }
+    else
     {
-        return;
+    [fDecombBox setHidden:YES];
+    [fDeinterlaceBox setHidden:NO];
+    fPictureFilterSettings.usedecomb = 0;
+    fPictureFilterSettings.decomb = 0;
+    [self adjustFilterDisplay:fDeinterlacePopUp];
+    [fDeinterlacePopUp selectItemAtIndex: fPictureFilterSettings.deinterlace];
     }
-    fPicture++;
-    [self Display: HB_ANIMATE_FORWARD];
+	[self FilterSettingsChanged: sender];
 }
 
-- (IBAction) ClosePanel: (id) sender
+
+- (IBAction) FilterSettingsChanged: (id) sender
 {
 
-	[NSApp stopModal];
+    fPictureFilterSettings.detelecine  = [fDetelecinePopUp indexOfSelectedItem];
+    [self adjustFilterDisplay:fDetelecinePopUp];
+    
+    fPictureFilterSettings.decomb = [fDecombPopUp indexOfSelectedItem];
+    [self adjustFilterDisplay:fDecombPopUp];
+    
+    fPictureFilterSettings.deinterlace = [fDeinterlacePopUp indexOfSelectedItem];
+    [self adjustFilterDisplay:fDeinterlacePopUp];
+    
+    fPictureFilterSettings.denoise = [fDenoisePopUp indexOfSelectedItem];
+    [self adjustFilterDisplay:fDenoisePopUp];
+    
+    if ([fDeblockField stringValue] == @"Off")
+    {
+        fPictureFilterSettings.deblock  = 0;
+    }
+    else
+    {
+        fPictureFilterSettings.deblock  = [fDeblockField intValue];
+    }
+    
+    fPictureFilterSettings.grayscale = [fGrayscaleCheck state];
+    
+    if (sender != nil)
+    {
+        [fHBController pictureSettingsDidChange];
+        
+    }   
+
 }
 
+- (void) adjustFilterDisplay: (id) sender
+{
+    
+    NSBox * filterBox = nil;
+    NSTextField * filterField;
+    if (sender == fDetelecinePopUp)
+    {
+        filterBox = fDetelecineBox;
+        filterField = fDetelecineField;
+    }
+    if (sender == fDecombPopUp)
+    {
+        filterBox = fDecombBox;
+        filterField = fDecombField;
+    }
+    if (sender == fDeinterlacePopUp)
+    {
+        filterBox = fDeinterlaceBox;
+        filterField = fDeinterlaceField;
+    }
+    
+    if (sender == fDenoisePopUp)
+    {
+        filterBox = fDenoiseBox;
+        filterField = fDenoiseField;
+    }
+    
+    NSSize currentSize = [filterBox frame].size;
+    if ([sender titleOfSelectedItem] == @"Custom")
+    {
+        currentSize.height = 60;
+    }
+    else
+    {
+        currentSize.height = 30;
+    }
+    /* Check to see if we have changed the size from current */
+    if (currentSize.height != [filterBox frame].size.height)
+    {
+        /* We are changing the size of the box, so recalc the origin */
+        NSPoint origin = [filterBox frame].origin;
+        /* See if we are expanding the box downwards */
+        if (currentSize.height > [filterBox frame].size.height)
+        {
+            origin.y = origin.y - currentSize.height / 2;
+        }
+        else
+        {
+            origin.y = origin.y + currentSize.height;
+        }
+        /* go ahead and resize the box */
+        [filterBox setFrameSize:currentSize];
+        [filterBox setFrameOrigin:origin];
+    }
+    
+}
+
+#pragma mark -
+
+- (IBAction) deblockSliderChanged: (id) sender
+{
+    if ([fDeblockSlider floatValue] == 4.0)
+    {
+    [fDeblockField setStringValue: [NSString stringWithFormat: @"Off"]];
+    }
+    else
+    {
+    [fDeblockField setStringValue: [NSString stringWithFormat: @"%.0f", [fDeblockSlider floatValue]]];
+    }
+	[self FilterSettingsChanged: sender];
+}
+
+
+- (int) detelecine
+{
+    return fPictureFilterSettings.detelecine;
+}
+
+- (NSString*) detelecineCustomString
+{
+    return [fDetelecineField stringValue];
+}
+
+- (void) setDetelecine: (int) setting
+{
+    fPictureFilterSettings.detelecine = setting;
+}
+
+- (void) setDetelecineCustomString: (NSString*) string 
+{
+    [fDetelecineField setStringValue:string];
+}
+
+- (int) deinterlace
+{
+    return fPictureFilterSettings.deinterlace;
+}
+- (NSString*) deinterlaceCustomString
+{
+    return [fDeinterlaceField stringValue];
+}
+
+- (void) setDeinterlaceCustomString: (NSString*) string 
+{
+    [fDeinterlaceField setStringValue:string];
+}
+
+- (void) setDeinterlace: (int) setting 
+{
+    fPictureFilterSettings.deinterlace = setting;
+}
+- (int) decomb
+{
+    return fPictureFilterSettings.decomb;
+}
+
+- (NSString*) decombCustomString
+{
+    return [fDecombField stringValue];
+}
+
+- (int) useDecomb
+{
+    return fPictureFilterSettings.usedecomb;
+}
+
+- (void) setUseDecomb: (int) setting
+{
+    fPictureFilterSettings.usedecomb = setting;
+    if (fPictureFilterSettings.usedecomb == 1)
+    {
+        [fDecombDeinterlaceSlider setFloatValue:0.0];
+    }
+    else
+    {
+        [fDecombDeinterlaceSlider setFloatValue:1.0];
+    }
+    [self modeDecombDeinterlaceSliderChanged:nil];
+}
+
+- (void) setDecomb: (int) setting {
+    fPictureFilterSettings.decomb = setting;
+}
+
+- (void) setDecombCustomString: (NSString*) string 
+{
+    [fDecombField setStringValue:string];
+}
+
+- (int) denoise
+{
+    return fPictureFilterSettings.denoise;
+}
+
+- (NSString*) denoiseCustomString
+{
+    return [fDenoiseField stringValue];
+}
+
+- (void) setDenoiseCustomString: (NSString*) string 
+{
+    [fDenoiseField setStringValue:string];
+}
+
+- (void) setDenoise: (int) setting
+{
+    fPictureFilterSettings.denoise = setting;
+}
+
+- (int) deblock
+{
+    return fPictureFilterSettings.deblock;
+}
+
+- (void) setDeblock: (int) setting
+{
+    fPictureFilterSettings.deblock = setting;
+}
+
+- (int) grayscale
+{
+    return fPictureFilterSettings.grayscale;
+}
+
+- (void) setGrayscale: (int) setting
+{
+    fPictureFilterSettings.grayscale = setting;
+}
+
+
+
 @end
+