Logo Search packages:      
Sourcecode: lame version File versions  Download package

AEncodeProperties.h

/**
 *
 * Lame ACM wrapper, encode/decode MP3 based RIFF/AVI files in MS Windows
 *
 *  Copyright (c) 2002 Steve Lhomme <steve.lhomme at free.fr>
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 *
 */
 
/*!
      \author Steve Lhomme
      \version \$Id: AEncodeProperties.h,v 1.5 2002/04/07 13:31:35 robux4 Exp $
*/

#if !defined(_AENCODEPROPERTIES_H__INCLUDED_)
#define _AENCODEPROPERTIES_H__INCLUDED_

#if _MSC_VER > 1000
#pragma once
#endif // _MSC_VER > 1000

#include <windows.h>
#include <string>

#include "ADbg/ADbg.h"
//#include "BladeMP3EncDLL.h"
#include "tinyxml/tinyxml.h"
//#include "AParameters/AParameters.h"

00043 typedef const struct {
      UINT id;
      const char *tip;
} ToolTipItem;
/**
  \class AEncodeProperties
  \brief the AEncodeProperties class is responsible for handling all the encoding properties
*/
00051 class AEncodeProperties  
{
public:
      /**
            \brief default constructor

            \param the windows module with which you can retrieve many informations
      */
      AEncodeProperties(HMODULE hModule);

      /**
            \brief default destructor
      */
00064       virtual ~AEncodeProperties() {}

      /**
            \enum BRMode
            \brief A bitrate mode (CBR, VBR, ABR)
      */
00070       enum BRMode { BR_CBR, BR_VBR, BR_ABR };

      /**
            \brief Handle all the commands that occur in the Config dialog box
      */
      bool HandleDialogCommand(const HWND parentWnd, const WPARAM wParam, const LPARAM lParam);
      /**
            \brief check wether 2 instances are equal, ie have the same encoding parameters
      */
      bool operator != (const AEncodeProperties & the_instance) const;

      /**
            \brief Check wether the Encode process should use the Copyright bit
      */
00084       inline const bool GetCopyrightMode() const { return bCopyright; }
      /**
            \brief Check wether the Encode process should use the CRC bit
      */
00088       inline const bool GetCRCMode() const { return bCRC; }
      /**
            \brief Check wether the Encode process should use the Original bit
      */
00092       inline const bool GetOriginalMode() const { return bOriginal; }
      /**
            \brief Check wether the Encode process should use the Private bit
      */
00096       inline const bool GetPrivateMode() const { return bPrivate; }
      /**
            \brief Check wether the Encode process should use the Smart Bitrate output
      */
00100       inline const bool GetSmartOutputMode() const { return bSmartOutput; }
      /**
            \brief Check wether the Encode process should allow Average Bitrate output
      */
00104       inline const bool GetAbrOutputMode() const { return bAbrOutput; }

      /**
            \brief Check wether the Encode process shouldn't use the Bit Reservoir
      */
00109       inline const bool GetNoBiResMode() const { return bNoBitRes; }

      /**
            \brief Check wether the Encode process should force the channel mode (stereo or mono resampling)
      */
00114       inline const bool GetForceChannelMode() const { return bForceChannel; }

      /**
            \brief Check wether the Encode process should use the VBR mode
      */
00119       inline const BRMode GetVBRUseMode() const { return mBRmode; }
      /**
            \brief Check wether the Encode process should use the Xing frame in the VBR mode
            \note the Xing frame is a silent frame at the beginning that contain VBR statistics about the file.
      */
00124       inline const bool GetXingFrameMode() const { return bXingFrame; }

      /**
            \brief Check wether the Encode process should resample before encoding
      */
00129       inline const bool GetResampleMode() const { return bResample; }
      
      /**
            \brief Set wether the Encode process should use the Copyright bit
      */
00134       inline void SetCopyrightMode(const bool bMode) { bCopyright = bMode; }
      /**
            \brief Set wether the Encode process should use the CRC bit
      */
00138       inline void SetCRCMode(const bool bMode) { bCRC = bMode; }
      /**
            \brief Set wether the Encode process should use the Original bit
      */
00142       inline void SetOriginalMode(const bool bMode) { bOriginal = bMode; }
      /**
            \brief Set wether the Encode process should use the Private bit
      */
00146       inline void SetPrivateMode(const bool bMode) { bPrivate = bMode; }

      /**
            \brief Set wether the Encode process should use the Smart Bitrate output
      */
00151       inline void SetSmartOutputMode(const bool bMode) { bSmartOutput = bMode; }
      /**
            \brief Set wether the Encode process should use the Average Bitrate output
      */
00155       inline void SetAbrOutputMode(const bool bMode) { bAbrOutput = bMode; }


      /**
            \brief Set wether the Encode process shouldn't use the Bit Reservoir
      */
00161       inline void SetNoBiResMode(const bool bMode) { bNoBitRes = bMode; }
      
      /**
            \brief Set wether the Encode process should force the channel mode (stereo or mono resampling)
      */
00166       inline void SetForceChannelMode(const bool bMode) { bForceChannel = bMode; }
      
      /**
            \brief Set wether the Encode process should use the VBR mode
      */
00171       inline void SetVBRUseMode(const BRMode mode) { mBRmode = mode; }

      /**
            \brief Set wether the Encode process should use the Xing frame in the VBR mode
            \note the Xing frame is a silent frame at the beginning that contain VBR statistics about the file.
      */
00177       inline void SetXingFrameMode(const bool bMode) { bXingFrame = bMode; }

      /**
            \brief CBR : Get the bitrate to use         / 
                   VBR : Get the minimum bitrate value
      */
      const unsigned int GetBitrateValue() const;

      /**
            \brief Get the current (VBR:min) bitrate for the specified MPEG version

            \param bitrate the data that will be filled with the bitrate
            \param MPEG_Version The MPEG version (MPEG1 or MPEG2)

            \return 0 if the bitrate is not found, 1 if the bitrate is found
      */
      const int GetBitrateValue(DWORD & bitrate, const DWORD MPEG_Version) const;
      /**
            \brief Get the current (VBR:min) bitrate for MPEG I

            \param bitrate the data that will be filled with the bitrate

            \return 0 if the bitrate is not found, 1 if the bitrate is found
      */
      const int GetBitrateValueMPEG1(DWORD & bitrate) const;
      /**
            \brief Get the current (VBR:min) bitrate for MPEG II

            \param bitrate the data that will be filled with the bitrate

            \return 0 if the bitrate is not found, 1 if the bitrate is found
      */
      const int GetBitrateValueMPEG2(DWORD & bitrate) const;

      /**
            \brief Get the current (VBR:min) bitrate in the form of a string

            \param string the string that will be filled
            \param string_size the size of the string

            \return -1 if the bitrate is not found, and the number of char copied otherwise
      */
00219       inline const int GetBitrateString(char * string, int string_size) const {return GetBitrateString(string,string_size,nMinBitrateIndex); }

      /**
            \brief Get the (VBR:min) bitrate corresponding to the specified index in the form of a string

            \param string the string that will be filled
            \param string_size the size of the string
            \param a_bitrateID the index in the Bitrate table

            \return -1 if the bitrate is not found, and the number of char copied otherwise
      */
      const int GetBitrateString(char * string, int string_size, int a_bitrateID) const;

      /**
            \brief Get the number of possible bitrates
      */
00235       inline const int GetBitrateLentgh() const { return sizeof(the_Bitrates) / sizeof(unsigned int); }
      /**
            \brief Get the number of possible sampling frequencies
      */
00239       inline const unsigned int GetResampleFreq() const { return the_SamplingFreqs[nSamplingFreqIndex]; }
      /**
            \brief Get the max compression ratio allowed (1:15 default)
      */
00243       inline double GetSmartRatio() const { return SmartRatioMax;}
      /**
            \brief Get the min ABR bitrate possible
      */
00247       inline unsigned int GetAbrBitrateMin() const { return AverageBitrate_Min;}
      /**
            \brief Get the max ABR bitrate possible
      */
00251       inline unsigned int GetAbrBitrateMax() const { return AverageBitrate_Max;}
      /**
            \brief Get the step between ABR bitrates
      */
00255       inline unsigned int GetAbrBitrateStep() const { return AverageBitrate_Step;}

      /**
            \brief Get the VBR attributes for a specified MPEG version

            \param MaxBitrate receive the maximum bitrate possible in the VBR mode
            \param Quality receive the quality value (0 to 9 see Lame doc for more info)
            \param VBRHeader receive the value that indicates wether the VBR/Xing header should be filled
            \param MPEG_Version The MPEG version (MPEG1 or MPEG2)

            \return the VBR mode (Old, New, ABR, MTRH, Default or None)
      */
//    VBRMETHOD GetVBRValue(DWORD & MaxBitrate, int & Quality, DWORD & AbrBitrate, BOOL & VBRHeader, const DWORD MPEG_Version) const;

      /**
            \brief Get the Lame DLL Location
      */
//    const char * GetDllLocation() const { return DllLocation.c_str(); }
      /**
            \brief Set the Lame DLL Location
      */
//    void SetDllLocation( const char * the_string ) { DllLocation = the_string; }

      /**
            \brief Get the output directory for encoding
      */
//    const char * GetOutputDirectory() const { return OutputDir.c_str(); }
      /**
            \brief Set the output directory for encoding
      */
//    void SetOutputDirectory( const char * the_string ) { OutputDir = the_string; }

      /**
            \brief Get the current channel mode to use
      */
      const unsigned int GetChannelModeValue() const;
      /**
            \brief Get the current channel mode in the form of a string
      */
00294       inline const char * GetChannelModeString() const {return GetChannelModeString(nChannelIndex); }
      /**
            \brief Get the channel mode in the form of a string for the specified Channel mode index

            \param a_channelID the Channel mode index (see GetChannelLentgh())
      */
      const char * GetChannelModeString(const int a_channelID) const;
      /**
            \brief Get the number of possible channel mode
      */
00304       inline const int GetChannelLentgh() const { return 3; }

      /**
            \brief Get the current preset to use, see lame documentation/code for more info on the possible presets
      */
//    const LAME_QUALTIY_PRESET GetPresetModeValue() const;
      /**
            \brief Get the preset in the form of a string for the specified Channel mode index

            \param a_presetID the preset index (see GetPresetLentgh())
      */
      const char * GetPresetModeString(const int a_presetID) const;
      /**
            \brief Get the number of possible presets
      */
//    inline const int GetPresetLentgh() const { return sizeof(the_Presets) / sizeof(LAME_QUALTIY_PRESET); }

      /**
            \brief Start the user configuration process (called by AOut::config())
      */
      bool Config(const HINSTANCE hInstance, const HWND HwndParent);

      /**
            \brief Init the config dialog box with the right texts and choices
      */
      bool InitConfigDlg(HWND hDialog);

      /**
            \brief Update the instance parameters from the config dialog box
      */
      bool UpdateValueFromDlg(HWND hDialog);
      /**
            \brief Update the config dialog box from the instance parameters
      */
      bool UpdateDlgFromValue(HWND hDialog);

      /**
            \brief Update the config dialog box with the BitRate mode
      */
      static void DisplayVbrOptions(const HWND hDialog, const BRMode the_mode);

      /**
            \brief Handle the saving of parameters when something has changed in the config dialog box
      */
      void SaveParams(const HWND hDialog);

      /**
            \brief Save the current parameters (current config in use)
      */
      void ParamsSave(void);
      /**
            \brief Load the parameters (current config in use)
      */
      void ParamsRestore(void);

      /**
            \brief Select the specified config name as the new default one
      */
      void SelectSavedParams(const std::string config_name);
      /**
            \brief Save the current parameters to the specified config name
      */
      void SaveValuesToStringKey(const std::string & config_name);
      /**
            \brief Rename the current config name to something else
      */
      bool RenameCurrentTo(const std::string & new_config_name);
      /**
            \brief Delete the config name from the saved configs
      */
      bool DeleteConfig(const std::string & config_name);

      ADbg              my_debug;

      /**
            \brief Update the slides value (on scroll)
      */
      void UpdateDlgFromSlides(HWND parent_window) const;

      static ToolTipItem Tooltips[13];
private:

      bool bCopyright;
      bool bCRC;
      bool bOriginal;
      bool bPrivate;
      bool bNoBitRes;
      BRMode mBRmode;
      bool bXingFrame;
      bool bForceChannel;
      bool bResample;
      bool bSmartOutput;
      bool bAbrOutput;

      int VbrQuality;
      unsigned int AverageBitrate_Min;
      unsigned int AverageBitrate_Max;
      unsigned int AverageBitrate_Step;

      double SmartRatioMax;

      static const unsigned int the_ChannelModes[3];
      int nChannelIndex;

      static const unsigned int the_Bitrates[18];
      static const unsigned int the_MPEG1_Bitrates[14];
      static const unsigned int the_MPEG2_Bitrates[14];
      int nMinBitrateIndex; // CBR and VBR
      int nMaxBitrateIndex; // only used in VBR mode

      static const unsigned int the_SamplingFreqs[9];
      int nSamplingFreqIndex;

//    static const LAME_QUALTIY_PRESET the_Presets[17];
      int nPresetIndex;

//    char DllLocation[512];
//    std::string DllLocation;
//    char OutputDir[MAX_PATH];
//    std::string OutputDir;

//    AParameters my_base_parameters;
      TiXmlDocument my_stored_data;
      std::string my_store_location;
      std::string my_current_config;

//    HINSTANCE hDllInstance;

      void SaveValuesToElement(TiXmlElement * the_element) const;
      inline void SetAttributeBool(TiXmlElement * the_elt,const std::string & the_string, const bool the_value) const;
      void UpdateConfigs(const HWND HwndDlg);
      void EnableAbrOptions(HWND hDialog, bool enable);

      HMODULE my_hModule;

      /**
            \brief

            \param config_name
            \param parentNode
      */
      void GetValuesFromKey(const std::string & config_name, const TiXmlNode & parentNode);
};

#endif // !defined(_AENCODEPROPERTIES_H__INCLUDED_)

Generated by  Doxygen 1.6.0   Back to index