OGGExportProcessor Class Reference

Inheritance diagram for OGGExportProcessor:

Collaboration diagram for OGGExportProcessor:

Public Member Functions
	~OGGExportProcessor () override
bool	Initialize (AudacityProject &project, const Parameters &parameters, const wxFileNameWrapper &filename, double t0, double t1, bool selectedOnly, double sampleRate, unsigned channels, MixerOptions::Downmix *mixerSpec, const Tags *tags) override
	Called before start processing. More...
ExportResult	Process (ExportProcessorDelegate &delegate) override
Public Member Functions inherited from ExportProcessor
	ExportProcessor (const ExportProcessor &)=delete
ExportProcessor &	operator= (const ExportProcessor &)=delete
	ExportProcessor ()=default
virtual	~ExportProcessor ()
virtual bool	Initialize (AudacityProject &project, const Parameters &parameters, const wxFileNameWrapper &filename, double t0, double t1, bool selectedOnly, double rate, unsigned channels, MixerOptions::Downmix *mixerSpec=nullptr, const Tags *tags=nullptr)=0
	Called before start processing. More...
virtual ExportResult	Process (ExportProcessorDelegate &delegate)=0

Static Private Member Functions
static void	FillComment (AudacityProject *project, vorbis_comment *comment, const Tags *metadata)

Private Attributes
struct {
TranslatableString   status
double   t0
double   t1
unsigned   numChannels
std::unique_ptr< Mixer >   mixer
std::unique_ptr< FileIO >   outFile
wxFileNameWrapper   fName
ogg_stream_state   stream
ogg_page   page
ogg_packet   packet
vorbis_info   info
vorbis_comment   comment
vorbis_dsp_state   dsp
vorbis_block   block
bool   stream_ok {false}
bool   analysis_state_ok {false}
}	context

Additional Inherited Members
Public Types inherited from ExportProcessor
using	Parameters = std::vector< std::tuple< ExportOptionID, ExportValue > >

Detailed Description

Definition at line 102 of file ExportOGG.cpp.

Constructor & Destructor Documentation

~OGGExportProcessor()

OGGExportProcessor::~OGGExportProcessor ( )

override

Definition at line 172 of file ExportOGG.cpp.

{
   if(context.stream_ok)
      ogg_stream_clear(&context.stream);
 
   if(context.analysis_state_ok)
   {
      vorbis_comment_clear(&context.comment);
      vorbis_block_clear(&context.block);
      vorbis_dsp_clear(&context.dsp);
   }
 
   vorbis_info_clear(&context.info);
}

References context.

Member Function Documentation

FillComment()

void OGGExportProcessor::FillComment ( AudacityProject *  project, vorbis_comment *  comment, const Tags *  metadata  )

staticprivate

Definition at line 379 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));
   }
}

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

Referenced by Initialize().

Here is the call graph for this function:

Here is the caller graph for this function:

Initialize()

bool OGGExportProcessor::Initialize ( AudacityProject &  project, const Parameters &  parameters, const wxFileNameWrapper &  filename, double  t0, double  t1, bool  selectedOnly, double  rate, unsigned  channels, MixerOptions::Downmix *  mixerSpec, const Tags *  tags  )

overridevirtual

Called before start processing.

Parameters

project	Processor may access project data, take care to exclude any data race
parameters	A format-dependent set of parameters used in exporting
selectedOnly	Set to true if all tracks should be mixed, to false if only the selected tracks should be mixed and exported.
tags	A Tags object that will over-ride the one in *project and be used to tag the file that is exported. @retern Implementations may simply return false without any error reporting. This is to temporarily preserve old behavior, which is to be removed in the nearest future.

Implements ExportProcessor.

Definition at line 188 of file ExportOGG.cpp.

{
   context.t0 = t0;
   context.t1 = t1;
   context.numChannels = numChannels;
 
   double    quality = ExportPluginHelpers::GetParameterValue(parameters, 0, 5) / 10.0;
 
   wxLogNull logNo;            // temporarily disable wxWidgets error messages
 
   // Many of the library functions called below return 0 for success and
   // various nonzero codes for failure.
 
   // Encoding setup
 
   vorbis_info_init(&context.info);
 
   if (vorbis_encode_init_vbr(&context.info, numChannels, (int)(sampleRate + 0.5), quality)) {
      // TODO: more precise message
      throw ExportException(_("Unable to export - rate or quality problem"));
   }
 
   context.outFile = std::make_unique<FileIO>(fName, FileIO::Output);
 
   if (!context.outFile->IsOpened()) {
      throw ExportException(_("Unable to open target file for writing"));
   }
 
   context.analysis_state_ok = vorbis_analysis_init(&context.dsp, &context.info) == 0 &&
       vorbis_block_init(&context.dsp, &context.block) == 0;
   // Set up analysis state and auxiliary encoding storage
   if (!context.analysis_state_ok) {
      throw ExportException(_("Unable to export - problem initialising"));
   }
 
   // Retrieve tags
   FillComment(&project, &context.comment, metadata);
 
   // 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));
   context.stream_ok = ogg_stream_init(&context.stream, rand()) == 0;
   if (!context.stream_ok) {
      throw ExportException(_("Unable to export - problem creating stream"));
   }
 
   // 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(&context.dsp, &context.comment, &bitstream_header, &comment_header,
         &codebook_header) ||
      // Place these headers into the stream
      ogg_stream_packetin(&context.stream, &bitstream_header) ||
      ogg_stream_packetin(&context.stream, &comment_header) ||
      ogg_stream_packetin(&context.stream, &codebook_header)) {
      throw ExportException(_("Unable to export - problem with packets"));
   }
 
   // Flushing these headers now guarantees that audio data will
   // start on a NEW page, which apparently makes streaming easier
   while (ogg_stream_flush(&context.stream, &context.page)) {
      if ( context.outFile->Write(context.page.header, context.page.header_len).GetLastError() ||
           context.outFile->Write(context.page.body, context.page.body_len).GetLastError()) {
         throw ExportException(_("Unable to export - problem with file"));
      }
   }
 
   context.mixer = ExportPluginHelpers::CreateMixer(
      project, selectionOnly, t0, t1, numChannels, SAMPLES_PER_RUN, false,
      sampleRate, floatSample, mixerSpec);
 
   context.status = selectionOnly
      ? XO("Exporting the selected audio as Ogg Vorbis")
      : XO("Exporting the audio as Ogg Vorbis");
 
   return true;
}

References _, context, ExportPluginHelpers::CreateMixer(), FillComment(), floatSample, fName, ExportPluginHelpers::GetParameterValue(), numChannels, FileIO::Output, project, anonymous_namespace{ClipSegmentTest.cpp}::sampleRate, SAMPLES_PER_RUN, t0, t1, and XO().

Here is the call graph for this function:

Process()

ExportResult OGGExportProcessor::Process ( ExportProcessorDelegate &  delegate )

overridevirtual

Implements ExportProcessor.

Definition at line 282 of file ExportOGG.cpp.

{
   delegate.SetStatusString(context.status);
   auto exportResult = ExportResult::Success;
   {
      int err;
      int eos = 0;
      while (exportResult == ExportResult::Success && !eos) {
         float **vorbis_buffer = vorbis_analysis_buffer(&context.dsp, SAMPLES_PER_RUN);
         auto samplesThisRun = context.mixer->Process();
 
         if (samplesThisRun == 0) {
            // Tell the library that we wrote 0 bytes - signalling the end.
            err = vorbis_analysis_wrote(&context.dsp, 0);
         }
         else {
 
            for (size_t i = 0; i < context.numChannels; i++) {
               float *temp = (float *)context.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(&context.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(&context.dsp, &context.block) == 1) {
 
            // analysis, assume we want to use bitrate management
            err = vorbis_analysis(&context.block, NULL);
            if (!err)
               err = vorbis_bitrate_addblock(&context.block);
 
            while (!err && vorbis_bitrate_flushpacket(&context.dsp, &context.packet)) {
 
               // add the packet to the bitstream
               err = ogg_stream_packetin(&context.stream, &context.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(&context.stream, &context.page);
                  if (!result) {
                     break;
                  }
 
                  if ( context.outFile->Write(context.page.header, context.page.header_len).GetLastError() ||
                       context.outFile->Write(context.page.body, context.page.body_len).GetLastError()) {
                     // TODO: more precise message
                     throw ExportDiskFullError(context.fName);
                  }
 
                  if (ogg_page_eos(&context.page)) {
                     eos = 1;
                  }
               }
            }
         }
 
         if (err) {
            // TODO: more precise message
            throw ExportErrorException("OGG:355");
         }
         exportResult = ExportPluginHelpers::UpdateProgress(
            delegate, *context.mixer, context.t0, context.t1);
      }
   }
 
   if ( !context.outFile->Close() ) {
      // TODO: more precise message
      throw ExportErrorException("OGG:366");
   }
 
   return exportResult;
}

References context, SAMPLES_PER_RUN, ExportProcessorDelegate::SetStatusString(), Success, and ExportPluginHelpers::UpdateProgress().

Here is the call graph for this function:

Member Data Documentation

analysis_state_ok

bool OGGExportProcessor::analysis_state_ok {false}

Definition at line 124 of file ExportOGG.cpp.

block

vorbis_block OGGExportProcessor::block

Definition at line 122 of file ExportOGG.cpp.

comment

vorbis_comment OGGExportProcessor::comment

Definition at line 120 of file ExportOGG.cpp.

Referenced by FillComment().

struct { ... } OGGExportProcessor::context

Referenced by Initialize(), Process(), and ~OGGExportProcessor().

dsp

vorbis_dsp_state OGGExportProcessor::dsp

Definition at line 121 of file ExportOGG.cpp.

fName

wxFileNameWrapper OGGExportProcessor::fName

Definition at line 112 of file ExportOGG.cpp.

Referenced by Initialize().

info

vorbis_info OGGExportProcessor::info

Definition at line 119 of file ExportOGG.cpp.

mixer

std::unique_ptr<Mixer> OGGExportProcessor::mixer

Definition at line 110 of file ExportOGG.cpp.

numChannels

unsigned OGGExportProcessor::numChannels

Definition at line 109 of file ExportOGG.cpp.

Referenced by Initialize().

outFile

std::unique_ptr<FileIO> OGGExportProcessor::outFile

Definition at line 111 of file ExportOGG.cpp.

packet

ogg_packet OGGExportProcessor::packet

Definition at line 117 of file ExportOGG.cpp.

page

ogg_page OGGExportProcessor::page

Definition at line 116 of file ExportOGG.cpp.

status

TranslatableString OGGExportProcessor::status

Definition at line 106 of file ExportOGG.cpp.

stream

ogg_stream_state OGGExportProcessor::stream

Definition at line 115 of file ExportOGG.cpp.

stream_ok

bool OGGExportProcessor::stream_ok {false}

Definition at line 123 of file ExportOGG.cpp.

t0

double OGGExportProcessor::t0

Definition at line 107 of file ExportOGG.cpp.

Referenced by Initialize().

t1

double OGGExportProcessor::t1

Definition at line 108 of file ExportOGG.cpp.

Referenced by Initialize().

---

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

• ExportOGG.cpp