ExportOGG Class Reference

Inheritance diagram for ExportOGG:

Collaboration diagram for ExportOGG:

Public Member Functions
	ExportOGG ()
void	OptionsCreate (ShuttleGui &S, int format) override
ProgressResult	Export (AudacityProject *project, std::unique_ptr< BasicUI::ProgressDialog > &pDialog, unsigned channels, const wxFileNameWrapper &fName, bool selectedOnly, double t0, double t1, MixerSpec *mixerSpec=NULL, const Tags *metadata=NULL, int subformat=0) override
	called to export audio into a file. More...
Public Member Functions inherited from ExportPlugin
	ExportPlugin ()
virtual	~ExportPlugin ()
int	AddFormat ()
	Add a NEW entry to the list of formats this plug-in can export. More...
void	SetFormat (const wxString &format, int index)
void	SetDescription (const TranslatableString &description, int index)
void	AddExtension (const FileExtension &extension, int index)
void	SetExtensions (FileExtensions extensions, int index)
void	SetMask (FileNames::FileTypes mask, int index)
void	SetMaxChannels (unsigned maxchannels, unsigned index)
void	SetCanMetaData (bool canmetadata, int index)
virtual int	GetFormatCount ()
virtual wxString	GetFormat (int index)
TranslatableString	GetDescription (int index)
virtual FileExtension	GetExtension (int index=0)
	Return the (first) file name extension for the sub-format. More...
virtual FileExtensions	GetExtensions (int index=0)
	Return all the file name extensions used for the sub-format. More...
FileNames::FileTypes	GetMask (int index)
virtual unsigned	GetMaxChannels (int index)
virtual bool	GetCanMetaData (int index)
virtual bool	IsExtension (const FileExtension &ext, int index)
virtual bool	DisplayOptions (wxWindow *parent, int format=0)
virtual void	OptionsCreate (ShuttleGui &S, int format)=0
virtual bool	CheckFileName (wxFileName &filename, int format=0)
virtual int	SetNumExportChannels ()
	Exporter plug-ins may override this to specify the number of channels in exported file. -1 for unspecified. More...
virtual ProgressResult	Export (AudacityProject *project, std::unique_ptr< BasicUI::ProgressDialog > &pDialog, unsigned channels, const wxFileNameWrapper &fName, bool selectedOnly, double t0, double t1, MixerSpec *mixerSpec=NULL, const Tags *metadata=NULL, int subformat=0)=0
	called to export audio into a file. More...

Private Member Functions
bool	FillComment (AudacityProject *project, vorbis_comment *comment, const Tags *metadata)

Additional Inherited Members
Public Types inherited from ExportPlugin
using	ProgressResult = BasicUI::ProgressResult
Protected Member Functions inherited from ExportPlugin
std::unique_ptr< Mixer >	CreateMixer (const TrackList &tracks, bool selectionOnly, double startTime, double stopTime, unsigned numOutChannels, size_t outBufferSize, bool outInterleaved, double outRate, sampleFormat outFormat, MixerSpec *mixerSpec)
Static Protected Member Functions inherited from ExportPlugin
static void	InitProgress (std::unique_ptr< BasicUI::ProgressDialog > &pDialog, const TranslatableString &title, const TranslatableString &message)
static void	InitProgress (std::unique_ptr< BasicUI::ProgressDialog > &pDialog, const wxFileNameWrapper &title, const TranslatableString &message)

Detailed Description

Definition at line 123 of file ExportOGG.cpp.

Constructor & Destructor Documentation

ExportOGG()

ExportOGG::ExportOGG

(

)

Definition at line 148 of file ExportOGG.cpp.

:  ExportPlugin()
{
   AddFormat();
   SetFormat(wxT("OGG"),0);
   AddExtension(wxT("ogg"),0);
   SetMaxChannels(255,0);
   SetCanMetaData(true,0);
   SetDescription(XO("Ogg Vorbis Files"),0);
}

References ExportPlugin::AddExtension(), ExportPlugin::AddFormat(), ExportPlugin::SetCanMetaData(), ExportPlugin::SetDescription(), ExportPlugin::SetFormat(), ExportPlugin::SetMaxChannels(), wxT(), and XO().

Here is the call graph for this function:

Member Function Documentation

Export()

ProgressResult ExportOGG::Export ( AudacityProject *  project, std::unique_ptr< BasicUI::ProgressDialog > &  pDialog, unsigned  channels, const wxFileNameWrapper &  fName, bool  selectedOnly, double  t0, double  t1, MixerSpec *  mixerSpec = NULL, const Tags *  metadata = NULL, int  subformat = 0  )

overridevirtual

called to export audio into a file.

Parameters

pDialog	To be initialized with pointer to a NEW ProgressDialog if it was null, otherwise gives an existing dialog to be reused (working around a problem in wxWidgets for Mac; see bug 1600)
selectedOnly	Set to true if all tracks should be mixed, to false if only the selected tracks should be mixed and exported.
metadata	A Tags object that will over-ride the one in *project and be used to tag the file that is exported.
subformat	Control which of the multiple formats this exporter is capable of exporting should be used. Used where a single export plug-in handles a number of related formats, but they have separate entries in the Format drop-down list box. For example, the options to export to "Other PCM", "AIFF 16 Bit" and "WAV 16 Bit" are all the same libsndfile export plug-in, but with subformat set to 0, 1, and 2 respectively.

Returns

ProgressResult::Failed or ProgressResult::Cancelled if export fails to complete for any reason, in which case this function is responsible for alerting the user. Otherwise ProgressResult::Success or ProgressResult::Stopped

Implements ExportPlugin.

Definition at line 159 of file ExportOGG.cpp.

{
   double    rate    = ProjectRate::Get( *project ).GetRate();
   const auto &tracks = TrackList::Get( *project );
   double    quality = (gPrefs->Read(wxT("/FileFormats/OggExportQuality"), 50)/(float)100.0);
 
   wxLogNull logNo;            // temporarily disable wxWidgets error messages
   auto updateResult = ProgressResult::Success;
   int       eos = 0;
 
   FileIO outFile(fName, FileIO::Output);
 
   if (!outFile.IsOpened()) {
      AudacityMessageBox( XO("Unable to open target file for writing") );
      return ProgressResult::Cancelled;
   }
 
   // All the Ogg and Vorbis encoding data
   ogg_stream_state stream;
   ogg_page         page;
   ogg_packet       packet;
 
   vorbis_info      info;
   vorbis_comment   comment;
   vorbis_dsp_state dsp;
   vorbis_block     block;
 
 
   auto cleanup1 = finally( [&] {
      vorbis_info_clear(&info);
   } );
 
 
   // Many of the library functions called below return 0 for success and
   // various nonzero codes for failure.
 
   // Encoding setup
   vorbis_info_init(&info);
   if (vorbis_encode_init_vbr(&info, numChannels, (int)(rate + 0.5), quality)) {
      // TODO: more precise message
      AudacityMessageBox( XO("Unable to export - rate or quality problem") );
      return ProgressResult::Cancelled;
   }
 
   auto cleanup2 = finally( [&] {
      ogg_stream_clear(&stream);
 
      vorbis_block_clear(&block);
      vorbis_dsp_clear(&dsp);
      vorbis_comment_clear(&comment);
   } );
 
   // Retrieve tags
   if (!FillComment(project, &comment, metadata)) {
      AudacityMessageBox( XO("Unable to export - problem with metadata") );
      return ProgressResult::Cancelled;
   }
 
   // Set up analysis state and auxiliary encoding storage
   if (vorbis_analysis_init(&dsp, &info) ||
       vorbis_block_init(&dsp, &block)) {
      AudacityMessageBox( XO("Unable to export - problem initialising") );
      return ProgressResult::Cancelled;
   }
 
   // Set up packet->stream encoder.  According to encoder example,
   // a random serial number makes it more likely that you can make
   // chained streams with concatenation.
   srand(time(NULL));
   if (ogg_stream_init(&stream, rand())) {
      AudacityMessageBox( XO("Unable to export - problem creating stream") );
      return ProgressResult::Cancelled;
   }
 
   // First we need to write the required headers:
   //    1. The Ogg bitstream header, which contains codec setup params
   //    2. The Vorbis comment header
   //    3. The bitstream codebook.
   //
   // After we create those our responsibility is complete, libvorbis will
   // take care of any other ogg bitstream constraints (again, according
   // to the example encoder source)
   ogg_packet bitstream_header;
   ogg_packet comment_header;
   ogg_packet codebook_header;
 
   if(vorbis_analysis_headerout(&dsp, &comment, &bitstream_header, &comment_header,
         &codebook_header) ||
      // Place these headers into the stream
      ogg_stream_packetin(&stream, &bitstream_header) ||
      ogg_stream_packetin(&stream, &comment_header) ||
      ogg_stream_packetin(&stream, &codebook_header)) {
      AudacityMessageBox( XO("Unable to export - problem with packets") );
      return ProgressResult::Cancelled;
   }
 
   // Flushing these headers now guarantees that audio data will
   // start on a NEW page, which apparently makes streaming easier
   while (ogg_stream_flush(&stream, &page)) {
      if ( outFile.Write(page.header, page.header_len).GetLastError() ||
           outFile.Write(page.body, page.body_len).GetLastError()) {
         AudacityMessageBox( XO("Unable to export - problem with file") );
         return ProgressResult::Cancelled;
      }
   }
 
   {
      auto mixer = CreateMixer(tracks, selectionOnly,
         t0, t1,
         numChannels, SAMPLES_PER_RUN, false,
         rate, floatSample, mixerSpec);
 
      InitProgress( pDialog, fName,
         selectionOnly
            ? XO("Exporting the selected audio as Ogg Vorbis")
            : XO("Exporting the audio as Ogg Vorbis") );
      auto &progress = *pDialog;
 
      while (updateResult == ProgressResult::Success && !eos) {
         float **vorbis_buffer = vorbis_analysis_buffer(&dsp, SAMPLES_PER_RUN);
         auto samplesThisRun = mixer->Process();
         int err;
         if (samplesThisRun == 0) {
            // Tell the library that we wrote 0 bytes - signalling the end.
            err = vorbis_analysis_wrote(&dsp, 0);
         }
         else {
 
            for (size_t i = 0; i < numChannels; i++) {
               float *temp = (float *)mixer->GetBuffer(i);
               memcpy(vorbis_buffer[i], temp, sizeof(float)*SAMPLES_PER_RUN);
            }
 
            // tell the encoder how many samples we have
            err = vorbis_analysis_wrote(&dsp, samplesThisRun);
         }
 
         // I don't understand what this call does, so here is the comment
         // from the example, verbatim:
         //
         //    vorbis does some data preanalysis, then divvies up blocks
         //    for more involved (potentially parallel) processing. Get
         //    a single block for encoding now
         while (!err && vorbis_analysis_blockout(&dsp, &block) == 1) {
 
            // analysis, assume we want to use bitrate management
            err = vorbis_analysis(&block, NULL);
            if (!err)
               err = vorbis_bitrate_addblock(&block);
 
            while (!err && vorbis_bitrate_flushpacket(&dsp, &packet)) {
 
               // add the packet to the bitstream
               err = ogg_stream_packetin(&stream, &packet);
 
               // From vorbis-tools-1.0/oggenc/encode.c:
               //   If we've gone over a page boundary, we can do actual output,
               //   so do so (for however many pages are available).
 
               while (!err && !eos) {
                  int result = ogg_stream_pageout(&stream, &page);
                  if (!result) {
                     break;
                  }
 
                  if ( outFile.Write(page.header, page.header_len).GetLastError() ||
                       outFile.Write(page.body, page.body_len).GetLastError()) {
                     // TODO: more precise message
                     ShowDiskFullExportErrorDialog(fName);
                     return ProgressResult::Cancelled;
                  }
 
                  if (ogg_page_eos(&page)) {
                     eos = 1;
                  }
               }
            }
         }
 
         if (err) {
            updateResult = ProgressResult::Cancelled;
            // TODO: more precise message
            ShowExportErrorDialog("OGG:355");
            break;
         }
 
         updateResult = progress.Poll(mixer->MixGetCurrentTime() - t0, t1 - t0);
      }
   }
 
   if ( !outFile.Close() ) {
      updateResult = ProgressResult::Cancelled;
      // TODO: more precise message
      ShowExportErrorDialog("OGG:366");
   }
 
   return updateResult;
}

References AudacityMessageBox(), RefreshCode::Cancelled, FileIO::Close(), ExportPlugin::CreateMixer(), FillComment(), floatSample, ProjectRate::Get(), TrackList::Get(), ProjectRate::GetRate(), gPrefs, ExportPlugin::InitProgress(), FileIO::IsOpened(), FileIO::Output, SAMPLES_PER_RUN, ShowDiskFullExportErrorDialog(), ShowExportErrorDialog(), BasicUI::Success, FileIO::Write(), wxT(), and XO().

Here is the call graph for this function:

FillComment()

bool ExportOGG::FillComment ( AudacityProject *  project, vorbis_comment *  comment, const Tags *  metadata  )

private

Definition at line 372 of file ExportOGG.cpp.

{
   // Retrieve tags from project if not over-ridden
   if (metadata == NULL)
      metadata = &Tags::Get( *project );
 
   vorbis_comment_init(comment);
 
   wxString n;
   for (const auto &pair : metadata->GetRange()) {
      n = pair.first;
      const auto &v = pair.second;
      if (n == TAG_YEAR) {
         n = wxT("DATE");
      }
      vorbis_comment_add_tag(comment,
                             (char *) (const char *) n.mb_str(wxConvUTF8),
                             (char *) (const char *) v.mb_str(wxConvUTF8));
   }
 
   return true;
}

References Tags::Get(), Tags::GetRange(), TAG_YEAR, and wxT().

Referenced by Export().

Here is the call graph for this function:

Here is the caller graph for this function:

OptionsCreate()

void ExportOGG::OptionsCreate ( ShuttleGui &  S, int  format  )

overridevirtual

Implements ExportPlugin.

Definition at line 367 of file ExportOGG.cpp.

{
   S.AddWindow( safenew ExportOGGOptions{ S.GetParent(), format } );
}

References format, S, and safenew.

---

The documentation for this class was generated from the following file:

• ExportOGG.cpp