Ticket #4712: tools_gui_tmp_lame_fix.patch

scummvm/tools/trunk/compress.h

@@ -87 +87 @@
         AudioFormat _format;
 
         // Settings
+        // These functions are used by the GUI Tools and by CLI argument parsing functions
         // mp3 settings
-        std::string _mp3CompressionType;
-        std::string _mp3MpegQuality;
-        std::string _mp3ABRBitrate;
-        std::string _mp3VBRMinBitrate;
-        std::string _mp3VBRMaxBitrate;
-        std::string _mp3VBRQuality;
+        void setMp3LamePath(const std::string&);
+        void setMp3CompressionType(const std::string&);
+        void setMp3MpegQuality(const std::string&);
+        void setMp3ABRBitrate(const std::string&);
+        void setMp3VBRMinBitrate(const std::string&);
+        void setMp3VBRMaxBitrate(const std::string&);
+        void setMp3VBRQuality(const std::string&);
 
         // flac
-        std::string _flacCompressionLevel;
-        std::string _flacBlockSize;
+        void setFlacCompressionLevel(const std::string&);
+        void setFlacBlockSize(const std::string&);
 
         // vorbis
-        std::string _oggQuality;
-        std::string _oggMinBitrate;
-        std::string _oggAvgBitrate;
-        std::string _oggMaxBitrate;
+        void setOggQuality(const std::string&);
+        void setOggMinBitrate(const std::string&);
+        void setOggAvgBitrate(const std::string&);
+        void setOggMaxBitrate(const std::string&);
 
 public:
         bool processMp3Parms();

scummvm/tools/trunk/gui/pages.cpp

@@ -833 +833 @@
 
 wxWindow *ChooseAudioOptionsMp3Page::CreatePanel(wxWindow *parent) {
         wxWindow *panel = WizardPage::CreatePanel(parent);
+        
+        wxSizer *sizer = new wxBoxSizer(wxVERTICAL);
+        
+        // Add a ScrolledWindow in that panel as there is a lot of options
+        // and there might not be enough place to display them all.
+        wxScrolledWindow *scroll = new wxScrolledWindow(panel);
+        scroll->SetScrollbars(10, 10, 60, 40);
+        
+        sizer->Add(scroll, 1, wxEXPAND | wxALL);
 
-
         /*
         "\nMP3 mode params:\n"
+        " -lame-path <path> Path to the lame excutable to use (default: lame)\n"
         " -b <rate>    <rate> is the target bitrate(ABR)/minimal bitrate(VBR) (default:" minBitrDef_str "%d)\n"
         " -B <rate>    <rate> is the maximum VBR/ABR bitrate (default:%" maxBitrDef_str ")\n"
         " --vbr        LAME uses the VBR mode (default)\n"
@@ -846 +855 @@
         " --silent     the output of LAME is hidden (default:disabled)\n"
         */
 
-        wxFlexGridSizer *sizer = new wxFlexGridSizer(6, 2, 10, 25);
-        sizer->AddGrowableCol(1);
+        // Grid
+        wxFlexGridSizer *gridSizer = new wxFlexGridSizer(7, 2, 10, 25);
+        gridSizer->AddGrowableCol(1);
 
+        // Create output selection
+        gridSizer->Add(new wxStaticText(scroll, wxID_ANY, wxT("Lame executable:")));
 
+        wxFilePickerCtrl *lamePicker = new wxFilePickerCtrl(
+                        scroll, wxID_ANY, _configuration.outputPath, wxT("Select lame executable"),
+                        wxT("lame"),
+                        wxDefaultPosition, wxSize(250, -1),
+                        wxFLP_USE_TEXTCTRL | wxFLP_FILE_MUST_EXIST | wxFLP_OPEN, wxDefaultValidator,
+                        wxT("LamePath")
+                );
+                
+        gridSizer->Add(lamePicker, wxSizerFlags().Expand());
+
         // Type of compression
-        sizer->Add(new wxStaticText(panel, wxID_ANY, wxT("Compression Type:")));
+        gridSizer->Add(new wxStaticText(scroll, wxID_ANY, wxT("Compression Type:")));
 
-        wxRadioButton *abrButton = new wxRadioButton(panel, wxID_ANY, wxT("ABR"),
+        wxRadioButton *abrButton = new wxRadioButton(scroll, wxID_ANY, wxT("ABR"),
                 wxDefaultPosition, wxDefaultSize, 0, wxDefaultValidator, wxT("ABR"));
 
         wxSizer *radioSizer = new wxBoxSizer(wxHORIZONTAL);
         radioSizer->Add(abrButton);
 
-        wxRadioButton *vbrButton = new wxRadioButton(panel, wxID_ANY, wxT("VBR"),
+        wxRadioButton *vbrButton = new wxRadioButton(scroll, wxID_ANY, wxT("VBR"),
                 wxDefaultPosition, wxDefaultSize, 0, wxDefaultValidator, wxT("VBR"));
         radioSizer->Add(vbrButton);
 
-        sizer->Add(radioSizer, wxSizerFlags().Expand());
+        gridSizer->Add(radioSizer, wxSizerFlags().Expand());
 
         // Bitrates
         const int possibleBitrateCount = 160 / 8;
@@ -872 +894 @@
                 possibleBitrates[i] << (i+1)*8;
         }
 
-        sizer->Add(new wxStaticText(panel, wxID_ANY, wxT("Minimum Bitrate:")));
+        gridSizer->Add(new wxStaticText(scroll, wxID_ANY, wxT("Minimum Bitrate:")));
 
         wxChoice *vbrMinBitrate = new wxChoice(
-                panel, wxID_ANY, wxDefaultPosition, wxDefaultSize,
+                scroll, wxID_ANY, wxDefaultPosition, wxDefaultSize,
                 possibleBitrateCount, possibleBitrates, 0, wxDefaultValidator, wxT("MinimumBitrate"));
-        sizer->Add(vbrMinBitrate, wxSizerFlags().Expand().Border(wxRIGHT, 100));
+        gridSizer->Add(vbrMinBitrate, wxSizerFlags().Expand().Border(wxRIGHT, 100));
 
 
-        sizer->Add(new wxStaticText(panel, wxID_ANY, wxT("Maximum Bitrate:")));
+        gridSizer->Add(new wxStaticText(scroll, wxID_ANY, wxT("Maximum Bitrate:")));
 
         wxChoice *vbrMaxBitrate = new wxChoice(
-                panel, wxID_ANY, wxDefaultPosition, wxDefaultSize,
+                scroll, wxID_ANY, wxDefaultPosition, wxDefaultSize,
                 possibleBitrateCount, possibleBitrates, 0, wxDefaultValidator, wxT("MaximumBitrate"));
-        sizer->Add(vbrMaxBitrate, wxSizerFlags().Expand().Border(wxRIGHT, 100));
+        gridSizer->Add(vbrMaxBitrate, wxSizerFlags().Expand().Border(wxRIGHT, 100));
 
 
-        sizer->Add(new wxStaticText(panel, wxID_ANY, wxT("Average Bitrate:")));
+        gridSizer->Add(new wxStaticText(scroll, wxID_ANY, wxT("Average Bitrate:")));
 
         wxChoice *abrAvgBitrate = new wxChoice(
-                panel, wxID_ANY, wxDefaultPosition, wxDefaultSize,
+                scroll, wxID_ANY, wxDefaultPosition, wxDefaultSize,
                 possibleBitrateCount, possibleBitrates, 0, wxDefaultValidator, wxT("AverageBitrate"));
-        sizer->Add(abrAvgBitrate, wxSizerFlags().Expand().Border(wxRIGHT, 100));
+        gridSizer->Add(abrAvgBitrate, wxSizerFlags().Expand().Border(wxRIGHT, 100));
 
         abrButton->Connect(wxEVT_COMMAND_RADIOBUTTON_SELECTED, wxCommandEventHandler(ChooseAudioOptionsMp3Page::onChangeCompressionType), NULL, this);
         vbrButton->Connect(wxEVT_COMMAND_RADIOBUTTON_SELECTED, wxCommandEventHandler(ChooseAudioOptionsMp3Page::onChangeCompressionType), NULL, this);
@@ -905 +927 @@
                 possibleQualities[i] << i;
         }
 
-        sizer->Add(new wxStaticText(panel, wxID_ANY, wxT("VBR Quality:")));
+        gridSizer->Add(new wxStaticText(scroll, wxID_ANY, wxT("VBR Quality:")));
 
         wxChoice *vbrQuality = new wxChoice(
-                panel, wxID_ANY, wxDefaultPosition, wxDefaultSize,
+                scroll, wxID_ANY, wxDefaultPosition, wxDefaultSize,
                 possibleQualityCount, possibleQualities, 0, wxDefaultValidator, wxT("VBRQuality"));
-        sizer->Add(vbrQuality, wxSizerFlags().Expand().Border(wxRIGHT, 100));
+        gridSizer->Add(vbrQuality, wxSizerFlags().Expand().Border(wxRIGHT, 100));
 
 
-        sizer->Add(new wxStaticText(panel, wxID_ANY, wxT("MPEG Quality:")));
+        gridSizer->Add(new wxStaticText(scroll, wxID_ANY, wxT("MPEG Quality:")));
 
         wxChoice *mpegQuality = new wxChoice(
-                panel, wxID_ANY, wxDefaultPosition, wxDefaultSize,
+                scroll, wxID_ANY, wxDefaultPosition, wxDefaultSize,
                 possibleQualityCount, possibleQualities, 0, wxDefaultValidator, wxT("MpegQuality"));
-        sizer->Add(mpegQuality, wxSizerFlags().Expand().Border(wxRIGHT, 100));
+        gridSizer->Add(mpegQuality, wxSizerFlags().Expand().Border(wxRIGHT, 100));
 
         // Finish the window
+        scroll->SetSizer(gridSizer);
         SetAlignedSizer(panel, sizer);
 
 
         // Load settings
+        lamePicker->SetPath(_configuration.mp3LamePath);
         if (_configuration.mp3CompressionType == wxT("ABR"))
                 abrButton->SetValue(true);
         else
@@ -941 +965 @@
 }
 
 void ChooseAudioOptionsMp3Page::save(wxWindow *panel) {
+        wxFilePickerCtrl *lamePath = static_cast<wxFilePickerCtrl *>(panel->FindWindowByName(wxT("LamePath")));
+        
         wxRadioButton *abr = static_cast<wxRadioButton *>(panel->FindWindowByName(wxT("ABR")));
 //      wxRadioButton *vbr = static_cast<wxRadioButton *>(panel->FindWindowByName(wxT("VBR")));
 
@@ -950 +976 @@
         wxChoice *vbrQuality = static_cast<wxChoice *>(panel->FindWindowByName(wxT("VBRQuality")));
         wxChoice *mpegQuality = static_cast<wxChoice *>(panel->FindWindowByName(wxT("MpegQuality")));
 
+        _configuration.mp3LamePath      = lamePath->GetPath();
         _configuration.mp3VBRMinBitrate = vbrMinBitrate->GetStringSelection();
         _configuration.mp3VBRMaxBitrate = vbrMaxBitrate->GetStringSelection();
         _configuration.mp3ABRBitrate    = abrAvgBitrate->GetStringSelection();

scummvm/tools/trunk/gui/gui_tools.cpp

@@ -146 +146 @@
                 compression->_format               = conf.selectedAudioFormat;
 
                 // mp3
-                compression->_mp3ABRBitrate        = (const char *)conf.mp3ABRBitrate.mb_str();
-                compression->_mp3CompressionType   = (const char *)conf.mp3CompressionType.mb_str();
-                compression->_mp3MpegQuality       = (const char *)conf.mp3MpegQuality.mb_str();
-                compression->_mp3ABRBitrate        = (const char *)conf.mp3ABRBitrate.mb_str();
-                compression->_mp3VBRMinBitrate     = (const char *)conf.mp3VBRMinBitrate.mb_str();
-                compression->_mp3VBRMaxBitrate     = (const char *)conf.mp3VBRMaxBitrate.mb_str();
-                compression->_mp3VBRQuality        = (const char *)conf.mp3VBRQuality.mb_str();
+                compression->setMp3LamePath       ( (const char *)conf.mp3LamePath.mb_str()        );
+                compression->setMp3CompressionType( (const char *)conf.mp3CompressionType.mb_str() );
+                compression->setMp3MpegQuality    ( (const char *)conf.mp3MpegQuality.mb_str()     );
+                compression->setMp3ABRBitrate     ( (const char *)conf.mp3ABRBitrate.mb_str()      );
+                compression->setMp3VBRMinBitrate  ( (const char *)conf.mp3VBRMinBitrate.mb_str()   );
+                compression->setMp3VBRMaxBitrate  ( (const char *)conf.mp3VBRMaxBitrate.mb_str()   );
+                compression->setMp3VBRQuality     ( (const char *)conf.mp3VBRQuality.mb_str()      );
 
                 // flac
-                compression->_flacCompressionLevel = (const char *)conf.flacCompressionLevel.mb_str();
-                compression->_flacBlockSize        = (const char *)conf.flacBlockSize.mb_str();
+                compression->setFlacCompressionLevel( (const char *)conf.flacCompressionLevel.mb_str() );
+                compression->setFlacBlockSize       ( (const char *)conf.flacBlockSize.mb_str()        );
 
                 // vorbis
-                compression->_oggQuality           = (const char *)conf.oggQuality.mb_str();
-                compression->_oggMinBitrate        = (const char *)conf.oggMinBitrate.mb_str();
-                compression->_oggAvgBitrate        = (const char *)conf.oggAvgBitrate.mb_str();
-                compression->_oggMaxBitrate        = (const char *)conf.oggMaxBitrate.mb_str();
+                compression->setOggQuality    ( (const char *)conf.oggQuality.mb_str()    );
+                compression->setOggMinBitrate ( (const char *)conf.oggMinBitrate.mb_str() );
+                compression->setOggAvgBitrate ( (const char *)conf.oggAvgBitrate.mb_str() );
+                compression->setOggMaxBitrate ( (const char *)conf.oggMaxBitrate.mb_str() );
         }
 
         _backend->run();

scummvm/tools/trunk/gui/configuration.cpp

@@ -37 +37 @@
         advancedAudioSettings = false;
 
         // mp3 params
+        mp3LamePath = wxT("lame");
         mp3CompressionType = wxT("VBR");
         mp3MpegQuality = wxT("2");
 
@@ -67 +68 @@
         filecnf->Read(wxT("outputpath"), &outputPath);
 
         // mp3 params
+        filecnf->Read(wxT("mp3LamePath"), &mp3LamePath, mp3LamePath);
         filecnf->Read(wxT("mp3CompressionType"), &mp3CompressionType, mp3CompressionType);
         filecnf->Read(wxT("mp3MpegQuality"), &mp3MpegQuality, mp3MpegQuality);
         filecnf->Read(wxT("mp3ABRBitrate"), &mp3ABRBitrate, mp3ABRBitrate);
@@ -92 +94 @@
 
         wxFileName op(outputPath);
         filecnf->Write(wxT("outputpath"), op.GetPath(wxPATH_GET_VOLUME | wxPATH_GET_SEPARATOR));
+        filecnf->Write(wxT("mp3LamePath"), mp3LamePath);
 
         if (all) {
                 // mp3 params

scummvm/tools/trunk/gui/configuration.h

@@ -84 +84 @@
         bool advancedAudioSettings;
 
         // mp3 settings
+        wxString mp3LamePath;
         wxString mp3CompressionType;
         wxString mp3MpegQuality;
         wxString mp3ABRBitrate;

scummvm/tools/trunk/compress.cpp

@@ -48 +48 @@
         uint32 algqual;
         uint32 vbrqual;
         bool silent;
+        std::string lamePath;
 };
 
 struct oggencparams {
@@ -70 +71 @@
         uint8 bitsPerSample;
 };
 
-lameparams encparms = { minBitrDef, maxBitrDef, false, algqualDef, vbrqualDef, 0 };
+lameparams encparms = { minBitrDef, maxBitrDef, false, algqualDef, vbrqualDef, 0, "lame" };
 oggencparams oggparms = { -1, -1, -1, (float)oggqualDef, 0 };
 flaccparams flacparms = { flacCompressDef, flacBlocksizeDef, false, false };
 rawtype rawAudioType = { false, false, 8 };
@@ -123 +124 @@
         char *tmp = fbuf;
 
         if (compmode == AUDIO_MP3) {
-                tmp += sprintf(tmp, "lame -t ");
+                tmp += sprintf(tmp, "%s -t ", encparms.lamePath.c_str());
                 if (rawInput) {
                         tmp += sprintf(tmp, "-r ");
                         tmp += sprintf(tmp, "--bitwidth %d ", rawAudioType.bitsPerSample);
@@ -772 +773 @@
         encodeAudio(outName, true, real_samplerate, tempEncoded, compMode);
 }
 
+// mp3 settings
+void CompressionTool::setMp3LamePath(const std::string& arg) {
+        encparms.lamePath = arg;
+}
+
+void CompressionTool::setMp3CompressionType(const std::string& arg) {
+        encparms.abr = (arg == "ABR");
+}
+
+void CompressionTool::setMp3MpegQuality(const std::string& arg) {
+        encparms.algqual = atoi(arg.c_str());
+        
+        if (encparms.algqual == 0 && arg != "0")
+                throw ToolException("Quality (-q) must be a number.");
+        
+        if (encparms.algqual > 9)
+                throw ToolException("Quality (-q) out of bounds, must be between 0 and 9.");
+}
+
+void CompressionTool::setMp3ABRBitrate(const std::string& arg) {
+        setMp3VBRMinBitrate(arg);
+}
+
+void CompressionTool::setMp3VBRMinBitrate(const std::string& arg) {
+        encparms.minBitr = atoi(arg.c_str());
+        
+        if (encparms.minBitr == 0 && arg != "0")
+                throw ToolException("Minimum bitrate (-b) must be a number.");
+        
+        if (encparms.minBitr < 8 || encparms.minBitr > 160)
+                throw ToolException("Minimum bitrate out of bounds (-b), must be between 8 and 160.");
+}
+
+void CompressionTool::setMp3VBRMaxBitrate(const std::string& arg) {
+        encparms.maxBitr = atoi(arg.c_str());
+        
+        if (encparms.maxBitr == 0 && arg != "0")
+                throw ToolException("Maximum bitrate (-B) must be a number.");
+
+        if ((encparms.maxBitr % 8) != 0)
+                encparms.maxBitr -= encparms.maxBitr % 8;
+
+        if (encparms.maxBitr < 8 || encparms.maxBitr > 160)
+                throw ToolException("Maximum bitrate out of bounds (-B), must be between 8 and 160.");
+}
+
+void CompressionTool::setMp3VBRQuality(const std::string& arg) {
+        encparms.vbrqual = atoi(arg.c_str());
+        if (encparms.vbrqual > 9)
+                throw ToolException("Quality (-q) out of bounds, must be between 0 and 9.");
+}
+
+// flac
+void CompressionTool::setFlacCompressionLevel(const std::string& arg) {
+        flacparms.compressionLevel = atoi(arg.c_str());
+        
+        if (flacparms.compressionLevel == 0 && arg != "0")
+                throw ToolException("FLAC compression level must be a number.");
+
+        if (flacparms.compressionLevel < 0 || flacparms.compressionLevel > 8)
+                throw ToolException("FLAC compression level ot of bounds, must be between 0 and 8.");
+                
+}
+
+void CompressionTool::setFlacBlockSize(const std::string& arg) {
+        flacparms.blocksize = atoi(arg.c_str());
+
+        if (flacparms.blocksize == 0 && arg != "0")
+                throw ToolException("FLAC block size (-b) must be a number.");
+}
+
+// vorbis
+void CompressionTool::setOggQuality(const std::string& arg) {
+        oggparms.quality = (float)atoi(arg.c_str());
+        
+        if (oggparms.quality == 0. && arg != "0")
+                throw ToolException("Quality (-q) must be a number.");
+        
+        if (oggparms.quality < 0. || oggparms.quality > 10.)
+                throw ToolException("Quality out of bounds (-q), must be between 0 and 10.");
+}
+
+void CompressionTool::setOggMinBitrate(const std::string& arg) {
+        oggparms.minBitr = atoi(arg.c_str());
+
+        if (oggparms.minBitr == 0 && arg != "0")
+                throw ToolException("Minimum bitrate (-m) must be a number.");
+
+        if ((oggparms.minBitr % 8) != 0)
+                oggparms.minBitr -= oggparms.minBitr % 8;
+        
+        if (oggparms.minBitr < 8 || oggparms.minBitr > 160)
+                throw ToolException("Minimum bitrate out of bounds (-m), must be between 8 and 160.");
+}
+
+void CompressionTool::setOggAvgBitrate(const std::string& arg) {
+        oggparms.nominalBitr = atoi(arg.c_str());
+        
+        if (oggparms.nominalBitr == 0 && arg != "0")
+                throw ToolException("Nominal bitrate (-b) must be a number.");
+
+        if ((oggparms.nominalBitr % 8) != 0)
+                oggparms.nominalBitr -= oggparms.nominalBitr % 8;
+
+        if (oggparms.nominalBitr < 8 || oggparms.nominalBitr > 160)
+                throw ToolException("Nominal bitrate out of bounds (-b), must be between 8 and 160.");
+}
+
+void CompressionTool::setOggMaxBitrate(const std::string& arg) {
+        oggparms.maxBitr = atoi(arg.c_str());
+
+        if (oggparms.maxBitr == 0 && arg != "0")
+                throw ToolException("Maximum bitrate (-M) must be a number.");
+
+        if ((oggparms.maxBitr % 8) != 0)
+                oggparms.maxBitr -= oggparms.maxBitr % 8;
+
+        if (oggparms.maxBitr < 8 || oggparms.maxBitr > 160)
+                throw ToolException("Maximum bitrate out of bounds (-M), must be between 8 and 160.");
+}
+
 bool CompressionTool::processMp3Parms() {
         while (!_arguments.empty()) {
                 std::string arg = _arguments.front();
@@ -781 +903 @@
                         encparms.abr = 0;
                 } else if (arg == "--abr") {
                         encparms.abr = 1;
+                } else if (arg == "-lame-path") {
+                        if (_arguments.empty())
+                                throw ToolException("Could not parse command line options, expected value after -lame-path");
+                        setMp3LamePath(_arguments.front());
+                        _arguments.pop_front();
+
                 } else if (arg == "-b") {
                         if (_arguments.empty())
                                 throw ToolException("Could not parse command line options, expected value after -b");
-                        encparms.minBitr = atoi(_arguments.front().c_str());
-
-                        if (encparms.minBitr > 160)
-                                throw ToolException("Minimum bitrate out of bounds (-b), must be between 8 and 160.");
-
-                        if (encparms.minBitr == 0 && _arguments.front() != "0")
-                                throw ToolException("Minimum bitrate (-b) must be a number.");
-
-                        if (encparms.minBitr < 8)
-                                throw ToolException("Minimum bitrate out of bounds (-b), must be between 8 and 160.");
-
+                        setMp3VBRMinBitrate(_arguments.front());
                         _arguments.pop_front();
 
                 } else if (arg == "-B") {
                         if (_arguments.empty())
                                 throw ToolException("Could not parse command line options, expected value after -B");
-                        encparms.maxBitr = atoi(_arguments.front().c_str());
-
-                        if ((encparms.maxBitr % 8) != 0) {
-                                encparms.maxBitr -= encparms.maxBitr % 8;
-                        }
-
-                        if (encparms.maxBitr > 160)
-                                throw ToolException("Maximum bitrate out of bounds (-B), must be between 8 and 160.");
-
-                        if (encparms.maxBitr == 0 && _arguments.front() != "0")
-                                throw ToolException("Maximum bitrate (-B) must be a number.");
-
-                        if (encparms.maxBitr < 8)
-                                throw ToolException("Maximum bitrate out of bounds (-B), must be between 8 and 160.");
-
+                        setMp3VBRMaxBitrate(_arguments.front());
                         _arguments.pop_front();
 
                 } else if (arg == "-V") {
                         if (_arguments.empty())
                                 throw ToolException("Could not parse command line options, expected value after -V");
-                        encparms.vbrqual = atoi(_arguments.front().c_str());
-
-                        if (encparms.vbrqual > 9)
-                                throw ToolException("Quality (-q) out of bounds, must be between 0 and 9.");
-
+                        setMp3VBRQuality(_arguments.front());
                         _arguments.pop_front();
 
                 } else if (arg == "-q") {
                         if (_arguments.empty())
                                 throw ToolException("Could not parse command line options, expected value after -q");
-                        encparms.algqual = atoi(_arguments.front().c_str());
-
-                        if (encparms.algqual > 9)
-                                throw ToolException("Quality (-q) out of bounds, must be between 0 and 9.");
-
+                        setMp3MpegQuality(_arguments.front());
                         _arguments.pop_front();
 
                 } else if (arg == "--silent") {
@@ -856 +952 @@
                 if (arg == "-b") {
                         if (_arguments.empty())
                                 throw ToolException("Could not parse command line options, expected value after -b");
-                        oggparms.nominalBitr = atoi(_arguments.front().c_str());
-
-                        if ((oggparms.nominalBitr % 8) != 0)
-                                oggparms.nominalBitr -= oggparms.nominalBitr % 8;
-
-                        if (oggparms.nominalBitr > 160)
-                                throw ToolException("Nominal bitrate out of bounds (-b), must be between 8 and 160.");
-
-                        if (oggparms.nominalBitr == 0 && _arguments.front() != "0")
-                                throw ToolException("Nominal bitrate (-b) must be a number.");
-
-                        if (oggparms.nominalBitr < 8)
-                                throw ToolException("Nominal bitrate out of bounds (-b), must be between 8 and 160.");
-
+                        setOggAvgBitrate(_arguments.front());
                         _arguments.pop_front();
 
                 } else if (arg == "-m") {
                         if (_arguments.empty())
                                 throw ToolException("Could not parse command line options, expected value after -m");
-                        oggparms.minBitr = atoi(_arguments.front().c_str());
-
-                        if ((oggparms.minBitr % 8) != 0)
-                                oggparms.minBitr -= oggparms.minBitr % 8;
-
-                        if (oggparms.minBitr > 160)
-                                throw ToolException("Minimal bitrate out of bounds (-m), must be between 8 and 160.");
-
-                        if (oggparms.minBitr == 0 && _arguments.front() != "0")
-                                throw ToolException("Minimal bitrate (-m) must be a number.");
-
-                        if (oggparms.minBitr < 8)
-                                throw ToolException("Minimal bitrate out of bounds (-m), must be between 8 and 160.");
-
+                        setOggMinBitrate(_arguments.front());
                         _arguments.pop_front();
 
                 } else if (arg == "-M") {
                         if (_arguments.empty())
                                 throw ToolException("Could not parse command line options, expected value after -M");
-                        oggparms.maxBitr = atoi(_arguments.front().c_str());
-
-                        if ((oggparms.maxBitr % 8) != 0)
-                                oggparms.maxBitr -= oggparms.maxBitr % 8;
-
-                        if (oggparms.maxBitr > 160)
-                                throw ToolException("Minimal bitrate out of bounds (-M), must be between 8 and 160.");
-
-                        if (oggparms.maxBitr == 0 && _arguments.front() != "0")
-                                throw ToolException("Minimal bitrate (-M) must be a number.");
-
-                        if (oggparms.maxBitr < 8)
-                                throw ToolException("Minimal bitrate out of bounds (-M), must be between 8 and 160.");
-
+                        setOggMaxBitrate(_arguments.front());
                         _arguments.pop_front();
 
                 } else if (arg == "-q") {
-                        oggparms.quality = (float)atoi(_arguments.front().c_str());
-
-                        if (oggparms.quality == 0 && _arguments.front() != "0")
-                                throw ToolException("Quality (-q) must be a number.");
-
+                        if (_arguments.empty())
+                                throw ToolException("Could not parse command line options, expected value after -q");
+                        setOggQuality(_arguments.front());
                         _arguments.pop_front();
 
                 } else if (arg == "--silent") {
@@ -937 +992 @@
                 if (arg == "-b") {
                         if (_arguments.empty())
                                 throw ToolException("Could not parse command line options, expected value after -b");
-                        flacparms.blocksize = atoi(_arguments.front().c_str());
+                        setFlacBlockSize(_arguments.front());
                         _arguments.pop_front();
                 } else if (arg == "--fast") {
                         flacparms.compressionLevel = 0;
@@ -1057 +1112 @@
 
         if (_supportedFormats & AUDIO_MP3) {
                 os << "\nMP3 mode params:\n";
+                os << " -lame-path <path> Path to the lame excutable to use (default: lame)\n";
                 os << " -b <rate>    <rate> is the target bitrate(ABR)/minimal bitrate(VBR) (default:" << minBitrDef << "%d)\n";
                 os << " -B <rate>    <rate> is the maximum VBR/ABR bitrate (default:%" << maxBitrDef << ")\n";
                 os << " --vbr        LAME uses the VBR mode (default)\n";