NSLocalizedString(@" Do you want to reload them ?", nil));
}
- // call didDimissReloadQueue: (NSWindow *)sheet returnCode: (int)returnCode contextInfo: (void *)contextInfo
- // right below to either clear the old queue or keep it loaded up.
}
else
{
int hbInstances = 0;
for (aDictionary in runningAppDictionaries)
{
- // NSLog(@"Open App: %@", [aDictionary valueForKey:@"NSApplicationName"]);
-
if ([[aDictionary valueForKey:@"NSApplicationName"] isEqualToString:@"HandBrake"])
{
hbInstances++;
[fSrcAngleLabel setHidden:YES];
[fSrcAnglePopUp setHidden:YES];
+ /* Setup the start / stop popup */
+ [fEncodeStartStopPopUp removeAllItems];
+ [fEncodeStartStopPopUp addItemWithTitle: @"Chapters"];
+ [fEncodeStartStopPopUp addItemWithTitle: @"Seconds"];
+ [fEncodeStartStopPopUp addItemWithTitle: @"Frames"];
+ /* Align the start / stop widgets with the chapter popups */
+ [fSrcTimeStartEncodingField setFrameOrigin:[fSrcChapterStartPopUp frame].origin];
+ [fSrcTimeEndEncodingField setFrameOrigin:[fSrcChapterEndPopUp frame].origin];
+
+ [fSrcFrameStartEncodingField setFrameOrigin:[fSrcChapterStartPopUp frame].origin];
+ [fSrcFrameEndEncodingField setFrameOrigin:[fSrcChapterEndPopUp frame].origin];
+
/* Destination box*/
NSMenuItem *menuItem;
[fDstFormatPopUp removeAllItems];
[fVidEncoderPopUp addItemWithTitle: @"FFmpeg"];
-
/* Video quality */
[fVidTargetSizeField setIntValue: 700];
[fVidBitrateField setIntValue: 1000];
fAudTrack2DrcField, fAudTrack3DrcSlider, fAudTrack3DrcField, fAudTrack4DrcSlider,fAudTrack4DrcField,
fQueueStatus,fPresetsAdd,fPresetsDelete,fSrcAngleLabel,fSrcAnglePopUp,
fCreateChapterMarkers,fVidTurboPassCheck,fDstMp4LargeFileCheck,fSubForcedCheck,fPresetsOutlineView,
- fAudDrcLabel,fDstMp4HttpOptFileCheck,fDstMp4iPodFileCheck,fVidQualityRFField,fVidQualityRFLabel};
+ fAudDrcLabel,fDstMp4HttpOptFileCheck,fDstMp4iPodFileCheck,fVidQualityRFField,fVidQualityRFLabel,
+ fEncodeStartStopPopUp,fSrcTimeStartEncodingField,fSrcTimeEndEncodingField,fSrcFrameStartEncodingField,fSrcFrameEndEncodingField};
for( unsigned i = 0;
i < sizeof( controls ) / sizeof( NSControl * ); i++ )
break;
}
#undef p
+
#define p s.param.working
+
+ case HB_STATE_SEARCHING:
+ {
+ NSMutableString * string;
+ NSString * pass_desc;
+
+ /* Update text field */
+ pass_desc = @"";
+ //string = [NSMutableString stringWithFormat: NSLocalizedString( @"Searching for start point: pass %d %@ of %d, %.2f %%", @"" ), p.job_cur, pass_desc, p.job_count, 100.0 * p.progress];
+ /* For now, do not announce "pass x of x for the search phase ... */
+ string = [NSMutableString stringWithFormat: NSLocalizedString( @"Searching for start point ... : %.2f %%", @"" ), 100.0 * p.progress];
+
+ if( p.seconds > -1 )
+ {
+ [string appendFormat:
+ NSLocalizedString( @" (ETA %02dh%02dm%02ds)", @"" ), p.hours, p.minutes, p.seconds];
+ }
+
+ [fStatusField setStringValue: string];
+ /* Set the status string in fQueueController as well */
+ [fQueueController setQueueStatusString: string];
+ /* Update slider */
+ CGFloat progress_total = ( p.progress + p.job_cur - 1 ) / p.job_count;
+ [fRipIndicator setIndeterminate: NO];
+ [fRipIndicator setDoubleValue:100.0 * progress_total];
+
+ // If progress bar hasn't been revealed at the bottom of the window, do
+ // that now. This code used to be in doRip. I moved it to here to handle
+ // the case where hb_start is called by HBQueueController and not from
+ // HBController.
+ if( !fRipIndicatorShown )
+ {
+ NSRect frame = [fWindow frame];
+ if( frame.size.width <= 591 )
+ frame.size.width = 591;
+ frame.size.height += 36;
+ frame.origin.y -= 36;
+ [fWindow setFrame:frame display:YES animate:YES];
+ fRipIndicatorShown = YES;
+
+ }
+
+ /* Update dock icon */
+ /* Note not done yet */
+ break;
+ }
+
+
case HB_STATE_WORKING:
{
NSMutableString * string;
hb_state_t s;
hb_get_state( fHandle, &s );
- if (s.state == HB_STATE_SCANNING && ([ident isEqualToString: StartEncodingIdentifier] || [ident isEqualToString: AddToQueueIdentifier]))
- return NO;
-
+ if (s.state == HB_STATE_SCANNING)
+ {
+
+ if ([ident isEqualToString: ChooseSourceIdentifier])
+ {
+ [toolbarItem setImage: [NSImage imageNamed: @"Stop"]];
+ [toolbarItem setLabel: @"Cancel Scan"];
+ [toolbarItem setPaletteLabel: @"Cancel Scanning"];
+ [toolbarItem setToolTip: @"Cancel Scanning Source"];
+ return YES;
+ }
+
+ if ([ident isEqualToString: StartEncodingIdentifier] || [ident isEqualToString: AddToQueueIdentifier])
+ return NO;
+ }
+ else
+ {
+ if ([ident isEqualToString: ChooseSourceIdentifier])
+ {
+ [toolbarItem setImage: [NSImage imageNamed: @"Source"]];
+ [toolbarItem setLabel: @"Source"];
+ [toolbarItem setPaletteLabel: @"Source"];
+ [toolbarItem setToolTip: @"Choose Video Source"];
+ return YES;
+ }
+ }
+
hb_get_state2( fQueueEncodeLibhb, &s );
- if (s.state == HB_STATE_WORKING || s.state == HB_STATE_MUXING)
+ if (s.state == HB_STATE_WORKING || s.state == HB_STATE_SEARCHING || s.state == HB_STATE_MUXING)
{
if ([ident isEqualToString: StartEncodingIdentifier])
{
/* This end of encode action is called as each encode rolls off of the queue */
if([[NSUserDefaults standardUserDefaults] boolForKey: @"sendToMetaX"] == YES)
{
- NSAppleScript *myScript = [[NSAppleScript alloc] initWithSource: [NSString stringWithFormat: @"%@%@%@", @"tell application \"MetaX\" to open (POSIX file \"", filePath, @"\")"]];
- [myScript executeAndReturnError: nil];
- [myScript release];
+ NSString *sendToApp = [[NSUserDefaults standardUserDefaults] objectForKey: @"SendCompletedEncodeToApp"];
+ if (![sendToApp isEqualToString:@"None"])
+ {
+ [self writeToActivityLog: "trying to send encode to: %s", [sendToApp UTF8String]];
+ NSAppleScript *myScript = [[NSAppleScript alloc] initWithSource: [NSString stringWithFormat: @"%@%@%@%@%@", @"tell application \"",sendToApp,@"\" to open (POSIX file \"", filePath, @"\")"]];
+ [myScript executeAndReturnError: nil];
+ [myScript release];
+ }
+
}
}
#pragma mark -
/*Opens the source browse window, called from Open Source widgets */
- (IBAction) browseSources: (id) sender
{
+
+ hb_state_t s;
+ hb_get_state( fHandle, &s );
+ if (s.state == HB_STATE_SCANNING)
+ {
+ [self cancelScanning:nil];
+ return;
+ }
+
+
NSOpenPanel * panel;
panel = [NSOpenPanel openPanel];
if ([[scanPath lastPathComponent] isEqualToString: @"VIDEO_TS"])
{
/* If VIDEO_TS Folder is chosen, choose its parent folder for the source display name
- we have to use the title->dvd value so we get the proper name of the volume if a physical dvd is the source*/
+ we have to use the title->path value so we get the proper name of the volume if a physical dvd is the source*/
displayTitlescanSourceName = [[scanPath stringByDeletingLastPathComponent] lastPathComponent];
}
else
/* make sure we remove any path extension as this can also be an '.mpg' file */
browsedSourceDisplayName = [[path lastPathComponent] retain];
}
+ applyQueueToScan = NO;
[self performScan:path scanTitleNum:0];
}
{
[NSApp endSheet: fScanSrcTitlePanel];
[fScanSrcTitlePanel orderOut: self];
-
+
if(sender == fScanSrcTitleOpenButton)
{
/* We setup the scan status in the main window to indicate a source title scan */
[fScanIndicator startAnimation: nil];
/* We use the performScan method to actually perform the specified scan passing the path and the title
- * to be scanned
- */
+ * to be scanned
+ */
+ applyQueueToScan = NO;
[self performScan:[fScanSrcTitlePathField stringValue] scanTitleNum:[fScanSrcTitleNumField intValue]];
}
}
/* Here we actually tell hb_scan to perform the source scan, using the path to source and title number*/
- (void) performScan:(NSString *) scanPath scanTitleNum: (int) scanTitleNum
{
- /* set the bool applyQueueToScan so that we dont apply a queue setting to the final scan */
- applyQueueToScan = NO;
+
/* use a bool to determine whether or not we can decrypt using vlc */
BOOL cancelScanDecrypt = 0;
+ BOOL vlcFound = 0;
NSString *path = scanPath;
HBDVDDetector *detector = [HBDVDDetector detectorForPath:path];
{
/* VLC was found in /Applications so all is well, we can carry on using vlc's libdvdcss.dylib for decrypting if needed */
[self writeToActivityLog: "VLC app found for decrypting physical dvd"];
+ vlcFound = 1;
}
/* test for architecture of the vlc app */
NSArray *vlc_architecturesArray = [[NSBundle bundleWithPath:@"/Applications/VLC.app"] executableArchitectures];
- if (hb_arch == 64 && !vlcIntel64bit && cancelScanDecrypt != 1)
+ if (vlcFound && hb_arch == 64 && !vlcIntel64bit && cancelScanDecrypt != 1)
{
/* we are 64 bit */
[self writeToActivityLog: "cannot open physical dvd VLC found but not 64 bit, scan cancelled"];
cancelScanDecrypt = 1;
}
- else if (status == NSAlertDefaultReturn)
+ else if (status == NSAlertAlternateReturn)
{
[self writeToActivityLog: "user overrode 64-bit warning trying to open physical dvd without proper decryption"];
cancelScanDecrypt = 0;
}
}
- else if (hb_arch == 32 && !vlcIntel32bit && cancelScanDecrypt != 1)
+ else if (vlcFound && hb_arch == 32 && !vlcIntel32bit && cancelScanDecrypt != 1)
{
/* we are 32 bit */
/* Appropriate VLC not found, so cancel */
[self writeToActivityLog: "cannot open physical dvd VLC found but not 32 bit, scan cancelled"];
cancelScanDecrypt = 1;
}
- else if (status == NSAlertDefaultReturn)
+ else if (status == NSAlertAlternateReturn)
{
[self writeToActivityLog: "user overrode 32-bit warning trying to open physical dvd without proper decryption"];
cancelScanDecrypt = 0;
/* We use our advance pref to determine how many previews to scan */
int hb_num_previews = [[[NSUserDefaults standardUserDefaults] objectForKey:@"PreviewsNumber"] intValue];
/* set title to NULL */
- //fTitle = NULL;
+ fTitle = NULL;
hb_scan( fHandle, [path UTF8String], scanTitleNum, hb_num_previews, 1 );
[fSrcDVD2Field setStringValue:@"Scanning new source ..."];
}
}
+- (IBAction) cancelScanning:(id)sender
+{
+ hb_scan_stop(fHandle);
+}
+
- (IBAction) showNewScan:(id)sender
{
hb_list_t * list;
}
else
{
- /* We increment the successful scancount here by one,
+ if (applyQueueToScan == YES)
+ {
+ /* we are a rescan of an existing queue item and need to apply the queued settings to the scan */
+ [self writeToActivityLog: "showNewScan: This is a queued item rescan"];
+
+ }
+ else if (applyQueueToScan == NO)
+ {
+ [self writeToActivityLog: "showNewScan: This is a new source item scan"];
+ }
+ else
+ {
+ [self writeToActivityLog: "showNewScan: cannot grok scan status"];
+ }
+
+ /* We increment the successful scancount here by one,
which we use at the end of this function to tell the gui
if this is the first successful scan since launch and whether
or not we should set all settings to the defaults */
-
currentSuccessfulScanCount++;
[[fWindow toolbar] validateVisibleItems];
currentSource = [NSString stringWithUTF8String: title->name];
/*Set DVD Name at top of window with the browsedSourceDisplayName grokked right before -performScan */
+ if (!browsedSourceDisplayName)
+ {
+ browsedSourceDisplayName = @"NoNameDetected";
+ }
[fSrcDVD2Field setStringValue:browsedSourceDisplayName];
- /* Use the dvd name in the default output field here
- May want to add code to remove blank spaces for some dvd names*/
+ /* If its a queue rescan for edit, get the queue item output path */
+ /* if not, its a new source scan. */
/* Check to see if the last destination has been set,use if so, if not, use Desktop */
- if ([[NSUserDefaults standardUserDefaults] stringForKey:@"LastDestinationDirectory"])
+ if (applyQueueToScan == YES)
+ {
+ [fDstFile2Field setStringValue: [NSString stringWithFormat:@"%@", [[QueueFileArray objectAtIndex:fqueueEditRescanItemNum] objectForKey:@"DestinationPath"]]];
+ }
+ else if ([[NSUserDefaults standardUserDefaults] stringForKey:@"LastDestinationDirectory"])
{
[fDstFile2Field setStringValue: [NSString stringWithFormat:
@"%@/%@.mp4", [[NSUserDefaults standardUserDefaults] stringForKey:@"LastDestinationDirectory"],[browsedSourceDisplayName stringByDeletingPathExtension]]];
}
[fSrcTitlePopUp addItemWithTitle: [NSString
- stringWithFormat: @"%d - %02dh%02dm%02ds",
- title->index, title->hours, title->minutes,
+ stringWithFormat: @"%s %d - %02dh%02dm%02ds",
+ title->name,title->index, title->hours, title->minutes,
title->seconds]];
}
- // Select the longuest title
- [fSrcTitlePopUp selectItemAtIndex: indxpri];
+ /* if we are a stream, select the first title */
+ if (title->type == HB_STREAM_TYPE)
+ {
+ [fSrcTitlePopUp selectItemAtIndex: 0];
+ }
+ else
+ {
+ /* if not then select the longest title (dvd) */
+ [fSrcTitlePopUp selectItemAtIndex: indxpri];
+ }
[self titlePopUpChanged:nil];
SuccessfulScan = YES;
/* if its the initial successful scan after awakeFromNib */
if (currentSuccessfulScanCount == 1)
{
+ [self encodeStartStopPopUpChanged:nil];
+
[self selectDefaultPreset:nil];
// Open preview window now if it was visible when HB was closed
[self showPicturePanel:nil];
}
+ if (applyQueueToScan == YES)
+ {
+ /* we are a rescan of an existing queue item and need to apply the queued settings to the scan */
+ [self writeToActivityLog: "showNewScan: calling applyQueueSettingsToMainWindow"];
+ [self applyQueueSettingsToMainWindow:nil];
+
+ }
}
[queueFileJob setObject:[NSNumber numberWithInt:2] forKey:@"Status"];
/* Source and Destination Information */
- [queueFileJob setObject:[NSString stringWithUTF8String: title->dvd] forKey:@"SourcePath"];
+ [queueFileJob setObject:[NSString stringWithUTF8String: title->path] forKey:@"SourcePath"];
[queueFileJob setObject:[fSrcDVD2Field stringValue] forKey:@"SourceName"];
[queueFileJob setObject:[NSNumber numberWithInt:title->index] forKey:@"TitleNumber"];
[queueFileJob setObject:[NSNumber numberWithInt:[fSrcAnglePopUp indexOfSelectedItem] + 1] forKey:@"TitleAngle"];
- [queueFileJob setObject:[NSNumber numberWithInt:[fSrcChapterStartPopUp indexOfSelectedItem] + 1] forKey:@"ChapterStart"];
+ /* Determine and set a variable to tell hb what start and stop times to use ... chapters vs seconds */
+ if( [fEncodeStartStopPopUp indexOfSelectedItem] == 0 )
+ {
+ [queueFileJob setObject:[NSNumber numberWithInt:0] forKey:@"fEncodeStartStop"];
+ }
+ else if ([fEncodeStartStopPopUp indexOfSelectedItem] == 1)
+ {
+ [queueFileJob setObject:[NSNumber numberWithInt:1] forKey:@"fEncodeStartStop"];
+ }
+ else if ([fEncodeStartStopPopUp indexOfSelectedItem] == 2)
+ {
+ [queueFileJob setObject:[NSNumber numberWithInt:2] forKey:@"fEncodeStartStop"];
+ }
+ /* Chapter encode info */
+ [queueFileJob setObject:[NSNumber numberWithInt:[fSrcChapterStartPopUp indexOfSelectedItem] + 1] forKey:@"ChapterStart"];
[queueFileJob setObject:[NSNumber numberWithInt:[fSrcChapterEndPopUp indexOfSelectedItem] + 1] forKey:@"ChapterEnd"];
+ /* Time (pts) encode info */
+ [queueFileJob setObject:[NSNumber numberWithInt:[fSrcTimeStartEncodingField intValue]] forKey:@"StartSeconds"];
+ [queueFileJob setObject:[NSNumber numberWithInt:[fSrcTimeEndEncodingField intValue] - [fSrcTimeStartEncodingField intValue]] forKey:@"StopSeconds"];
+ /* Frame number encode info */
+ [queueFileJob setObject:[NSNumber numberWithInt:[fSrcFrameStartEncodingField intValue]] forKey:@"StartFrame"];
+ [queueFileJob setObject:[NSNumber numberWithInt:[fSrcFrameEndEncodingField intValue] - [fSrcFrameStartEncodingField intValue]] forKey:@"StopFrame"];
+
+
+ /* The number of seek points equals the number of seconds announced in the title as that is our current granularity */
+ int title_duration_seconds = (title->hours * 3600) + (title->minutes * 60) + (title->seconds);
+ [queueFileJob setObject:[NSNumber numberWithInt:title_duration_seconds] forKey:@"SourceTotalSeconds"];
[queueFileJob setObject:[fDstFile2Field stringValue] forKey:@"DestinationPath"];
}
/* Subtitles*/
- NSMutableArray *subtitlesArray = [[NSMutableArray alloc] init];
- [queueFileJob setObject:[NSArray arrayWithArray: [fSubtitlesDelegate getSubtitleArray: subtitlesArray]] forKey:@"SubtitleList"];
+ NSMutableArray *subtitlesArray = [[NSMutableArray alloc] initWithArray:[fSubtitlesDelegate getSubtitleArray] copyItems:YES];
+ [queueFileJob setObject:[NSArray arrayWithArray: subtitlesArray] forKey:@"SubtitleList"];
[subtitlesArray autorelease];
/* Now we go ahead and set the "job->values in the plist for passing right to fQueueEncodeLibhb */
/* set the bool so that showNewScan knows to apply the appropriate queue
* settings as this is a queue rescan
*/
- applyQueueToScan = YES;
+ //applyQueueToScan = YES;
NSString *path = scanPath;
HBDVDDetector *detector = [HBDVDDetector detectorForPath:path];
-
- /*On Screen Notification*/
- //int status;
- //status = NSRunAlertPanel(@"HandBrake is now loading up a new queue item...",@"Would You Like to wait until you add another encode?", @"Cancel", @"Okay", nil);
- //[NSApp requestUserAttention:NSCriticalRequest];
-
+
if( [detector isVideoDVD] )
{
// The chosen path was actually on a DVD, so use the raw block
}
}
-/* This method was originally used to load up a new queue item in the gui and
- * then start processing it. However we now have modified -prepareJob and use a second
- * instance of libhb to do our actual encoding, therefor right now it is not required.
- * Nonetheless I want to leave this in here
- * because basically its everything we need to be able to actually modify a pending queue
- * item in the gui and resave it. At least for now - dynaflash
- */
-
-- (IBAction)applyQueueSettings:(id)sender
+/* This assumes that we have re-scanned and loaded up a new queue item to send to libhb as fQueueEncodeLibhb */
+- (void) processNewQueueEncode
{
+ hb_list_t * list = hb_get_titles( fQueueEncodeLibhb );
+ hb_title_t * title = (hb_title_t *) hb_list_item( list,0 ); // is always zero since now its a single title scan
+ hb_job_t * job = title->job;
+
+ if( !hb_list_count( list ) )
+ {
+ [self writeToActivityLog: "processNewQueueEncode WARNING nothing found in the title list"];
+ }
+
NSMutableDictionary * queueToApply = [QueueFileArray objectAtIndex:currentQueueEncodeIndex];
- hb_job_t * job = fTitle->job;
+ [self writeToActivityLog: "Preset: %s", [[queueToApply objectForKey:@"PresetName"] UTF8String]];
+ [self writeToActivityLog: "processNewQueueEncode number of passes expected is: %d", ([[queueToApply objectForKey:@"VideoTwoPass"] intValue] + 1)];
+ job->file = [[queueToApply objectForKey:@"DestinationPath"] UTF8String];
+ //[self writeToActivityLog: "processNewQueueEncode sending to prepareJob"];
+ [self prepareJob];
+
+ /*
+ * If scanning we need to do some extra setup of the job.
+ */
+ if( job->indepth_scan == 1 )
+ {
+ char *x264opts_tmp;
+
+ /*
+ * When subtitle scan is enabled do a fast pre-scan job
+ * which will determine which subtitles to enable, if any.
+ */
+ job->pass = -1;
+ x264opts_tmp = job->x264opts;
+
+ job->x264opts = NULL;
+
+ job->indepth_scan = 1;
+
+
+ /*
+ * Add the pre-scan job
+ */
+ hb_add( fQueueEncodeLibhb, job );
+ job->x264opts = x264opts_tmp;
+ }
+
+ if( [[queueToApply objectForKey:@"VideoTwoPass"] intValue] == 1 )
+ {
+ job->indepth_scan = 0;
+
+
+
+ job->pass = 1;
+
+ hb_add( fQueueEncodeLibhb, job );
+
+ job->pass = 2;
+
+ job->x264opts = (char *)calloc(1024, 1); /* Fixme, this just leaks */
+ strcpy(job->x264opts, [[queueToApply objectForKey:@"x264Option"] UTF8String]);
+
+ hb_add( fQueueEncodeLibhb, job );
+
+ }
+ else
+ {
+ job->indepth_scan = 0;
+ job->pass = 0;
+
+ hb_add( fQueueEncodeLibhb, job );
+ }
+
+ NSString *destinationDirectory = [[queueToApply objectForKey:@"DestinationPath"] stringByDeletingLastPathComponent];
+ [[NSUserDefaults standardUserDefaults] setObject:destinationDirectory forKey:@"LastDestinationDirectory"];
+ /* Lets mark our new encode as 1 or "Encoding" */
+ [queueToApply setObject:[NSNumber numberWithInt:1] forKey:@"Status"];
+ [self saveQueueFileItem];
+
+ /* we need to clean up the subtitle tracks after the job(s) have been set */
+ int num_subtitle_tracks = hb_list_count(job->list_subtitle);
+ int ii;
+ for(ii = 0; ii < num_subtitle_tracks; ii++)
+ {
+ hb_subtitle_t * subtitle;
+ subtitle = (hb_subtitle_t *)hb_list_item(job->list_subtitle, 0);
+
+
+ hb_list_rem(job->list_subtitle, subtitle);
+ free(subtitle);
+ }
+
+
+ /* We should be all setup so let 'er rip */
+ [self doRip];
+}
+
+
+
+#pragma mark -
+#pragma mark Queue Item Editing
+
+/* Rescans the chosen queue item back into the main window */
+- (void)rescanQueueItemToMainWindow:(NSString *) scanPath scanTitleNum: (int) scanTitleNum selectedQueueItem: (int) selectedQueueItem
+{
+ fqueueEditRescanItemNum = selectedQueueItem;
+ [self writeToActivityLog: "rescanQueueItemToMainWindow: Re-scanning queue item at index:%d",fqueueEditRescanItemNum];
+ applyQueueToScan = YES;
+ /* Set the browsedSourceDisplayName for showNewScan */
+ browsedSourceDisplayName = [[QueueFileArray objectAtIndex:fqueueEditRescanItemNum] objectForKey:@"SourceName"];
+ [self performScan:scanPath scanTitleNum:scanTitleNum];
+}
+
+
+/* We use this method after a queue item rescan for edit.
+ * it largely mirrors -selectPreset in terms of structure.
+ * Assumes that a queue item has been reloaded into the main window.
+ */
+- (IBAction)applyQueueSettingsToMainWindow:(id)sender
+{
+ NSMutableDictionary * queueToApply = [QueueFileArray objectAtIndex:fqueueEditRescanItemNum];
+ hb_job_t * job = fTitle->job;
+ if (queueToApply)
+ {
+ [self writeToActivityLog: "applyQueueSettingsToMainWindow: queue item found"];
+ }
/* Set title number and chapters */
/* since the queue only scans a single title, we really don't need to pick a title */
- //[fSrcTitlePopUp selectItemAtIndex: [[queueToApply objectForKey:@"TitleNumber"] intValue] - 1];
+ [fSrcTitlePopUp selectItemAtIndex: [[queueToApply objectForKey:@"TitleNumber"] intValue] - 1];
[fSrcChapterStartPopUp selectItemAtIndex: [[queueToApply objectForKey:@"ChapterStart"] intValue] - 1];
[fSrcChapterEndPopUp selectItemAtIndex: [[queueToApply objectForKey:@"ChapterEnd"] intValue] - 1];
[fVidTargetSizeField setStringValue:[queueToApply objectForKey:@"VideoTargetSize"]];
[fVidBitrateField setStringValue:[queueToApply objectForKey:@"VideoAvgBitrate"]];
- [fVidQualitySlider setFloatValue:[[queueToApply objectForKey:@"VideoQualitySlider"] floatValue]];
+ /* Since we are now using RF Values for the slider, we detect if the preset uses an old quality float.
+ * So, check to see if the quality value is less than 1.0 which should indicate the old ".062" type
+ * quality preset. Caveat: in the case of x264, where the RF scale starts at 0, it would misinterpret
+ * a preset that uses 0.0 - 0.99 for RF as an old style preset. Not sure how to get around that one yet,
+ * though it should be a corner case since it would pretty much be a preset for lossless encoding. */
+ if ([[queueToApply objectForKey:@"VideoQualitySlider"] floatValue] < 1.0)
+ {
+ /* For the quality slider we need to convert the old percent's to the new rf scales */
+ float rf = (([fVidQualitySlider maxValue] - [fVidQualitySlider minValue]) * [[queueToApply objectForKey:@"VideoQualitySlider"] floatValue]);
+ [fVidQualitySlider setFloatValue:rf];
+
+ }
+ else
+ {
+ /* Since theora's qp value goes up from left to right, we can just set the slider float value */
+ if ([[fVidEncoderPopUp selectedItem] tag] == HB_VCODEC_THEORA)
+ {
+ [fVidQualitySlider setFloatValue:[[queueToApply objectForKey:@"VideoQualitySlider"] floatValue]];
+ }
+ else
+ {
+ /* since ffmpeg and x264 use an "inverted" slider (lower qp/rf values indicate a higher quality) we invert the value on the slider */
+ [fVidQualitySlider setFloatValue:([fVidQualitySlider maxValue] + [fVidQualitySlider minValue]) - [[queueToApply objectForKey:@"VideoQualitySlider"] floatValue]];
+ }
+ }
[self videoMatrixChanged:nil];
-
+ [self writeToActivityLog: "applyQueueSettingsToMainWindow: video matrix changed"];
/* Video framerate */
/* For video preset video framerate, we want to make sure that Same as source does not conflict with the
detected framerate in the fVidRatePopUp so we use index 0*/
[fVidTurboPassCheck setState:[[queueToApply objectForKey:@"VideoTurboTwoPass"] intValue]];
/*Audio*/
- if ([queueToApply objectForKey:@"Audio1Track"] > 0)
+
+
+ /* Now lets add our new tracks to the audio list here */
+ if ([[queueToApply objectForKey:@"Audio1Track"] intValue] > 0)
{
- if ([fAudLang1PopUp indexOfSelectedItem] == 0)
- {
- [fAudLang1PopUp selectItemAtIndex: 1];
- }
+ [fAudLang1PopUp selectItemAtIndex: [[queueToApply objectForKey:@"Audio1Track"] intValue]];
[self audioTrackPopUpChanged: fAudLang1PopUp];
[fAudTrack1CodecPopUp selectItemWithTitle:[queueToApply objectForKey:@"Audio1Encoder"]];
[self audioTrackPopUpChanged: fAudTrack1CodecPopUp];
+
[fAudTrack1MixPopUp selectItemWithTitle:[queueToApply objectForKey:@"Audio1Mixdown"]];
- /* check to see if the selections was available, if not, rerun audioTrackPopUpChanged using the codec to just set the default
- * mixdown*/
- if ([fAudTrack1MixPopUp selectedItem] == nil)
- {
- [self audioTrackPopUpChanged: fAudTrack1CodecPopUp];
- }
- [fAudTrack1RatePopUp selectItemWithTitle:[chosenPreset objectForKey:@"Audio1Samplerate"]];
- /* We set the presets bitrate if it is *not* an AC3 track since that uses the input bitrate */
- if (![[queueToApply objectForKey:@"Audio1Encoder"] isEqualToString:@"AC3 Passthru"])
- {
- [fAudTrack1BitratePopUp selectItemWithTitle:[queueToApply objectForKey:@"Audio1Bitrate"]];
- }
+
+ [fAudTrack1RatePopUp selectItemWithTitle:[queueToApply objectForKey:@"Audio1Samplerate"]];
+ [fAudTrack1BitratePopUp selectItemWithTitle:[queueToApply objectForKey:@"Audio1Bitrate"]];
+
[fAudTrack1DrcSlider setFloatValue:[[queueToApply objectForKey:@"Audio1TrackDRCSlider"] floatValue]];
[self audioDRCSliderChanged: fAudTrack1DrcSlider];
}
- if ([queueToApply objectForKey:@"Audio2Track"] > 0)
+ else
{
- if ([fAudLang2PopUp indexOfSelectedItem] == 0)
- {
- [fAudLang2PopUp selectItemAtIndex: 1];
- }
+ [fAudLang1PopUp selectItemAtIndex: 0];
+ [self audioTrackPopUpChanged: fAudLang1PopUp];
+ }
+ if ([[queueToApply objectForKey:@"Audio2Track"] intValue] > 0)
+ {
+ [fAudLang2PopUp selectItemAtIndex: [[queueToApply objectForKey:@"Audio2Track"] intValue]];
[self audioTrackPopUpChanged: fAudLang2PopUp];
[fAudTrack2CodecPopUp selectItemWithTitle:[queueToApply objectForKey:@"Audio2Encoder"]];
[self audioTrackPopUpChanged: fAudTrack2CodecPopUp];
+
[fAudTrack2MixPopUp selectItemWithTitle:[queueToApply objectForKey:@"Audio2Mixdown"]];
- /* check to see if the selections was available, if not, rerun audioTrackPopUpChanged using the codec to just set the default
- * mixdown*/
- if ([fAudTrack2MixPopUp selectedItem] == nil)
- {
- [self audioTrackPopUpChanged: fAudTrack2CodecPopUp];
- }
+
[fAudTrack2RatePopUp selectItemWithTitle:[queueToApply objectForKey:@"Audio2Samplerate"]];
- /* We set the presets bitrate if it is *not* an AC3 track since that uses the input bitrate */
- if (![[queueToApply objectForKey:@"Audio2Encoder"] isEqualToString:@"AC3 Passthru"])
- {
- [fAudTrack2BitratePopUp selectItemWithTitle:[queueToApply objectForKey:@"Audio2Bitrate"]];
- }
+ [fAudTrack2BitratePopUp selectItemWithTitle:[queueToApply objectForKey:@"Audio2Bitrate"]];
+
[fAudTrack2DrcSlider setFloatValue:[[queueToApply objectForKey:@"Audio2TrackDRCSlider"] floatValue]];
[self audioDRCSliderChanged: fAudTrack2DrcSlider];
}
- if ([queueToApply objectForKey:@"Audio3Track"] > 0)
+ else
{
- if ([fAudLang3PopUp indexOfSelectedItem] == 0)
- {
- [fAudLang3PopUp selectItemAtIndex: 1];
- }
+ [fAudLang2PopUp selectItemAtIndex: 0];
+ [self audioTrackPopUpChanged: fAudLang2PopUp];
+ }
+ if ([[queueToApply objectForKey:@"Audio3Track"] intValue] > 0)
+ {
+ [fAudLang3PopUp selectItemAtIndex: [[queueToApply objectForKey:@"Audio3Track"] intValue]];
[self audioTrackPopUpChanged: fAudLang3PopUp];
[fAudTrack3CodecPopUp selectItemWithTitle:[queueToApply objectForKey:@"Audio3Encoder"]];
[self audioTrackPopUpChanged: fAudTrack3CodecPopUp];
+
[fAudTrack3MixPopUp selectItemWithTitle:[queueToApply objectForKey:@"Audio3Mixdown"]];
- /* check to see if the selections was available, if not, rerun audioTrackPopUpChanged using the codec to just set the default
- * mixdown*/
- if ([fAudTrack3MixPopUp selectedItem] == nil)
- {
- [self audioTrackPopUpChanged: fAudTrack3CodecPopUp];
- }
+
[fAudTrack3RatePopUp selectItemWithTitle:[queueToApply objectForKey:@"Audio3Samplerate"]];
- /* We set the presets bitrate if it is *not* an AC3 track since that uses the input bitrate */
- if (![[queueToApply objectForKey:@"Audio3Encoder"] isEqualToString: @"AC3 Passthru"])
- {
- [fAudTrack3BitratePopUp selectItemWithTitle:[queueToApply objectForKey:@"Audio3Bitrate"]];
- }
+ [fAudTrack3BitratePopUp selectItemWithTitle:[queueToApply objectForKey:@"Audio3Bitrate"]];
+
[fAudTrack3DrcSlider setFloatValue:[[queueToApply objectForKey:@"Audio3TrackDRCSlider"] floatValue]];
[self audioDRCSliderChanged: fAudTrack3DrcSlider];
}
- if ([queueToApply objectForKey:@"Audio4Track"] > 0)
+ else
+ {
+ [fAudLang3PopUp selectItemAtIndex: 0];
+ [self audioTrackPopUpChanged: fAudLang3PopUp];
+ }
+ if ([[queueToApply objectForKey:@"Audio4Track"] intValue] > 0)
+ {
+ [fAudLang4PopUp selectItemAtIndex: [[queueToApply objectForKey:@"Audio4Track"] intValue]];
+ [self audioTrackPopUpChanged: fAudLang4PopUp];
+ [fAudTrack4CodecPopUp selectItemWithTitle:[queueToApply objectForKey:@"Audio4Encoder"]];
+ [self audioTrackPopUpChanged: fAudTrack4CodecPopUp];
+
+ [fAudTrack4MixPopUp selectItemWithTitle:[queueToApply objectForKey:@"Audio4Mixdown"]];
+
+ [fAudTrack4RatePopUp selectItemWithTitle:[queueToApply objectForKey:@"Audio4Samplerate"]];
+ [fAudTrack4BitratePopUp selectItemWithTitle:[queueToApply objectForKey:@"Audio4Bitrate"]];
+
+ [fAudTrack4DrcSlider setFloatValue:[[queueToApply objectForKey:@"Audio4TrackDRCSlider"] floatValue]];
+ [self audioDRCSliderChanged: fAudTrack4DrcSlider];
+ }
+ else
+ {
+ [fAudLang4PopUp selectItemAtIndex: 0];
+ [self audioTrackPopUpChanged: fAudLang4PopUp];
+ }
+
+ [self writeToActivityLog: "applyQueueSettingsToMainWindow: audio set up"];
+ /*Subtitles*/
+ /* Crashy crashy right now, working on it */
+ [fSubtitlesDelegate setNewSubtitles:[queueToApply objectForKey:@"SubtitleList"]];
+ [fSubtitlesTable reloadData];
+ /* Picture Settings */
+
+ /* If Cropping is set to custom, then recall all four crop values from
+ when the preset was created and apply them */
+ if ([[queueToApply objectForKey:@"PictureAutoCrop"] intValue] == 0)
+ {
+ [fPictureController setAutoCrop:NO];
+
+ /* Here we use the custom crop values saved at the time the preset was saved */
+ job->crop[0] = [[queueToApply objectForKey:@"PictureTopCrop"] intValue];
+ job->crop[1] = [[queueToApply objectForKey:@"PictureBottomCrop"] intValue];
+ job->crop[2] = [[queueToApply objectForKey:@"PictureLeftCrop"] intValue];
+ job->crop[3] = [[queueToApply objectForKey:@"PictureRightCrop"] intValue];
+
+ }
+ else /* if auto crop has been saved in preset, set to auto and use post scan auto crop */
{
- if ([fAudLang4PopUp indexOfSelectedItem] == 0)
- {
- [fAudLang4PopUp selectItemAtIndex: 1];
- }
- [self audioTrackPopUpChanged: fAudLang4PopUp];
- [fAudTrack4CodecPopUp selectItemWithTitle:[queueToApply objectForKey:@"Audio4Encoder"]];
- [self audioTrackPopUpChanged: fAudTrack4CodecPopUp];
- [fAudTrack4MixPopUp selectItemWithTitle:[queueToApply objectForKey:@"Audio4Mixdown"]];
- /* check to see if the selections was available, if not, rerun audioTrackPopUpChanged using the codec to just set the default
- * mixdown*/
- if ([fAudTrack4MixPopUp selectedItem] == nil)
- {
- [self audioTrackPopUpChanged: fAudTrack4CodecPopUp];
- }
- [fAudTrack4RatePopUp selectItemWithTitle:[queueToApply objectForKey:@"Audio4Samplerate"]];
- /* We set the presets bitrate if it is *not* an AC3 track since that uses the input bitrate */
- if (![[chosenPreset objectForKey:@"Audio4Encoder"] isEqualToString:@"AC3 Passthru"])
- {
- [fAudTrack4BitratePopUp selectItemWithTitle:[queueToApply objectForKey:@"Audio4Bitrate"]];
- }
- [fAudTrack4DrcSlider setFloatValue:[[queueToApply objectForKey:@"Audio4TrackDRCSlider"] floatValue]];
- [self audioDRCSliderChanged: fAudTrack4DrcSlider];
+ [fPictureController setAutoCrop:YES];
+ /* Here we use the auto crop values determined right after scan */
+ job->crop[0] = AutoCropTop;
+ job->crop[1] = AutoCropBottom;
+ job->crop[2] = AutoCropLeft;
+ job->crop[3] = AutoCropRight;
+
}
- /*Subtitles*/
- [fSubPopUp selectItemWithTitle:[queueToApply objectForKey:@"Subtitles"]];
- /* Forced Subtitles */
- [fSubForcedCheck setState:[[queueToApply objectForKey:@"SubtitlesForced"] intValue]];
-
- /* Picture Settings */
/* we check to make sure the presets width/height does not exceed the sources width/height */
if (fTitle->width < [[queueToApply objectForKey:@"PictureWidth"] intValue] || fTitle->height < [[queueToApply objectForKey:@"PictureHeight"] intValue])
{
/* if so, then we use the sources height and width to avoid scaling up */
- job->width = fTitle->width;
- job->height = fTitle->height;
+ //job->width = fTitle->width;
+ //job->height = fTitle->height;
+ [self revertPictureSizeToMax:nil];
}
else // source width/height is >= the preset height/width
{
job->anamorphic.mode = [[queueToApply objectForKey:@"PicturePAR"] intValue];
- /* If Cropping is set to custom, then recall all four crop values from
- when the preset was created and apply them */
- if ([[queueToApply objectForKey:@"PictureAutoCrop"] intValue] == 0)
+ [self writeToActivityLog: "applyQueueSettingsToMainWindow: picture sizing set up"];
+
+
+ /* Filters */
+
+ /* We only allow *either* Decomb or Deinterlace. So check for the PictureDecombDeinterlace key.
+ * also, older presets may not have this key, in which case we also check to see if that preset had PictureDecomb
+ * specified, in which case we use decomb and ignore any possible Deinterlace settings as using both was less than
+ * sane.
+ */
+ [fPictureController setUseDecomb:1];
+ [fPictureController setDecomb:0];
+ [fPictureController setDeinterlace:0];
+ if ([[queueToApply objectForKey:@"PictureDecombDeinterlace"] intValue] == 1 || [[queueToApply objectForKey:@"PictureDecomb"] intValue] > 0)
{
- [fPictureController setAutoCrop:NO];
-
- /* Here we use the custom crop values saved at the time the preset was saved */
- job->crop[0] = [[queueToApply objectForKey:@"PictureTopCrop"] intValue];
- job->crop[1] = [[queueToApply objectForKey:@"PictureBottomCrop"] intValue];
- job->crop[2] = [[queueToApply objectForKey:@"PictureLeftCrop"] intValue];
- job->crop[3] = [[queueToApply objectForKey:@"PictureRightCrop"] intValue];
-
+ /* we are using decomb */
+ /* Decomb */
+ if ([[queueToApply objectForKey:@"PictureDecomb"] intValue] > 0)
+ {
+ [fPictureController setDecomb:[[queueToApply objectForKey:@"PictureDecomb"] intValue]];
+
+ /* if we are using "Custom" in the decomb setting, also set the custom string*/
+ if ([[queueToApply objectForKey:@"PictureDecomb"] intValue] == 1)
+ {
+ [fPictureController setDecombCustomString:[queueToApply objectForKey:@"PictureDecombCustom"]];
+ }
+ }
}
- else /* if auto crop has been saved in preset, set to auto and use post scan auto crop */
+ else
{
- [fPictureController setAutoCrop:YES];
- /* Here we use the auto crop values determined right after scan */
- job->crop[0] = AutoCropTop;
- job->crop[1] = AutoCropBottom;
- job->crop[2] = AutoCropLeft;
- job->crop[3] = AutoCropRight;
-
+ /* We are using Deinterlace */
+ /* Deinterlace */
+ if ([[queueToApply objectForKey:@"PictureDeinterlace"] intValue] > 0)
+ {
+ [fPictureController setUseDecomb:0];
+ [fPictureController setDeinterlace:[[queueToApply objectForKey:@"PictureDeinterlace"] intValue]];
+ /* if we are using "Custom" in the deinterlace setting, also set the custom string*/
+ if ([[queueToApply objectForKey:@"PictureDeinterlace"] intValue] == 1)
+ {
+ [fPictureController setDeinterlaceCustomString:[queueToApply objectForKey:@"PictureDeinterlaceCustom"]];
+ }
+ }
}
- /* Filters */
- /* Deinterlace */
- [fPictureController setDeinterlace:[[queueToApply objectForKey:@"PictureDeinterlace"] intValue]];
/* Detelecine */
- [fPictureController setDetelecine:[[queueToApply objectForKey:@"PictureDetelecine"] intValue]];
+ if ([[queueToApply objectForKey:@"PictureDetelecine"] intValue] > 0)
+ {
+ [fPictureController setDetelecine:[[queueToApply objectForKey:@"PictureDetelecine"] intValue]];
+ /* if we are using "Custom" in the detelecine setting, also set the custom string*/
+ if ([[queueToApply objectForKey:@"PictureDetelecine"] intValue] == 1)
+ {
+ [fPictureController setDetelecineCustomString:[queueToApply objectForKey:@"PictureDetelecineCustom"]];
+ }
+ }
+ else
+ {
+ [fPictureController setDetelecine:0];
+ }
+
/* Denoise */
- [fPictureController setDenoise:[[queueToApply objectForKey:@"PictureDenoise"] intValue]];
+ if ([[queueToApply objectForKey:@"PictureDenoise"] intValue] > 0)
+ {
+ [fPictureController setDenoise:[[queueToApply objectForKey:@"PictureDenoise"] intValue]];
+ /* if we are using "Custom" in the denoise setting, also set the custom string*/
+ if ([[queueToApply objectForKey:@"PictureDenoise"] intValue] == 1)
+ {
+ [fPictureController setDenoiseCustomString:[queueToApply objectForKey:@"PictureDenoiseCustom"]];
+ }
+ }
+ else
+ {
+ [fPictureController setDenoise:0];
+ }
+
/* Deblock */
- [fPictureController setDeblock:[[queueToApply objectForKey:@"PictureDeblock"] intValue]];
- /* Decomb */
- [fPictureController setDecomb:[[queueToApply objectForKey:@"PictureDecomb"] intValue]];
- /* Grayscale */
- [fPictureController setGrayscale:[[queueToApply objectForKey:@"VideoGrayScale"] intValue]];
+ if ([[queueToApply objectForKey:@"PictureDeblock"] intValue] == 1)
+ {
+ /* if its a one, then its the old on/off deblock, set on to 5*/
+ [fPictureController setDeblock:5];
+ }
+ else
+ {
+ /* use the settings intValue */
+ [fPictureController setDeblock:[[queueToApply objectForKey:@"PictureDeblock"] intValue]];
+ }
- [self calculatePictureSizing:nil];
+ if ([[queueToApply objectForKey:@"VideoGrayScale"] intValue] == 1)
+ {
+ [fPictureController setGrayscale:1];
+ }
+ else
+ {
+ [fPictureController setGrayscale:0];
+ }
+ /* we call SetTitle: in fPictureController so we get an instant update in the Picture Settings window */
+ [fPictureController SetTitle:fTitle];
+ [fPictureController SetTitle:fTitle];
+ [self calculatePictureSizing:nil];
+ [self writeToActivityLog: "applyQueueSettingsToMainWindow: picture filters set up"];
/* somehow we need to figure out a way to tie the queue item to a preset if it used one */
//[queueFileJob setObject:[fPresetSelectedDisplay stringValue] forKey:@"PresetName"];
// [queueFileJob setObject:[NSNumber numberWithInt:[fPresetsOutlineView selectedRow]] forKey:@"PresetIndexNum"];
/* We need to set this bool back to NO, in case the user wants to do a scan */
//applyQueueToScan = NO;
- /* so now we go ahead and process the new settings */
- [self processNewQueueEncode];
+ /* Not that source is loaded and settings applied, delete the queue item from the queue */
+ [self writeToActivityLog: "applyQueueSettingsToMainWindow: deleting queue item:%d",fqueueEditRescanItemNum];
+ [self removeQueueFileItem:fqueueEditRescanItemNum];
}
-/* This assumes that we have re-scanned and loaded up a new queue item to send to libhb as fQueueEncodeLibhb */
-- (void) processNewQueueEncode
-{
- hb_list_t * list = hb_get_titles( fQueueEncodeLibhb );
- hb_title_t * title = (hb_title_t *) hb_list_item( list,0 ); // is always zero since now its a single title scan
- hb_job_t * job = title->job;
-
- if( !hb_list_count( list ) )
- {
- [self writeToActivityLog: "processNewQueueEncode WARNING nothing found in the title list"];
- }
-
- NSMutableDictionary * queueToApply = [QueueFileArray objectAtIndex:currentQueueEncodeIndex];
- [self writeToActivityLog: "Preset: %s", [[queueToApply objectForKey:@"PresetName"] UTF8String]];
- [self writeToActivityLog: "processNewQueueEncode number of passes expected is: %d", ([[queueToApply objectForKey:@"VideoTwoPass"] intValue] + 1)];
- job->file = [[queueToApply objectForKey:@"DestinationPath"] UTF8String];
- //[self writeToActivityLog: "processNewQueueEncode sending to prepareJob"];
- [self prepareJob];
-
- /*
- * If scanning we need to do some extra setup of the job.
- */
- if( job->indepth_scan == 1 )
- {
- char *x264opts_tmp;
-
- /*
- * When subtitle scan is enabled do a fast pre-scan job
- * which will determine which subtitles to enable, if any.
- */
- job->pass = -1;
- x264opts_tmp = job->x264opts;
-
- job->x264opts = NULL;
-
- job->indepth_scan = 1;
-
-
- /*
- * Add the pre-scan job
- */
- hb_add( fQueueEncodeLibhb, job );
- job->x264opts = x264opts_tmp;
- }
-
-
- if( [[queueToApply objectForKey:@"VideoTwoPass"] intValue] == 1 )
- {
- job->indepth_scan = 0;
-
-
-
- job->pass = 1;
-
- hb_add( fQueueEncodeLibhb, job );
-
- job->pass = 2;
-
- job->x264opts = (char *)calloc(1024, 1); /* Fixme, this just leaks */
- strcpy(job->x264opts, [[queueToApply objectForKey:@"x264Option"] UTF8String]);
-
- hb_add( fQueueEncodeLibhb, job );
-
- }
- else
- {
- job->indepth_scan = 0;
- job->pass = 0;
-
- hb_add( fQueueEncodeLibhb, job );
- }
-
- NSString *destinationDirectory = [[queueToApply objectForKey:@"DestinationPath"] stringByDeletingLastPathComponent];
- [[NSUserDefaults standardUserDefaults] setObject:destinationDirectory forKey:@"LastDestinationDirectory"];
- /* Lets mark our new encode as 1 or "Encoding" */
- [queueToApply setObject:[NSNumber numberWithInt:1] forKey:@"Status"];
- [self saveQueueFileItem];
-
- /* we need to clean up the subtitle tracks after the job(s) have been set */
- int num_subtitle_tracks = hb_list_count(job->list_subtitle);
- int ii;
- for(ii = 0; ii < num_subtitle_tracks; ii++)
- {
- hb_subtitle_t * subtitle;
- subtitle = (hb_subtitle_t *)hb_list_item(job->list_subtitle, 0);
-
-
- hb_list_rem(job->list_subtitle, subtitle);
- free(subtitle);
- }
-
-
- /* We should be all setup so let 'er rip */
- [self doRip];
-}
-
#pragma mark -
#pragma mark Live Preview
/* Note,this is much like prepareJob, but directly sets the job vars so Picture Preview
}
/* Subtitle settings */
- NSMutableArray *subtitlesArray = nil;
- subtitlesArray = [[NSMutableArray alloc] initWithArray:[fSubtitlesDelegate getSubtitleArray: subtitlesArray]];
+ NSMutableArray *subtitlesArray = [[NSMutableArray alloc] initWithArray:[fSubtitlesDelegate getSubtitleArray] copyItems:YES];
-
- int subtitle = nil;
+int subtitle = nil;
int force;
int burned;
int def;
if (subt != NULL)
{
- [self writeToActivityLog: "Setting Subtitle: %s", subt];
-
hb_subtitle_config_t sub_config = subt->config;
if (!burned && job->mux == HB_MUX_MKV &&
hb_audio_config_t * audio;
/* Title Angle for dvdnav */
job->angle = [[queueToApply objectForKey:@"TitleAngle"] intValue];
- /* Chapter selection */
- job->chapter_start = [[queueToApply objectForKey:@"JobChapterStart"] intValue];
- job->chapter_end = [[queueToApply objectForKey:@"JobChapterEnd"] intValue];
+
+ if([[queueToApply objectForKey:@"fEncodeStartStop"] intValue] == 0)
+ {
+ /* Chapter selection */
+ [self writeToActivityLog: "Start / Stop set to chapters"];
+ job->chapter_start = [[queueToApply objectForKey:@"JobChapterStart"] intValue];
+ job->chapter_end = [[queueToApply objectForKey:@"JobChapterEnd"] intValue];
+ }
+ else if ([[queueToApply objectForKey:@"fEncodeStartStop"] intValue] == 1)
+ {
+ /* we are pts based start / stop */
+ [self writeToActivityLog: "Start / Stop set to seconds ..."];
+
+ /* Point A to Point B. Since we cannot get frame accurate start times, attempt to glean a semi-accurate start time based on a percentage of the
+ * scanned title time as per live preview, while in some cases inaccurate its the best I can do with what I have barring a pre-scan index afaik.
+ */
+ /* Attempt to bastardize the live preview code to get a roughly 1 second accurate point a to point b encode ... */
+ /* get the start seconds from the start seconds field */
+ int start_seconds = [[queueToApply objectForKey:@"StartSeconds"] intValue];
+ //job->start_at_preview = start_seconds;
+ /* The number of seek points equals the number of seconds announced in the title as that is our current granularity */
+ //job->seek_points = [[queueToApply objectForKey:@"SourceTotalSeconds"] intValue];
+ job->pts_to_start = start_seconds * 90000LL;
+ /* Stop seconds is actually the duration of encode, so subtract the end seconds from the start seconds */
+ int stop_seconds = [[queueToApply objectForKey:@"StopSeconds"] intValue];
+ job->pts_to_stop = stop_seconds * 90000LL;
+
+ /* A bunch of verbose activity log messages to check on what should be expected */
+ [self writeToActivityLog: "point a to b should start at: %d seconds", start_seconds];
+ [self writeToActivityLog: "point a to b should start at (hh:mm:ss): %d:%d:%d", start_seconds / 3600, ( start_seconds / 60 ) % 60,start_seconds % 60];
+ [self writeToActivityLog: "point a to b duration: %d seconds", stop_seconds];
+ [self writeToActivityLog: "point a to b duration (hh:mm:ss): %d:%d:%d", stop_seconds / 3600, ( stop_seconds / 60 ) % 60,stop_seconds % 60];
+ [self writeToActivityLog: "point a to b should end at: %d seconds", start_seconds + stop_seconds];
+ [self writeToActivityLog: "point a to b should end at (hh:mm:ss): %d:%d:%d", (start_seconds + stop_seconds) / 3600, ( (start_seconds + stop_seconds) / 60 ) % 60,(start_seconds + stop_seconds) % 60];
+ }
+ else if ([[queueToApply objectForKey:@"fEncodeStartStop"] intValue] == 2)
+ {
+ /* we are frame based start / stop */
+ [self writeToActivityLog: "Start / Stop set to frames ..."];
+
+ /* Point A to Point B. Since we cannot get frame accurate start times, attempt to glean a semi-accurate start time based on a percentage of the
+ * scanned title time as per live preview, while in some cases inaccurate its the best I can do with what I have barring a pre-scan index afaik.
+ */
+ /* Attempt to bastardize the live preview code to get a roughly 1 second accurate point a to point b encode ... */
+ /* get the start seconds from the start seconds field */
+ int start_frame = [[queueToApply objectForKey:@"StartFrame"] intValue];
+ //job->start_at_preview = start_seconds;
+ /* The number of seek points equals the number of seconds announced in the title as that is our current granularity */
+ //job->seek_points = [[queueToApply objectForKey:@"SourceTotalSeconds"] intValue];
+ job->frame_to_start = start_frame;
+ /* Stop seconds is actually the duration of encode, so subtract the end seconds from the start seconds */
+ int stop_frame = [[queueToApply objectForKey:@"StopFrame"] intValue];
+ job->frame_to_stop = stop_frame;
+
+ /* A bunch of verbose activity log messages to check on what should be expected */
+ [self writeToActivityLog: "point a to b should start at frame %d", start_frame];
+ [self writeToActivityLog: "point a to b duration: %d frames", stop_frame];
+ [self writeToActivityLog: "point a to b should end at frame %d", start_frame + stop_frame];
+ }
+
+
+
/* Format (Muxer) and Video Encoder */
job->mux = [[queueToApply objectForKey:@"JobFileFormatMux"] intValue];
job->vcodec = [[queueToApply objectForKey:@"JobVideoEncoderVcodec"] intValue];
sub_config.offset = [[tempObject objectForKey:@"subtitleTrackSrtOffset"] intValue];
/* we need to srncpy file name and codeset */
- //sub_config.src_filename = [[tempObject objectForKey:@"subtitleSourceSrtFilePath"] UTF8String];
strncpy(sub_config.src_filename, [[tempObject objectForKey:@"subtitleSourceSrtFilePath"] UTF8String], 128);
- //sub_config.src_codeset = [[tempObject objectForKey:@"subtitleTrackSrtCharCode"] UTF8String];
strncpy(sub_config.src_codeset, [[tempObject objectForKey:@"subtitleTrackSrtCharCode"] UTF8String], 40);
sub_config.force = 0;
if (subt != NULL)
{
- [self writeToActivityLog: "Setting Subtitle: %s", subt];
-
hb_subtitle_config_t sub_config = subt->config;
if (!burned && job->mux == HB_MUX_MKV &&
hb_title_t * title = (hb_title_t*)
hb_list_item( list, [fSrcTitlePopUp indexOfSelectedItem] );
+ /* If we are a stream type, grok the output file name from title->name upon title change */
+ if (title->type == HB_STREAM_TYPE)
+ {
+ /* we set the default name according to the new title->name */
+ [fDstFile2Field setStringValue: [NSString stringWithFormat:
+ @"%@/%@.%@", [[fDstFile2Field stringValue] stringByDeletingLastPathComponent],
+ [NSString stringWithUTF8String: title->name],
+ [[fDstFile2Field stringValue] pathExtension]]];
+ /* If we have more than one title and are stream then we have a batch, change the source to read out the parent folder also */
+ if ( hb_list_count( list ) > 1 )
+ {
+ [fSrcDVD2Field setStringValue:[NSString stringWithFormat:@"%@/%@", browsedSourceDisplayName,[NSString stringWithUTF8String: title->name]]];
+ }
+ }
+
+ /* For point a to point b pts encoding, set the start and end fields to 0 and the title duration in seconds respectively */
+ int duration = (title->hours * 3600) + (title->minutes * 60) + (title->seconds);
+ [fSrcTimeStartEncodingField setStringValue: [NSString stringWithFormat: @"%d", 0]];
+ [fSrcTimeEndEncodingField setStringValue: [NSString stringWithFormat: @"%d", duration]];
+ /* For point a to point b frame encoding, set the start and end fields to 0 and the title duration * announced fps in seconds respectively */
+ [fSrcFrameStartEncodingField setStringValue: [NSString stringWithFormat: @"%d", 1]];
+ //[fSrcFrameEndEncodingField setStringValue: [NSString stringWithFormat: @"%d", ((title->hours * 3600) + (title->minutes * 60) + (title->seconds)) * 24]];
+ [fSrcFrameEndEncodingField setStringValue: [NSString stringWithFormat: @"%d", duration * (title->rate / title->rate_base)]];
+
/* If Auto Naming is on. We create an output filename of dvd name - title number */
if( [[NSUserDefaults standardUserDefaults] boolForKey:@"DefaultAutoNaming"] > 0 && ( hb_list_count( list ) > 1 ) )
{
title->index,
[[fDstFile2Field stringValue] pathExtension]]];
}
-
+ /* Update encode start / stop variables */
+
+
+
/* Update chapter popups */
[fSrcChapterStartPopUp removeAllItems];
[fSrcChapterEndPopUp removeAllItems];
[self selectPreset:nil];
}
+- (IBAction) encodeStartStopPopUpChanged: (id) sender;
+{
+ if( [fEncodeStartStopPopUp isEnabled] )
+ {
+ /* We are chapters */
+ if( [fEncodeStartStopPopUp indexOfSelectedItem] == 0 )
+ {
+ [fSrcChapterStartPopUp setHidden: NO];
+ [fSrcChapterEndPopUp setHidden: NO];
+
+ [fSrcTimeStartEncodingField setHidden: YES];
+ [fSrcTimeEndEncodingField setHidden: YES];
+
+ [fSrcFrameStartEncodingField setHidden: YES];
+ [fSrcFrameEndEncodingField setHidden: YES];
+
+ [self chapterPopUpChanged:nil];
+ }
+ /* We are time based (seconds) */
+ else if ([fEncodeStartStopPopUp indexOfSelectedItem] == 1)
+ {
+ [fSrcChapterStartPopUp setHidden: YES];
+ [fSrcChapterEndPopUp setHidden: YES];
+
+ [fSrcTimeStartEncodingField setHidden: NO];
+ [fSrcTimeEndEncodingField setHidden: NO];
+
+ [fSrcFrameStartEncodingField setHidden: YES];
+ [fSrcFrameEndEncodingField setHidden: YES];
+
+ [self startEndSecValueChanged:nil];
+ }
+ /* We are frame based */
+ else if ([fEncodeStartStopPopUp indexOfSelectedItem] == 2)
+ {
+ [fSrcChapterStartPopUp setHidden: YES];
+ [fSrcChapterEndPopUp setHidden: YES];
+
+ [fSrcTimeStartEncodingField setHidden: YES];
+ [fSrcTimeEndEncodingField setHidden: YES];
+
+ [fSrcFrameStartEncodingField setHidden: NO];
+ [fSrcFrameEndEncodingField setHidden: NO];
+
+ [self startEndFrameValueChanged:nil];
+ }
+ }
+}
+
- (IBAction) chapterPopUpChanged: (id) sender
{
[fSrcDuration2Field setStringValue: [NSString stringWithFormat:
@"%02lld:%02lld:%02lld", duration / 3600, ( duration / 60 ) % 60,
duration % 60]];
-
+
[self calculateBitrate: sender];
if ( [fSrcChapterStartPopUp indexOfSelectedItem] == [fSrcChapterEndPopUp indexOfSelectedItem] )
}
}
+- (IBAction) startEndSecValueChanged: (id) sender
+{
+
+ int duration = [fSrcTimeEndEncodingField intValue] - [fSrcTimeStartEncodingField intValue];
+ [fSrcDuration2Field setStringValue: [NSString stringWithFormat:
+ @"%02d:%02d:%02d", duration / 3600, ( duration / 60 ) % 60,
+ duration % 60]];
+
+ //[self calculateBitrate: sender];
+
+}
+
+- (IBAction) startEndFrameValueChanged: (id) sender
+{
+ hb_list_t * list = hb_get_titles( fHandle );
+ hb_title_t * title = (hb_title_t*)
+ hb_list_item( list, [fSrcTitlePopUp indexOfSelectedItem] );
+
+ int duration = ([fSrcFrameEndEncodingField intValue] - [fSrcFrameStartEncodingField intValue]) / (title->rate / title->rate_base);
+ [fSrcDuration2Field setStringValue: [NSString stringWithFormat:
+ @"%02d:%02d:%02d", duration / 3600, ( duration / 60 ) % 60,
+ duration % 60]];
+
+ //[self calculateBitrate: sender];
+}
+
+
- (IBAction) formatPopUpChanged: (id) sender
{
NSString * string = [fDstFile2Field stringValue];
float sliderRfInverse = ([fVidQualitySlider maxValue] - [fVidQualitySlider floatValue]) + [fVidQualitySlider minValue];
/* If the encoder is theora, use the float, otherwise use the inverse float*/
- float sliderRfToPercent;
+ //float sliderRfToPercent;
if ([[fVidEncoderPopUp selectedItem] tag] == HB_VCODEC_THEORA)
{
- [fVidQualityRFField setStringValue: [NSString stringWithFormat: @"%.2f", [fVidQualitySlider floatValue]]];
- sliderRfToPercent = [fVidQualityRFField floatValue] / ([fVidQualitySlider maxValue] - [fVidQualitySlider minValue]);
+ [fVidQualityRFField setStringValue: [NSString stringWithFormat: @"%.2f", [fVidQualitySlider floatValue]]];
}
else
{
[fVidQualityRFField setStringValue: [NSString stringWithFormat: @"%.2f", sliderRfInverse]];
- sliderRfToPercent = ( ([fVidQualitySlider maxValue] - [fVidQualitySlider minValue]) - ([fVidQualityRFField floatValue] - [fVidQualitySlider minValue])) / ([fVidQualitySlider maxValue] - [fVidQualitySlider minValue]);
}
- [fVidConstantCell setTitle: [NSString stringWithFormat:
- NSLocalizedString( @"Constant quality: %.2f %%", @"" ), 100 * sliderRfToPercent]];
-
[self customSettingUsed: sender];
}
[self audioTrackPopUpChanged: audiocodecPopUp];
[mixdownPopUp selectItemWithTitle:[tempObject objectForKey:@"AudioMixdown"]];
- /* check to see if the selections was available, if not, rerun audioTrackPopUpChanged using the codec to just set the default
+ [self audioTrackMixdownChanged: mixdownPopUp];
+ /* check to see if the selection was available, if not, rerun audioTrackPopUpChanged using the codec to just set the default
* mixdown*/
if ([mixdownPopUp selectedItem] == nil)
{
[self audioTrackPopUpChanged: audiocodecPopUp];
+ [self writeToActivityLog: "presetSelected mixdown not selected, rerun audioTrackPopUpChanged"];
}
[sampleratePopUp selectItemWithTitle:[tempObject objectForKey:@"AudioSamplerate"]];
/* We set the presets bitrate if it is *not* an AC3 track since that uses the input bitrate */
if (![[tempObject objectForKey:@"AudioEncoder"] isEqualToString:@"AC3 Passthru"])
{
[bitratePopUp selectItemWithTitle:[tempObject objectForKey:@"AudioBitrate"]];
+ /* check to see if the bitrate selection was available, if not, rerun audioTrackMixdownChanged using the mixdown to just set the
+ *default mixdown bitrate*/
+ if ([bitratePopUp selectedItem] == nil)
+ {
+ [self audioTrackMixdownChanged: mixdownPopUp];
+ }
}
[drcSlider setFloatValue:[[tempObject objectForKey:@"AudioTrackDRCSlider"] floatValue]];
[self audioDRCSliderChanged: drcSlider];
OSDN Git Service
