Changeset 377768a


Ignore:
Timestamp:
01/30/10 23:52:47 (7 years ago)
Author:
sr55 <sr55.hb@…>
Branches:
master
Children:
0581eb1
Parents:
971ab73
Message:

WinGui:

  • Added some code to allow direct execution of the CLI rather than using CMD. This may be useful later on.
  • Re-factoring. Added Many code comments / Cleaned up some code style issues.

git-svn-id: svn://svn.handbrake.fr/HandBrake/trunk@3088 b64f7644-9d1e-0410-96f1-a4d463321fa5

Location:
win/C#
Files:
1 added
1 deleted
12 edited
2 moved

Legend:

Unmodified
Added
Removed
  • win/C#/EncodeQueue/Encode.cs

    r9ae5e6d r377768a  
    1313namespace Handbrake.EncodeQueue
    1414{
     15    /// <summary>
     16    /// Class which handles the CLI
     17    /// </summary>
    1518    public class Encode
    1619    {
     20        /// <summary>
     21        /// Process ID
     22        /// </summary>
    1723        private int ProcessID { get; set; }
    1824
     
    121127
    122128        /// <summary>
     129        /// Function to run the CLI directly rather than via CMD
     130        /// TODO: Code to handle the Log data has yet to be written.
     131        /// TODO: Code to handle the % / ETA info has to be written.
     132        /// </summary>
     133        protected void DirectRun(string query)
     134        {
     135            try
     136            {
     137                if (EncodeStarted != null)
     138                    EncodeStarted(this, new EventArgs());
     139
     140                IsEncoding = true;
     141
     142                // Setup the job
     143                string handbrakeCLIPath = Path.Combine(Environment.CurrentDirectory, "HandBrakeCLI.exe");
     144                Process hbProc = new Process
     145                {
     146                    StartInfo =
     147                    {
     148                        FileName = handbrakeCLIPath,
     149                        Arguments = query,
     150                        UseShellExecute = false,
     151                        RedirectStandardOutput = true,
     152                        RedirectStandardError = true,
     153                        RedirectStandardInput = true,
     154                        CreateNoWindow = false,
     155                        WindowStyle = ProcessWindowStyle.Minimized
     156                    }
     157                };
     158
     159                // Setup the redirects
     160                hbProc.ErrorDataReceived += new DataReceivedEventHandler(HbProcErrorDataReceived);
     161                hbProc.OutputDataReceived += new DataReceivedEventHandler(HbProcOutputDataReceived);
     162
     163                // Start the process
     164                hbProc.Start();
     165
     166                // Set the Process Priority
     167                switch (Properties.Settings.Default.processPriority)
     168                {
     169                    case "Realtime":
     170                        hbProc.PriorityClass = ProcessPriorityClass.RealTime;
     171                        break;
     172                    case "High":
     173                        hbProc.PriorityClass = ProcessPriorityClass.High;
     174                        break;
     175                    case "Above Normal":
     176                        hbProc.PriorityClass = ProcessPriorityClass.AboveNormal;
     177                        break;
     178                    case "Normal":
     179                        hbProc.PriorityClass = ProcessPriorityClass.Normal;
     180                        break;
     181                    case "Low":
     182                        hbProc.PriorityClass = ProcessPriorityClass.Idle;
     183                        break;
     184                    default:
     185                        hbProc.PriorityClass = ProcessPriorityClass.BelowNormal;
     186                        break;
     187                }
     188
     189                // Set the class items
     190                HbProcess = hbProc;
     191                ProcessID = hbProc.Id;
     192                ProcessHandle = hbProc.Handle;
     193
     194            }
     195            catch (Exception exc)
     196            {
     197                Console.WriteLine(exc);
     198            }
     199        }
     200
     201        /// <summary>
    123202        /// Kill the CLI process
    124203        /// </summary>
     
    139218
    140219        /// <summary>
     220        /// Attempt to Safely kill a DirectRun() CLI
     221        /// NOTE: This will not work with a MinGW CLI
     222        /// Note: http://www.cygwin.com/ml/cygwin/2006-03/msg00330.html
     223        /// </summary>
     224        public void SafelyClose()
     225        {
     226            if ((int)ProcessHandle == 0)
     227                return;
     228
     229            // Allow the CLI to exit cleanly
     230            Win32.SetForegroundWindow((int)ProcessHandle);
     231            SendKeys.Send("^C");
     232
     233            // HbProcess.StandardInput.AutoFlush = true;
     234            // HbProcess.StandardInput.WriteLine("^C");
     235        }
     236
     237        /// <summary>
     238        /// Recieve the Standard Error information and process it
     239        /// </summary>
     240        /// <param name="sender"></param>
     241        /// <param name="e"></param>
     242        private static void HbProcErrorDataReceived(object sender, DataReceivedEventArgs e)
     243        {
     244            // TODO: Recieve the Log data and process it
     245            throw new NotImplementedException();
     246        }
     247
     248        /// <summary>
     249        /// Standard Input Data Recieved from the CLI
     250        /// </summary>
     251        /// <param name="sender"></param>
     252        /// <param name="e"></param>
     253        private static void HbProcOutputDataReceived(object sender, DataReceivedEventArgs e)
     254        {
     255            // TODO: Recieve the %, ETA, FPS etc and process it
     256            throw new NotImplementedException();
     257        }
     258
     259        /// <summary>
    141260        /// Perform an action after an encode. e.g a shutdown, standby, restart etc.
    142261        /// </summary>
    143262        protected void Finish()
    144263        {
     264            if (EncodeEnded != null)
     265                EncodeEnded(this, new EventArgs());
     266
    145267            IsEncoding = false;
    146268
  • win/C#/EncodeQueue/Queue.cs

    r9ae5e6d r377768a  
    2222        private int NextJobId;
    2323
    24         #region Event Handlers
    25         /// <summary>
    26         /// Fires when an encode job has been started.
    27         /// </summary>
    28         public event EventHandler NewJobStarted;
    29 
    3024        /// <summary>
    3125        /// Fires when a pause to the encode queue has been requested.
     
    3428
    3529        /// <summary>
    36         /// Fires when an encode job has been completed.
    37         /// </summary>
    38         public event EventHandler CurrentJobCompleted;
    39 
    40         /// <summary>
    4130        /// Fires when the entire encode queue has completed.
    4231        /// </summary>
    4332        public event EventHandler QueueCompleted;
    44         #endregion
    4533
    4634        #region Queue
     
    330318                Run(query);
    331319
    332                 if (NewJobStarted != null)
    333                     NewJobStarted(this, new EventArgs());
    334 
    335320                HbProcess.WaitForExit();
    336321
     
    347332                    GrowlCommunicator.Notify("Encode Completed", "Put down that cocktail...\nyour Handbrake encode is done.");
    348333
    349                 if (CurrentJobCompleted != null)
    350                     CurrentJobCompleted(this, new EventArgs());
    351 
    352334                while (PauseRequested) // Need to find a better way of doing this.
    353335                {
  • win/C#/Functions/Main.cs

    rf6357db r377768a  
    126126        /// the Source Name, DVD title and DVD Chapters
    127127        /// </summary>
    128         public static string AutoName(frmMain mainWindow) //ComboBox drpDvdtitle, string chapter_start, string chatper_end, string source, string dest, int format, Boolean chapters)
     128        public static string AutoName(frmMain mainWindow)
    129129        {
    130130            string AutoNamePath = string.Empty;
  • win/C#/Functions/PresetLoader.cs

    r8d85eac r377768a  
    88using System.Drawing;
    99using System.Windows.Forms;
     10using Handbrake.Model;
    1011
    1112namespace Handbrake.Functions
     
    2122        /// <param name="name">Name of the preset</param>
    2223        /// <param name="pictureSettings">Save picture settings in the preset</param>
    23         public static void presetLoader(frmMain mainWindow, QueryParser presetQuery, string name, Boolean pictureSettings)
     24        public static void LoadPreset(frmMain mainWindow, QueryParser presetQuery, string name, Boolean pictureSettings)
    2425        {
    25             // ---------------------------
    26             // Setup the GUI
    27             // ---------------------------
    28 
    2926            #region Source
    3027            // Reset some vaules to stock first to prevent errors.
  • win/C#/Functions/QueryGenerator.cs

    rf6357db r377768a  
    1818        /// Generates a full CLI query for either encoding or previe encoeds if duration and preview are defined.
    1919        /// </summary>
    20         /// <param name="mainWindow"></param>
    21         /// <param name="mode"></param>
    22         /// <param name="duration"></param>
    23         /// <param name="preview"></param>
    24         /// <returns></returns>
    25         public string GenerateCLIQuery(frmMain mainWindow, int mode, int duration, string preview)
     20        /// <param name="mainWindow">The Main Window</param>
     21        /// <param name="mode">What Mode. (Point to Point Encoding)  Chapters, Seconds, Frames OR Preview Encode</param>
     22        /// <param name="duration">time in seconds for preview mode</param>
     23        /// <param name="preview"> --start-at-preview (int) </param>
     24        /// <returns>CLI Query </returns>
     25        public static string GenerateCLIQuery(frmMain mainWindow, int mode, int duration, string preview)
    2626        {
    2727            string query = "";
     
    543543        }
    544544
     545        /// <summary>
     546        /// Return the CLI Mixdown name
     547        /// </summary>
     548        /// <param name="selectedAudio">GUI mixdown name</param>
     549        /// <returns>CLI mixdown name</returns>
    545550        private static string GetMixDown(string selectedAudio)
    546551        {
     
    563568            }
    564569        }
     570
     571        /// <summary>
     572        /// Get the CLI Audio Encoder name
     573        /// </summary>
     574        /// <param name="selectedEncoder">string The GUI Encode name</param>
     575        /// <returns>string CLI encoder name</returns>
    565576        private static string GetAudioEncoder(string selectedEncoder)
    566577        {
     
    581592            }
    582593        }
     594
     595        /// <summary>
     596        /// Create a CSV file with the data from the Main Window Chapters tab
     597        /// </summary>
     598        /// <param name="mainWindow">Main Window</param>
     599        /// <param name="filePathName">Path to save the csv file</param>
     600        /// <returns>True if successful </returns>
    583601        private static Boolean ChapterCSVSave(frmMain mainWindow, string filePathName)
    584602        {
  • win/C#/Functions/QueryParser.cs

    r8d85eac r377768a  
    1010using System.Windows.Forms;
    1111using System.Collections;
     12using Handbrake.Model;
    1213
    1314namespace Handbrake.Functions
    1415{
    15     internal class QueryParser
     16    public class QueryParser
    1617    {
    1718        private static readonly CultureInfo Culture = new CultureInfo("en-US", false);
     
    366367
    367368                // Create new Audio Track Classes and store them in the ArrayList
    368                 ArrayList AllAudioTrackInfo = new ArrayList();
     369                ArrayList allAudioTrackInfo = new ArrayList();
    369370                for (int x = 0; x < encoderCount; x++)
    370371                {
     
    394395                            track.DRC = trackDRCvalues[x].Trim();
    395396
    396                     AllAudioTrackInfo.Add(track);
    397                 }
    398                 thisQuery.AudioInformation = AllAudioTrackInfo;
     397                    allAudioTrackInfo.Add(track);
     398                }
     399                thisQuery.AudioInformation = allAudioTrackInfo;
    399400
    400401                // Subtitle Stuff
     
    432433            return thisQuery;
    433434        }
     435
     436        /// <summary>
     437        /// Get the GUI equiv to a CLI mixdown
     438        /// </summary>
     439        /// <param name="mixdown"></param>
     440        /// <returns></returns>
    434441        private static string GetMixDown(string mixdown)
    435442        {
     
    450457            }
    451458        }
     459
     460        /// <summary>
     461        /// Get the GUI equiv to a CLI audio encoder
     462        /// </summary>
     463        /// <param name="audioEnc"></param>
     464        /// <returns></returns>
    452465        private static string GetAudioEncoder(string audioEnc)
    453466        {
     
    469482        }
    470483    }
    471 
    472     public class AudioTrack
    473     {
    474         public AudioTrack()
    475         {
    476             // Default Values
    477             Track = "Automatic";
    478             MixDown = "Automatic";
    479             SampleRate = "Auto";
    480             Bitrate = "Auto";
    481             DRC = "1";
    482         }
    483         public string Track { get; set; }
    484         public string MixDown { get; set; }
    485         public string Encoder { get; set; }
    486         public string Bitrate { get; set; }
    487         public string SampleRate { get; set; }
    488         public string DRC { get; set; }
    489     }
    490484}
  • win/C#/Functions/Scan.cs

    r15678a6a r377768a  
    1616    public class Scan
    1717    {
    18         private DVD _thisDvd;
    19         private Parser _readData;
    20         private Process _hbProc;
    21         private string _scanProgress;
     18        private DVD ThisDvd;
     19        private Parser ReadData;
     20        private Process HbProc;
     21        private string ScanProgress;
     22
     23        /// <summary>
     24        /// Scan has Started
     25        /// </summary>
    2226        public event EventHandler ScanStared;
     27
     28        /// <summary>
     29        /// Scan has completed
     30        /// </summary>
    2331        public event EventHandler ScanCompleted;
     32
     33        /// <summary>
     34        /// Scan process has changed to a new title
     35        /// </summary>
    2436        public event EventHandler ScanStatusChanged;
    2537
     38        /// <summary>
     39        /// Scan a Source Path.
     40        /// Title 0: scan all
     41        /// </summary>
     42        /// <param name="sourcePath">Path to the file to scan</param>
     43        /// <param name="title">int title number. 0 for scan all</param>
    2644        public void ScanSource(string sourcePath, int title)
    2745        {
     
    3048        }
    3149
     50        /// <summary>
     51        /// Object containing the information parsed in the scan.
     52        /// </summary>
     53        /// <returns></returns>
    3254        public DVD SouceData()
    3355        {
    34             return _thisDvd;
     56            return ThisDvd;
    3557        }
    3658
     59        /// <summary>
     60        /// Raw log output from HandBrake CLI
     61        /// </summary>
     62        /// <returns></returns>
    3763        public String LogData()
    3864        {
    39             return _readData.Buffer;
     65            return ReadData.Buffer;
    4066        }
    4167
     68        /// <summary>
     69        /// Progress of the scan.
     70        /// </summary>
     71        /// <returns></returns>
    4272        public String ScanStatus()
    4373        {
    44             return _scanProgress;
     74            return ScanProgress;
    4575        }
    4676
     77        /// <summary>
     78        /// The Scan Process
     79        /// </summary>
     80        /// <returns></returns>
    4781        public Process ScanProcess()
    4882        {
    49             return _hbProc;
     83            return HbProc;
    5084        }
    5185
     86        /// <summary>
     87        /// Start a scan for a given source path and title
     88        /// </summary>
     89        /// <param name="sourcePath"></param>
     90        /// <param name="title"></param>
    5291        private void RunScan(object sourcePath, int title)
    5392        {
     
    69108                    dvdnav = " --no-dvdnav";
    70109
    71                 _hbProc = new Process
     110                HbProc = new Process
    72111                {
    73112                    StartInfo =
     
    81120                    }
    82121                };
    83                 _hbProc.Start();
     122                HbProc.Start();
    84123
    85                 _readData = new Parser(_hbProc.StandardError.BaseStream);
    86                 _readData.OnScanProgress += new ScanProgressEventHandler(OnScanProgress);
    87                 _thisDvd = DVD.Parse(_readData);
     124                ReadData = new Parser(HbProc.StandardError.BaseStream);
     125                ReadData.OnScanProgress += new ScanProgressEventHandler(OnScanProgress);
     126                ThisDvd = DVD.Parse(ReadData);
    88127
    89128                // Write the Buffer out to file.
    90129                StreamWriter scanLog = new StreamWriter(dvdInfoPath);
    91                 scanLog.Write(_readData.Buffer);
     130                scanLog.Write(ReadData.Buffer);
    92131                scanLog.Flush();
    93132                scanLog.Close();
     
    102141        }
    103142
     143        /// <summary>
     144        /// Fire an event when the scan process progresses
     145        /// </summary>
     146        /// <param name="sender"></param>
     147        /// <param name="currentTitle"></param>
     148        /// <param name="titleCount"></param>
    104149        private void OnScanProgress(object sender, int currentTitle, int titleCount)
    105150        {
    106             _scanProgress = string.Format("Processing Title: {0} of {1}", currentTitle, titleCount);
     151            ScanProgress = string.Format("Processing Title: {0} of {1}", currentTitle, titleCount);
    107152            if (ScanStatusChanged != null)
    108153                ScanStatusChanged(this, new EventArgs());
  • win/C#/HandBrakeCS.csproj

    r5a0f5af r377768a  
    223223      <DependentUpon>frmActivityWindow.cs</DependentUpon>
    224224    </Compile>
     225    <Compile Include="Model\AudioTrack.cs" />
    225226    <Compile Include="Presets\Export.cs" />
    226     <Compile Include="Presets\Import.cs" />
     227    <Compile Include="Presets\PlistPresetHandler.cs" />
    227228    <Compile Include="Presets\preset.cs" />
    228229    <Compile Include="Presets\PresetsHandler.cs" />
  • win/C#/Presets/PlistPresetHandler.cs

    r8d85eac r377768a  
    1 using System;
     1/*  PlistPresetHandler.cs $
     2       
     3           This file is part of the HandBrake source code.
     4           Homepage: <http://handbrake.fr/>.
     5           It may be used under the terms of the GNU General Public License. */
     6
     7using System;
    28using System.IO;
     9using System.Text;
    310using System.Xml;
    411using System.Windows.Forms;
    512using System.Collections;
    613using Handbrake.Functions;
     14using Handbrake.Model;
    715
    816namespace Handbrake.Presets
    917{
    10     class Import
     18    public class PlistPresetHandler
    1119    {
    12         public QueryParser importMacPreset(string filename)
     20        /* WARNING This file is not complete!!!!!!
     21         *
     22         * TODO
     23         * 1. Hookup all the widgets in the GUI so it exports real values.
     24         * 2. Check for any missing key/value pairs
     25         * 3. Test with MacGui / Cleanup code  / Retest
     26         */
     27
     28        private XmlTextWriter Writer;
     29
     30        /// <summary>
     31        /// Import a Plist preset generated by the Mac or Linux GUI
     32        /// </summary>
     33        /// <param name="filename"></param>
     34        /// <returns></returns>
     35        public static QueryParser Import(string filename)
    1336        {
    1437            XmlNode root = null;
     
    270293        }
    271294
    272         // --- It's the end of the road
     295        /// <summary>
     296        /// Export a preset to a Plist file readable by the Mac and Linux GUI's
     297        /// </summary>
     298        /// <param name="path"></param>
     299        public void Export(string path)
     300        {
     301            Writer = new XmlTextWriter("C:\\test.xml", Encoding.UTF8);
     302
     303            // Header
     304            Writer.WriteStartDocument();
     305            Writer.WriteDocType("plist", "-//Apple//DTD PLIST 1.0//EN", @"http://www.apple.com/DTDs/PropertyList-1.0.dtd", null);
     306
     307            Writer.WriteStartElement("plist");
     308            Writer.WriteStartElement("array");
     309
     310            // Add New Preset Here. Can write multiple presets here if required in future.
     311            WritePreset();
     312
     313            // Footer
     314            Writer.WriteEndElement();
     315            Writer.WriteEndElement();
     316
     317            Writer.WriteEndDocument();
     318
     319            // Closeout
     320            Writer.Close();
     321        }
     322       
     323        /// <summary>
     324        /// Write a Plist file
     325        /// </summary>
     326        private void WritePreset()
     327        {
     328            Writer.WriteStartElement("dict");
     329            AudioListArrayDict();
     330            AddEncodeSettings();
     331
     332            Writer.WriteEndElement();
     333        }
     334
     335        /// <summary>
     336        /// Add all the encode settings to the preset
     337        /// </summary>
     338        private void AddEncodeSettings()
     339        {
     340            AddEncodeElement("ChapterMarkers", "integer", "");
     341            AddEncodeElement("Default", "integer", "");
     342            AddEncodeElement("FileFormat", "String", "");
     343            AddBooleanElement("Folder", true);
     344            AddEncodeElement("Mp4HttpOptimize", "integer", "");
     345            AddEncodeElement("Mp4LargeFile", "integer", "");
     346            AddEncodeElement("Mp4iPodCompatible", "integer", "");
     347            AddEncodeElement("PictureAutoCrop", "integer", "");
     348            AddEncodeElement("PictureBottomCrop", "integer", "");
     349            AddEncodeElement("PictureDeblock", "integer", "");
     350            AddEncodeElement("PictureDecomb", "integer", "");
     351            AddEncodeElement("PictureDecombCustom", "string", "");
     352            AddEncodeElement("PictureDecombDeinterlace", "integer", "");
     353            AddEncodeElement("PictureDeinterlace", "integer", "");
     354            AddEncodeElement("PictureDeinterlaceCustom", "string", "");
     355            AddEncodeElement("PictureDenoise", "integer", "");
     356            AddEncodeElement("PictureDenoiseCustom", "string", "");
     357            AddEncodeElement("PictureDetelecine", "integer", "");
     358            AddEncodeElement("PictureDetelecineCustom", "string", "");
     359            AddEncodeElement("PictureHeight", "integer", "");
     360            AddEncodeElement("PictureKeepRatio", "integer", "");
     361            AddEncodeElement("PictureLeftCrop", "integer", "");
     362            AddEncodeElement("PicturePAR", "integer", "");
     363            AddEncodeElement("PictureRightCrop", "integer", "");
     364            AddEncodeElement("PictureTopCrop", "integer", "");
     365            AddEncodeElement("PictureWidth", "integer", "");
     366            AddEncodeElement("PresetBuildNumber", "string", "");
     367            AddEncodeElement("PresetDescription", "string", "");
     368            AddEncodeElement("PresetName", "string", "");
     369            AddEncodeElement("Type", "integer", "");
     370            AddEncodeElement("UsesMaxPictureSettings", "integer", "");
     371            AddEncodeElement("UsesPictureFilters", "integer", "");
     372            AddEncodeElement("UsesPictureSettings", "integer", "");
     373            AddEncodeElement("VideoAvgBitrate", "string", "");
     374            AddEncodeElement("VideoEncoder", "string", "");
     375            AddEncodeElement("VideoFramerate", "string", "");
     376            AddEncodeElement("VideoGrayScale", "integer", "");
     377            AddEncodeElement("VideoQualitySlider", "real", "");
     378            AddEncodeElement("VideoQualityType", "integer", "");
     379            AddEncodeElement("VideoTargetSize", "string", "");
     380            AddEncodeElement("VideoTurboTwoPass", "integer", "");
     381            AddEncodeElement("VideoTwoPass", "integer", "");
     382            AddEncodeElement("x264Option", "string", "");
     383        }
     384
     385        /// <summary>
     386        /// Add Preset setting + value
     387        /// </summary>
     388        /// <param name="keyName"></param>
     389        /// <param name="value"></param>
     390        private void AddBooleanElement(string keyName, Boolean value)
     391        {
     392            Writer.WriteStartElement("key");
     393            Writer.WriteString(keyName);
     394            Writer.WriteEndElement();
     395            if (value)
     396            {
     397                Writer.WriteStartElement("true");
     398                Writer.WriteEndElement();
     399            }
     400            else
     401            {
     402                Writer.WriteStartElement("false");
     403                Writer.WriteEndElement();
     404            }
     405        }
     406
     407        /// <summary>
     408        /// Add Preset setting + value
     409        /// </summary>
     410        /// <param name="keyName"></param>
     411        /// <param name="type"></param>
     412        /// <param name="value"></param>
     413        private void AddEncodeElement(string keyName, string type, string value)
     414        {
     415            Writer.WriteElementString("key", keyName);
     416            Writer.WriteElementString(type, value);
     417        }
     418
     419        /// <summary>
     420        /// Add List of audio tracks
     421        /// </summary>
     422        private void AudioListArrayDict()
     423        {
     424            Writer.WriteStartElement("key");
     425            Writer.WriteString("AudioList");
     426            Writer.WriteEndElement();
     427
     428            Writer.WriteStartElement("array");
     429            AddAudioItem();
     430            AddAudioItem();
     431            Writer.WriteEndElement();
     432        }
     433
     434        /// <summary>
     435        /// Add List of audio tracks
     436        /// </summary>
     437        private void AddAudioItem()
     438        {
     439            int bitrate = 448;
     440            string encoder = "AC3 Passthru";
     441            string mixdown = "AC3 Passthru";
     442            string sample = "Auto";
     443            int track = 1;
     444            double drc = 0.0;
     445            string desc = "English (AC3) (5.1 ch)";
     446
     447            Writer.WriteStartElement("dict");
     448
     449            Writer.WriteElementString("key", "AudioBitrate");
     450            Writer.WriteElementString("string", bitrate.ToString());
     451
     452            Writer.WriteElementString("key", "AudioEncoder");
     453            Writer.WriteElementString("string", encoder);
     454
     455            Writer.WriteElementString("key", "AudioMixdown");
     456            Writer.WriteElementString("string", mixdown);
     457
     458            Writer.WriteElementString("key", "AudioSamplerate");
     459            Writer.WriteElementString("string", sample);
     460
     461            Writer.WriteElementString("key", "AudioTrack");
     462            Writer.WriteElementString("integer", track.ToString());
     463
     464            Writer.WriteElementString("key", "AudioTrackDRCSlider");
     465            Writer.WriteElementString("real", drc.ToString());
     466
     467            Writer.WriteElementString("key", "AudioTrackDescription");
     468            Writer.WriteElementString("string", desc);
     469
     470            Writer.WriteEndElement();
     471        }
    273472    }
    274473}
  • win/C#/Presets/PresetsHandler.cs

    r52413428 r377768a  
    1717    public class PresetsHandler
    1818    {
    19         List<Preset> _presets = new List<Preset>();
    20         List<Preset> _userPresets = new List<Preset>();
     19        List<Preset> Presets = new List<Preset>();
     20        List<Preset> UserPresets = new List<Preset>();
    2121        private static readonly XmlSerializer Ser = new XmlSerializer(typeof(List<Preset>));
    22         readonly string _userPresetFile = Environment.GetFolderPath(Environment.SpecialFolder.ApplicationData) + "\\HandBrake\\user_presets.xml";
    23         readonly string _hbPresetFile = Environment.GetFolderPath(Environment.SpecialFolder.ApplicationData) + "\\HandBrake\\presets.xml";
     22        readonly string UserPresetFile = Environment.GetFolderPath(Environment.SpecialFolder.ApplicationData) + "\\HandBrake\\user_presets.xml";
     23        readonly string HbPresetFile = Environment.GetFolderPath(Environment.SpecialFolder.ApplicationData) + "\\HandBrake\\presets.xml";
    2424
    2525        /// <summary>
     
    2828        /// <param name="presetName">String, The name of the new preset</param>
    2929        /// <param name="query">String, the CLI query for the new preset</param>
    30         /// <param name="pictureSettings"> Bool, store crop/picture sizes in the _presets</param>
     30        /// <param name="pictureSettings"> Bool, store crop/picture sizes in the Presets</param>
    3131        public Boolean Add(string presetName, string query, Boolean pictureSettings)
    3232        {
     
    3434            {
    3535                Preset newPreset = new Preset { Name = presetName, Query = query, PictureSettings = pictureSettings, Version = Properties.Settings.Default.hb_version };
    36                 _userPresets.Add(newPreset);
     36                UserPresets.Add(newPreset);
    3737                UpdatePresetFiles();
    3838                return true;
     
    5151
    5252            // Built In Presets
    53             foreach (Preset item in _presets)
     53            foreach (Preset item in Presets)
    5454            {
    5555                if (item.Name != name)
     
    5858                }
    5959            }
    60             _presets = newPresets;
     60            Presets = newPresets;
    6161
    6262            // User Presets
    63             foreach (Preset item in _userPresets)
     63            foreach (Preset item in UserPresets)
    6464            {
    6565                if (item.Name != name)
     
    6868                }
    6969            }
    70             _userPresets = newUserPresets;
    71 
    72             // Rebuild the _userPresets.xml file
     70            UserPresets = newUserPresets;
     71
     72            // Rebuild the UserPresets.xml file
    7373            UpdatePresetFiles();
    7474            UpdatePresetFiles();
     
    7676
    7777        /// <summary>
    78         /// Remove all built in _presets;
     78        /// Remove all built in Presets;
    7979        /// </summary>
    8080        public void RemoveBuiltInPresets()
    8181        {
    82             _presets.Clear();
     82            Presets.Clear();
    8383            UpdatePresetFiles();
    8484        }
     
    9393        {
    9494            // User Presets
    95             foreach (Preset item in _userPresets)
     95            foreach (Preset item in UserPresets)
    9696            {
    9797                if (item.Name == presetName)
     
    113113        {
    114114            // Built In Presets
    115             foreach (Preset item in _presets)
     115            foreach (Preset item in Presets)
    116116            {
    117117                if (item.Name == name)
     
    120120
    121121            // User Presets
    122             foreach (Preset item in _userPresets)
     122            foreach (Preset item in UserPresets)
    123123            {
    124124                if (item.Name == name)
     
    134134        public void UpdateBuiltInPresets()
    135135        {
    136             // Create a new tempory file and execute the CLI to get the built in _presets.
     136            // Create a new tempory file and execute the CLI to get the built in Presets.
    137137            string handbrakeCLIPath = Path.Combine(Application.StartupPath, "HandBrakeCLI.exe");
    138138            string presetsPath = Path.Combine(Path.GetTempPath(), "temp_presets.dat");
     
    148148            }
    149149
    150             // Clear the current built in _presets and now parse the tempory _presets file.
    151             _presets.Clear();
     150            // Clear the current built in Presets and now parse the tempory Presets file.
     151            Presets.Clear();
    152152
    153153            if (File.Exists(presetsPath))
     
    180180                                                   PictureSettings = pic
    181181                                               };
    182                         _presets.Add(newPreset);
     182                        Presets.Add(newPreset);
    183183                    }
    184184                }
     
    187187            }
    188188
    189             // Finally, Create a new or update the current _presets.xml file
     189            // Finally, Create a new or update the current Presets.xml file
    190190            UpdatePresetFiles();
    191191        }
    192192
    193193        /// <summary>
    194         /// Load in the preset data from _presets.xml and _userPresets.xml
    195         /// Load it into the 2 arraylist's _presets and _userPresets
     194        /// Load in the preset data from Presets.xml and UserPresets.xml
     195        /// Load it into the 2 arraylist's Presets and UserPresets
    196196        /// </summary>
    197197        private void LoadPresetData()
    198198        {
    199             // First clear the _presets arraylists
    200             _presets.Clear();
    201             _userPresets.Clear();
     199            // First clear the Presets arraylists
     200            Presets.Clear();
     201            UserPresets.Clear();
    202202
    203203            try
    204204            {
    205                 // Load in the users _presets from _userPresets.xml
    206                 if (File.Exists(_hbPresetFile))
    207                 {
    208                     using (FileStream strm = new FileStream(_hbPresetFile, FileMode.Open, FileAccess.Read))
     205                // Load in the users Presets from UserPresets.xml
     206                if (File.Exists(HbPresetFile))
     207                {
     208                    using (FileStream strm = new FileStream(HbPresetFile, FileMode.Open, FileAccess.Read))
    209209                    {
    210210                        if (strm.Length != 0)
     
    214214                            if (list != null)
    215215                                foreach (Preset preset in list)
    216                                     _presets.Add(preset);
     216                                    Presets.Add(preset);
    217217                        }
    218218                    }
     
    223223                MessageBox.Show(
    224224                    "HandBrakes preset file appears to have been corrupted. This file will now be re-generated!\n" +
    225                     "If the problem presists, please delete the file: \n\n" + _hbPresetFile, "Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
     225                    "If the problem presists, please delete the file: \n\n" + HbPresetFile, "Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
    226226                UpdateBuiltInPresets();
    227227            }
     
    229229            try
    230230            {
    231                 // Load in the users _presets from _userPresets.xml
    232                 if (File.Exists(_userPresetFile))
    233                 {
    234                     using (FileStream strm = new FileStream(_userPresetFile, FileMode.Open, FileAccess.Read))
     231                // Load in the users Presets from UserPresets.xml
     232                if (File.Exists(UserPresetFile))
     233                {
     234                    using (FileStream strm = new FileStream(UserPresetFile, FileMode.Open, FileAccess.Read))
    235235                    {
    236236                        if (strm.Length != 0)
     
    240240                            if (list != null)
    241241                                foreach (Preset preset in list)
    242                                     _userPresets.Add(preset);
     242                                    UserPresets.Add(preset);
    243243                        }
    244244                    }
     
    251251                    "Your presets will not be loaded. You may need to re-create your presets.\n\n" +
    252252                    "Your user presets file has been renamed to 'user_presets.xml.old' and is located in:\n " +
    253                     Path.GetDirectoryName(_userPresetFile) + "\n" +
     253                    Path.GetDirectoryName(UserPresetFile) + "\n" +
    254254                    "You may be able to recover some presets if you know the XML language.", "Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
    255255
    256256                // Recover from Error.
    257                 if (File.Exists(_userPresetFile))
    258                 {
    259                     string disabledFile = _userPresetFile + ".old";
     257                if (File.Exists(UserPresetFile))
     258                {
     259                    string disabledFile = UserPresetFile + ".old";
    260260                    if (File.Exists(disabledFile))
    261261                        File.Delete(disabledFile);
    262                     File.Move(_userPresetFile, disabledFile);
     262                    File.Move(UserPresetFile, disabledFile);
    263263                }
    264264
     
    277277            TreeNode rootNode = null;
    278278
    279             if (_presets.Count != 0) // Built In Presets
    280             {
    281 
    282                 foreach (Preset preset in _presets)
     279            if (Presets.Count != 0) // Built In Presets
     280            {
     281
     282                foreach (Preset preset in Presets)
    283283                {
    284284                    if (preset.Category != category)
     
    295295
    296296            rootNode = null; category = null;
    297             foreach (Preset preset in _userPresets) // User Presets
     297            foreach (Preset preset in UserPresets) // User Presets
    298298            {
    299299                if (preset.Category != category && preset.Category != null)
     
    318318            try
    319319            {
    320                 using (FileStream strm = new FileStream(_hbPresetFile, FileMode.Create, FileAccess.Write))
    321                 {
    322                     Ser.Serialize(strm, _presets);
     320                using (FileStream strm = new FileStream(HbPresetFile, FileMode.Create, FileAccess.Write))
     321                {
     322                    Ser.Serialize(strm, Presets);
    323323                    strm.Close();
    324324                    strm.Dispose();
    325325                }
    326326
    327                 using (FileStream strm = new FileStream(_userPresetFile, FileMode.Create, FileAccess.Write))
    328                 {
    329                     Ser.Serialize(strm, _userPresets);
     327                using (FileStream strm = new FileStream(UserPresetFile, FileMode.Create, FileAccess.Write))
     328                {
     329                    Ser.Serialize(strm, UserPresets);
    330330                    strm.Close();
    331331                    strm.Dispose();
     
    339339
    340340        /// <summary>
    341         /// Check if the preset "name" exists in either _presets or _userPresets lists.
     341        /// Check if the preset "name" exists in either Presets or UserPresets lists.
    342342        /// </summary>
    343343        /// <param name="name"></param>
     
    349349
    350350            // Built In Presets
    351             foreach (Preset item in _presets)
     351            foreach (Preset item in Presets)
    352352            {
    353353                if (item.Name == name)
     
    356356
    357357            // User Presets
    358             foreach (Preset item in _userPresets)
     358            foreach (Preset item in UserPresets)
    359359            {
    360360                if (item.Name == name)
     
    366366
    367367        /// <summary>
    368         /// Check if the user preset "name" exists in _userPresets list.
     368        /// Check if the user preset "name" exists in UserPresets list.
    369369        /// </summary>
    370370        /// <param name="name"></param>
     
    376376
    377377            // User Presets
    378             foreach (Preset item in _userPresets)
     378            foreach (Preset item in UserPresets)
    379379            {
    380380                if (item.Name == name)
     
    386386
    387387        /// <summary>
    388         /// Check if the built in _presets stored are not out of date.
     388        /// Check if the built in Presets stored are not out of date.
    389389        /// Update them if they are.
    390390        /// </summary>
     
    393393        {
    394394            LoadPresetData();
    395             // Update built-in _presets if the built-in _presets belong to an older version.
    396             if (_presets.Count != 0)
    397                 if (_presets[0].Version != Properties.Settings.Default.hb_version)
     395            // Update built-in Presets if the built-in Presets belong to an older version.
     396            if (Presets.Count != 0)
     397                if (Presets[0].Version != Properties.Settings.Default.hb_version)
    398398                {
    399399                    UpdateBuiltInPresets();
  • win/C#/frmMain.cs

    r2cc277f r377768a  
    2525        Queue encodeQueue = new Queue();
    2626        PresetsHandler presetHandler = new PresetsHandler();
    27         QueryGenerator queryGen = new QueryGenerator();
    2827
    2928        // Globals: Mainly used for tracking. *********************************
     
    115114
    116115                        QueryParser presetQuery = QueryParser.Parse(query);
    117                         PresetLoader.presetLoader(this, presetQuery, Properties.Settings.Default.defaultPreset, loadPictureSettings);
     116                        PresetLoader.LoadPreset(this, presetQuery, Properties.Settings.Default.defaultPreset, loadPictureSettings);
    118117
    119118                        x264Panel.X264_StandardizeOptString();
     
    223222
    224223            // Handle Encode Start / Finish / Pause
    225             encodeQueue.CurrentJobCompleted += new EventHandler(encodeEnded);
     224           
    226225            encodeQueue.QueuePauseRequested += new EventHandler(encodePaused);
    227             encodeQueue.NewJobStarted += new EventHandler(encodeStarted);
     226            encodeQueue.EncodeStarted += new EventHandler(encodeStarted);
     227            encodeQueue.EncodeEnded += new EventHandler(encodeEnded);
    228228
    229229            // Handle a file being draged onto the GUI.
     
    397397        private void btn_new_preset_Click(object sender, EventArgs e)
    398398        {
    399             Form preset = new frmAddPreset(this, queryGen.GenerateCLIQuery(this, drop_mode.SelectedIndex, 0, null), presetHandler);
     399            Form preset = new frmAddPreset(this, QueryGenerator.GenerateCLIQuery(this, drop_mode.SelectedIndex, 0, null), presetHandler);
    400400            preset.ShowDialog();
    401401        }
     
    603603
    604604                        // Now load the preset
    605                         PresetLoader.presetLoader(this, presetQuery, presetName, loadPictureSettings);
     605                        PresetLoader.LoadPreset(this, presetQuery, presetName, loadPictureSettings);
    606606
    607607                        // The x264 widgets will need updated, so do this now:
     
    629629        private void importPreset()
    630630        {
    631             Import imp = new Import();
    632631            if (openPreset.ShowDialog() == DialogResult.OK)
    633632            {
    634                 QueryParser parsed = imp.importMacPreset(openPreset.FileName);
     633                QueryParser parsed = PlistPresetHandler.Import(openPreset.FileName);
    635634                if (presetHandler.CheckIfUserPresetExists(parsed.PresetName + " (Imported)"))
    636635                {
     
    639638                    if (result == DialogResult.Yes)
    640639                    {
    641                         PresetLoader.presetLoader(this, parsed, parsed.PresetName, parsed.UsesPictureSettings);
    642                         presetHandler.Update(parsed.PresetName + " (Imported)", queryGen.GenerateCLIQuery(this, drop_mode.SelectedIndex, 0, null),
     640                        PresetLoader.LoadPreset(this, parsed, parsed.PresetName, parsed.UsesPictureSettings);
     641                        presetHandler.Update(parsed.PresetName + " (Imported)", QueryGenerator.GenerateCLIQuery(this, drop_mode.SelectedIndex, 0, null),
    643642                                                   parsed.UsesPictureSettings);
    644643                    }
     
    646645                else
    647646                {
    648                     PresetLoader.presetLoader(this, parsed, parsed.PresetName, parsed.UsesPictureSettings);
    649                     presetHandler.Add(parsed.PresetName, queryGen.GenerateCLIQuery(this, drop_mode.SelectedIndex, 0, null), parsed.UsesPictureSettings);
    650 
    651                     if (presetHandler.Add(parsed.PresetName + " (Imported)", queryGen.GenerateCLIQuery(this, drop_mode.SelectedIndex, 0, null), parsed.UsesPictureSettings))
     647                    PresetLoader.LoadPreset(this, parsed, parsed.PresetName, parsed.UsesPictureSettings);
     648                    presetHandler.Add(parsed.PresetName, QueryGenerator.GenerateCLIQuery(this, drop_mode.SelectedIndex, 0, null), parsed.UsesPictureSettings);
     649
     650                    if (presetHandler.Add(parsed.PresetName + " (Imported)", QueryGenerator.GenerateCLIQuery(this, drop_mode.SelectedIndex, 0, null), parsed.UsesPictureSettings))
    652651                    {
    653652                        TreeNode preset_treeview = new TreeNode(parsed.PresetName + " (Imported)") { ForeColor = Color.Black };
     
    672671                DialogResult result;
    673672                if (Properties.Settings.Default.enocdeStatusInGui && !Properties.Settings.Default.showCliForInGuiEncodeStatus)
    674                     result = MessageBox.Show("Are you sure you wish to cancel the encode?\n\nPlease note, when 'Enable in-GUI encode status' is enabled, stopping this encode will render the file unplayable. ",
    675                         "Cancel Encode?",MessageBoxButtons.YesNo,MessageBoxIcon.Question);
     673                {
     674                    result = MessageBox.Show(
     675                            "Are you sure you wish to cancel the encode?\n\nPlease note, when 'Enable in-GUI encode status' is enabled, stopping this encode will render the file unplayable. ",
     676                            "Cancel Encode?", MessageBoxButtons.YesNo, MessageBoxIcon.Question);
     677                }
    676678                else
     679                {
    677680                    result = MessageBox.Show("Are you sure you wish to cancel the encode?", "Cancel Encode?",
    678                         MessageBoxButtons.YesNo, MessageBoxIcon.Question);
     681                                             MessageBoxButtons.YesNo, MessageBoxIcon.Question);
     682                }
    679683
    680684                if (result == DialogResult.Yes)
     
    691695                    else
    692696                    {
    693                         // Allow the CLI to exit cleanly
    694                         Win32.SetForegroundWindow((int) encodeQueue.ProcessHandle);
    695                         SendKeys.Send("^C");
     697                        encodeQueue.SafelyClose();
    696698                    }
    697699
     
    704706                if (encodeQueue.Count != 0 || (!string.IsNullOrEmpty(sourcePath) && !string.IsNullOrEmpty(text_destination.Text)))
    705707                {
    706                     string generatedQuery = queryGen.GenerateCLIQuery(this, drop_mode.SelectedIndex, 0, null);
    707                     string specifiedQuery = rtf_query.Text != "" ? rtf_query.Text : queryGen.GenerateCLIQuery(this, drop_mode.SelectedIndex, 0, null);
     708                    string generatedQuery = QueryGenerator.GenerateCLIQuery(this, drop_mode.SelectedIndex, 0, null);
     709                    string specifiedQuery = rtf_query.Text != "" ? rtf_query.Text : QueryGenerator.GenerateCLIQuery(this, drop_mode.SelectedIndex, 0, null);
    708710                    string query = string.Empty;
    709711
     
    774776            else
    775777            {
    776                 String query = queryGen.GenerateCLIQuery(this, drop_mode.SelectedIndex, 0, null);
     778                String query = QueryGenerator.GenerateCLIQuery(this, drop_mode.SelectedIndex, 0, null);
    777779                if (rtf_query.Text != "")
    778780                    query = rtf_query.Text;
     
    14891491        private void btn_generate_Query_Click(object sender, EventArgs e)
    14901492        {
    1491             rtf_query.Text = queryGen.GenerateCLIQuery(this, drop_mode.SelectedIndex, 0, null);
     1493            rtf_query.Text = QueryGenerator.GenerateCLIQuery(this, drop_mode.SelectedIndex, 0, null);
    14921494        }
    14931495        private void btn_clear_Click(object sender, EventArgs e)
     
    16831685
    16841686                // Now load the preset
    1685                 PresetLoader.presetLoader(this, presetQuery, "Load Back From Queue", true);
     1687                PresetLoader.LoadPreset(this, presetQuery, "Load Back From Queue", true);
    16861688
    16871689                // The x264 widgets will need updated, so do this now:
  • win/C#/frmPreview.cs

    r9ae5e6d r377768a  
    1414    public partial class frmPreview : Form
    1515    {
    16         readonly QueryGenerator HbCommonFunc = new QueryGenerator();
    1716        readonly Queue Process = new Queue();
    1817        private delegate void UpdateUIHandler();
     
    6463            int duration;
    6564            int.TryParse(cb_duration.Text, out duration);
    66             String query = HbCommonFunc.GenerateCLIQuery(MainWindow, 3, duration, cb_preview.Text);
     65            String query = QueryGenerator.GenerateCLIQuery(MainWindow, 3, duration, cb_preview.Text);
    6766            ThreadPool.QueueUserWorkItem(ProcMonitor, query);
    6867        }
     
    9998                int duration;
    10099                int.TryParse(cb_duration.Text, out duration);
    101                 String query = HbCommonFunc.GenerateCLIQuery(MainWindow, 3, duration, cb_preview.Text);
     100                String query = QueryGenerator.GenerateCLIQuery(MainWindow, 3, duration, cb_preview.Text);
    102101
    103102                ThreadPool.QueueUserWorkItem(ProcMonitor, query);
  • win/C#/frmQueue.cs

    ra6a1746 r377768a  
    1111using Handbrake.EncodeQueue;
    1212using System.Collections.ObjectModel;
     13using Handbrake.Model;
    1314
    1415namespace Handbrake
     
    2728
    2829            this.queue = q;
    29             queue.NewJobStarted += new EventHandler(QueueOnEncodeStart);
     30            queue.EncodeStarted += new EventHandler(QueueOnEncodeStart);
    3031            queue.QueueCompleted += new EventHandler(QueueOnQueueFinished);
    3132            queue.QueuePauseRequested += new EventHandler(QueueOnPaused);
     
    177178                // Display The Audio Track Information
    178179                string audio = string.Empty;
    179                 foreach (Functions.AudioTrack track in parsed.AudioInformation)
     180                foreach (AudioTrack track in parsed.AudioInformation)
    180181                {
    181182                    if (audio != "")
     
    230231                // Display The Audio Track Information
    231232                string audio = string.Empty;
    232                 foreach (Functions.AudioTrack track in parsed.AudioInformation)
     233                foreach (AudioTrack track in parsed.AudioInformation)
    233234                {
    234235                    if (audio != "")
Note: See TracChangeset for help on using the changeset viewer.