ExportFFmpegDialogs.h

Go to the documentation of this file.

/**********************************************************************
 
Audacity: A Digital Audio Editor
 
ExportFFmpegDialogs.h
 
LRN
 
**********************************************************************/
 
#if !defined(__EXPORT_FFMPEG_DIALOGS_H__)
#define __EXPORT_FFMPEG_DIALOGS_H__
 
#if defined(USE_FFMPEG)
 
#include "../FFmpeg.h"
#include "FFmpegFunctions.h"
 
#include "XMLFileReader.h"
#include "FileNames.h"
 
#include <unordered_map>
#include "Identifier.h"
 
class wxArrayStringEx;
 
class wxArrayString;
class wxCheckBox;
class wxStaticText;
class wxTextCtrl;
 
enum FFmpegExposedFormat
{
   FMT_M4A,
   FMT_AC3,
   FMT_AMRNB,
   FMT_OPUS,
   FMT_WMA2,
   FMT_OTHER,
   FMT_LAST
};
 
#define AV_CANMETA (AV_VERSION_INT(255, 255, 255))
 
struct ExposedFormat
{
   FFmpegExposedFormat fmtid; 
   const wxChar *name;        
   const FileExtension extension;   
   const wxChar *shortname;   
   unsigned maxchannels;      
   const int canmetadata;           
   bool canutf8;              
   const TranslatableString description; 
   AudacityAVCodecID codecid;         
   bool compiledIn;           
};
 
 
struct CompatibilityEntry
{
   const wxChar *fmt; 
   AudacityAVCodecID codec; 
};
 
 
class ExportFFmpegAC3Options final : public wxPanelWrapper
{
public:
 
   ExportFFmpegAC3Options(wxWindow *parent, int format);
   virtual ~ExportFFmpegAC3Options();
 
   void PopulateOrExchange(ShuttleGui & S);
   bool TransferDataToWindow() override;
   bool TransferDataFromWindow() override;
 
   static const int iAC3SampleRates[];
 
private:
 
   wxChoice *mBitRateChoice;
   int mBitRateFromChoice;
};
 
class ExportFFmpegAACOptions final : public wxPanelWrapper
{
public:
 
   ExportFFmpegAACOptions(wxWindow *parent, int format);
   virtual ~ExportFFmpegAACOptions();
 
   void PopulateOrExchange(ShuttleGui & S);
   bool TransferDataToWindow() override;
   bool TransferDataFromWindow() override;
};
 
class ExportFFmpegAMRNBOptions final : public wxPanelWrapper
{
public:
 
   ExportFFmpegAMRNBOptions(wxWindow *parent, int format);
   virtual ~ExportFFmpegAMRNBOptions();
 
   void PopulateOrExchange(ShuttleGui & S);
   bool TransferDataToWindow() override;
   bool TransferDataFromWindow() override;
 
private:
 
   wxChoice *mBitRateChoice;
   int mBitRateFromChoice;
};
 
class ExportFFmpegOPUSOptions final : public wxPanelWrapper
{
public:
 
   ExportFFmpegOPUSOptions(wxWindow *parent, int format);
   ~ExportFFmpegOPUSOptions();
 
   void PopulateOrExchange(ShuttleGui & S);
   bool TransferDataToWindow() override;
   bool TransferDataFromWindow() override;
 
   static const int iOPUSSampleRates[];
 
private:
 
   wxSlider *mBitRateSlider;
   int mBitRateFromSlider;
 
   wxChoice *mVbrChoice;
   int mVbrFromChoice;
 
   wxSlider *mComplexitySlider;
   int mComplexityFromSlider;
 
   wxChoice *mFramesizeChoice;
   int mFramesizeFromChoice;
 
   wxChoice *mApplicationChoice;
   int mApplicationFromChoice;
 
   wxChoice *mCuttoffChoice;
   int mCutoffFromChoice;
};
 
class ExportFFmpegWMAOptions final : public wxPanelWrapper
{
public:
 
   ExportFFmpegWMAOptions(wxWindow *parent, int format);
   ~ExportFFmpegWMAOptions();
 
   void PopulateOrExchange(ShuttleGui & S);
   bool TransferDataToWindow() override;
   bool TransferDataFromWindow() override;
 
   static const int iWMASampleRates[];
 
private:
 
   wxChoice *mBitRateChoice;
   int mBitRateFromChoice;
};
 
class ExportFFmpegCustomOptions final : public wxPanelWrapper
{
public:
 
   ExportFFmpegCustomOptions(wxWindow *parent, int format);
   ~ExportFFmpegCustomOptions();
 
   void PopulateOrExchange(ShuttleGui & S);
   bool TransferDataToWindow() override;
   bool TransferDataFromWindow() override;
 
   void OnOpen(wxCommandEvent & evt);
 
private:
   wxTextCtrl *mFormat;
   wxTextCtrl *mCodec;
 
   DECLARE_EVENT_TABLE()
};
 
struct ApplicableFor
{
   bool                 enable;  
   int                  control; 
   AudacityAVCodecID codec;      
   const char          *format;  
};
 
class FFmpegPresets;
 
class ExportFFmpegOptions final : public wxDialogWrapper
{
public:
 
   ExportFFmpegOptions(wxWindow *parent);
   ~ExportFFmpegOptions();
   void PopulateOrExchange(ShuttleGui & S);
   void OnOK(wxCommandEvent& event);
   void OnGetURL(wxCommandEvent& event);
   void OnFormatList(wxCommandEvent& event);
   void DoOnFormatList();
   void OnCodecList(wxCommandEvent& event);
   void DoOnCodecList();
   void OnAllFormats(wxCommandEvent& event);
   void OnAllCodecs(wxCommandEvent& event);
   void OnSavePreset(wxCommandEvent& event);
   void OnLoadPreset(wxCommandEvent& event);
   void OnDeletePreset(wxCommandEvent& event);
   void OnImportPresets(wxCommandEvent& event);
   void OnExportPresets(wxCommandEvent& event);
   bool SavePreset( bool bCheckForOverwrite);
 
 
   // Static tables
   static CompatibilityEntry CompatibilityList[];
   static ExposedFormat fmts[];
   static const int iAACSampleRates[];
   static ApplicableFor apptable[];
 
private:
 
   wxArrayString mShownFormatNames;
   wxArrayString mShownFormatLongNames;
   wxArrayString mShownCodecNames;
   wxArrayString mShownCodecLongNames;
   wxArrayStringEx mFormatNames;
   wxArrayString mFormatLongNames;
   wxArrayStringEx mCodecNames;
   wxArrayString mCodecLongNames;
 
   wxListBox *mFormatList;
   wxListBox *mCodecList;
 
   wxStaticText *mFormatName;
   wxStaticText *mCodecName;
 
   wxComboBox *mPresetCombo;
 
   int mBitRateFromChoice;
   int mSampleRateFromChoice;
 
   std::unique_ptr<FFmpegPresets> mPresets;
 
   wxArrayStringEx mPresetNames;
 
   std::shared_ptr<FFmpegFunctions> mFFmpeg;
 
   void FindSelectedFormat(wxString **name, wxString **longname);
 
   void FindSelectedCodec(wxString **name, wxString **longname);
 
   void FetchFormatList();
 
   int FetchCompatibleFormatList(AudacityAVCodecID id, wxString* selfmt);
 
   void FetchCodecList();
 
   int FetchCompatibleCodecList(const wxChar* fmt, AudacityAVCodecID id);
 
   void FetchPresetList();
 
   bool ReportIfBadCombination();
 
 
   // Enables/disables controls based on format/codec combination,
   // leaving only relevant controls enabled.
   // Hiding the controls may have been a better idea,
   // but it's hard to hide their text labels too
   void EnableDisableControls(AVCodecWrapper *cdc, wxString *selfmt);
   DECLARE_EVENT_TABLE()
};
 
//----------------------------------------------------------------------------
// FFmpegPresets
//----------------------------------------------------------------------------
 
class FFmpegPreset
{
public:
   FFmpegPreset();
   ~FFmpegPreset();
 
   wxString mPresetName;
   wxArrayString mControlState;
 
};
 
using FFmpegPresetMap = std::unordered_map<wxString, FFmpegPreset>;
 
class FFmpegPresets : XMLTagHandler
{
public:
   FFmpegPresets();
   ~FFmpegPresets();
 
   void GetPresetList(wxArrayString &list);
   void LoadPreset(ExportFFmpegOptions *parent, wxString &name);
   bool SavePreset(ExportFFmpegOptions *parent, wxString &name);
   void DeletePreset(wxString &name);
   bool OverwriteIsOk( wxString &name );
   FFmpegPreset *FindPreset(wxString &name);
 
   void ImportPresets(wxString &filename);
   void ExportPresets(wxString &filename);
 
   bool HandleXMLTag(const std::string_view& tag, const AttributesList &attrs) override;
   XMLTagHandler *HandleXMLChild(const std::string_view& tag) override;
   void WriteXMLHeader(XMLWriter &xmlFile) const;
   void WriteXML(XMLWriter &xmlFile) const;
 
private:
 
   FFmpegPresetMap mPresets;
   FFmpegPreset *mPreset; // valid during XML parsing only
   bool mAbortImport; // tells importer to ignore the rest of the import
};
 
#endif
 
#endif //__EXPORT_FFMPEG_DIALOGS_H__