It may be used under the terms of the GNU General Public License. */
#import "PictureController.h"
+#import "Controller.h"
+#import "HBPreviewController.h"
-@interface PictureController (Private)
-- (NSSize)optimalViewSizeForImageSize: (NSSize)imageSize;
-- (void)resizeSheetForViewSize: (NSSize)viewSize;
-- (void)setViewSize: (NSSize)viewSize;
-- (BOOL)viewNeedsToResizeToSize: (NSSize)newSize;
-
-@end
@implementation PictureController
-- (id)initWithDelegate:(id)del
+- (id)init
{
if (self = [super initWithWindowNibName:@"PictureSettings"])
{
// go away.
[self window];
- delegate = del;
- fPicturePreviews = [[NSMutableDictionary dictionaryWithCapacity: HB_NUM_HBLIB_PICTURES] retain];
- /* Init libhb with check for updates libhb style set to "0" so its ignored and lets sparkle take care of it */
- int loggingLevel = [[[NSUserDefaults standardUserDefaults] objectForKey:@"LoggingLevel"] intValue];
- fPreviewLibhb = hb_init(loggingLevel, 0);
- }
+ fPreviewController = [[PreviewController alloc] init];
+ }
return self;
}
-- (void) dealloc
+//------------------------------------------------------------------------------------
+// Displays and brings the picture window to the front
+//------------------------------------------------------------------------------------
+- (IBAction) showPictureWindow: (id)sender
+{
+ if ([fPreviewController fullScreen] == YES)
+ {
+ [self showWindow:sender];
+ [[NSUserDefaults standardUserDefaults] setBool:YES forKey:@"PictureSizeWindowIsOpen"];
+ [self setToFullScreenMode];
+ }
+ else
+ {
+ if ([[self window] isVisible])
+ {
+ [[self window] close];
+ }
+ else
+ {
+ [self showWindow:sender];
+ [[NSUserDefaults standardUserDefaults] setBool:YES forKey:@"PictureSizeWindowIsOpen"];
+ [self setToWindowedMode];
+ }
+ }
+ [self adjustFilterDisplay:nil];
+ [self adjustSizingDisplay:nil];
+}
+
+- (BOOL) previewFullScreenMode
+{
+ return [fPreviewController fullScreen];
+}
+
+/* this method is used to detect clicking on a tab in fSizeFilterView */
+- (void)tabView:(NSTabView *)tabView didSelectTabViewItem:(NSTabViewItem *)tabViewItem
+{
+
+[self resizeInspectorForTab:nil];
+
+}
+
+#pragma mark -
+
+/* resizeInspectorForTab is called at launch, and each time either the
+ * Size or Filters tab is clicked. Size gives a horizontally oriented
+ * inspector and Filters is a vertically aligned inspector.
+ */
+- (IBAction) resizeInspectorForTab: (id)sender
+{
+ NSRect frame = [[self window] frame];
+ NSPoint windowOrigin = [[self window] frame].origin;
+ NSSize screenSize = [[[self window] screen] frame].size;
+ NSPoint screenOrigin = [[[self window] screen] frame].origin;
+
+ /* We base our inspector size/layout on which tab is active for fSizeFilterView */
+ /* we are 1 which is Filters*/
+ if ([fSizeFilterView indexOfTabViewItem: [fSizeFilterView selectedTabViewItem]] == 1)
+ {
+ frame.size.width = 314;
+ /* we glean the height from the size of the boxes plus the extra window space
+ * needed for non boxed display
+ */
+ frame.size.height = 110.0 + [fDetelecineBox frame].size.height + [fDecombDeinterlaceBox frame].size.height + [fDenoiseBox frame].size.height + [fDeblockBox frame].size.height;
+ /* Hide the size readout at the bottom as the vertical inspector is not wide enough */
+ [fSizeInfoField setHidden:YES];
+ }
+ else // we are Tab index 0 which is size
+ {
+ frame.size.width = 50.0 + [fPictureSizeBox frame].size.width + [fPictureCropBox frame].size.width;
+ frame.size.height = [fPictureSizeBox frame].size.height + 85;
+ /* hide the size summary field at the bottom */
+ [fSizeInfoField setHidden:NO];
+ }
+ /* get delta's for the change in window size */
+ CGFloat deltaX = frame.size.width - [[self window] frame].size.width;
+ CGFloat deltaY = frame.size.height - [[self window] frame].size.height;
+
+ /* Check to see if we have changed the height from current */
+ //if (frame.size.height != [[self window] frame].size.height)
+ //{
+ /* change the inspector origin via the deltaY */
+ frame.origin.y -= deltaY;
+ /* keep the inspector centered so the tabs stay in place */
+ frame.origin.x -= deltaX / 2.0;
+ //}
+
+ /* we make sure we are not horizontally off of our screen.
+ * this would be the case if we are on the vertical filter tab
+ * and we hit the size tab and the inspector grows horizontally
+ * off the screen to the right
+ */
+ if ((frame.origin.x + frame.size.width) > (screenOrigin.x + screenSize.width))
+ {
+ /* the right side of the preview is off the screen, so shift to the left */
+ frame.origin.x = (screenOrigin.x + screenSize.width) - frame.size.width;
+ }
+
+ [[self window] setFrame:frame display:YES animate:YES];
+}
+
+- (IBAction) adjustSizingDisplay: (id) sender
+{
+ NSSize pictureSizingBoxSize = [fPictureSizeBox frame].size;
+
+ NSPoint fPictureSizeBoxOrigin = [fPictureSizeBox frame].origin;
+ NSSize pictureCropBoxSize = [fPictureCropBox frame].size;
+ NSPoint fPictureCropBoxOrigin = [fPictureCropBox frame].origin;
+
+ if ([fAnamorphicPopUp indexOfSelectedItem] == 3) // custom / power user jamboree
+ {
+ pictureSizingBoxSize.width = 530;
+
+ /* Set visibility of capuj widgets */
+ [fParWidthField setHidden: NO];
+ [fParHeightField setHidden: NO];
+ [fParWidthLabel setHidden: NO];
+ [fParHeightLabel setHidden: NO];
+ [fDisplayWidthField setHidden: NO];
+ [fDisplayWidthLabel setHidden: NO];
+ [fModulusLabel setHidden: NO];
+ [fModulusPopUp setHidden: NO];
+ /* adjust/move keep ar checkbox */
+ [fRatioLabel setHidden: YES];
+ [fRatioLabel2 setHidden: NO];
+
+ /* Optionally swith the Storage and Display width positions*/
+ /*
+ NSPoint fWidthLabelOrigin = [fWidthLabel frame].origin;
+ NSPoint fWidthFieldOrigin = [fWidthField frame].origin;
+ NSPoint fWidthStepperOrigin = [fWidthStepper frame].origin;
+ fWidthFieldOrigin.x = [fRatioLabel2 frame].origin.x + [fRatioLabel2 frame].size.width + 4;
+ [fWidthField setFrameOrigin:fWidthFieldOrigin];
+
+ fWidthStepperOrigin.x = [fWidthField frame].origin.x + [fWidthField frame].size.width + 4;
+ [fWidthStepper setFrameOrigin:fWidthStepperOrigin];
+
+ fWidthLabelOrigin.x = [fWidthField frame].origin.x - [fWidthLabel frame].size.width - 4;
+ [fWidthLabel setFrameOrigin:fWidthLabelOrigin];
+ [fWidthLabel setStringValue:@"Storage Width:"];
+ */
+
+ /* set the origin for fRatioCheck so origin.y == fRatioLabel2
+ * and origin.x == fDisplayWidthField
+ */
+ NSPoint fRatioCheckOrigin = [fRatioCheck frame].origin;
+ fRatioCheckOrigin.y = [fRatioLabel2 frame].origin.y - 2;
+ fRatioCheckOrigin.x = [fRatioLabel2 frame].origin.x + [fRatioLabel2 frame].size.width + 4;
+ [fRatioCheck setFrameOrigin:fRatioCheckOrigin];
+
+ }
+ else
+ {
+ pictureSizingBoxSize.width = 200;
+
+ /* Set visibility of capuj widgets */
+ [fParWidthField setHidden: YES];
+ [fParHeightField setHidden: YES];
+ [fParWidthLabel setHidden: YES];
+ [fParHeightLabel setHidden: YES];
+ [fDisplayWidthField setHidden: YES];
+ [fDisplayWidthLabel setHidden: YES];
+ [fModulusLabel setHidden: YES];
+ [fModulusPopUp setHidden: YES];
+ /* adjust/move keep ar checkbox */
+ [fRatioLabel setHidden: NO];
+ [fRatioLabel2 setHidden: YES];
+
+ /* Optionally swith the Storage and Display width positions*/
+
+ /*
+ NSPoint fWidthLabelOrigin = [fWidthLabel frame].origin;
+ NSPoint fWidthFieldOrigin = [fWidthField frame].origin;
+ NSPoint fWidthStepperOrigin = [fWidthStepper frame].origin;
+
+ fWidthFieldOrigin.x = [fHeightField frame].origin.x;
+ [fWidthField setFrameOrigin:fWidthFieldOrigin];
+
+ fWidthStepperOrigin.x = [fHeightStepper frame].origin.x;
+ [fWidthStepper setFrameOrigin:fWidthStepperOrigin];
+
+ fWidthLabelOrigin.x = [fWidthField frame].origin.x - [fWidthLabel frame].size.width -4;
+ [fWidthLabel setFrameOrigin:fWidthLabelOrigin];
+ [fWidthLabel setStringValue:@"Width:"];
+ */
+
+
+ /* set the origin for fRatioCheck so origin.y == fRatioLabel
+ * and origin.x == fWidthStepper
+ */
+ NSPoint fRatioCheckOrigin = [fRatioCheck frame].origin;
+ fRatioCheckOrigin.y = [fRatioLabel frame].origin.y - 2;
+ fRatioCheckOrigin.x = [fWidthStepper frame].origin.x - 2;
+ [fRatioCheck setFrameOrigin:fRatioCheckOrigin];
+
+ }
+
+ /* Check to see if we have changed the size from current */
+ if (pictureSizingBoxSize.height != [fPictureSizeBox frame].size.height || pictureSizingBoxSize.width != [fPictureSizeBox frame].size.width)
+ {
+ /* Get our delta for the change in picture size box height */
+ CGFloat deltaYSizeBoxShift = pictureSizingBoxSize.height - [fPictureSizeBox frame].size.height;
+ fPictureSizeBoxOrigin.y -= deltaYSizeBoxShift;
+ /* Get our delta for the change in picture size box width */
+ CGFloat deltaXSizeBoxShift = pictureSizingBoxSize.width - [fPictureSizeBox frame].size.width;
+ //fPictureSizeBoxOrigin.x += deltaXSizeBoxShift;
+ /* set our new Picture size box size */
+ [fPictureSizeBox setFrameSize:pictureSizingBoxSize];
+ [fPictureSizeBox setFrameOrigin:fPictureSizeBoxOrigin];
+
+ pictureCropBoxSize.height += deltaYSizeBoxShift;
+ fPictureCropBoxOrigin.y -= deltaYSizeBoxShift;
+ fPictureCropBoxOrigin.x += deltaXSizeBoxShift;
+
+ [fPictureCropBox setFrameSize:pictureCropBoxSize];
+ [[fPictureCropBox animator] setFrameOrigin:fPictureCropBoxOrigin];
+ }
+
+
+ /* now we call to resize the entire inspector window */
+ [self resizeInspectorForTab:nil];
+}
+
+- (IBAction) adjustFilterDisplay: (id) sender
{
- hb_stop(fPreviewLibhb);
- if (fPreviewMoviePath)
+
+ NSBox * filterBox = nil;
+ NSTextField * filterField;
+ if (sender == fDetelecinePopUp)
+ {
+ filterBox = fDetelecineBox;
+ filterField = fDetelecineField;
+ }
+
+ if (sender == fDecombDeinterlaceSlider)
+ {
+ if ([fDecombDeinterlaceSlider floatValue] == 0.0)
+ {
+ filterBox = fDecombBox;
+ filterField = fDecombField;
+ }
+ else
+ {
+ filterBox = fDeinterlaceBox;
+ filterField = fDeinterlaceField;
+ }
+ }
+
+ 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;
+ NSRect boxFrame = [filterBox frame];
+
+ if ([sender titleOfSelectedItem] == @"Custom")
+ {
+
+ currentSize.height = 60;
+
+ }
+ else
{
- [[NSFileManager defaultManager] removeFileAtPath:fPreviewMoviePath handler:nil];
- [fPreviewMoviePath release];
- }
+ 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 boxOrigin = [filterBox frame].origin;
+ /* We get the deltaY here for how much we are expanding/contracting the box vertically */
+ CGFloat deltaYBoxShift = currentSize.height - [filterBox frame].size.height;
+ boxOrigin.y -= deltaYBoxShift;
+
+ boxFrame.size.height = currentSize.height;
+ boxFrame.origin.y = boxOrigin.y;
+ [filterBox setFrame:boxFrame];
+
+ /* go ahead and resize the box */
+ //[[filterBox animator] setFrameSize:currentSize];
+ //[[filterBox animator] setFrameOrigin:origin];
+
+
+ if (filterBox == fDecombBox || filterBox == fDeinterlaceBox)
+ {
+ /* fDecombDeinterlaceBox*/
+ NSSize decombDeinterlaceBoxSize = [fDecombDeinterlaceBox frame].size;
+ NSPoint decombDeinterlaceBoxOrigin = [fDecombDeinterlaceBox frame].origin;
+
+ //decombDeinterlaceBoxSize.height = [filterBox frame].size.height + 50;
+ if (sender == fDecombDeinterlaceSlider)
+ {
+ [fHBController writeToActivityLog: "Sender is deinterlace decomb slider"];
+ }
+
+ if ([fDeinterlaceBox isHidden] == YES)
+ {
+ decombDeinterlaceBoxSize.height = [fDecombBox frame].size.height + 50;
+ [fHBController writeToActivityLog: "Resize by Decomb box"];
+ }
+ else
+ {
+ decombDeinterlaceBoxSize.height = [fDeinterlaceBox frame].size.height + 50;
+ [fHBController writeToActivityLog: "Resize by Deinterlace box"];
+ }
+ /* get delta's for the change in window size */
+
+ CGFloat deltaYdecombDeinterlace = decombDeinterlaceBoxSize.height - [fDecombDeinterlaceBox frame].size.height;
+
+ deltaYBoxShift = deltaYdecombDeinterlace;
+
+ decombDeinterlaceBoxOrigin.y -= deltaYdecombDeinterlace;
+
+ [fDecombDeinterlaceBox setFrameSize:decombDeinterlaceBoxSize];
+ [fDecombDeinterlaceBox setFrameOrigin:decombDeinterlaceBoxOrigin];
+ }
+
+ /* now we must reset the origin of each box below the adjusted box*/
+ NSPoint decombDeintOrigin = [fDecombDeinterlaceBox frame].origin;
+ NSPoint denoiseOrigin = [fDenoiseBox frame].origin;
+ NSPoint deblockOrigin = [fDeblockBox frame].origin;
+ if (sender == fDetelecinePopUp)
+ {
+ decombDeintOrigin.y -= deltaYBoxShift;
+ [fDecombDeinterlaceBox setFrameOrigin:decombDeintOrigin];
+
+ denoiseOrigin.y -= deltaYBoxShift;
+ [fDenoiseBox setFrameOrigin:denoiseOrigin];
+
+ deblockOrigin.y -= deltaYBoxShift;
+ [fDeblockBox setFrameOrigin:deblockOrigin];
+ }
+ if (sender == fDecombPopUp || sender == fDeinterlacePopUp)
+ {
+ denoiseOrigin.y -= deltaYBoxShift;
+ [fDenoiseBox setFrameOrigin:denoiseOrigin];
+
+ deblockOrigin.y -= deltaYBoxShift;
+ [fDeblockBox setFrameOrigin:deblockOrigin];
+ }
+
+ if (sender == fDenoisePopUp)
+ {
+ deblockOrigin.y -= deltaYBoxShift;
+ [fDeblockBox setFrameOrigin:deblockOrigin];
+ }
+
+ /* now we call to resize the entire inspector window */
+ [self resizeInspectorForTab:nil];
+ }
+
+}
+
+
+#pragma mark -
+
+- (IBAction) previewGoWindowed: (id)sender
+{
+ [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];
+}
+
+- (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];
+}
+
+- (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];
- [fLibhbTimer invalidate];
- [fLibhbTimer release];
+ /* Setup our layers for core animation */
+ [fSizeFilterView setWantsLayer:YES];
+ [fPictureSizeBox setWantsLayer:YES];
+ [fPictureCropBox setWantsLayer:YES];
- [fPicturePreviews release];
+}
+
+
+- (void)windowWillClose:(NSNotification *)aNotification
+{
+[[NSUserDefaults standardUserDefaults] setBool:NO forKey:@"PictureSizeWindowIsOpen"];
+}
+
+- (BOOL)windowShouldClose:(id)fPictureWindow
+{
+ return YES;
+}
+
+- (void) dealloc
+{
+ [fPreviewController release];
[super dealloc];
}
{
fHandle = handle;
+ [fPreviewController SetHandle: fHandle];
+}
+
+- (void) SetTitle: (hb_title_t *) title
+{
+ hb_job_t * job = title->job;
+
+ fTitle = title;
+
[fWidthStepper setValueWraps: NO];
[fWidthStepper setIncrement: 16];
[fWidthStepper setMinValue: 64];
[fCropRightStepper setIncrement: 2];
[fCropRightStepper setMinValue: 0];
- /* we set the preview length popup in seconds */
- [fPreviewMovieLengthPopUp removeAllItems];
- [fPreviewMovieLengthPopUp addItemWithTitle: @"5"];
- [fPreviewMovieLengthPopUp addItemWithTitle: @"10"];
- [fPreviewMovieLengthPopUp addItemWithTitle: @"15"];
- [fPreviewMovieLengthPopUp addItemWithTitle: @"20"];
- [fPreviewMovieLengthPopUp addItemWithTitle: @"25"];
- [fPreviewMovieLengthPopUp addItemWithTitle: @"30"];
- [fPreviewMovieLengthPopUp addItemWithTitle: @"35"];
- [fPreviewMovieLengthPopUp addItemWithTitle: @"40"];
- [fPreviewMovieLengthPopUp addItemWithTitle: @"45"];
- [fPreviewMovieLengthPopUp addItemWithTitle: @"50"];
- [fPreviewMovieLengthPopUp addItemWithTitle: @"55"];
- [fPreviewMovieLengthPopUp addItemWithTitle: @"60"];
-
- if ([[NSUserDefaults standardUserDefaults] objectForKey:@"PreviewLength"])
- {
- [fPreviewMovieLengthPopUp selectItemWithTitle:[[NSUserDefaults standardUserDefaults] objectForKey:@"PreviewLength"]];
- }
- else
- {
- /* currently hard set default to 10 seconds */
- [fPreviewMovieLengthPopUp selectItemAtIndex: 1];
- }
-}
-
-- (void) SetTitle: (hb_title_t *) title
-{
- hb_job_t * job = title->job;
-
- fTitle = title;
-
[fWidthStepper setMaxValue: title->width];
[fWidthStepper setIntValue: job->width];
[fWidthField setIntValue: job->width];
{
[fAnamorphicPopUp addItemWithTitle: @"Loose"];
}
- [fAnamorphicPopUp selectItemAtIndex: job->pixel_ratio];
+ [fAnamorphicPopUp addItemWithTitle: @"Custom"];
+ [fAnamorphicPopUp selectItemAtIndex: job->anamorphic.mode];
+
+ //[self adjustSizingDisplay:nil];
+
+ /* populate the modulus popup here */
+ [fModulusPopUp removeAllItems];
+ [fModulusPopUp addItemWithTitle: @"16"];
+ [fModulusPopUp addItemWithTitle: @"8"];
+ [fModulusPopUp addItemWithTitle: @"4"];
+ [fModulusPopUp addItemWithTitle: @"2"];
+ if (job->anamorphic.mode == 3)
+ {
+ [fModulusPopUp selectItemWithTitle: [NSString stringWithFormat:@"%d",job->anamorphic.modulus]];
+ }
+ else
+ {
+ [fModulusPopUp selectItemWithTitle: @"16"];
+ }
/* We initially set the previous state of keep ar to on */
keepAspectRatioPreviousState = 1;
[fCropMatrix selectCellAtRow: 0 column:0];
}
- /* Set filters widgets according to the filters struct */
- [fDetelecineCheck setState:fPictureFilterSettings.detelecine];
+ /* Set filters widgets according to the filters struct */
+ [fDetelecinePopUp selectItemAtIndex:fPictureFilterSettings.detelecine];
+ [fDecombPopUp selectItemAtIndex:fPictureFilterSettings.decomb];
[fDeinterlacePopUp selectItemAtIndex: fPictureFilterSettings.deinterlace];
[fDenoisePopUp selectItemAtIndex: fPictureFilterSettings.denoise];
- [fDeblockCheck setState: fPictureFilterSettings.deblock];
+ [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];
+
+ titleDarWidth = job->anamorphic.dar_width;
+ titleDarHeight = job->anamorphic.dar_height;
+
+ titleParWidth = job->anamorphic.par_width;
+ titleParHeight = job->anamorphic.par_height;
+
[self SettingsChanged: nil];
}
-/* we use this to setup the initial picture filters upon first launch, after that their states
-are maintained across different sources */
-- (void) setInitialPictureFilters
+- (IBAction) storageLinkChanged: (id) sender
{
- /* we use a popup to show the deinterlace settings */
- [fDeinterlacePopUp removeAllItems];
- [fDeinterlacePopUp addItemWithTitle: @"None"];
- [fDeinterlacePopUp addItemWithTitle: @"Fast"];
- [fDeinterlacePopUp addItemWithTitle: @"Slow"];
- [fDeinterlacePopUp addItemWithTitle: @"Slower"];
-
- /* Set deinterlaces level according to the integer in the main window */
- [fDeinterlacePopUp selectItemAtIndex: fPictureFilterSettings.deinterlace];
+ /* since we have a tickless slider, make sure we are at 0.0 or 1.0 */
+ if ([fStorageLinkSlider floatValue] < 0.50)
+ {
+ [fStorageLinkSlider setFloatValue:0.0];
+ /* set slider labels to reflect choice */
+ [fStorageLinkParLabel setEnabled:YES];
+ [fStorageLinkDisplayLabel setEnabled:NO];
- /* we use a popup to show the denoise settings */
- [fDenoisePopUp removeAllItems];
- [fDenoisePopUp addItemWithTitle: @"None"];
- [fDenoisePopUp addItemWithTitle: @"Weak"];
- [fDenoisePopUp addItemWithTitle: @"Medium"];
- [fDenoisePopUp addItemWithTitle: @"Strong"];
- /* Set denoises level according to the integer in the main window */
- [fDenoisePopUp selectItemAtIndex: fPictureFilterSettings.denoise];
+ }
+ else
+ {
+ [fStorageLinkSlider setFloatValue:1.0];
+ /* set slider labels to reflect choice */
+ [fStorageLinkParLabel setEnabled:NO];
+ [fStorageLinkDisplayLabel setEnabled:YES];
+ }
- /* we use a popup to show the decomb settings */
- [fDecombPopUp removeAllItems];
- [fDecombPopUp addItemWithTitle: @"None"];
- [fDecombPopUp addItemWithTitle: @"Default"];
- [fDecombPopUp addItemWithTitle: @"Custom"];
- /* Set denoises level according to the integer in the main window */
- [fDecombPopUp selectItemAtIndex: fPictureFilterSettings.decomb];
-
}
-// Adjusts the window to draw the current picture (fPicture) adjusting its size as
-// necessary to display as much of the picture as possible.
-- (void) displayPreview
+- (IBAction) parLinkChanged: (id) sender
{
-
- /* lets make sure that the still picture view is not hidden and that
- * the movie preview is
- */
- [fMovieView pause:nil];
- [fMovieView setHidden:YES];
- [fMovieCreationProgressIndicator stopAnimation: nil];
- [fMovieCreationProgressIndicator setHidden: YES];
-
- [fPictureView setHidden:NO];
-
- [fPictureView setImage: [self imageForPicture: fPicture]];
-
- NSSize displaySize = NSMakeSize( ( CGFloat )fTitle->width, ( CGFloat )fTitle->height );
- /* Set the picture size display fields below the Preview Picture*/
- if( fTitle->job->pixel_ratio == 1 ) // Original PAR Implementation
- {
- output_width = fTitle->width-fTitle->job->crop[2]-fTitle->job->crop[3];
- output_height = fTitle->height-fTitle->job->crop[0]-fTitle->job->crop[1];
- display_width = output_width * fTitle->job->pixel_aspect_width / fTitle->job->pixel_aspect_height;
- [fInfoField setStringValue:[NSString stringWithFormat:
- @"Source: %dx%d, Output: %dx%d, Anamorphic: %dx%d",
- fTitle->width, fTitle->height, output_width, output_height, display_width, output_height]];
- displaySize.width *= ( ( CGFloat )fTitle->job->pixel_aspect_width ) / ( ( CGFloat )fTitle->job->pixel_aspect_height );
- }
- else if (fTitle->job->pixel_ratio == 2) // Loose Anamorphic
+ /* since we have a tickless slider, make sure we are at 0.0 or 1.0 */
+ if ([fParLinkSlider floatValue] < 0.50)
{
- display_width = output_width * output_par_width / output_par_height;
- [fInfoField setStringValue:[NSString stringWithFormat:
- @"Source: %dx%d, Output: %dx%d, Anamorphic: %dx%d",
- fTitle->width, fTitle->height, output_width, output_height, display_width, output_height]];
-
- displaySize.width = display_width;
+ [fParLinkSlider setFloatValue:0.0];
+ /* set slider labels to reflect choice */
+ [fParLinkStorageLabel setEnabled:YES];
+ [fParLinkDisplayLabel setEnabled:NO];
}
- else // No Anamorphic
+ else
{
- [fInfoField setStringValue: [NSString stringWithFormat:
- @"Source: %dx%d, Output: %dx%d", fTitle->width, fTitle->height,
- fTitle->job->width, fTitle->job->height]];
+ [fParLinkSlider setFloatValue:1.0];
+ /* set slider labels to reflect choice */
+ [fParLinkStorageLabel setEnabled:NO];
+ [fParLinkDisplayLabel setEnabled:YES];
}
+
+}
- NSSize viewSize = [self optimalViewSizeForImageSize:displaySize];
- if( [self viewNeedsToResizeToSize:viewSize] )
+- (IBAction) displayLinkChanged: (id) sender
+{
+ /* since we have a tickless slider, make sure we are at 0.0 or 1.0 */
+ if ([fDisplayLinkSlider floatValue] < 0.50)
{
- /* In the case of loose anamorphic, do not resize the window when scaling down */
- if (fTitle->job->pixel_ratio != 2 || [fWidthField intValue] == fTitle->width)
- {
- [self resizeSheetForViewSize:viewSize];
- [self setViewSize:viewSize];
- }
+ [fDisplayLinkSlider setFloatValue:0.0];
+ /* set slider labels to reflect choice */
+ [fDisplayLinkStorageLabel setEnabled:YES];
+ [fDisplayLinkParLabel setEnabled:NO];
}
-
- // Show the scaled text (use the height to check since the width can vary
- // with anamorphic video).
- if( ( ( int )viewSize.height ) != fTitle->height )
+ else
{
- CGFloat scale = viewSize.width / ( ( CGFloat ) fTitle->width );
- NSString *scaleString = [NSString stringWithFormat:
- NSLocalizedString( @" (Preview scaled to %.0f%% actual size)",
- @"String shown when a preview is scaled" ),
- scale * 100.0];
- [fInfoField setStringValue: [[fInfoField stringValue] stringByAppendingString:scaleString]];
+ [fDisplayLinkSlider setFloatValue:1.0];
+ /* set slider labels to reflect choice */
+ [fDisplayLinkStorageLabel setEnabled:NO];
+ [fDisplayLinkParLabel setEnabled:YES];
}
+
+}
-}
-
-- (IBAction) previewDurationPopUpChanged: (id) sender
+- (IBAction) SettingsChanged: (id) sender
{
+ hb_job_t * job = fTitle->job;
+ [fModulusPopUp setEnabled:NO];
+ job->anamorphic.modulus = 16;
-[[NSUserDefaults standardUserDefaults] setObject:[fPreviewMovieLengthPopUp titleOfSelectedItem] forKey:@"PreviewLength"];
-
-}
-
-
-
-- (IBAction) deblockSliderChanged: (id) sender
-{
- if ([fDeblockSlider floatValue] == 4.0)
- {
- [fDeblockField setStringValue: [NSString stringWithFormat: @"Off"]];
- }
- else
- {
- [fDeblockField setStringValue: [NSString stringWithFormat: @"%.0f", [fDeblockSlider floatValue]]];
- }
- [self SettingsChanged: sender];
-}
-
-- (IBAction) SettingsChanged: (id) sender
-{
- hb_job_t * job = fTitle->job;
+ /* Since custom anamorphic allows for a height setting > fTitle->height
+ * check to make sure it is returned to fTitle->height for all other modes
+ */
+ [fHeightStepper setMaxValue: fTitle->height];
autoCrop = ( [fCropMatrix selectedRow] == 0 );
[fCropTopStepper setEnabled: !autoCrop];
[fCropBottomStepper setEnabled: !autoCrop];
[fCropLeftStepper setEnabled: !autoCrop];
[fCropRightStepper setEnabled: !autoCrop];
-
+
if( autoCrop )
{
memcpy( job->crop, fTitle->crop, 4 * sizeof( int ) );
job->crop[3] = [fCropRightStepper intValue];
}
+ [fRatioCheck setEnabled: YES];
+
+
+ [fParWidthField setEnabled: NO];
+ [fParHeightField setEnabled: NO];
+ [fDisplayWidthField setEnabled: NO];
+
+ /* If we are not custom anamorphic, make sure we retain the orginal par */
+ if( [fAnamorphicPopUp indexOfSelectedItem] != 3 )
+ {
+ job->anamorphic.par_width = titleParWidth;
+ job->anamorphic.par_height = titleParHeight;
+ [fRatioLabel setHidden: NO];
+
+ [fWidthStepper setIncrement: 16];
+ [fHeightStepper setIncrement: 16];
+ }
+ else
+ {
+ [fWidthStepper setIncrement: [[fModulusPopUp titleOfSelectedItem] intValue]];
+ [fHeightStepper setIncrement: [[fModulusPopUp titleOfSelectedItem] intValue]];
+ }
+
if( [fAnamorphicPopUp indexOfSelectedItem] > 0 )
{
- if ([fAnamorphicPopUp indexOfSelectedItem] == 2) // Loose anamorphic
+ if ([fAnamorphicPopUp indexOfSelectedItem] == 1) // strict
{
- job->pixel_ratio = 2;
+ [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];
+ [fHeightStepper setEnabled: NO];
+ [fHeightField setEnabled: NO];
+ [fRatioCheck setEnabled: NO];
+ }
+ else if ([fAnamorphicPopUp indexOfSelectedItem] == 2) // Loose anamorphic
+ {
+ job->anamorphic.mode = 2;
[fWidthStepper setEnabled: YES];
[fWidthField setEnabled: YES];
+ [fRatioCheck setEnabled: NO];
+ [fHeightStepper setEnabled: NO];
+ [fHeightField setEnabled: NO];
/* 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
*/
job->height = [fHeightStepper intValue];
}
- else // must be "1" or strict anamorphic
+ else if ([fAnamorphicPopUp indexOfSelectedItem] == 3) // custom / power user jamboree
{
- [fWidthStepper setIntValue: fTitle->width-fTitle->job->crop[2]-fTitle->job->crop[3]];
- [fWidthField setIntValue: fTitle->width-fTitle->job->crop[2]-fTitle->job->crop[3]];
+
+#pragma mark - STARTCapuj
+
+ job->anamorphic.mode = 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];
+ /* Set the status of our custom ana only widgets accordingly */
+ /* for mod 3 we can use modulus other than 16 */
+ [fModulusPopUp setEnabled:YES];
+ job->anamorphic.modulus = [[fModulusPopUp titleOfSelectedItem] intValue];
- job->pixel_ratio = 1;
- [fWidthStepper setEnabled: NO];
- [fWidthField setEnabled: NO];
+ [fWidthStepper setEnabled: YES];
+ [fWidthField setEnabled: YES];
+
+ [fHeightStepper setEnabled: YES];
+ /* for capuj the storage field is immaterial */
+ [fHeightField setEnabled: YES];
+
+ [fRatioCheck setEnabled: YES];
+ if (sender == fRatioCheck)
+ {
+ if ([fRatioCheck state] == NSOnState)
+ {
+ [fParWidthField setEnabled: NO];
+ [fParHeightField setEnabled: NO];
+ }
+ else
+ {
+ [fParWidthField setEnabled: YES];
+ [fParHeightField setEnabled: YES];
+ }
+ }
+
+ [fParWidthField setEnabled: YES];
+ [fParHeightField setEnabled: YES];
+
+ [fDisplayWidthField setEnabled: YES];
+
+
+ /* If we are coming into custom anamorphic we reset the par to original
+ * which gives us a way back if things get hosed up.
+ */
+
+ if (sender == fAnamorphicPopUp)
+ {
+ /* When entering custom anamorphic, we start with keep ar on */
+ [fRatioCheck setState: NSOnState];
+ /*
+ KEEPING ASPECT RATIO
+ Disable editing: PIXEL WIDTH, PIXEL HEIGHT
+ */
+ [fParWidthField setEnabled: NO];
+ [fParHeightField setEnabled: NO];
+
+ job->width = [fWidthStepper intValue];
+ job->height = [fHeightStepper intValue];
+
+ /* make sure our par is set back to original */
+ job->anamorphic.par_width = titleParWidth;
+ job->anamorphic.par_height = titleParHeight;
+
+ [fParWidthField setIntValue: titleParWidth];
+ [fParHeightField setIntValue: titleParHeight];
+
+ /* modify our par dims from our storage dims */
+ hb_set_anamorphic_size(job, &output_width, &output_height, &output_par_width, &output_par_height);
+ float par_display_width = (float)output_width * (float)output_par_width / (float)output_par_height;
+
+ /* go ahead and mod the display dims */
+ [fDisplayWidthField setStringValue: [NSString stringWithFormat:@"%.2f", par_display_width]];
+
+ job->anamorphic.dar_width = [fDisplayWidthField floatValue];
+ job->anamorphic.dar_height = (float)[fHeightStepper intValue];
+
+ /* Set our dar here assuming we are just coming into capuj mode */
+ dar = [fDisplayWidthField floatValue] / (float)[fHeightField intValue];
+
+ }
+
+ /* For capuj we disable these fields if we are keeping the dispay aspect */
+ if ([fRatioCheck state] == NSOnState)
+ {
+ /*
+ KEEPING ASPECT RATIO
+ DAR = DISPLAY WIDTH / DISPLAY HEIGHT (cache after every modification) */
+ /*Disable editing: PIXEL WIDTH, PIXEL HEIGHT */
+
+ [fParWidthField setEnabled: NO];
+ [fParHeightField setEnabled: NO];
+
+ /* Changing DISPLAY WIDTH: */
+ if (sender == fDisplayWidthField)
+ {
+ job->anamorphic.dar_width = [fDisplayWidthField floatValue];
+ /* Changes HEIGHT to keep DAR */
+ /* calculate the height to retain the dar */
+ int raw_calulated_height = (int)((int)[fDisplayWidthField floatValue] / dar);
+ /* now use the modulus to go lower if there is a remainder */
+ /* Note to me, raw_calulated_height % [[fModulusPopUp titleOfSelectedItem] intValue]
+ * gives me the remainder we are not mod (whatever our modulus is) subtract that from
+ * the actual calculated value derived from the dar to round down to the nearest mod value.
+ * This should be desireable over rounding up to the next mod value
+ */
+ int modulus_height = raw_calulated_height - (raw_calulated_height % [[fModulusPopUp titleOfSelectedItem] intValue]);
+ if (modulus_height > fTitle->height)
+ {
+ [fHeightStepper setMaxValue: modulus_height];
+ }
+ [fHeightStepper setIntValue: modulus_height];
+ job->anamorphic.dar_height = (float)[fHeightStepper intValue];
+ job->height = [fHeightStepper intValue];
+
+ /* Changes PIXEL WIDTH to new DISPLAY WIDTH */
+ [fParWidthField setIntValue: [fDisplayWidthField intValue]];
+ job->anamorphic.par_width = [fParWidthField intValue];
+ /* Changes PIXEL HEIGHT to STORAGE WIDTH */
+ [fParHeightField setIntValue: [fWidthField intValue]];
+ job->anamorphic.par_height = [fParHeightField intValue];
+
+ }
+ /* Changing HEIGHT: */
+ if (sender == fHeightStepper)
+ {
+ job->anamorphic.dar_height = (float)[fHeightStepper intValue];
+ job->height = [fHeightStepper intValue];
+
+ /* Changes DISPLAY WIDTH to keep DAR*/
+ [fDisplayWidthField setStringValue: [NSString stringWithFormat: @"%.2f",[fHeightStepper intValue] * dar]];
+ job->anamorphic.dar_width = [fDisplayWidthField floatValue];
+ /* Changes PIXEL WIDTH to new DISPLAY WIDTH */
+ [fParWidthField setIntValue: [fDisplayWidthField intValue]];
+ job->anamorphic.par_width = [fParWidthField intValue];
+ /* Changes PIXEL HEIGHT to STORAGE WIDTH */
+ [fParHeightField setIntValue: [fWidthField intValue]];
+ job->anamorphic.par_height = [fParHeightField intValue];
+ }
+ /* Changing STORAGE_WIDTH: */
+ if (sender == fWidthStepper)
+ {
+ job->width = [fWidthStepper intValue];
+
+ job->anamorphic.dar_width = [fDisplayWidthField floatValue];
+ job->anamorphic.dar_height = [fHeightStepper floatValue];
+
+ /* Changes PIXEL WIDTH to DISPLAY WIDTH */
+ [fParWidthField setIntValue: [fDisplayWidthField intValue]];
+ job->anamorphic.par_width = [fParWidthField intValue];
+ /* Changes PIXEL HEIGHT to new STORAGE WIDTH */
+ [fParHeightField setIntValue: [fWidthStepper intValue]];
+ job->anamorphic.par_height = [fParHeightField intValue];
+ }
+ }
+ else if ([fRatioCheck state] == NSOffState)
+ {
+ /* Changing STORAGE_WIDTH: */
+ if (sender == fWidthStepper)
+ {
+ job->width = [fWidthStepper intValue];
+ /* changes DISPLAY WIDTH to STORAGE WIDTH * PIXEL WIDTH / PIXEL HEIGHT */
+ [fDisplayWidthField setStringValue: [NSString stringWithFormat: @"%.2f",(float)[fWidthStepper intValue] * [fParWidthField intValue] / [fParHeightField intValue]]];
+ job->anamorphic.dar_width = [fDisplayWidthField floatValue];
+ }
+ /* Changing PIXEL dimensions */
+ if (sender == fParWidthField || sender == fParHeightField)
+ {
+ job->anamorphic.par_width = [fParWidthField intValue];
+ job->anamorphic.par_height = [fParHeightField intValue];
+ /* changes DISPLAY WIDTH to STORAGE WIDTH * PIXEL WIDTH / PIXEL HEIGHT */
+ [fDisplayWidthField setStringValue: [NSString stringWithFormat: @"%.2f",(float)[fWidthStepper intValue] * [fParWidthField intValue] / [fParHeightField intValue]]];
+ job->anamorphic.dar_width = [fDisplayWidthField floatValue];
+ }
+ /* Changing DISPLAY WIDTH: */
+ if (sender == fDisplayWidthField)
+ {
+ job->anamorphic.dar_width = [fDisplayWidthField floatValue];
+ job->anamorphic.dar_height = (float)[fHeightStepper intValue];
+ /* changes PIXEL WIDTH to DISPLAY WIDTH and PIXEL HEIGHT to STORAGE WIDTH */
+ [fParWidthField setIntValue: [fDisplayWidthField intValue]];
+ job->anamorphic.par_width = [fParWidthField intValue];
+
+ [fParHeightField setIntValue: [fWidthField intValue]];
+ job->anamorphic.par_height = [fParHeightField intValue];
+ hb_set_anamorphic_size(job, &output_width, &output_height, &output_par_width, &output_par_height);
+ }
+ /* Changing HEIGHT: */
+ if (sender == fHeightStepper)
+ {
+ /* just....changes the height.*/
+ job->anamorphic.dar_height = [fHeightStepper intValue];
+ job->height = [fHeightStepper intValue];
+ }
+
+ }
+
+#pragma mark - END Capuj
}
/* if the sender is the Anamorphic checkbox, record the state
{
keepAspectRatioPreviousState = [fRatioCheck state];
}
- [fRatioCheck setState:NSOffState];
- [fRatioCheck setEnabled: NO];
-
-
- [fHeightStepper setEnabled: NO];
- [fHeightField setEnabled: NO];
+ if ([fAnamorphicPopUp indexOfSelectedItem] != 3)
+ {
+ [fRatioCheck setState:NSOffState];
+ }
}
else
{
job->width = [fWidthStepper intValue];
job->height = [fHeightStepper intValue];
- job->pixel_ratio = 0;
+ job->anamorphic.mode = 0;
[fWidthStepper setEnabled: YES];
[fWidthField setEnabled: YES];
[fHeightStepper setEnabled: YES];
}
- job->keep_ratio = ( [fRatioCheck state] == NSOnState );
+ //job->keep_ratio = ( [fRatioCheck state] == NSOnState );
- fPictureFilterSettings.deinterlace = [fDeinterlacePopUp indexOfSelectedItem];
- /* if the gui deinterlace settings are fast through slowest, the job->deinterlace
- value needs to be set to one, for the job as well as the previews showing deinterlacing
- otherwise set job->deinterlace to 0 or "off" */
- if (fPictureFilterSettings.deinterlace > 0)
+ if ([fAnamorphicPopUp indexOfSelectedItem] != 3)
{
- job->deinterlace = 1;
- }
- else
- {
- job->deinterlace = 0;
- }
- fPictureFilterSettings.denoise = [fDenoisePopUp indexOfSelectedItem];
-
- fPictureFilterSettings.detelecine = [fDetelecineCheck state];
-
- if ([fDeblockField stringValue] == @"Off")
- {
- fPictureFilterSettings.deblock = 0;
- }
- else
- {
- fPictureFilterSettings.deblock = [fDeblockField intValue];
- }
-
- fPictureFilterSettings.decomb = [fDecombPopUp indexOfSelectedItem];
-
- if( job->keep_ratio )
- {
- if( sender == fWidthStepper || sender == fRatioCheck ||
- sender == fCropTopStepper || sender == fCropBottomStepper )
+ job->keep_ratio = ( [fRatioCheck state] == NSOnState );
+ if( job->keep_ratio )
{
- hb_fix_aspect( job, HB_KEEP_WIDTH );
- if( job->height > fTitle->height )
+ if( sender == fWidthStepper || sender == fRatioCheck ||
+ sender == fCropTopStepper || sender == fCropBottomStepper )
{
- job->height = fTitle->height;
- hb_fix_aspect( job, HB_KEEP_HEIGHT );
+ hb_fix_aspect( job, HB_KEEP_WIDTH );
+ if( job->height > fTitle->height )
+ {
+ job->height = fTitle->height;
+ hb_fix_aspect( job, HB_KEEP_HEIGHT );
+ }
}
- }
- else
- {
- hb_fix_aspect( job, HB_KEEP_HEIGHT );
- if( job->width > fTitle->width )
+ else
{
- job->width = fTitle->width;
- hb_fix_aspect( job, HB_KEEP_WIDTH );
+ hb_fix_aspect( job, HB_KEEP_HEIGHT );
+ if( job->width > fTitle->width )
+ {
+ job->width = fTitle->width;
+ hb_fix_aspect( job, HB_KEEP_WIDTH );
+ }
}
+
}
- // hb_get_preview can't handle sizes that are larger than the original title
+ }
+
+ // hb_get_preview can't handle sizes that are larger than the original title
+ if ([fAnamorphicPopUp indexOfSelectedItem] != 3)
+ {
// 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];
- if( [fAnamorphicPopUp indexOfSelectedItem] < 2 )
- {
+ if( [fAnamorphicPopUp indexOfSelectedItem] != 2) // if we are not loose or custom
+ {
[fHeightStepper setIntValue: job->height];
[fHeightField setIntValue: job->height];
}
+
[fCropTopStepper setIntValue: job->crop[0]];
[fCropTopField setIntValue: job->crop[0]];
[fCropBottomStepper setIntValue: job->crop[1]];
[fCropLeftField setIntValue: job->crop[2]];
[fCropRightStepper setIntValue: job->crop[3]];
[fCropRightField setIntValue: job->crop[3]];
+
+ //[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)
+ {
+ [self reloadStillPreview];
+ }
+
+ /* we get the sizing info to display from fPreviewController */
+ [fSizeInfoField setStringValue: [fPreviewController pictureSizeInfoString]];
+
+ if (sender != nil)
+ {
+ [fHBController pictureSettingsDidChange];
+ }
+
+ if ([[self window] isVisible])
+ {
+ [self adjustSizingDisplay:nil];
+ }
+
+}
+
+- (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
// Purge the existing picture previews so they get recreated the next time
// they are needed.
- [self purgeImageCache];
+ // [fPreviewController purgeImageCache];
/* We actually call displayPreview now from pictureSliderChanged which keeps
* our picture preview slider in sync with the previews being shown
*/
- //[self displayPreview];
- [self pictureSliderChanged:nil];
+ //[fPreviewController pictureSliderChanged:nil];
}
-
- if (sender != nil)
- {
- if ([delegate respondsToSelector:@selector(pictureSettingsDidChange)])
- [delegate pictureSettingsDidChange];
- }
}
-- (IBAction) pictureSliderChanged: (id) sender
+
+#pragma mark -
+
+- (BOOL) autoCrop
{
- // Show the picture view
- [fCreatePreviewMovieButton setTitle: @"Live Preview"];
- [fPictureView setHidden:NO];
- [fMovieView pause:nil];
- [fMovieView setHidden:YES];
- [fPreviewMovieStatusField setHidden: YES];
-
- int newPicture = [fPictureSlider intValue];
- if (newPicture != fPicture)
- {
- fPicture = newPicture;
- }
- [self displayPreview];
-
+ return autoCrop;
+}
+- (void) setAutoCrop: (BOOL) setting
+{
+ autoCrop = setting;
}
-#pragma mark Movie Preview
-- (IBAction) createMoviePreview: (id) sender
+- (BOOL) allowLooseAnamorphic
+{
+ return allowLooseAnamorphic;
+}
+
+- (void) setAllowLooseAnamorphic: (BOOL) setting
{
- /* Lets make sure the still picture previews are showing in case
- * there is currently a movie showing */
- [self pictureSliderChanged:nil];
+ allowLooseAnamorphic = setting;
+}
+
+- (IBAction)showPreviewPanel: (id)sender forTitle: (hb_title_t *)title
+{
+ //[self SetTitle:title];
+ [self showWindow:sender];
+ //[self adjustSizingDisplay:nil];
+ //[self adjustFilterDisplay:nil];
+
+}
+
+
+#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];
- /* Rip or Cancel ? */
- hb_state_t s;
- hb_get_state2( fPreviewLibhb, &s );
+ [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];
- if(s.state == HB_STATE_WORKING || s.state == HB_STATE_PAUSED)
- {
-
- play_movie = NO;
- hb_stop( fPreviewLibhb );
- [fPictureView setHidden:NO];
- [fMovieView pause:nil];
- [fMovieView setHidden:YES];
- [fPictureSlider setHidden:NO];
- [fCreatePreviewMovieButton setTitle: @"Live Preview"];
- return;
- }
+ /* 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"];
- /* we use controller.mm's prepareJobForPreview to go ahead and set all of our settings
- * however, we want to use a temporary destination field of course
- * so that we do not put our temp preview in the users chosen
- * directory */
+ /* 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];
- hb_job_t * job = fTitle->job;
- /* We run our current setting through prepeareJob in Controller.mm
- * just as if it were a regular encode */
- if ([delegate respondsToSelector:@selector(prepareJobForPreview)])
- {
- [delegate prepareJobForPreview];
- }
+
+}
+
+
+
+
+- (IBAction) modeDecombDeinterlaceSliderChanged: (id) sender
+{
- /* Destination file. We set this to our preview directory
- * changing the extension appropriately.*/
- if (fTitle->job->mux == HB_MUX_MP4) // MP4 file
- {
- /* we use .m4v for our mp4 files so that ac3 and chapters in mp4 will play properly */
- fPreviewMoviePath = @"~/Library/Application Support/HandBrake/Previews/preview_temp.m4v";
- }
- else if (fTitle->job->mux == HB_MUX_MKV) // MKV file
+ /* since its a tickless slider, we have to make sure we are on or off */
+ if ([fDecombDeinterlaceSlider floatValue] < 0.50)
{
- fPreviewMoviePath = @"~/Library/Application Support/HandBrake/Previews/preview_temp.mkv";
+ [fDecombDeinterlaceSlider setFloatValue:0.0];
}
- else if (fTitle->job->mux == HB_MUX_AVI) // AVI file
- {
- fPreviewMoviePath = @"~/Library/Application Support/HandBrake/Previews/preview_temp.avi";
- }
- else if (fTitle->job->mux == HB_MUX_OGM) // OGM file
+ else
{
- fPreviewMoviePath = @"~/Library/Application Support/HandBrake/Previews/preview_temp.ogm";
+ [fDecombDeinterlaceSlider setFloatValue:1.0];
}
- fPreviewMoviePath = [[fPreviewMoviePath stringByExpandingTildeInPath]retain];
- /* See if there is an existing preview file, if so, delete it */
- if( ![[NSFileManager defaultManager] fileExistsAtPath:fPreviewMoviePath] )
+ /* Decomb selected*/
+ if ([fDecombDeinterlaceSlider floatValue] == 0.0)
{
- [[NSFileManager defaultManager] removeFileAtPath:fPreviewMoviePath
- handler:nil];
+ [fDecombBox setHidden:NO];
+ [fDeinterlaceBox setHidden:YES];
+ fPictureFilterSettings.decomb = [fDecombPopUp indexOfSelectedItem];
+ fPictureFilterSettings.usedecomb = 1;
+ fPictureFilterSettings.deinterlace = 0;
+ [fDecombPopUp selectItemAtIndex:fPictureFilterSettings.decomb];
+ [self adjustFilterDisplay:fDecombPopUp];
}
+ else
+ {
+ [fDecombBox setHidden:YES];
+ [fDeinterlaceBox setHidden:NO];
+ fPictureFilterSettings.usedecomb = 0;
+ fPictureFilterSettings.decomb = 0;
+ [fDeinterlacePopUp selectItemAtIndex: fPictureFilterSettings.deinterlace];
+ [self adjustFilterDisplay:fDeinterlacePopUp];
+ }
+ [self FilterSettingsChanged: fDecombDeinterlaceSlider];
+}
+
+
+- (IBAction) FilterSettingsChanged: (id) sender
+{
- /* We now direct our preview encode to fPreviewMoviePath */
- fTitle->job->file = [fPreviewMoviePath UTF8String];
-
- job->start_at_preview = fPicture + 1;
-
- /* we use the preview duration popup to get the specified
- * number of seconds for the preview encode.
- */
-
- job->pts_to_stop = [[fPreviewMovieLengthPopUp titleOfSelectedItem] intValue] * 90000LL;
-
- /* lets go ahead and send it off to libhb
- * Note: unlike a full encode, we only send 1 pass regardless if the final encode calls for 2 passes.
- * this should suffice for a fairly accurate short preview and cuts our preview generation time in half.
- */
- hb_add( fPreviewLibhb, job );
-
- [fPictureSlider setHidden:YES];
- [fMovieCreationProgressIndicator setHidden: NO];
- [fPreviewMovieStatusField setHidden: NO];
- [self startReceivingLibhbNotifications];
+ fPictureFilterSettings.detelecine = [fDetelecinePopUp indexOfSelectedItem];
+ [self adjustFilterDisplay:fDetelecinePopUp];
+ fPictureFilterSettings.decomb = [fDecombPopUp indexOfSelectedItem];
+ [self adjustFilterDisplay:fDecombPopUp];
- [fCreatePreviewMovieButton setTitle: @"Cancel Preview"];
+ fPictureFilterSettings.deinterlace = [fDeinterlacePopUp indexOfSelectedItem];
+ [self adjustFilterDisplay:fDeinterlacePopUp];
- play_movie = YES;
+ fPictureFilterSettings.denoise = [fDenoisePopUp indexOfSelectedItem];
+ [self adjustFilterDisplay:fDenoisePopUp];
- /* Let fPreviewLibhb do the job */
- hb_start( fPreviewLibhb );
-
-}
-
-- (void) startReceivingLibhbNotifications
-{
- if (!fLibhbTimer)
+ if ([fDeblockField stringValue] == @"Off")
{
- fLibhbTimer = [NSTimer scheduledTimerWithTimeInterval:0.5 target:self selector:@selector(libhbTimerFired:) userInfo:nil repeats:YES];
- [fLibhbTimer retain];
+ fPictureFilterSettings.deblock = 0;
}
-}
-
-- (void) stopReceivingLibhbNotifications
-{
- if (fLibhbTimer)
+ else
{
- [fLibhbTimer invalidate];
- [fLibhbTimer release];
- fLibhbTimer = nil;
+ fPictureFilterSettings.deblock = [fDeblockField intValue];
}
-}
-- (void) libhbTimerFired: (NSTimer*)theTimer
-{
- hb_state_t s;
- hb_get_state( fPreviewLibhb, &s );
- [self libhbStateChanged: s];
-}
-- (void) libhbStateChanged: (hb_state_t &)state
-{
- switch( state.state )
+
+ fPictureFilterSettings.grayscale = [fGrayscaleCheck state];
+
+ if (sender != nil)
{
- case HB_STATE_IDLE:
- case HB_STATE_SCANNING:
- case HB_STATE_SCANDONE:
- break;
-
- case HB_STATE_WORKING:
- {
-#define p state.param.working
-
- NSMutableString * string;
- /* Update text field */
- string = [NSMutableString stringWithFormat: NSLocalizedString( @"Encoding %d seconds of preview %d: %.2f %%", @"" ), [[fPreviewMovieLengthPopUp titleOfSelectedItem] intValue], fPicture + 1, 100.0 * p.progress];
-
- if( p.seconds > -1 )
- {
- [string appendFormat:
- NSLocalizedString( @" (%.2f fps, avg %.2f fps, ETA %02dh%02dm%02ds)", @"" ),
- p.rate_cur, p.rate_avg, p.hours, p.minutes, p.seconds];
- }
- [fPreviewMovieStatusField setStringValue: string];
-
- [fMovieCreationProgressIndicator setIndeterminate: NO];
- /* Update slider */
- [fMovieCreationProgressIndicator setDoubleValue: 100.0 * p.progress];
-
- [fCreatePreviewMovieButton setTitle: @"Cancel Preview"];
-
- break;
-
- }
-#undef p
-
-#define p state.param.muxing
- case HB_STATE_MUXING:
- {
- // Update fMovieCreationProgressIndicator
- [fMovieCreationProgressIndicator setIndeterminate: YES];
- [fMovieCreationProgressIndicator startAnimation: nil];
- [fPreviewMovieStatusField setStringValue: [NSString stringWithFormat:
- NSLocalizedString( @"Muxing Preview ...", @"" )]];
- break;
- }
-#undef p
- case HB_STATE_PAUSED:
- [fMovieCreationProgressIndicator stopAnimation: nil];
- break;
-
- case HB_STATE_WORKDONE:
- {
- // Delete all remaining jobs since libhb doesn't do this on its own.
- hb_job_t * job;
- while( ( job = hb_job(fPreviewLibhb, 0) ) )
- hb_rem( fHandle, job );
-
- [self stopReceivingLibhbNotifications];
- [fPreviewMovieStatusField setStringValue: @""];
- [fPreviewMovieStatusField setHidden: YES];
-
- [fMovieCreationProgressIndicator stopAnimation: nil];
- [fMovieCreationProgressIndicator setHidden: YES];
- /* we make sure the picture slider and preview match */
- [self pictureSliderChanged:nil];
- [fPictureSlider setHidden:NO];
-
- // Show the movie view
- if (play_movie)
- {
- [self showMoviePreview:fPreviewMoviePath];
- }
-
- [fCreatePreviewMovieButton setTitle: @"Live Preview"];
-
-
- break;
- }
- }
-
+ [fHBController pictureSettingsDidChange];
+
+ }
+
}
-- (IBAction) showMoviePreview: (NSString *) path
+
+#pragma mark -
+
+- (IBAction) deblockSliderChanged: (id) sender
{
- /* Since the gray background for the still images is part of
- * fPictureView, lets leave the picture view visible and postion
- * the fMovieView over the image portion of fPictureView so
- * we retain the gray cropping border we have already established
- * with the still previews
- */
- [fMovieView setHidden:NO];
-
- /* Load the new movie into fMovieView */
- QTMovie * aMovie;
- NSRect movieBounds;
- if (path)
+ if ([fDeblockSlider floatValue] == 4.0)
{
- [fMovieView setControllerVisible: YES];
- /* let's make sure there is no movie currently set */
- [fMovieView setMovie:nil];
-
- aMovie = [QTMovie movieWithFile:path error:nil];
-
- /* we get some size information from the preview movie */
- Rect movieBox;
- GetMovieBox ([aMovie quickTimeMovie], &movieBox);
- movieBounds = [fMovieView movieBounds];
- movieBounds.size.height = movieBox.bottom - movieBox.top;
-
- if ([fMovieView isControllerVisible])
- movieBounds.size.height += [fMovieView controllerBarHeight];
- /* since for whatever the reason I cannot seem to get the [fMovieView controllerBarHeight]
- * For now just use 15 for additional height as it seems to line up well
- */
- movieBounds.size.height += 15;
-
- movieBounds.size.width = movieBox.right - movieBox.left;
-
- /* We need to find out if the preview movie needs to be scaled down so
- * that it doesn't overflow our available viewing container (just like for image
- * in -displayPreview) for HD sources, etc. [fPictureViewArea frame].size.height*/
- if( ((int)movieBounds.size.height) > [fPictureView frame].size.height )
- {
- /* The preview movie would be larger than the available viewing area
- * in the preview movie, so we go ahead and scale it down to the same size
- * as the still preview or we readjust our window to allow for the added height if need be
- */
- NSSize displaySize = NSMakeSize( (float)movieBounds.size.width, (float)movieBounds.size.height );
- //NSSize displaySize = NSMakeSize( (float)fTitle->width, (float)fTitle->height );
- NSSize viewSize = [self optimalViewSizeForImageSize:displaySize];
- if( [self viewNeedsToResizeToSize:viewSize] )
- {
-
- [self resizeSheetForViewSize:viewSize];
- [self setViewSize:viewSize];
-
- }
-
- [fMovieView setFrameSize:viewSize];
- }
- else
- {
- /* Since the preview movie is smaller than the available viewing area
- * we can go ahead and use the preview movies native size */
- [fMovieView setFrameSize:movieBounds.size];
- }
-
- // lets reposition the movie if need be
- NSPoint origin = [fPictureViewArea frame].origin;
- origin.x += trunc(([fPictureViewArea frame].size.width -
- [fMovieView frame].size.width) / 2.0);
- /* Since we are adding 15 to the height to allow for the controller bar
- * we need to subtract half of that for the origin.y to get the controller bar
- * below the movie to it lines up vertically with where our still preview was
- */
- origin.y += trunc((([fPictureViewArea frame].size.height -
- [fMovieView frame].size.height) / 2.0) - 7.5);
- [fMovieView setFrameOrigin:origin];
-
- [fMovieView setMovie:aMovie];
- /// to actually play the movie
- [fMovieView play:aMovie];
+ [fDeblockField setStringValue: [NSString stringWithFormat: @"Off"]];
}
else
{
- aMovie = nil;
- }
-
+ [fDeblockField setStringValue: [NSString stringWithFormat: @"%.0f", [fDeblockSlider floatValue]]];
+ }
+ [self FilterSettingsChanged: sender];
}
-#pragma mark -
-- (IBAction) ClosePanel: (id) sender
+- (int) detelecine
{
- if ([delegate respondsToSelector:@selector(pictureSettingsDidChange)])
- [delegate pictureSettingsDidChange];
-
- [NSApp endSheet:[self window]];
- [[self window] orderOut:self];
+ return fPictureFilterSettings.detelecine;
}
-- (BOOL) autoCrop
+- (NSString*) detelecineCustomString
{
- return autoCrop;
-}
-- (void) setAutoCrop: (BOOL) setting
-{
- autoCrop = setting;
+ return [fDetelecineField stringValue];
}
-- (BOOL) allowLooseAnamorphic
+- (void) setDetelecine: (int) setting
{
- return allowLooseAnamorphic;
+ fPictureFilterSettings.detelecine = setting;
}
-- (void) setAllowLooseAnamorphic: (BOOL) setting
+- (void) setDetelecineCustomString: (NSString*) string
{
- allowLooseAnamorphic = setting;
+ [fDetelecineField setStringValue:string];
}
-- (int) detelecine
+- (int) deinterlace
{
- return fPictureFilterSettings.detelecine;
+ return fPictureFilterSettings.deinterlace;
}
-
-- (void) setDetelecine: (int) setting
+- (NSString*) deinterlaceCustomString
{
- fPictureFilterSettings.detelecine = setting;
+ return [fDeinterlaceField stringValue];
}
-- (int) deinterlace
+- (void) setDeinterlaceCustomString: (NSString*) string
{
- return fPictureFilterSettings.deinterlace;
+ [fDeinterlaceField setStringValue:string];
}
-- (void) setDeinterlace: (int) setting {
+- (void) setDeinterlace: (int) setting
+{
fPictureFilterSettings.deinterlace = setting;
}
- (int) decomb
return fPictureFilterSettings.decomb;
}
-- (void) setDecomb: (int) setting {
- fPictureFilterSettings.decomb = setting;
-}
-- (int) denoise
+- (NSString*) decombCustomString
{
- return fPictureFilterSettings.denoise;
+ return [fDecombField stringValue];
}
-- (void) setDenoise: (int) setting
+- (int) useDecomb
{
- fPictureFilterSettings.denoise = setting;
+ return fPictureFilterSettings.usedecomb;
}
-- (int) deblock
+- (void) setUseDecomb: (int) setting
{
- return fPictureFilterSettings.deblock;
+ fPictureFilterSettings.usedecomb = setting;
+ if (fPictureFilterSettings.usedecomb == 1)
+ {
+ [fDecombDeinterlaceSlider setFloatValue:0.0];
+ }
+ else
+ {
+ [fDecombDeinterlaceSlider setFloatValue:1.0];
+ }
+ [self modeDecombDeinterlaceSliderChanged:nil];
}
-- (void) setDeblock: (int) setting
-{
- fPictureFilterSettings.deblock = setting;
+- (void) setDecomb: (int) setting {
+ fPictureFilterSettings.decomb = setting;
}
-- (IBAction)showPreviewPanel: (id)sender forTitle: (hb_title_t *)title
+- (void) setDecombCustomString: (NSString*) string
{
- [self SetTitle:title];
- [self showWindow:sender];
-
+ [fDecombField setStringValue:string];
}
-
-// This function converts an image created by libhb (specified via pictureIndex) into
-// an NSImage suitable for the GUI code to use. If removeBorders is YES,
-// makeImageForPicture crops the image generated by libhb stripping off the gray
-// border around the content. This is the low-level method that generates the image.
-// -imageForPicture calls this function whenever it can't find an image in its cache.
-+ (NSImage *) makeImageForPicture: (int)pictureIndex
- libhb:(hb_handle_t*)handle
- title:(hb_title_t*)title
- removeBorders:(BOOL)removeBorders
+- (int) denoise
{
- if (removeBorders)
- {
- // |<---------- title->width ----------->|
- // | |<---- title->job->width ---->| |
- // | | | |
- // .......................................
- // ....+-----------------------------+....
- // ....| |....<-- gray border
- // ....| |....
- // ....| |....
- // ....| |<------- image
- // ....| |....
- // ....| |....
- // ....| |....
- // ....| |....
- // ....| |....
- // ....+-----------------------------+....
- // .......................................
-
- static uint8_t * buffer;
- static int bufferSize;
-
- // Make sure we have a big enough buffer to receive the image from libhb. libhb
- // creates images with a one-pixel border around the original content. Hence we
- // add 2 pixels horizontally and vertically to the buffer size.
- int srcWidth = title->width + 2;
- int srcHeight= title->height + 2;
- int newSize;
- newSize = srcWidth * srcHeight * 4;
- if( bufferSize < newSize )
- {
- bufferSize = newSize;
- buffer = (uint8_t *) realloc( buffer, bufferSize );
- }
-
- hb_get_preview( handle, title, pictureIndex, buffer );
-
- // Create an NSBitmapImageRep and copy the libhb image into it, converting it from
- // libhb's format to one suitable for NSImage. Along the way, we'll strip off the
- // border around libhb's image.
-
- // The image data returned by hb_get_preview is 4 bytes per pixel, BGRA format.
- // Alpha is ignored.
-
- int dstWidth = title->job->width;
- int dstHeight = title->job->height;
- NSBitmapFormat bitmapFormat = (NSBitmapFormat)NSAlphaFirstBitmapFormat;
- NSBitmapImageRep * imgrep = [[[NSBitmapImageRep alloc]
- initWithBitmapDataPlanes:nil
- pixelsWide:dstWidth
- pixelsHigh:dstHeight
- bitsPerSample:8
- samplesPerPixel:3 // ignore alpha
- hasAlpha:NO
- isPlanar:NO
- colorSpaceName:NSCalibratedRGBColorSpace
- bitmapFormat:bitmapFormat
- bytesPerRow:dstWidth * 4
- bitsPerPixel:32] autorelease];
-
- int borderTop = (srcHeight - dstHeight) / 2;
- int borderLeft = (srcWidth - dstWidth) / 2;
-
- UInt32 * src = (UInt32 *)buffer;
- UInt32 * dst = (UInt32 *)[imgrep bitmapData];
- src += borderTop * srcWidth; // skip top rows in src to get to first row of dst
- src += borderLeft; // skip left pixels in src to get to first pixel of dst
- for (int r = 0; r < dstHeight; r++)
- {
- for (int c = 0; c < dstWidth; c++)
-#if TARGET_RT_LITTLE_ENDIAN
- *dst++ = Endian32_Swap(*src++);
-#else
- *dst++ = *src++;
-#endif
- src += (srcWidth - dstWidth); // skip to next row in src
- }
-
- NSImage * img = [[[NSImage alloc] initWithSize: NSMakeSize(dstWidth, dstHeight)] autorelease];
- [img addRepresentation:imgrep];
-
- return img;
- }
- else
- {
- // Make sure we have big enough buffer
- static uint8_t * buffer;
- static int bufferSize;
-
- int newSize;
- newSize = ( title->width + 2 ) * (title->height + 2 ) * 4;
- if( bufferSize < newSize )
- {
- bufferSize = newSize;
- buffer = (uint8_t *) realloc( buffer, bufferSize );
- }
-
- hb_get_preview( handle, title, pictureIndex, buffer );
-
- // The image data returned by hb_get_preview is 4 bytes per pixel, BGRA format.
- // We'll copy that into an NSImage swapping it to ARGB in the process. Alpha is
- // ignored.
- int width = title->width + 2; // hblib adds a one-pixel border to the image
- int height = title->height + 2;
- int numPixels = width * height;
- NSBitmapFormat bitmapFormat = (NSBitmapFormat)NSAlphaFirstBitmapFormat;
- NSBitmapImageRep * imgrep = [[[NSBitmapImageRep alloc]
- initWithBitmapDataPlanes:nil
- pixelsWide:width
- pixelsHigh:height
- bitsPerSample:8
- samplesPerPixel:3 // ignore alpha
- hasAlpha:NO
- isPlanar:NO
- colorSpaceName:NSCalibratedRGBColorSpace
- bitmapFormat:bitmapFormat
- bytesPerRow:width * 4
- bitsPerPixel:32] autorelease];
-
- UInt32 * src = (UInt32 *)buffer;
- UInt32 * dst = (UInt32 *)[imgrep bitmapData];
- for (int i = 0; i < numPixels; i++)
-#if TARGET_RT_LITTLE_ENDIAN
- *dst++ = Endian32_Swap(*src++);
-#else
- *dst++ = *src++;
-#endif
-
- NSImage * img = [[[NSImage alloc] initWithSize: NSMakeSize(width, height)] autorelease];
- [img addRepresentation:imgrep];
-
- return img;
- }
+ return fPictureFilterSettings.denoise;
}
-// Returns the preview image for the specified index, retrieving it from its internal
-// cache or by calling makeImageForPicture if it is not cached. Generally, you should
-// use imageForPicture so that images are cached. Calling makeImageForPicture will
-// always generate a new copy of the image.
-- (NSImage *) imageForPicture: (int) pictureIndex
+- (NSString*) denoiseCustomString
{
- // The preview for the specified index may not currently exist, so this method
- // generates it if necessary.
- NSString * key = [NSString stringWithFormat:@"%d", pictureIndex];
- NSImage * theImage = [fPicturePreviews objectForKey:key];
- if (!theImage)
- {
- theImage = [PictureController makeImageForPicture:pictureIndex libhb:fHandle title:fTitle removeBorders: NO];
- [fPicturePreviews setObject:theImage forKey:key];
- }
- return theImage;
+ return [fDenoiseField stringValue];
}
-// Purges all images from the cache. The next call to imageForPicture will cause a new
-// image to be generated.
-- (void) purgeImageCache
+- (void) setDenoiseCustomString: (NSString*) string
{
- [fPicturePreviews removeAllObjects];
+ [fDenoiseField setStringValue:string];
}
-@end
-
-@implementation PictureController (Private)
-
-//
-// -[PictureController(Private) optimalViewSizeForImageSize:]
-//
-// Given the size of the preview image to be shown, returns the best possible
-// size for the view.
-//
-- (NSSize)optimalViewSizeForImageSize: (NSSize)imageSize
+- (void) setDenoise: (int) setting
{
- // The min size is 320x240
- CGFloat minWidth = 320.0;
- CGFloat minHeight = 240.0;
-
- NSSize screenSize = [[NSScreen mainScreen] frame].size;
- NSSize sheetSize = [[self window] frame].size;
- NSSize viewAreaSize = [fPictureViewArea frame].size;
- CGFloat paddingX = sheetSize.width - viewAreaSize.width;
- CGFloat paddingY = sheetSize.height - viewAreaSize.height;
- /* Since we are now non-modal, lets go ahead and allow the mac size to
- * go up to the full screen height or width below. Am leaving the original
- * code here that blindjimmy setup for 85% in case we don't like it.
- */
- // The max size of the view is when the sheet is taking up 85% of the screen.
- //CGFloat maxWidth = (0.85 * screenSize.width) - paddingX;
- //CGFloat maxHeight = (0.85 * screenSize.height) - paddingY;
- CGFloat maxWidth = screenSize.width - paddingX;
- CGFloat maxHeight = screenSize.height - paddingY;
-
- NSSize resultSize = imageSize;
-
- // Its better to have a view that's too small than a view that's too big, so
- // apply the maximum constraints last.
- if( resultSize.width < minWidth )
- {
- resultSize.height *= (minWidth / resultSize.width);
- resultSize.width = minWidth;
- }
- if( resultSize.height < minHeight )
- {
- resultSize.width *= (minHeight / resultSize.height);
- resultSize.height = minHeight;
- }
- if( resultSize.width > maxWidth )
- {
- resultSize.height *= (maxWidth / resultSize.width);
- resultSize.width = maxWidth;
- }
- if( resultSize.height > maxHeight )
- {
- resultSize.width *= (maxHeight / resultSize.height);
- resultSize.height = maxHeight;
- }
-
- return resultSize;
+ fPictureFilterSettings.denoise = setting;
}
-//
-// -[PictureController(Private) resizePanelForViewSize:animate:]
-//
-// Resizes the entire sheet to accomodate a view of a particular size.
-//
-- (void)resizeSheetForViewSize: (NSSize)viewSize
+- (int) deblock
{
- // Figure out the deltas for the new frame area
- NSSize currentSize = [fPictureViewArea frame].size;
- CGFloat deltaX = viewSize.width - currentSize.width;
- CGFloat deltaY = viewSize.height - currentSize.height;
-
- // Now resize the whole panel by those same deltas, but don't exceed the min
- NSRect frame = [[self window] frame];
- NSSize maxSize = [[self window] maxSize];
- NSSize minSize = [[self window] minSize];
- frame.size.width += deltaX;
- frame.size.height += deltaY;
- if( frame.size.width < minSize.width )
- {
- frame.size.width = minSize.width;
- }
- if( frame.size.height < minSize.height )
- {
- frame.size.height = minSize.height;
- }
-
- // But now the sheet is off-center, so also shift the origin to center it and
- // keep the top aligned.
- if( frame.size.width != [[self window] frame].size.width )
- frame.origin.x -= (deltaX / 2.0);
-
- if( frame.size.height != [[self window] frame].size.height )
- frame.origin.y -= deltaY;
+ return fPictureFilterSettings.deblock;
+}
- [[self window] setFrame:frame display:YES animate:YES];
+- (void) setDeblock: (int) setting
+{
+ fPictureFilterSettings.deblock = setting;
}
-//
-// -[PictureController(Private) setViewSize:]
-//
-// Changes the view's size and centers it vertically inside of its area.
-// Assumes resizeSheetForViewSize: has already been called.
-//
-- (void)setViewSize: (NSSize)viewSize
+- (int) grayscale
{
- [fPictureView setFrameSize:viewSize];
-
- // center it vertically
- NSPoint origin = [fPictureViewArea frame].origin;
- origin.y += ([fPictureViewArea frame].size.height -
- [fPictureView frame].size.height) / 2.0;
- [fPictureView setFrameOrigin:origin];
+ return fPictureFilterSettings.grayscale;
}
-//
-// -[PictureController(Private) viewNeedsToResizeToSize:]
-//
-// Returns YES if the view will need to resize to match the given size.
-//
-- (BOOL)viewNeedsToResizeToSize: (NSSize)newSize
+- (void) setGrayscale: (int) setting
{
- NSSize viewSize = [fPictureView frame].size;
- return (newSize.width != viewSize.width || newSize.height != viewSize.height);
+ fPictureFilterSettings.grayscale = setting;
}
+
+
@end
+
OSDN Git Service
